diff --git a/apps/desktop/src/main/bootstrap/post-auth-identity.ts b/apps/desktop/src/main/bootstrap/post-auth-identity.ts
index 85fc36f4..5e4513cc 100644
--- a/apps/desktop/src/main/bootstrap/post-auth-identity.ts
+++ b/apps/desktop/src/main/bootstrap/post-auth-identity.ts
@@ -59,7 +59,7 @@ export interface PostAuthDeps {
      */
     clearBlocked(): void
   }
-  media: {
+  media?: {
     selfAvatar(options?: { force?: boolean | undefined }): Promise<{
       path: string | null
       reason: string | null
@@ -270,7 +270,7 @@ export async function applyPostAuthIdentity(
   deps.dataPlane.clearBlocked()
 
   await confirmIdentity(deps, channelId)
-  await refreshAccountProfile(deps, status)
+  if (deps.media !== undefined) await refreshAccountProfile(deps, status)
 }
 
 /**
@@ -431,6 +431,7 @@ async function refreshAccountProfile(
   deps: PostAuthDeps,
   status: Extract<AuthStatus, { state: "authorized" }>,
 ): Promise<void> {
+  if (deps.media === undefined) return
   const { media, auth, logger, toFileUrl } = deps
   try {
     /**
@@ -495,5 +496,7 @@ export function scopedChannelIdFor(
   channelId: string,
   binOverride: string | null | undefined,
 ): string {
+  /** Codex 记录与 DWS 二进制来源无关，不能继承 DWS 的来源后缀。 */
+  if (channelId === "codex") return channelId
   return scopedChannelId(channelId, sourceKeyOf(binOverride ?? undefined))
 }
diff --git a/apps/desktop/src/main/bootstrap/startup.ts b/apps/desktop/src/main/bootstrap/startup.ts
index b2ab6a1e..8090b247 100644
--- a/apps/desktop/src/main/bootstrap/startup.ts
+++ b/apps/desktop/src/main/bootstrap/startup.ts
@@ -7,6 +7,7 @@
  */
 import { randomUUID } from "node:crypto"
 import { existsSync, mkdirSync, rmSync, statSync, writeFileSync } from "node:fs"
+import { homedir } from "node:os"
 import { dirname, join } from "node:path"
 import Database from "better-sqlite3"
 import { app, powerMonitor, shell, type BrowserWindow } from "electron"
@@ -29,6 +30,7 @@ import {
 } from "@mycontext/store"
 import {
   ChannelHost,
+  createCodexLocalPlugin,
   createDingTalkPlugin,
   createFeishuPlugin,
   createRegistry,
@@ -436,7 +438,14 @@ export function bootstrapApp(mainDir: string): AppContext {
         : `lark-cli-${process.platform}-${process.arch === "x64" ? "x64" : process.arch}`,
     ),
   })
-  const registry = createRegistry([dingtalk, feishu])
+  const codex = createCodexLocalPlugin({
+    recordsRoot: () => {
+      const configured = process.env["CODEX_HOME"]?.trim()
+      return configured === undefined || configured === "" ? join(homedir(), ".codex") : configured
+    },
+    consentRoot: () => vaultPaths?.codexAuthRoot ?? "",
+  })
+  const registry = createRegistry([dingtalk, feishu, codex])
 
   let window: BrowserWindow | null = null
   /**
@@ -2873,8 +2882,15 @@ export function bootstrapApp(mainDir: string): AppContext {
           void mounted.klServer.ensureReady().catch(() => undefined)
         }
       }
+      const plugin = registry.get(channelId)
       await applyPostAuthIdentity(
-        { dataPlane, media, auth, logger, toFileUrl: toLocalFileUrl },
+        {
+          dataPlane,
+          auth,
+          logger,
+          toFileUrl: toLocalFileUrl,
+          ...(plugin.avatars === undefined ? {} : { media }),
+        },
         status,
         /**
          * ★ 把渠道传下去 —— 不传的话身份会写到**主渠道**那张表上，
diff --git a/apps/desktop/src/main/services/channel.service.ts b/apps/desktop/src/main/services/channel.service.ts
index e61426e8..f3636189 100644
--- a/apps/desktop/src/main/services/channel.service.ts
+++ b/apps/desktop/src/main/services/channel.service.ts
@@ -68,6 +68,7 @@ export class ChannelService {
         descriptionKey: plugin.meta.descriptionKey,
         available: plugin.meta.available,
         stepKeys: plugin.auth.describeStepKeys(),
+        authModes: plugin.auth.supportedModes?.() ?? ["loopback", "device"],
         status,
         loginInProgress: this.options.host.isLoginInProgress(plugin.meta.id),
         /**
@@ -83,6 +84,7 @@ export class ChannelService {
           sendAs: [...plugin.capabilities.sendAs],
           domains: [...plugin.capabilities.domains],
           isolatedCredentials: plugin.capabilities.isolatedCredentials,
+          avatars: plugin.avatars !== undefined,
         },
       })
     }
diff --git a/apps/desktop/src/renderer/features/channels/channel-auth-panel.tsx b/apps/desktop/src/renderer/features/channels/channel-auth-panel.tsx
index c38343a4..033b187d 100644
--- a/apps/desktop/src/renderer/features/channels/channel-auth-panel.tsx
+++ b/apps/desktop/src/renderer/features/channels/channel-auth-panel.tsx
@@ -175,7 +175,8 @@ export function ChannelAuthPanel({ channel, variant = "settings" }: ChannelAuthP
     selfExternalId === null
       ? null
       : (selfAvatars.data?.find((e) => e.externalId === selfExternalId)?.path ?? null)
-  const scopePrefix = channel.id === "feishu" ? "feishuScope" : "scope"
+  const scopePrefix =
+    channel.id === "feishu" ? "feishuScope" : channel.id === "codex" ? "codexScope" : "scope"
   /**
    * 「本机已有登录态」这句话的 i18n key —— **按渠道分**。
    *
@@ -190,7 +191,9 @@ export function ChannelAuthPanel({ channel, variant = "settings" }: ChannelAuthP
   const machineSessionKey =
     channel.id === "feishu"
       ? "onboarding.machineSessionHintFeishu"
-      : "onboarding.machineSessionHint"
+      : channel.id === "codex"
+        ? "onboarding.machineSessionHintCodex"
+        : "onboarding.machineSessionHint"
 
   /**
    * 渠道侧的昵称（钉钉叫花名）。
@@ -458,11 +461,13 @@ export function ChannelAuthPanel({ channel, variant = "settings" }: ChannelAuthP
         */}
         {t(accountConnected ? "actions.reauthorize" : "actions.start")}
       </Button>
-      <Tooltip content={t("actions.useCodeHint")} placement="top">
-        <Button size="md" variant="secondary" disabled={running} onClick={() => begin("device")}>
-          {t("actions.useCode")}
-        </Button>
-      </Tooltip>
+      {(channel.authModes ?? ["loopback", "device"]).includes("device") ? (
+        <Tooltip content={t("actions.useCodeHint")} placement="top">
+          <Button size="md" variant="secondary" disabled={running} onClick={() => begin("device")}>
+            {t("actions.useCode")}
+          </Button>
+        </Tooltip>
+      ) : null}
       {/*
         ── 退出授权 / 切换账号 ──────────────────────────────────
 
@@ -542,7 +547,7 @@ export function ChannelAuthPanel({ channel, variant = "settings" }: ChannelAuthP
         `useFetchSelfAvatar` —— 后者会连账号级头像一起写，那会让"在飞书点
         刷新、切回钉钉看到飞书那张"（已修，见那个 hook 的说明）。
       */}
