@botcord/daemon 0.2.55 → 0.2.57

package/dist/provision.js

@@ -263,6 +263,9 @@ export function createProvisioner(opts) {
                 });
                 return { ok: true, result };
             }
+            case "wake_agent": {
+                return handleWakeAgent(gateway, frame.params);
+            }
             default:
                 daemonLog.warn("provision.dispatch: unknown frame type", {
                     type: frame.type,
@@ -275,6 +278,71 @@ export function createProvisioner(opts) {
         }
     };
 }
+async function handleWakeAgent(gateway, raw) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+        return {
+            ok: false,
+            error: { code: "bad_params", message: "wake_agent params must be an object" },
+        };
+    }
+    const params = raw;
+    const agentId = params.agent_id || params.agentId;
+    const message = params.message;
+    if (!agentId || typeof agentId !== "string") {
+        return {
+            ok: false,
+            error: { code: "bad_params", message: "wake_agent requires params.agent_id" },
+        };
+    }
+    if (!message || typeof message !== "string") {
+        return {
+            ok: false,
+            error: { code: "bad_params", message: "wake_agent requires params.message" },
+        };
+    }
+    const channels = gateway.snapshot().channels;
+    if (!channels[agentId]) {
+        return {
+            ok: false,
+            error: { code: "agent_not_loaded", message: `agent ${agentId} is not loaded in daemon gateway` },
+        };
+    }
+    const runId = params.run_id || params.runId || `wake-${Date.now()}`;
+    const scheduleId = params.schedule_id || params.scheduleId;
+    const dedupeKey = params.dedupe_key || params.dedupeKey;
+    const conversationId = `rm_schedule_${agentId}`;
+    const msg = {
+        id: runId,
+        channel: agentId,
+        accountId: agentId,
+        conversation: {
+            id: conversationId,
+            kind: "direct",
+            title: "BotCord Scheduler",
+            threadId: scheduleId ?? null,
+        },
+        sender: {
+            id: "hub",
+            name: "BotCord Scheduler",
+            kind: "system",
+        },
+        text: message,
+        raw: {
+            source_type: "botcord_schedule",
+            schedule_id: scheduleId,
+            run_id: runId,
+            dedupe_key: dedupeKey,
+        },
+        mentioned: true,
+        receivedAt: Date.now(),
+        trace: {
+            id: runId,
+            streamable: false,
+        },
+    };
+    await gateway.injectInbound(msg);
+    return { ok: true, result: { agent_id: agentId } };
+}
 function validateGatewayParams(raw, spec) {
     if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
         return {

package/dist/working-memory.js

@@ -240,6 +240,11 @@ export function buildWorkingMemoryPrompt(opts) {
         "- sections: named buckets (contacts, pending_tasks, preferences, etc.).",
         "- Updating one section never touches others. Empty content deletes a section.",
         "",
+        "For cross-room work, update memory before or immediately after delegating:",
+        "- If you accept a request in one room and continue it in another, record a `pending_tasks` entry with source room id/name, target room id/name, requested deliverable, current status, and where to report completion.",
+        "- When a delegated room replies or delivers an artifact, consult `pending_tasks` before deciding `NO_REPLY`; if it matches a pending handoff, acknowledge, update status, and send the promised follow-up to the source room when appropriate.",
+        "- Remove or mark the entry done once the source room has been updated.",
+        "",
         "Only update when something meaningful changes. Keep each section tight.",
     ];
     if (!workingMemory) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.55",
+  "version": "0.2.57",
   "description": "BotCord local daemon — bridges Hub inbox push to local Claude Code / Codex / Gemini CLIs",
   "type": "module",
   "bin": {

package/src/__tests__/diagnostics.test.ts

@@ -0,0 +1,46 @@
+import { existsSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { createDiagnosticBundle } from "../diagnostics.js";
+
+describe("diagnostics bundle", () => {
+  it("writes a zip bundle under ~/.botcord/diagnostics", async () => {
+    const tmp = mkdtempSync(path.join(tmpdir(), "botcord-diag-test-"));
+    const logFile = path.join(tmp, "daemon.log");
+    const configFile = path.join(tmp, "config.json");
+    const snapshotFile = path.join(tmp, "snapshot.json");
+    const diagnosticsDir = path.join(tmp, "diagnostics");
+    writeFileSync(logFile, 'Authorization: Bearer secret-token\n{"refreshToken":"drt_secret"}\n');
+    writeFileSync(configFile, '{"token":"agent-secret","ok":true}\n');
+    writeFileSync(snapshotFile, '{"version":1}\n');
+
+    const bundle = await createDiagnosticBundle({
+      diagnosticsDir,
+      logFile,
+      configFile,
+      snapshotFile,
+      doctor: { text: "doctor ok", json: { ok: true } },
+    });
+    expect(bundle.filename).toMatch(/^botcord-daemon-diagnostics-.*\.zip$/);
+    expect(bundle.path).toContain(diagnosticsDir);
+    expect(existsSync(bundle.path)).toBe(true);
+    const bytes = readFileSync(bundle.path);
+    expect(bytes.subarray(0, 4).toString("binary")).toBe("PK\u0003\u0004");
+
+    const listing = execFileSync("unzip", ["-l", bundle.path], {
+      encoding: "utf8",
+    });
+    expect(listing).toContain("daemon.log");
+    expect(listing).toContain("doctor.json");
+    expect(listing).toContain("status.json");
+    expect(listing).toContain("config.json.redacted");
+
+    const log = execFileSync("unzip", ["-p", bundle.path, "daemon.log"], {
+      encoding: "utf8",
+    });
+    expect(log).toContain("Authorization: Bearer [REDACTED]");
+    expect(log).toContain('"refreshToken":"[REDACTED]"');
+  }, 20_000);
+});

package/src/__tests__/provision.test.ts

@@ -104,6 +104,7 @@ interface FakeGateway {
   upsertManagedRoute: ReturnType<typeof vi.fn>;
   removeManagedRoute: ReturnType<typeof vi.fn>;
   replaceManagedRoutes: ReturnType<typeof vi.fn>;
+  injectInbound: ReturnType<typeof vi.fn>;
   listManagedRoutes: () => GatewayRoute[];
   snapshot: () => GatewayRuntimeSnapshot;
 }
@@ -128,6 +129,7 @@ function makeFakeGateway(initialChannelIds: string[] = []): FakeGateway {
       managed.clear();
       for (const [id, route] of routes) managed.set(id, route);
     }),
+    injectInbound: vi.fn(async () => {}),
     listManagedRoutes: (): GatewayRoute[] => Array.from(managed.values()),
     snapshot: (): GatewayRuntimeSnapshot => ({
       channels: Object.fromEntries(
@@ -251,6 +253,49 @@ describe("list_agent_files handler", () => {
   });
 });
 
+describe("wake_agent handler", () => {
+  it("injects a scheduled turn into the gateway dispatcher", async () => {
+    const gw = makeFakeGateway(["ag_wake"]);
+    const handler = createProvisioner({ gateway: gw as any });
+    const res = await handler({
+      id: "req_wake",
+      type: "wake_agent",
+      params: {
+        agent_id: "ag_wake",
+        message: "【BotCord 自主任务】执行本轮工作目标。",
+        run_id: "sr_test",
+        schedule_id: "sch_test",
+        dedupe_key: "sch_test:1:auto",
+      },
+    });
+
+    expect(res.ok).toBe(true);
+    expect(gw.injectInbound).toHaveBeenCalledTimes(1);
+    const msg = gw.injectInbound.mock.calls[0][0];
+    expect(msg.id).toBe("sr_test");
+    expect(msg.channel).toBe("ag_wake");
+    expect(msg.accountId).toBe("ag_wake");
+    expect(msg.sender.id).toBe("hub");
+    expect(msg.sender.kind).toBe("system");
+    expect(msg.text).toContain("BotCord 自主任务");
+    expect(msg.conversation.threadId).toBe("sch_test");
+  });
+
+  it("rejects wake_agent for an unloaded agent", async () => {
+    const gw = makeFakeGateway(["ag_loaded"]);
+    const handler = createProvisioner({ gateway: gw as any });
+    const res = await handler({
+      id: "req_wake_missing",
+      type: "wake_agent",
+      params: { agent_id: "ag_missing", message: "tick" },
+    });
+
+    expect(res.ok).toBe(false);
+    expect(res.error?.code).toBe("agent_not_loaded");
+    expect(gw.injectInbound).not.toHaveBeenCalled();
+  });
+});
+
 describe("reload_config handler", () => {
   it("adds agents listed in config but missing from gateway", async () => {
     mockState.cfg = {

package/src/__tests__/working-memory.test.ts

@@ -207,6 +207,15 @@ describe("buildWorkingMemoryPrompt", () => {
     expect(p).toContain("currently empty");
   });
 
+  it("instructs agents to persist cross-room handoffs", () => {
+    const p = wm.buildWorkingMemoryPrompt({ workingMemory: null });
+    expect(p).toContain("For cross-room work");
+    expect(p).toContain("pending_tasks");
+    expect(p).toContain("source room");
+    expect(p).toContain("target room");
+    expect(p).toContain("where to report completion");
+  });
+
   it("renders goal + named sections", () => {
     const p = wm.buildWorkingMemoryPrompt({
       workingMemory: {
@@ -237,4 +246,3 @@ describe("buildWorkingMemoryPrompt", () => {
     expect(p).toContain("‹current_memory›");
   });
 });
-

package/src/daemon.ts

@@ -46,6 +46,7 @@ import { composeBotCordUserTurn } from "./turn-text.js";
 import { UserAuthManager } from "./user-auth.js";
 import { PolicyResolver } from "./gateway/policy-resolver.js";
 import { scanMention } from "./mention-scan.js";
+import { createDiagnosticBundle, uploadDiagnosticBundle } from "./diagnostics.js";
 
 /**
  * Default hard cap for a single runtime turn. Long-running coding/research
@@ -558,7 +559,30 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
     const provisioner = createProvisioner({ gateway, policyResolver, onAgentInstalled });
     controlChannel = new ControlChannel({
       auth: userAuth,
-      handle: provisioner,
+      handle: async (frame) => {
+        if (frame.type === "collect_diagnostics") {
+          logger.info("diagnostics: collect requested", { frameId: frame.id });
+          const bundle = await createDiagnosticBundle();
+          const upload = await uploadDiagnosticBundle({ auth: userAuth, bundle });
+          logger.info("diagnostics: uploaded", {
+            frameId: frame.id,
+            bundleId: upload.bundleId,
+            sizeBytes: upload.sizeBytes,
+            localPath: bundle.path,
+          });
+          return {
+            ok: true,
+            result: {
+              bundle_id: upload.bundleId,
+              filename: upload.filename,
+              size_bytes: upload.sizeBytes,
+              expires_at: upload.expiresAt ?? null,
+              local_path: bundle.path,
+            },
+          };
+        }
+        return provisioner(frame);
+      },
     });
     try {
       await controlChannel.start();

package/src/diagnostics.ts

@@ -0,0 +1,348 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir, hostname, platform, release, arch } from "node:os";
+import path from "node:path";
+import { Buffer } from "node:buffer";
+import { deflateRawSync } from "node:zlib";
+import {
+  AUTH_EXPIRED_FLAG_PATH,
+  USER_AUTH_PATH,
+  type UserAuthManager,
+  type UserAuthRecord,
+} from "./user-auth.js";
+import {
+  CONFIG_FILE_PATH,
+  PID_PATH,
+  SNAPSHOT_PATH,
+  loadConfig,
+  type DaemonConfig,
+} from "./config.js";
+import { LOG_FILE_PATH } from "./log.js";
+import {
+  channelsFromDaemonConfig,
+  defaultHttpFetcher,
+  renderDoctor,
+  runDoctor,
+  type DoctorFileReader,
+  type DoctorRuntimeEntry,
+} from "./doctor.js";
+import { detectRuntimes } from "./adapters/runtimes.js";
+
+const DIAGNOSTICS_DIR = path.join(homedir(), ".botcord", "diagnostics");
+const MAX_UPLOAD_BYTES = 50 * 1024 * 1024;
+
+export interface CreateDiagnosticBundleOptions {
+  diagnosticsDir?: string;
+  logFile?: string;
+  configFile?: string;
+  snapshotFile?: string;
+  doctor?: { text: string; json: unknown };
+}
+
+export interface DiagnosticBundleResult {
+  path: string;
+  filename: string;
+  sizeBytes: number;
+  createdAt: string;
+}
+
+export interface DiagnosticUploadResult {
+  bundleId: string;
+  filename: string;
+  sizeBytes: number;
+  expiresAt?: string;
+}
+
+const SECRET_PATTERNS: Array<[RegExp, string]> = [
+  [/(Authorization:\s*Bearer\s+)[^\s"']+/gi, "$1[REDACTED]"],
+  [/("?(?:accessToken|access_token|refreshToken|refresh_token|token|privateKey|private_key|secret)"?\s*:\s*")[^"]+(")/gi, "$1[REDACTED]$2"],
+  [/(drt_)[A-Za-z0-9_-]+/g, "$1[REDACTED]"],
+  [/(dit_)[A-Za-z0-9_-]+/g, "$1[REDACTED]"],
+  [/([?&](?:token|access_token|refresh_token|install_token)=)[^&\s"']+/gi, "$1[REDACTED]"],
+];
+
+function redact(input: string): string {
+  let out = input;
+  for (const [pattern, replacement] of SECRET_PATTERNS) {
+    out = out.replace(pattern, replacement);
+  }
+  return out;
+}
+
+function safeReadText(file: string): string | null {
+  if (!existsSync(file)) return null;
+  try {
+    return redact(readFileSync(file, "utf8"));
+  } catch (err) {
+    return `read failed: ${err instanceof Error ? err.message : String(err)}\n`;
+  }
+}
+
+function readUserAuthSummary(): Record<string, unknown> | null {
+  const raw = safeReadText(USER_AUTH_PATH);
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw) as Record<string, unknown>;
+    return {
+      userId: typeof parsed.userId === "string" ? parsed.userId : null,
+      daemonInstanceId:
+        typeof parsed.daemonInstanceId === "string" ? parsed.daemonInstanceId : null,
+      hubUrl: typeof parsed.hubUrl === "string" ? parsed.hubUrl : null,
+      expiresAt: typeof parsed.expiresAt === "number" ? parsed.expiresAt : null,
+      loggedInAt: typeof parsed.loggedInAt === "string" ? parsed.loggedInAt : null,
+      label: typeof parsed.label === "string" ? parsed.label : null,
+      authExpiredFlagPresent: existsSync(AUTH_EXPIRED_FLAG_PATH),
+    };
+  } catch (err) {
+    return {
+      error: `user-auth summary failed: ${err instanceof Error ? err.message : String(err)}`,
+      authExpiredFlagPresent: existsSync(AUTH_EXPIRED_FLAG_PATH),
+    };
+  }
+}
+
+const fsFileReader: DoctorFileReader = {
+  readFile(p: string): string | null {
+    if (!existsSync(p)) return null;
+    try {
+      return readFileSync(p, "utf8");
+    } catch {
+      return null;
+    }
+  },
+};
+
+async function buildDoctorEntries(): Promise<{
+  text: string;
+  json: unknown;
+}> {
+  const entries: DoctorRuntimeEntry[] = detectRuntimes();
+  let channels: ReturnType<typeof channelsFromDaemonConfig> = [];
+  let cfgForEndpoints: DaemonConfig | null = null;
+  try {
+    cfgForEndpoints = loadConfig();
+    channels = channelsFromDaemonConfig(cfgForEndpoints);
+  } catch {
+    channels = [];
+  }
+  if (cfgForEndpoints?.openclawGateways && cfgForEndpoints.openclawGateways.length > 0) {
+    const { collectRuntimeSnapshotAsync } = await import("./provision.js");
+    const snap = await collectRuntimeSnapshotAsync({ cfg: cfgForEndpoints });
+    const byId = new Map(snap.runtimes.map((r) => [r.id, r]));
+    for (const e of entries) {
+      const r = byId.get(e.id);
+      if (r?.endpoints) e.endpoints = r.endpoints;
+    }
+  }
+  const input = await runDoctor(entries, channels, {
+    credentialsPath: (accountId) =>
+      path.join(homedir(), ".botcord", "credentials", `${accountId}.json`),
+    fileReader: fsFileReader,
+    fetcher: defaultHttpFetcher,
+    timeoutMs: 5_000,
+  });
+  return { text: renderDoctor(input), json: input };
+}
+
+function crc32(buf: Buffer): number {
+  let crc = 0xffffffff;
+  for (const b of buf) {
+    crc ^= b;
+    for (let i = 0; i < 8; i += 1) {
+      crc = (crc >>> 1) ^ (crc & 1 ? 0xedb88320 : 0);
+    }
+  }
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+function dosDateTime(date: Date): { time: number; date: number } {
+  const year = Math.max(1980, date.getFullYear());
+  return {
+    time: (date.getHours() << 11) | (date.getMinutes() << 5) | Math.floor(date.getSeconds() / 2),
+    date: ((year - 1980) << 9) | ((date.getMonth() + 1) << 5) | date.getDate(),
+  };
+}
+
+function u16(n: number): Buffer {
+  const b = Buffer.alloc(2);
+  b.writeUInt16LE(n & 0xffff, 0);
+  return b;
+}
+
+function u32(n: number): Buffer {
+  const b = Buffer.alloc(4);
+  b.writeUInt32LE(n >>> 0, 0);
+  return b;
+}
+
+function createZip(entries: Array<{ name: string; data: string | Buffer }>): Buffer {
+  const localParts: Buffer[] = [];
+  const centralParts: Buffer[] = [];
+  let offset = 0;
+  const now = new Date();
+  const dt = dosDateTime(now);
+
+  for (const entry of entries) {
+    const name = Buffer.from(entry.name.replace(/^\/+/, ""), "utf8");
+    const data = Buffer.isBuffer(entry.data)
+      ? entry.data
+      : Buffer.from(entry.data, "utf8");
+    const compressed = deflateRawSync(data, { level: 9 });
+    const crc = crc32(data);
+    const local = Buffer.concat([
+      u32(0x04034b50),
+      u16(20),
+      u16(0),
+      u16(8),
+      u16(dt.time),
+      u16(dt.date),
+      u32(crc),
+      u32(compressed.length),
+      u32(data.length),
+      u16(name.length),
+      u16(0),
+      name,
+      compressed,
+    ]);
+    localParts.push(local);
+
+    centralParts.push(Buffer.concat([
+      u32(0x02014b50),
+      u16(20),
+      u16(20),
+      u16(0),
+      u16(8),
+      u16(dt.time),
+      u16(dt.date),
+      u32(crc),
+      u32(compressed.length),
+      u32(data.length),
+      u16(name.length),
+      u16(0),
+      u16(0),
+      u16(0),
+      u16(0),
+      u32(0),
+      u32(offset),
+      name,
+    ]));
+    offset += local.length;
+  }
+
+  const central = Buffer.concat(centralParts);
+  const end = Buffer.concat([
+    u32(0x06054b50),
+    u16(0),
+    u16(0),
+    u16(entries.length),
+    u16(entries.length),
+    u32(central.length),
+    u32(offset),
+    u16(0),
+  ]);
+  return Buffer.concat([...localParts, central, end]);
+}
+
+export async function createDiagnosticBundle(
+  opts: CreateDiagnosticBundleOptions = {},
+): Promise<DiagnosticBundleResult> {
+  const createdAt = new Date();
+  const stamp = createdAt.toISOString().replace(/[:.]/g, "-");
+  const filename = `botcord-daemon-diagnostics-${stamp}.zip`;
+  const diagnosticsDir = opts.diagnosticsDir ?? DIAGNOSTICS_DIR;
+  const logFile = opts.logFile ?? LOG_FILE_PATH;
+  const configFile = opts.configFile ?? CONFIG_FILE_PATH;
+  const snapshotFile = opts.snapshotFile ?? SNAPSHOT_PATH;
+  mkdirSync(diagnosticsDir, { recursive: true, mode: 0o700 });
+
+  const doctor = opts.doctor ?? await buildDoctorEntries();
+  const status = {
+    createdAt: createdAt.toISOString(),
+    host: hostname(),
+    platform: platform(),
+    release: release(),
+    arch: arch(),
+    node: process.version,
+    pidPath: PID_PATH,
+    pid: process.pid,
+    configPath: configFile,
+    snapshotPath: snapshotFile,
+    logPath: logFile,
+    diagnosticsDir,
+    userAuth: readUserAuthSummary(),
+  };
+
+  const entries: Array<{ name: string; data: string | Buffer }> = [
+    { name: "README.txt", data: "BotCord daemon diagnostics bundle. Sensitive tokens are redacted before packaging.\n" },
+    { name: "status.json", data: JSON.stringify(status, null, 2) + "\n" },
+    { name: "doctor.txt", data: doctor.text + "\n" },
+    { name: "doctor.json", data: JSON.stringify(doctor.json, null, 2) + "\n" },
+  ];
+  const log = safeReadText(logFile);
+  entries.push({
+    name: "daemon.log",
+    data: log ?? `no log file at ${logFile}\n`,
+  });
+  const config = safeReadText(configFile);
+  entries.push({
+    name: "config.json.redacted",
+    data: config ?? `no config file at ${configFile}\n`,
+  });
+  const snapshot = safeReadText(snapshotFile);
+  entries.push({
+    name: "snapshot.json",
+    data: snapshot ?? `no snapshot file at ${snapshotFile}\n`,
+  });
+
+  const zip = createZip(entries);
+  const out = path.join(diagnosticsDir, filename);
+  writeFileSync(out, zip, { mode: 0o600 });
+  return {
+    path: out,
+    filename,
+    sizeBytes: zip.length,
+    createdAt: createdAt.toISOString(),
+  };
+}
+
+export async function uploadDiagnosticBundle(opts: {
+  auth: UserAuthManager;
+  bundle: DiagnosticBundleResult;
+}): Promise<DiagnosticUploadResult> {
+  const record: UserAuthRecord | null = opts.auth.current;
+  if (!record) throw new Error("daemon not logged in");
+  const data = readFileSync(opts.bundle.path);
+  if (data.length > MAX_UPLOAD_BYTES) {
+    throw new Error(`diagnostic bundle is too large (${data.length} bytes, max ${MAX_UPLOAD_BYTES})`);
+  }
+  const token = await opts.auth.ensureAccessToken();
+  const url = `${record.hubUrl.replace(/\/+$/, "")}/daemon/diagnostics/upload`;
+  const resp = await fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/zip",
+      "X-BotCord-Filename": opts.bundle.filename,
+    },
+    body: data,
+  });
+  const json = await resp.json().catch(() => null) as Record<string, unknown> | null;
+  if (!resp.ok) {
+    const detail =
+      typeof json?.detail === "string"
+        ? json.detail
+        : typeof json?.error === "string"
+          ? json.error
+          : `HTTP ${resp.status}`;
+    throw new Error(`diagnostic upload failed: ${detail}`);
+  }
+  const bundleId = typeof json?.bundle_id === "string" ? json.bundle_id : null;
+  if (!bundleId) throw new Error("diagnostic upload response missing bundle_id");
+  return {
+    bundleId,
+    filename: typeof json?.filename === "string" ? json.filename : opts.bundle.filename,
+    sizeBytes: typeof json?.size_bytes === "number" ? json.size_bytes : data.length,
+    ...(typeof json?.expires_at === "string" ? { expiresAt: json.expires_at } : {}),
+  };
+}
+
+export { DIAGNOSTICS_DIR };

package/src/gateway/__tests__/claude-code-adapter.test.ts

@@ -349,5 +349,40 @@ process.stdout.write(JSON.stringify({type:"result", subtype:"success", session_i
       const modeIdx = argv.indexOf("--permission-mode");
       expect(argv[modeIdx + 1]).toBe("plan");
     });
+
+    it("drops inherited Codex-only extraArgs while preserving shared Claude flags", async () => {
+      const adapter = new ClaudeCodeAdapter({ binary: echoScript() });
+      const ctrl = new AbortController();
+      const res = await adapter.run({
+        text: "x",
+        sessionId: null,
+        accountId: "ag_test",
+        cwd: tmpRoot,
+        signal: ctrl.signal,
+        trustLevel: "public",
+        extraArgs: [
+          "-c",
+          'model="gpt-5.2"',
+          "--sandbox",
+          "read-only",
+          "--skip-git-repo-check",
+          "--json",
+          "-p",
+          "codex-profile",
+          "--model",
+          "sonnet",
+        ],
+      });
+      const argv = JSON.parse(res.text) as string[];
+      expect(argv).not.toContain("-c");
+      expect(argv).not.toContain('model="gpt-5.2"');
+      expect(argv).not.toContain("--sandbox");
+      expect(argv).not.toContain("read-only");
+      expect(argv).not.toContain("--skip-git-repo-check");
+      expect(argv).not.toContain("--json");
+      expect(argv).not.toContain("codex-profile");
+      expect(argv).toContain("--model");
+      expect(argv[argv.indexOf("--model") + 1]).toBe("sonnet");
+    });
   });
 });