-      {accountConnected ? (
+      {accountConnected && channel.capabilities?.avatars === true ? (
         <Tooltip content={t("actions.refreshAvatarHint")} placement="top">
           <Button
             size="md"
@@ -1301,7 +1306,11 @@ function SharedCredentialNote({ channelId }: { channelId: string }) {
       <Trans
         ns="channels"
         i18nKey={
-          channelId === "feishu" ? "settings.feishuCredentialNote" : "settings.sharedCredentialNote"
+          channelId === "feishu"
+            ? "settings.feishuCredentialNote"
+            : channelId === "codex"
+              ? "settings.codexCredentialNote"
+              : "settings.sharedCredentialNote"
         }
         values={{
           command: channelId === "feishu" ? "lark-cli auth logout --json" : "dws auth logout",
diff --git a/packages/channels/src/index.ts b/packages/channels/src/index.ts
index d3c70da6..ca92ad3e 100644
--- a/packages/channels/src/index.ts
+++ b/packages/channels/src/index.ts
@@ -99,6 +99,9 @@ export {
 } from "./plugins/feishu/index.js"
 export type { FeishuPluginOptions } from "./plugins/feishu/index.js"
 
+export { createCodexLocalPlugin } from "./plugins/codex-local/index.js"
+export type { CodexLocalPluginOptions } from "./plugins/codex-local/index.js"
+
 export {
   parseLocalTime,
   formatLocalTime,
diff --git a/packages/channels/src/plugins/codex-local/auth.ts b/packages/channels/src/plugins/codex-local/auth.ts
new file mode 100644
index 00000000..5b985b3f
--- /dev/null
+++ b/packages/channels/src/plugins/codex-local/auth.ts
@@ -0,0 +1,122 @@
+/**
+ * 本地编码助手记录的授权。
+ *
+ * 这里的“授权”不是 OAuth：记录已经在本机磁盘上。它只负责保存一份按 vault
+ * 隔离的显式同意标记，避免应用一发现目录就自动读取用户历史。
+ */
+import { constants } from "node:fs"
+import { access, mkdir, rm, writeFile } from "node:fs/promises"
+import { join } from "node:path"
+import { AppError } from "@mycontext/kernel"
+import type { AuthContext, AuthStatus, ChannelAuth } from "../../types.js"
+
+const CONSENT_FILE = "enabled.json"
+const LOCAL_CORP_ID = "local-machine"
+const LOCAL_USER_ID = "local-user"
+
+export interface CodexLocalAuthOptions {
+  /** 外部记录根目录。通常是 `$CODEX_HOME`，未设置时由宿主传默认目录。 */
+  recordsRoot: () => string
+  /** 当前 vault 内的授权标记目录；未登录时为空串。 */
+  consentRoot: () => string
+}
+
+function markerPath(options: CodexLocalAuthOptions): string | null {
+  const root = options.consentRoot().trim()
+  return root === "" ? null : join(root, CONSENT_FILE)
+}
+
+async function readable(path: string): Promise<boolean> {
+  try {
+    await access(path, constants.R_OK)
+    return true
+  } catch {
+    return false
+  }
+}
+
+function authorizedStatus(): Extract<AuthStatus, { state: "authorized" }> {
+  return {
+    state: "authorized",
+    corpId: LOCAL_CORP_ID,
+    corpName: "本机",
+    userId: LOCAL_USER_ID,
+    userName: "本机用户",
+    accessExpiresAt: null,
+    refreshExpiresAt: null,
+    daysUntilRefreshExpiry: null,
+  }
+}
+
+export class CodexLocalAuth implements ChannelAuth {
+  constructor(private readonly options: CodexLocalAuthOptions) {}
+
+  supportedModes() {
+    return ["loopback" as const]
+  }
+
+  describeStepKeys(): string[] {
+    return ["channels:codex.steps.review", "channels:codex.steps.enable"]
+  }
+
+  async status(): Promise<AuthStatus> {
+    const marker = markerPath(this.options)
+    if (marker === null || !(await readable(marker))) return { state: "unauthorized" }
+    if (!(await readable(this.options.recordsRoot()))) {
+      return {
+        state: "expired",
+        corpName: "本机",
+        userName: "本机用户",
+      }
+    }
+    return authorizedStatus()
+  }
+
+  async login(ctx: AuthContext): Promise<AuthStatus> {
+    ctx.signal.throwIfAborted()
+    ctx.onProgress({ phase: "starting" })
+
+    const recordsRoot = this.options.recordsRoot()
+    if (!(await readable(recordsRoot))) {
+      throw new AppError("CHANNEL_LOCAL_RECORDS_UNAVAILABLE", "找不到可读的本地记录目录", {
+        retryable: false,
+        messageKey: "errors:channel.localRecordsUnavailable",
+      })
+    }
+
+    const marker = markerPath(this.options)
+    if (marker === null) {
+      throw new AppError("CHANNEL_NOT_READY", "请先登录 MyContext 再连接本地记录", {
+        retryable: false,
+        messageKey: "errors:channel.localRecordsNeedLogin",
+      })
+    }
+
+    ctx.signal.throwIfAborted()
+    await mkdir(this.options.consentRoot(), { recursive: true })
+    await writeFile(marker, `${JSON.stringify({ version: 1 })}\n`, {
+      encoding: "utf8",
+      mode: 0o600,
+    })
+    const status = authorizedStatus()
+    ctx.onProgress({ phase: "succeeded", status })
+    return status
+  }
+
+  async logout(): Promise<boolean> {
+    const marker = markerPath(this.options)
+    if (marker === null) return false
+    const existed = await readable(marker)
+    await rm(marker, { force: true })
+    return existed
+  }
+}
+
+export const CODEX_LOCAL_IDENTITY = {
+  userId: LOCAL_USER_ID,
+  openIds: [{ kind: "local_user", value: LOCAL_USER_ID }],
+  displayNames: ["本机用户"],
+  corpId: LOCAL_CORP_ID,
+  corpName: "本机",
+  source: "get-self" as const,
+}
diff --git a/packages/channels/src/plugins/codex-local/index.ts b/packages/channels/src/plugins/codex-local/index.ts
new file mode 100644
index 00000000..972f8de2
--- /dev/null
+++ b/packages/channels/src/plugins/codex-local/index.ts
@@ -0,0 +1,46 @@
+/** 本地编码助手记录：显式授权后，只读采集用户主动输入。 */
+import type { ChannelPlugin } from "../../types.js"
+import { CODEX_LOCAL_IDENTITY, CodexLocalAuth, type CodexLocalAuthOptions } from "./auth.js"
+import { CodexLocalRecordReader, type CodexLocalRecordReaderOptions } from "./records.js"
+
+export interface CodexLocalPluginOptions
+  extends CodexLocalAuthOptions,
+    CodexLocalRecordReaderOptions {}
+
+export function createCodexLocalPlugin(options: CodexLocalPluginOptions): ChannelPlugin {
+  const reader = new CodexLocalRecordReader(options)
+  return {
+    meta: {
+      id: "codex",
+      labelKey: "channels:codex.label",
+      descriptionKey: "channels:codex.description",
+      available: true,
+    },
+    capabilities: {
+      chatTypes: ["direct"],
+      ingest: ["poll"],
+      changeProbe: true,
+      media: false,
+      sendAs: [],
+      domains: ["chat"],
+      isolatedCredentials: true,
+    },
+    auth: new CodexLocalAuth(options),
+    ingest: {
+      probe: async (signal) => await reader.probe(signal),
+      pull: async (spec) => await reader.pull(spec),
+    },
+    identity: {
+      resolveSelf: async () => CODEX_LOCAL_IDENTITY,
+    },
+    conversations: {
+      list: async (signal) => await reader.conversations(signal),
+    },
+    exportProfile: {
+      workspaceId: "workspace:local-coding-agent",
+      workspaceLabel: "本地编码助手",
+      deepLinkScheme: "mycontext",
+      senderIdField: "senderLocalUserId",
+    },
+  }
+}
diff --git a/packages/channels/src/plugins/codex-local/records.ts b/packages/channels/src/plugins/codex-local/records.ts
new file mode 100644
index 00000000..a5bcdbc3
--- /dev/null
+++ b/packages/channels/src/plugins/codex-local/records.ts
@@ -0,0 +1,424 @@
+/**
+ * 本地编码助手会话记录读取器。
+ *
+ * 记录目录可能达到 GB 级，正文读取必须满足三条约束：
+ * 1. 会话目录只读首行元数据，不为了列标题扫描整份文件；
+ * 2. 正文只扫描与请求时间窗相交的文件；
+ * 3. 文件未变化时复用解析结果，避免每两分钟重读历史。
+ *
+ * 只接收 `event_msg.user_message`。系统/开发者提示、模型回答、推理、工具调用和
+ * 命令输出全部排除，既避免把生成内容学成用户事实，也避免把诊断输出带入图库。
+ */
+import { createHash } from "node:crypto"
+import { createReadStream } from "node:fs"
+import { readFile, readdir, stat } from "node:fs/promises"
+import { join } from "node:path"
+import { createInterface } from "node:readline"
+import { AppError } from "@mycontext/kernel"
+import type {
+  ChannelConversationItem,
+  ChannelConversationList,
+  ChannelPullPage,
+  ChannelPullSpec,
+  ParsedConversationLike,
+  ParsedMessageLike,
+} from "../../types.js"
+
+const SESSION_SUFFIX = ".jsonl"
+const CURSOR_KIND = "codex-local-v1"
+const TITLE_LIMIT = 80
+const CATALOG_CONCURRENCY = 32
+const MESSAGE_CONCURRENCY = 4
+
+interface SessionCatalogEntry {
+  id: string
+  path: string
+  title: string
+  createdAt: number
+  updatedAt: number
+  size: number
+}
+
+interface ParsedUserMessage {
+  externalId: string
+  conversationExternalId: string
+  text: string
+  sentAt: number
+}
+
+interface CachedMessages {
+  size: number
+  updatedAt: number
+  messages: ParsedUserMessage[]
+}
+
+interface CursorValue {
+  kind: typeof CURSOR_KIND
+  sentAt: number
+  externalId: string
+}
+
+export interface CodexLocalRecordReaderOptions {
+  recordsRoot: () => string
+}
+
+function object(value: unknown): Record<string, unknown> {
+  return typeof value === "object" && value !== null ? (value as Record<string, unknown>) : {}
+}
+
+function parseJson(line: string): Record<string, unknown> | null {
+  try {
+    return object(JSON.parse(line) as unknown)
+  } catch {
+    return null
+  }
+}
+
+function timestamp(value: unknown): number | null {
+  if (typeof value !== "string") return null
+  const parsed = Date.parse(value)
+  return Number.isFinite(parsed) ? parsed : null
+}
+
+function compactTitle(value: string): string {
+  const compact = value.replace(/\s+/g, " ").trim()
+  return compact.length <= TITLE_LIMIT ? compact : `${compact.slice(0, TITLE_LIMIT - 1)}…`
+}
+
+function messageId(sessionId: string, sentAt: number, text: string, duplicate: number): string {
+  const digest = createHash("sha256")
+    .update(sessionId)
+    .update("\0")
+    .update(String(sentAt))
+    .update("\0")
+    .update(text)
+    .update("\0")
+    .update(String(duplicate))
+    .digest("hex")
+    .slice(0, 32)
+  return `codex-msg-${digest}`
+}
+
+function encodeCursor(value: CursorValue): string {
+  return Buffer.from(JSON.stringify(value), "utf8").toString("base64url")
+}
+
+function decodeCursor(value: string | null): CursorValue | null {
+  if (value === null) return null
+  try {
+    const parsed = object(JSON.parse(Buffer.from(value, "base64url").toString("utf8")) as unknown)
+    if (
+      parsed["kind"] !== CURSOR_KIND ||
+      typeof parsed["sentAt"] !== "number" ||
+      typeof parsed["externalId"] !== "string"
+    ) {
+      return null
+    }
+    return {
+      kind: CURSOR_KIND,
+      sentAt: parsed["sentAt"],
+      externalId: parsed["externalId"],
+    }
+  } catch {
+    return null
+  }
+}
+
+function afterCursor(message: ParsedUserMessage, cursor: CursorValue | null): boolean {
+  if (cursor === null) return true
+  if (message.sentAt !== cursor.sentAt) return message.sentAt > cursor.sentAt
+  return message.externalId > cursor.externalId
+}
+
+async function mapConcurrent<T, R>(
+  values: readonly T[],
+  concurrency: number,
+  transform: (value: T) => Promise<R>,
+): Promise<R[]> {
+  const result = new Array<R>(values.length)
+  let next = 0
+  const worker = async (): Promise<void> => {
+    while (next < values.length) {
+      const index = next
+      next += 1
+      const value = values[index]
+      if (value !== undefined) result[index] = await transform(value)
+    }
+  }
+  await Promise.all(
+    Array.from({ length: Math.min(concurrency, values.length) }, async () => await worker()),
+  )
+  return result
+}
+
+async function filesBelow(root: string): Promise<string[]> {
+  const found: string[] = []
+  const walk = async (dir: string): Promise<void> => {
+    let entries
+    try {
+      entries = await readdir(dir, { withFileTypes: true })
+    } catch (error) {
+      const code = object(error)["code"]
+      if (code === "ENOENT") return
+      throw error
+    }
+    for (const entry of entries) {
+      const path = join(dir, entry.name)
+      if (entry.isDirectory()) await walk(path)
+      else if (entry.isFile() && entry.name.endsWith(SESSION_SUFFIX)) found.push(path)
+    }
+  }
+  await walk(root)
+  return found
+}
+
+async function firstLine(path: string, signal?: AbortSignal): Promise<string | null> {
+  signal?.throwIfAborted()
+  const lines = createInterface({
+    input: createReadStream(path, { encoding: "utf8" }),
+    crlfDelay: Infinity,
+  })
+  try {
+    for await (const line of lines) {
+      signal?.throwIfAborted()
+      return line
+    }
+    return null
+  } finally {
+    lines.close()
+  }
+}
+
+async function indexedTitles(root: string): Promise<Map<string, string>> {
+  const titles = new Map<string, string>()
+  try {
+    const body = await readFile(join(root, "session_index.jsonl"), "utf8")
+    for (const line of body.split("\n")) {
+      if (line.trim() === "") continue
+      const row = parseJson(line)
+      const id = row?.["id"]
+      const title = row?.["thread_name"]
+      if (typeof id === "string" && typeof title === "string" && title.trim() !== "") {
+        titles.set(id, compactTitle(title))
+      }
+    }
+  } catch (error) {
+    if (object(error)["code"] !== "ENOENT") throw error
+  }
+  return titles
+}
+
+function sessionMeta(line: string | null): { id: string; createdAt: number } | null {
+  if (line === null) return null
+  const row = parseJson(line)
+  if (row?.["type"] !== "session_meta") return null
+  const payload = object(row["payload"])
+  /**
+   * `id` 是任务主键；`session_id` 在新版本里可能被一组派生任务共享。
+   * 反过来优先会把数百个文件折叠成两百多个“会话”，实机探针抓到过。
+   */
+  const id = payload["id"] ?? payload["session_id"]
+  const createdAt = timestamp(payload["timestamp"]) ?? timestamp(row["timestamp"])
+  if (typeof id !== "string" || createdAt === null) return null
+  return { id, createdAt }
+}
+
+export class CodexLocalRecordReader {
+  private readonly cache = new Map<string, CachedMessages>()
+
+  constructor(private readonly options: CodexLocalRecordReaderOptions) {}
+
+  async conversations(signal?: AbortSignal): Promise<ChannelConversationList> {
+    const catalog = await this.catalog(signal)
+    return {
+      items: catalog
+        .map<ChannelConversationItem>((entry) => ({
+          externalId: entry.id,
+          title: entry.title,
+          kind: "direct",
+          memberCount: 2,
+          lastMessageAt: entry.updatedAt,
+        }))
+        .sort((left, right) => (right.lastMessageAt ?? 0) - (left.lastMessageAt ?? 0)),
+      truncated: false,
+    }
+  }
+
+  async probe(signal?: AbortSignal) {
+    const catalog = await this.catalog(signal)
+    return {
+      conversations: catalog.map((entry) => ({
+        externalId: entry.id,
+        lastMsgAt: entry.updatedAt,
+        unreadCount: null,
+      })),
+    }
+  }
+
+  async pull(spec: ChannelPullSpec): Promise<ChannelPullPage> {
+    spec.signal?.throwIfAborted()
+    const catalog = await this.catalog(spec.signal)
+    const candidates = catalog.filter(
+      (entry) => entry.createdAt <= spec.end && entry.updatedAt >= spec.start,
+    )
+    const messages = (
+      await mapConcurrent(
+        candidates,
+        MESSAGE_CONCURRENCY,
+        async (entry) => await this.messages(entry, spec.signal),
+      )
+    )
+      .flat()
+      .filter((message) => message.sentAt >= spec.start && message.sentAt <= spec.end)
+      .sort((left, right) =>
+        left.sentAt === right.sentAt
+          ? left.externalId.localeCompare(right.externalId)
+          : left.sentAt - right.sentAt,
+      )
+
+    const cursor = decodeCursor(spec.cursor)
+    const remaining = messages.filter((message) => afterCursor(message, cursor))
+    const pageMessages = remaining.slice(0, Math.max(1, spec.limit))
+    const hasMore = remaining.length > pageMessages.length
+    const last = pageMessages.at(-1)
+    const nextCursor =
+      hasMore && last !== undefined
+        ? encodeCursor({ kind: CURSOR_KIND, sentAt: last.sentAt, externalId: last.externalId })
+        : null
+    const byId = new Map(catalog.map((entry) => [entry.id, entry]))
+    const conversationIds = new Set(pageMessages.map((message) => message.conversationExternalId))
+    const conversations: ParsedConversationLike[] = [...conversationIds].map((id) => ({
+      externalId: id,
+      title: byId.get(id)?.title ?? null,
+      type: "direct",
+      memberCount: 2,
+    }))
+    const normalized: ParsedMessageLike[] = pageMessages.map((message) => ({
+      externalId: message.externalId,
+      conversationExternalId: message.conversationExternalId,
+      senderExternalId: "local-user",
+      senderDisplayName: "本机用户",
+      contentText: message.text,
+      contentJson: null,
+      quotedExternalId: null,
+      sentAt: message.sentAt,
+      mentions: [],
+      hasMedia: false,
+    }))
+
+    return {
+      conversations,
+      messages: normalized,
+      nextCursor,
+      hasMore,
+      itemCount: normalized.length,
+      /** 只保留已经通过角色过滤的最小重放形状，绝不复制整份外部会话。 */
+      rawPayload: JSON.stringify({
+        kind: CURSOR_KIND,
+        messages: normalized.map((message) => ({
+          externalId: message.externalId,
+          conversationExternalId: message.conversationExternalId,
+          contentText: message.contentText,
+          sentAt: message.sentAt,
+        })),
+      }),
+    }
+  }
+
+  private async catalog(signal?: AbortSignal): Promise<SessionCatalogEntry[]> {
+    signal?.throwIfAborted()
+    const root = this.options.recordsRoot()
+    const titles = await indexedTitles(root)
+    let paths: string[]
+    try {
+      paths = [
+        ...(await filesBelow(join(root, "sessions"))),
+        ...(await filesBelow(join(root, "archived_sessions"))),
+      ]
+    } catch (error) {
+      throw new AppError("CHANNEL_LOCAL_RECORDS_UNAVAILABLE", "读取本地会话目录失败", {
+        cause: error,
+        messageKey: "errors:channel.localRecordsReadFailed",
+      })
+    }
+
+    const current = new Set(paths)
+    for (const path of this.cache.keys()) {
+      if (!current.has(path)) this.cache.delete(path)
+    }
+
+    const rows = await mapConcurrent(
+      paths,
+      CATALOG_CONCURRENCY,
+      async (path): Promise<SessionCatalogEntry | null> => {
+        signal?.throwIfAborted()
+        try {
+          const [info, line] = await Promise.all([stat(path), firstLine(path, signal)])
+          const meta = sessionMeta(line)
+          if (meta === null) return null
+          const fallback = `本地任务 · ${new Date(meta.createdAt).toISOString().slice(0, 10)}`
+          return {
+            id: meta.id,
+            path,
+            title: titles.get(meta.id) ?? fallback,
+            createdAt: meta.createdAt,
+            updatedAt: info.mtimeMs,
+            size: info.size,
+          }
+        } catch (error) {
+          if (object(error)["code"] === "ENOENT") return null
+          throw error
+        }
+      },
+    )
+    const byId = new Map<string, SessionCatalogEntry>()
+    for (const row of rows) {
+      if (row === null) continue
+      const previous = byId.get(row.id)
+      if (previous === undefined || row.updatedAt >= previous.updatedAt) byId.set(row.id, row)
+    }
+    return [...byId.values()]
+  }
+
+  private async messages(
+    entry: SessionCatalogEntry,
+    signal?: AbortSignal,
+  ): Promise<ParsedUserMessage[]> {
+    const cached = this.cache.get(entry.path)
+    if (cached?.size === entry.size && cached.updatedAt === entry.updatedAt) return cached.messages
+
+    const messages: ParsedUserMessage[] = []
+    const duplicates = new Map<string, number>()
+    const lines = createInterface({
+      input: createReadStream(entry.path, { encoding: "utf8" }),
+      crlfDelay: Infinity,
+    })
+    try {
+      for await (const line of lines) {
+        signal?.throwIfAborted()
+        const row = parseJson(line)
+        if (row?.["type"] !== "event_msg") continue
+        const payload = object(row["payload"])
+        if (payload["type"] !== "user_message") continue
+        const text = payload["message"]
+        const sentAt = timestamp(row["timestamp"])
+        if (typeof text !== "string" || text.trim() === "" || sentAt === null) continue
+        const duplicateKey = `${sentAt}\0${text}`
+        const duplicate = duplicates.get(duplicateKey) ?? 0
+        duplicates.set(duplicateKey, duplicate + 1)
+        messages.push({
+          externalId: messageId(entry.id, sentAt, text, duplicate),
+          conversationExternalId: entry.id,
+          text,
+          sentAt,
+        })
+      }
+    } catch (error) {
+      if (object(error)["code"] !== "ENOENT") throw error
+    } finally {
+      lines.close()
+    }
+    this.cache.set(entry.path, { size: entry.size, updatedAt: entry.updatedAt, messages })
+    return messages
+  }
+}
diff --git a/packages/channels/src/types.ts b/packages/channels/src/types.ts
index 4c5af465..e2ac23e2 100644
--- a/packages/channels/src/types.ts
+++ b/packages/channels/src/types.ts
@@ -9,7 +9,7 @@
  */
 import type { Clock } from "@mycontext/kernel"
 
-export type ChannelId = "dingtalk" | "feishu"
+export type ChannelId = "dingtalk" | "feishu" | "codex"
 
 /**
  * 渠道元信息。
@@ -161,6 +161,8 @@ export interface AuthContext {
 }
 
 export interface ChannelAuth {
+  /** 渠道实际支持的授权入口；缺省保持历史行为（loopback + device）。 */
+  supportedModes?(): AuthMode[]
   /** 供 UI 展示的授权步骤说明的 i18n key（各渠道方式不同，由插件自己描述） */
   describeStepKeys(): string[]
   status(): Promise<AuthStatus>
diff --git a/packages/i18n/src/locales/en/channels.json b/packages/i18n/src/locales/en/channels.json
index 8849ad24..47ffad43 100644
--- a/packages/i18n/src/locales/en/channels.json
+++ b/packages/i18n/src/locales/en/channels.json
@@ -18,6 +18,14 @@
       "backToApp": "Return to the app; Lark content will enter the local database and knowledge graph"
     }
   },
+  "codex": {
+    "label": "Local Codex",
+    "description": "Read-only access to text you entered in local Codex tasks for the graph and search.",
+    "steps": {
+      "review": "Confirm that only text you submitted is collected; reasoning, tool output and system prompts are excluded",
+      "enable": "Click Authorize to enable local read-only collection for this MyContext account"
+    }
+  },
   "state": {
     "authorized": "Connected",
     "expired": "Expired",
@@ -93,14 +101,16 @@
     "machineSessionHint": "This computer already has a DingTalk session (sessions are shared across logins on the same machine). Authorize once for the current account so we know who you are — otherwise learning would use the wrong identity.",
     "accountTitle": "Connected account",
     "scopeTitle": "What you're authorizing",
-    "machineSessionHintFeishu": "Lark is authorized in this app. Confirm the identity once for this account so learning attributes messages to you."
+    "machineSessionHintFeishu": "Lark is authorized in this app. Confirm the identity once for this account so learning attributes messages to you.",
+    "machineSessionHintCodex": "Local Codex records are enabled for this account."
   },
   "settings": {
     "expiredHint": "Authorization expired — you'll need to scan again",
     "expiryWarning": "This authorization expires in {{days}} days. Re-authorizing now is a good idea.",
     "identityMismatch": "Identity misconfigured: this data is bound to \"{{boundCorp}}\", but the channel config directory currently resolves to \"{{channelCorp}}\". These should always match (each identity keeps its own data and config) — re-authorize to \"{{boundCorp}}\" to restore it, or switch to \"{{channelCorp}}\" and its own data.",
     "sharedCredentialNote": "The official DingTalk CLI stores credentials in your system keychain, shared with the CLI in your terminal. To clear them completely, run <1>{{command}}</1> in a terminal.",
-    "feishuCredentialNote": "Lark credentials are isolated inside this app's user directory and do not reuse your terminal CLI session. To clear them, run <1>{{command}}</1> in the app's isolated environment."
+    "feishuCredentialNote": "Lark credentials are isolated inside this app's user directory and do not reuse your terminal CLI session. To clear them, run <1>{{command}}</1> in the app's isolated environment.",
+    "codexCredentialNote": "Read-only access is isolated per MyContext account. Signing out stops collection without changing or deleting any Codex records."
   },
   "progress": {
     "browserOpened": "{{channel}} sign-in opened — scan the code to continue",
@@ -116,6 +126,14 @@
     "credentialsTitle": "Isolated authorization directory",
     "credentialsDescription": "The official Lark CLI handles authorization; credentials stay inside this app's isolated user directory."
   },
+  "codexScope": {
+    "readTitle": "Reads only your input",
+    "readDescription": "Reads only text you submitted in local Codex tasks and honors the selected time and task scope.",
+    "noSpeakTitle": "Generated and execution records stay out",
+    "noSpeakDescription": "Model answers, reasoning, system prompts, tool calls, command output and attachments are excluded.",
+    "credentialsTitle": "Explicitly enabled per account",
+    "credentialsDescription": "Message bodies are not scanned before authorization; consent stays in this account's vault."
+  },
   "avatarMiss": {
     "notPermitted": "This channel client lacks contacts permission, so avatars cannot be fetched — switch to a client that has it under \"custom client\" below.",
     "notSet": "This account has no avatar set on the platform.",
diff --git a/packages/i18n/src/locales/en/errors.json b/packages/i18n/src/locales/en/errors.json
index 3df8de9e..f752d6a6 100644
--- a/packages/i18n/src/locales/en/errors.json
+++ b/packages/i18n/src/locales/en/errors.json
@@ -11,7 +11,10 @@
     "authInProgress": "This channel is already being authorized",
     "authFailed": "Authorization failed: {{detail}}",
     "authNotDetected": "The authorization flow finished but no valid session was found — please try again",
-    "authLegacyTokenSlot": "This machine already has a legacy session that the channel CLI refuses to overwrite (it may be the only copy of a login you use in your terminal). Run a one-time login with your identity in a terminal to migrate it: dws auth login --profile <your org corpId>"
+    "authLegacyTokenSlot": "This machine already has a legacy session that the channel CLI refuses to overwrite (it may be the only copy of a login you use in your terminal). Run a one-time login with your identity in a terminal to migrate it: dws auth login --profile <your org corpId>",
+    "localRecordsUnavailable": "No readable local Codex records directory was found. Use Codex locally first or set CODEX_HOME correctly.",
+    "localRecordsNeedLogin": "Sign in to MyContext before enabling local Codex records for this account.",
+    "localRecordsReadFailed": "Local Codex records could not be read. Check directory permissions and try again."
   },
   "process": {
     "spawnFailed": "Could not start the required program",
@@ -68,6 +71,7 @@
     "INTERNAL": "Something unexpected went wrong",
     "CHANNEL_CLIENT_NOT_AUTHORIZED": "The current channel client is not authorized for this enterprise (not a login problem — re-scanning will not help). Switch clients in Settings: the bundled one and your own have different capabilities.",
     "CHANNEL_NOT_READY": "Channel is not ready yet; sign in and try again",
+    "CHANNEL_LOCAL_RECORDS_UNAVAILABLE": "The local Codex records directory is missing or unreadable",
     "CHANNEL_PIPELINE_NO_PORT": "No free local port available to start the graph service"
   }
 }
diff --git a/packages/i18n/src/locales/zh/channels.json b/packages/i18n/src/locales/zh/channels.json
index ed15e14c..82707964 100644
--- a/packages/i18n/src/locales/zh/channels.json
+++ b/packages/i18n/src/locales/zh/channels.json
@@ -18,6 +18,14 @@
       "backToApp": "授权完成后回到应用，飞书内容会进入本地数据库和知识图谱"
     }
   },
+  "codex": {
+    "label": "本地 Codex",
+    "description": "只读接入你在本机 Codex 中主动输入的内容，用于本地建图与检索。",
+    "steps": {
+      "review": "确认仅采集你主动输入的文字，不读取模型推理、工具输出或系统提示",
+      "enable": "点击「开始授权」后，为当前 MyContext 账号开启本地只读采集"
+    }
+  },
   "state": {
     "authorized": "已连接",
     "expired": "已过期",
@@ -93,14 +101,16 @@
     "machineSessionHint": "这台电脑上已有钉钉登录态（同一台电脑的登录会共用）。为当前账号授权一次，才能确定「你」是谁 —— 否则学习会用错身份。",
     "accountTitle": "已连接的账号",
     "scopeTitle": "授权范围",
-    "machineSessionHintFeishu": "已在本应用完成飞书授权。为当前账号确认一次身份，才能确定「你」是谁 —— 否则学习会用错身份。"
+    "machineSessionHintFeishu": "已在本应用完成飞书授权。为当前账号确认一次身份，才能确定「你」是谁 —— 否则学习会用错身份。",
+    "machineSessionHintCodex": "已允许读取当前账号的本地 Codex 记录。"
   },
   "settings": {
     "expiredHint": "授权已过期，需要重新扫码",
     "expiryWarning": "授权将在 {{days}} 天后过期，建议现在重新授权。",
     "identityMismatch": "身份配置异常：这份数据绑定的是「{{boundCorp}}」，而渠道配置目录里当前生效的是「{{channelCorp}}」。正常情况下两者应当一致（每个身份有自己独立的一份数据与配置）—— 请重新授权到「{{boundCorp}}」把它恢复，或切换到「{{channelCorp}}」自己的那份数据。",
     "sharedCredentialNote": "授权凭据由钉钉官方 CLI 保存在系统钥匙串，与你在终端里的登录态共用。如需彻底清除，请在终端执行 <1>{{command}}</1>。",
-    "feishuCredentialNote": "飞书凭据隔离保存在本应用用户目录，不复用你终端的默认 CLI 登录态。如需清除，请在应用对应的隔离环境执行 <1>{{command}}</1>。"
+    "feishuCredentialNote": "飞书凭据隔离保存在本应用用户目录，不复用你终端的默认 CLI 登录态。如需清除，请在应用对应的隔离环境执行 <1>{{command}}</1>。",
+    "codexCredentialNote": "只读权限按当前 MyContext 账号隔离保存；退出授权只会停止读取，不会修改或删除任何 Codex 记录。"
   },
   "progress": {
     "browserOpened": "已打开{{channel}}登录页，请扫码确认",
@@ -116,6 +126,14 @@
     "credentialsTitle": "授权目录独立隔离",
     "credentialsDescription": "授权由飞书官方 CLI 完成，凭据只保存在本应用的独立用户目录。"
   },
+  "codexScope": {
+    "readTitle": "只读用户输入",
+    "readDescription": "仅读取你在本机 Codex 任务中主动提交的文字，并遵守所选时间与任务范围。",
+    "noSpeakTitle": "排除生成与执行记录",
+    "noSpeakDescription": "模型回答、推理、系统提示、工具调用、命令输出和附件不会进入 MyContext。",
+    "credentialsTitle": "按账号显式开启",
+    "credentialsDescription": "未授权时不会扫描正文；授权标记保存在当前账号自己的 vault 中。"
+  },
   "avatarMiss": {
     "notPermitted": "当前渠道客户端没有通讯录权限，取不到头像 —— 在下面「自备客户端」里换一份有权限的即可。",
     "notSet": "这个账号在平台上没有设置头像。",
diff --git a/packages/i18n/src/locales/zh/errors.json b/packages/i18n/src/locales/zh/errors.json
index 28226d47..88ece599 100644
--- a/packages/i18n/src/locales/zh/errors.json
+++ b/packages/i18n/src/locales/zh/errors.json
@@ -11,7 +11,10 @@
     "authInProgress": "该渠道正在授权中",
     "authFailed": "授权失败：{{detail}}",
     "authNotDetected": "授权流程结束但未检测到有效登录态，请重试",
-    "authLegacyTokenSlot": "本机已有一份旧格式的登录态，渠道 CLI 拒绝覆盖它（怕误删你终端里在用的登录）。请在终端执行一次带身份的登录完成迁移：dws auth login --profile <你的组织 corpId>"
+    "authLegacyTokenSlot": "本机已有一份旧格式的登录态，渠道 CLI 拒绝覆盖它（怕误删你终端里在用的登录）。请在终端执行一次带身份的登录完成迁移：dws auth login --profile <你的组织 corpId>",
+    "localRecordsUnavailable": "找不到可读的本地 Codex 记录目录。请确认 Codex 已在本机使用过，或正确设置 CODEX_HOME。",
+    "localRecordsNeedLogin": "请先登录 MyContext，再为当前账号开启本地 Codex 记录。",
+    "localRecordsReadFailed": "读取本地 Codex 记录失败，请检查目录权限后重试。"
   },
   "process": {
     "spawnFailed": "无法启动所需的程序",
@@ -68,6 +71,7 @@
     "INTERNAL": "出现了未预期的问题",
     "CHANNEL_CLIENT_NOT_AUTHORIZED": "当前渠道客户端对这个企业没有开通所需能力（不是登录问题，重新扫码无效）。请到设置里换一份客户端：内置那份与自备那份开通的能力不同。",
     "CHANNEL_NOT_READY": "渠道尚未就绪，请先登录后重试",
+    "CHANNEL_LOCAL_RECORDS_UNAVAILABLE": "本地 Codex 记录目录不存在或不可读",
     "CHANNEL_PIPELINE_NO_PORT": "本机没有可用端口来启动图谱服务"
   }
 }
diff --git a/packages/ipc-contract/src/contract.ts b/packages/ipc-contract/src/contract.ts
index 6e4ff816..bc98f591 100644
--- a/packages/ipc-contract/src/contract.ts
+++ b/packages/ipc-contract/src/contract.ts
@@ -2147,6 +2147,8 @@ export const channelSummarySchema = z.object({
   available: z.boolean(),
   /** 授权步骤说明的 i18n key 列表，各渠道自述 */
   stepKeys: z.array(z.string()),
+  /** 渠道支持的授权入口；旧主进程缺失时 UI 保持原来的双入口。 */
+  authModes: z.array(authModeSchema).optional(),
   status: authStatusSchema,
   /** 是否正在授权中（用于 UI 禁用按钮与显示进度） */
   loginInProgress: z.boolean(),
@@ -2182,6 +2184,8 @@ export const channelSummarySchema = z.object({
      * 那一档（保守方向 —— 宁可少个入口，也不要在共用登录态的渠道上误退）。
      */
     isolatedCredentials: z.boolean().optional(),
+    /** 是否真的实现头像读取；缺省 false，避免新渠道出现一个必失败的刷新按钮。 */
+    avatars: z.boolean().optional(),
   }),
 })
 
diff --git a/packages/kernel/src/errors.ts b/packages/kernel/src/errors.ts
index e75f8ddb..95556399 100644
--- a/packages/kernel/src/errors.ts
+++ b/packages/kernel/src/errors.ts
@@ -42,6 +42,8 @@ export const ERROR_CODES = [
   "CHANNEL_UNSUPPORTED",
   /** 渠道的资源还没就绪（如凭据目录尚未随 vault 挂载）。接线漏了，不是用户错误。 */
   "CHANNEL_NOT_READY",
+  /** 用户显式开启的本地记录目录不存在、不可读或读取失败。 */
+  "CHANNEL_LOCAL_RECORDS_UNAVAILABLE",
   /** 找不到可用的 kl 端口（本机端口被占满）。 */
   "CHANNEL_PIPELINE_NO_PORT",
   // 数据面：解析与身份
diff --git a/packages/store/src/vault.ts b/packages/store/src/vault.ts
index 72ad00dd..043eefb3 100644
--- a/packages/store/src/vault.ts
+++ b/packages/store/src/vault.ts
@@ -63,6 +63,8 @@ export interface VaultPaths {
    * 关在这个目录里（见 `LarkCli.env()` 里那套 HOME/XDG 重定向）。
    */
   feishuAuthRoot: string
+  /** 本地编码助手记录的按 vault 授权标记；只存同意状态，不复制外部记录。 */
+  codexAuthRoot: string
 }
 
 export class VaultStore {
@@ -244,6 +246,7 @@ export class VaultStore {
        */
       dwsHome: join(root, "channels", "dingtalk", "dws-home"),
       feishuAuthRoot: join(root, "channels", "feishu"),
+      codexAuthRoot: join(root, "channels", "codex"),
     }
   }
 
diff --git a/tests/renderer/ui-regressions.test.ts b/tests/renderer/ui-regressions.test.ts
index b87ca5cc..74bc713a 100644
--- a/tests/renderer/ui-regressions.test.ts
+++ b/tests/renderer/ui-regressions.test.ts
@@ -128,13 +128,15 @@ describe("② 设置导航扁平 + 全局渠道切换", () => {
   })
 })
 
-describe("③ 钉钉也有刷新头像按钮", () => {
-  it("★★★ 刷新头像按钮不被 isolatedCredentials 挡住", () => {
+describe("③ 有头像能力的已连接渠道才显示刷新头像按钮", () => {
+  it("★★★ 刷新头像按钮由连接状态与 avatars 能力共同控制", () => {
     /**
      * 用户原话：「钉钉渠道那边得要有个刷新头像的按钮吧」。
      *
      * 它原来挂在只有飞书成立的 `isolatedCredentials` 分支里，所以钉钉看不到。
-     * 判据：按钮的显示条件是 `accountConnected`（两个渠道都成立）。
+     * 判据：按钮的显示条件包含 `accountConnected`，并且只对明确声明
+     * `avatars` 能力的渠道开放。这样钉钉/飞书仍可见，本地只读渠道不会出现
+     * 一个永远无法工作的按钮。
      *
      * 反证：把条件改回 `isolatedCredentials` → 转红。
      */
@@ -146,8 +148,8 @@ describe("③ 钉钉也有刷新头像按钮", () => {
      * `accountConnected`（失败态判据、按钮文案三元），随便一个都能命中。
      * 剥注释也不够，因为它们是真代码而不是注释。
      *
-     * 所以改成：从按钮往前找**最近的** `? (` 分支开头，断言它就是
-     * `{accountConnected ? (`。
+     * 所以改成：从按钮往前找**最近的** `? (` 分支开头，断言它就是连接态
+     * 与能力的联合门控。
      *
      * 反证：把那一行换成 `{isolatedCredentials ? (` → 转红（已实测）。
      */
@@ -160,7 +162,7 @@ describe("③ 钉钉也有刷新头像按钮", () => {
     const gateAt = before.lastIndexOf("? (")
     const gateLineStart = before.lastIndexOf("{", gateAt)
     const gate = before.slice(gateLineStart, gateAt + 3).replace(/\s+/g, " ")
-    expect(gate).toBe("{accountConnected ? (")
+    expect(gate).toBe("{accountConnected && channel.capabilities?.avatars === true ? (")
   })
 })
 
diff --git a/tests/unit/channels/codex-local.test.ts b/tests/unit/channels/codex-local.test.ts
new file mode 100644
index 00000000..9e676b22
--- /dev/null
+++ b/tests/unit/channels/codex-local.test.ts
@@ -0,0 +1,252 @@
+/**
+ * 本地 Codex 通道：只收用户输入，并且授权按 vault 显式保存。
+ *
+ * fixture 只保留真实 JSONL 的字段形状，所有 id、标题和正文均为编造值。
+ */
+import { appendFile, mkdir, writeFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { mkdtempSync } from "node:fs"
+import { describe, expect, it, vi } from "vitest"
+import { createCodexLocalPlugin } from "@mycontext/channels"
+import { isAppError } from "@mycontext/kernel"
+
+const FIRST_AT = Date.parse("2026-08-20T08:00:00.000Z")
+const SECOND_AT = Date.parse("2026-08-20T09:00:00.000Z")
+
+function line(value: unknown): string {
+  return `${JSON.stringify(value)}\n`
+}
+
+function sessionMeta(id: string, at: number): string {
+  return line({
+    timestamp: new Date(at).toISOString(),
+    type: "session_meta",
+    payload: {
+      id,
+      session_id: id,
+      timestamp: new Date(at).toISOString(),
+      cwd: "/workspace/example",
+      cli_version: "0.0.0-test",
+    },
+  })
+}
+
+function sessionMetaWithSharedSession(id: string, sharedSessionId: string, at: number): string {
+  return line({
+    timestamp: new Date(at).toISOString(),
+    type: "session_meta",
+    payload: {
+      id,
+      session_id: sharedSessionId,
+      timestamp: new Date(at).toISOString(),
+      cwd: "/workspace/example",
+      cli_version: "0.0.0-test",
+    },
+  })
+}
+
+function userMessage(text: string, at: number): string {
+  return line({
+    timestamp: new Date(at).toISOString(),
+    type: "event_msg",
+    payload: { type: "user_message", message: text, images: [], local_images: [] },
+  })
+}
+
+function excludedRecords(at: number): string {
+  return [
+    line({
+      timestamp: new Date(at).toISOString(),
+      type: "response_item",
+      payload: {
+        type: "message",
+        role: "user",
+        content: [{ type: "input_text", text: "FAKE_ENVIRONMENT_SECRET" }],
+      },
+    }),
+    line({
+      timestamp: new Date(at).toISOString(),
+      type: "response_item",
+      payload: {
+        type: "message",
+        role: "assistant",
+        content: [{ type: "output_text", text: "FAKE_MODEL_ANSWER" }],
+      },
+    }),
+    line({
+      timestamp: new Date(at).toISOString(),
+      type: "response_item",
+      payload: { type: "custom_tool_call_output", output: "FAKE_COMMAND_OUTPUT" },
+    }),
+  ].join("")
+}
+
+async function fixture() {
+  const root = mkdtempSync(join(tmpdir(), "mycontext-codex-local-"))
+  const sessions = join(root, "sessions", "2026", "08", "20")
+  const archived = join(root, "archived_sessions")
+  await mkdir(sessions, { recursive: true })
+  await mkdir(archived, { recursive: true })
+  await writeFile(
+    join(root, "session_index.jsonl"),
+    line({ id: "session-active-fake", thread_name: "重构本地索引", updated_at: "fake" }),
+  )
+  const activePath = join(sessions, "rollout-active-fake.jsonl")
+  await writeFile(
+    activePath,
+    [
+      sessionMeta("session-active-fake", FIRST_AT),
+      excludedRecords(FIRST_AT + 1),
+      userMessage("请整理这个模块的边界", FIRST_AT + 2),
+    ].join(""),
+  )
+  await writeFile(
+    join(archived, "rollout-archived-fake.jsonl"),
+    [
+      sessionMeta("session-archived-fake", SECOND_AT),
+      userMessage("归档任务里的输入", SECOND_AT + 2),
+    ].join(""),
+  )
+  return { root, activePath }
+}
+
+function pluginFor(root: string, consentRoot = "") {
+  return createCodexLocalPlugin({
+    recordsRoot: () => root,
+    consentRoot: () => consentRoot,
+  })
+}
+
+describe("CodexLocalRecordReader", () => {
+  it("列出活跃与归档任务，活跃任务使用本地索引标题", async () => {
+    const { root } = await fixture()
+    const plugin = pluginFor(root)
+
+    const result = await plugin.conversations!.list()
+
+    expect(result.truncated).toBe(false)
+    expect(result.items).toHaveLength(2)
+    expect(result.items.find((item) => item.externalId === "session-active-fake")?.title).toBe(
+      "重构本地索引",
+    )
+    expect(result.items.find((item) => item.externalId === "session-archived-fake")?.title).toMatch(
+      /^本地任务/,
+    )
+  })
+
+  it("优先使用任务 id，不能把共享 session_id 的派生任务折叠", async () => {
+    const root = mkdtempSync(join(tmpdir(), "mycontext-codex-shared-session-"))
+    const sessions = join(root, "sessions")
+    await mkdir(sessions, { recursive: true })
+    await writeFile(
+      join(sessions, "rollout-a.jsonl"),
+      sessionMetaWithSharedSession("task-a-fake", "shared-session-fake", FIRST_AT),
+    )
+    await writeFile(
+      join(sessions, "rollout-b.jsonl"),
+      sessionMetaWithSharedSession("task-b-fake", "shared-session-fake", SECOND_AT),
+    )
+    const plugin = pluginFor(root)
+
+    const result = await plugin.conversations!.list()
+
+    expect(result.items.map((item) => item.externalId).sort()).toEqual([
+      "task-a-fake",
+      "task-b-fake",
+    ])
+  })
+
+  it("只采 event_msg.user_message，排除环境注入、模型回答与工具输出", async () => {
+    const { root } = await fixture()
+    const plugin = pluginFor(root)
+
+    const page = await plugin.ingest.pull({
+      start: FIRST_AT,
+      end: SECOND_AT - 1,
+      cursor: null,
+      limit: 20,
+    })
+
+    expect(page.messages.map((message) => message.contentText)).toEqual(["请整理这个模块的边界"])
+    expect(page.messages[0]?.senderExternalId).toBe("local-user")
+    expect(page.rawPayload).not.toContain("FAKE_ENVIRONMENT_SECRET")
+    expect(page.rawPayload).not.toContain("FAKE_MODEL_ANSWER")
+    expect(page.rawPayload).not.toContain("FAKE_COMMAND_OUTPUT")
+  })
+
+  it("游标按时间与稳定消息 id 翻页，文件追加后缓存会失效", async () => {
+    const { root, activePath } = await fixture()
+    const plugin = pluginFor(root)
+    const window = { start: FIRST_AT, end: SECOND_AT + 10_000, limit: 1 }
+
+    const first = await plugin.ingest.pull({ ...window, cursor: null })
+    expect(first.hasMore).toBe(true)
+    expect(first.nextCursor).not.toBeNull()
+
+    const second = await plugin.ingest.pull({ ...window, cursor: first.nextCursor })
+    expect(second.messages.map((message) => message.contentText)).toEqual(["归档任务里的输入"])
+
+    await appendFile(activePath, userMessage("追加的一轮输入", SECOND_AT + 3))
+    const afterAppend = await plugin.ingest.pull({
+      start: SECOND_AT + 3,
+      end: SECOND_AT + 10_000,
+      limit: 1,
+      cursor: null,
+    })
+    expect(afterAppend.messages.map((message) => message.contentText)).toEqual(["追加的一轮输入"])
+  })
+})
+
+describe("CodexLocalAuth", () => {
+  it("未显式同意时不连接；授权和退出只改当前 vault 的标记", async () => {
+    const { root } = await fixture()
+    const consentRoot = mkdtempSync(join(tmpdir(), "mycontext-codex-consent-"))
+    const auth = pluginFor(root, consentRoot).auth
+    const onProgress = vi.fn()
+
+    await expect(auth.status()).resolves.toEqual({ state: "unauthorized" })
+    const connected = await auth.login({
+      mode: "loopback",
+      signal: new AbortController().signal,
+      onProgress,
+    })
+
+    expect(connected.state).toBe("authorized")
+    await expect(auth.status()).resolves.toMatchObject({
+      state: "authorized",
+      userId: "local-user",
+    })
+    expect(onProgress).toHaveBeenCalledWith(expect.objectContaining({ phase: "succeeded" }))
+    await expect(auth.logout()).resolves.toBe(true)
+    await expect(auth.status()).resolves.toEqual({ state: "unauthorized" })
+  })
+
+  it("记录目录不存在时快速失败并给稳定错误码", async () => {
+    const consentRoot = mkdtempSync(join(tmpdir(), "mycontext-codex-consent-"))
+    const auth = pluginFor(join(consentRoot, "missing"), consentRoot).auth
+
+    let thrown: unknown
+    try {
+      await auth.login({
+        mode: "loopback",
+        signal: new AbortController().signal,
+        onProgress: vi.fn(),
+      })
+    } catch (error) {
+      thrown = error
+    }
+    expect(isAppError(thrown) && thrown.code).toBe("CHANNEL_LOCAL_RECORDS_UNAVAILABLE")
+  })
+
+  it("插件声明只读 chat、无发送能力且只提供单一授权入口", async () => {
+    const { root } = await fixture()
+    const consentRoot = mkdtempSync(join(tmpdir(), "mycontext-codex-consent-"))
+    const plugin = pluginFor(root, consentRoot)
+
+    expect(plugin.meta.id).toBe("codex")
+    expect(plugin.capabilities.domains).toEqual(["chat"])
+    expect(plugin.capabilities.sendAs).toEqual([])
+    expect(plugin.auth.supportedModes?.()).toEqual(["loopback"])
+  })
+})
diff --git a/tests/unit/desktop/scoped-channel-id-wiring.test.ts b/tests/unit/desktop/scoped-channel-id-wiring.test.ts
index c695a0b3..a2b2f218 100644
--- a/tests/unit/desktop/scoped-channel-id-wiring.test.ts
+++ b/tests/unit/desktop/scoped-channel-id-wiring.test.ts
@@ -81,4 +81,9 @@ describe("★★★ 来源作用域：内置不加后缀、自备按路径分流
   it("★ 换渠道 → 前缀跟着换", () => {
     expect(scopedChannelIdFor("feishu", "/opt/x/dws")).toMatch(/^feishu@src-/)
   })
+
+  /** Codex 是本地记录目录，不应被无关的 DWS 二进制路径拆成多个身份。 */
+  it("★ Codex 不继承 DWS 来源后缀", () => {
+    expect(scopedChannelIdFor("codex", "/opt/x/dws")).toBe("codex")
+  })
 })
diff --git a/tests/unit/store/vault-paths.test.ts b/tests/unit/store/vault-paths.test.ts
index 7a37beec..5eb95d18 100644
--- a/tests/unit/store/vault-paths.test.ts
+++ b/tests/unit/store/vault-paths.test.ts
@@ -45,6 +45,7 @@ const ALL_KEYS: readonly (keyof VaultPaths)[] = [
   "agentHome",
   "dwsHome",
   "feishuAuthRoot",
+  "codexAuthRoot",
 ]
 
 describe("每个落点都在 vault 目录内", () => {