@chorus-aidlc/chorus 0.12.0 → 0.12.1

package/cli/daemon.mjs

@@ -18,8 +18,8 @@ import {
   resolvePermissionMode,
   yoloWarningLine,
 } from "./daemon-permission-mode.mjs";
-import { resolveAgentType } from "./daemon-agent.mjs";
-import { formatBanner } from "./daemon-banner.mjs";
+import { resolveAgentType, backendClientType } from "./daemon-agent.mjs";
+import { formatBanner, agentNotFoundWarningLine } from "./daemon-banner.mjs";
 import { ChorusClient, validateAndFetchIdentity } from "./chorus-client.mjs";
 import { SseListener } from "./sse-listener.mjs";
 import { createBackfill } from "./backfill.mjs";
@@ -27,7 +27,9 @@ import { EventRouter } from "./event-router.mjs";
 import { WakeQueue } from "./wake-queue.mjs";
 import { Waker } from "./waker.mjs";
 import { LineageResolver } from "./lineage.mjs";
-import { ClaudeSpawner, resolveClaudePath } from "./claude-spawner.mjs";
+import { resolveClaudePath } from "./claude-spawner.mjs";
+import { resolveCodexPath } from "./codex-spawner.mjs";
+import { selectSpawner } from "./spawner-select.mjs";
 import {
   createExecutionUploadHooks,
   createTranscriptUploadHooks,
@@ -95,9 +97,12 @@ function defaultLogger() {
 export function buildDaemon(creds, deps = {}) {
   const logger = deps.logger ?? defaultLogger();
   const permissionMode = deps.permissionMode ?? "chorus";
+  // The resolved agent backend selects which spawner the daemon injects
+  // (add-daemon-codex-backend). Defaults to claude-code, matching the prior
+  // hard-wired ClaudeSpawner. The spawn path below is backend-agnostic — it only
+  // ever calls the shared wake(...) contract.
+  const agentType = deps.agentType ?? "claude-code";
   // Per-wake verbose logging (daemon-startup-output), threaded into the Waker.
-  // agentType is currently display-only (banner/logs) — the spawn path is
-  // claude-code regardless (daemon-agent-selection reserves the slot only).
   const verbose = deps.verbose ?? false;
   // Escalation window for the interrupt killer (子3). Pre-resolved by runDaemon via
   // the layered resolver; falls back to the resolver's default here when not given,
@@ -112,7 +117,11 @@ export function buildDaemon(creds, deps = {}) {
   const lineage =
     deps.lineage ??
     new LineageResolver({ url: creds.url, apiKey: creds.apiKey, logger, fetchImpl: deps.fetchImpl });
-  const spawner = deps.spawner ?? new ClaudeSpawner({ logger, permissionMode });
+  // Inject the spawner for the resolved backend. claude-code → ClaudeSpawner
+  // (construction byte-identical to before); codex → CodexSpawner. `creds` are
+  // passed through so the Codex backend can export the daemon key into the woken
+  // process env (the Claude backend ignores creds — it gets its key via --mcp-config).
+  const spawner = deps.spawner ?? selectSpawner(agentType, { logger, permissionMode, creds });
   // The WakeQueue serializes per DIRECT idea (keyFor's key). It is shared across all
   // path-connections: serialization-per-idea still holds, and maxConcurrency caps the
   // whole process's in-flight wakes rather than per-cwd — the right global budget.
@@ -131,6 +140,40 @@ export function buildDaemon(creds, deps = {}) {
       ? deps.cwds
       : [deps.cwd];
 
+  // ===== All-conflict exit latch (add-daemon-connection-conflict-skip, Q3) =====
+  // Each declared connection resolves to exactly one terminal outcome: REGISTERED
+  // (saw connection_registered → onConnectionId) or CONFLICTED (saw
+  // connection_conflict → onConflict). When EVERY declared connection has resolved
+  // AND none registered (≥1 conflicted, 0 survived), the daemon has nothing to serve,
+  // so we settle `allConflict` — runDaemon races this against waitForever and returns
+  // a non-zero exit. The latch is evaluated only after all connections resolve (R5):
+  // a path still mid-handshake leaves `resolved < total`, so a partial conflict never
+  // triggers the exit. A connection that registers (even after some conflicted) flips
+  // `anyRegistered`, so the exit never fires while at least one path serves.
+  const totalConnections = cwdSet.length;
+  let resolvedConnections = 0;
+  let anyRegistered = false;
+  let settleAllConflict; // resolver, wired into the promise below
+  // A promise that settles ONLY in the all-paths-conflicted case. It never rejects and
+  // never settles otherwise (a serving daemon simply keeps waiting on waitForever).
+  const allConflict = new Promise((resolve) => {
+    settleAllConflict = resolve;
+  });
+  // Record one connection's terminal outcome and, once all have resolved, decide whether
+  // the whole daemon should exit. Idempotent per connection BY CONSTRUCTION: the guard
+  // lives here (flips the connection's own `outcome.resolved`) so a reconnect's repeated
+  // connection_registered — or any future caller — can never double-count, no matter the
+  // call site. The first terminal signal for a connection wins; later ones are no-ops.
+  function recordConnectionOutcome(outcome, registered) {
+    if (outcome.resolved) return;
+    outcome.resolved = true;
+    resolvedConnections += 1;
+    if (registered) anyRegistered = true;
+    if (resolvedConnections === totalConnections && !anyRegistered) {
+      settleAllConflict();
+    }
+  }
+
   /**
    * Build ONE independent path-connection bound to `cwd` (one SSE stream → one
    * DaemonConnection row, keyed by that cwd server-side). All per-connection state —
@@ -149,6 +192,13 @@ export function buildDaemon(creds, deps = {}) {
     /** @type {{ connectionUuid: string|null }} */
     const connectionState = { connectionUuid: null };
 
+    // Per-connection terminal-outcome bookkeeping (add-daemon-connection-conflict-skip).
+    // `resolved` guards recordConnectionOutcome against double-counting a reconnect's
+    // repeated connection_registered. `skipped` marks a cwd surrendered to a live
+    // different-process daemon — purely informational (the listener is torn down, so it
+    // simply never reconnects), kept on the returned object for inspection/tests.
+    const outcome = { resolved: false, skipped: false };
+
     // Interrupt reporter (子3): REST POST with the daemon's Bearer key. Injectable for
     // tests (shared across connections when injected — tests use a single connection).
     const reportInterrupt =
@@ -273,6 +323,9 @@ export function buildDaemon(creds, deps = {}) {
       makeSse({
         url: creds.url,
         apiKey: creds.apiKey,
+        // Self-report the SELECTED backend so the connection registry + presence UI
+        // label a codex daemon as `codex` (not the hardcoded `claude_code`).
+        clientType: backendClientType(agentType),
         // The working directory THIS connection serves (T3). `undefined` ⇒ the listener
         // reports its process cwd (single-path / HARD-1). It is just the served path.
         cwd,
@@ -283,13 +336,37 @@ export function buildDaemon(creds, deps = {}) {
             `[Chorus] registered as connection ${connectionUuid}` +
               (cwd ? ` (cwd=${cwd})` : "")
           );
+          // Terminal outcome: this path registered. recordConnectionOutcome is idempotent
+          // per connection, so a reconnect's repeated connection_registered counts once.
+          recordConnectionOutcome(outcome, true);
+        },
+        // Connection conflict (add-daemon-connection-conflict-skip, Q3/Q4): the server
+        // refused to register THIS cwd because a live different-process daemon already
+        // holds the same (agent, host, cwd). Warn prominently, tear the listener down
+        // (disconnect clears the reconnect timer + aborts), and mark the path skipped —
+        // it is never reconnected/re-probed for the process lifetime. Takeover happens
+        // only on the NEXT daemon start/restart. Independent closures mean skipping this
+        // path never disturbs another connection's dispatch/control.
+        onConflict: (event) => {
+          const conflictCwd = (event && event.cwd) ?? cwd ?? process.cwd();
+          const conflictHost = (event && event.host) || "this host";
+          logger.warn(
+            `[Chorus] ⚠ connection conflict: a live daemon already serves ` +
+              `(host=${conflictHost}, cwd=${conflictCwd}) — skipping this path. ` +
+              `Stop the other daemon (or wait for it to go offline) and restart to take it over.`
+          );
+          outcome.skipped = true;
+          // Tear down THIS path's listener: no reconnect, no re-probe (Q4).
+          sseListener.disconnect?.();
+          // Terminal outcome: this path conflicted (idempotent — counts once).
+          recordConnectionOutcome(outcome, false);
         },
         onControl,
         onReconnect: backfill,
         logger,
       });
 
-    return { cwd, connectionState, waker, router, backfill, sseListener, hooks };
+    return { cwd, connectionState, waker, router, backfill, sseListener, hooks, outcome };
   }
 
   // Build one connection per declared cwd. The order is the declaration order; the
@@ -309,6 +386,10 @@ export function buildDaemon(creds, deps = {}) {
     router: primary.router,
     sseListener: primary.sseListener,
     connections,
+    // Settles ONLY when every declared connection resolved and none registered
+    // (all paths already served by a live daemon — Q3). runDaemon races this against
+    // waitForever to exit non-zero. Never settles for a serving daemon.
+    allConflict,
     async start() {
       // Connect every path-connection. Each fires its own onConnect hook + SSE connect;
       // the daemon process cwd is untouched (NFR-3).
@@ -356,7 +437,11 @@ export async function runDaemon(flags = {}, deps = {}) {
   const askPrompt = deps.prompt ?? prompt;
   const writeCreds = deps.writeLoginFile ?? writeLoginFile;
   const version = deps.version ?? readVersion();
+  // Backend executable resolvers — injectable for tests. The SELECTED backend's
+  // resolver runs below (claude-code → findClaude, codex → findCodex), so the
+  // banner shows the right binary instead of always probing for `claude`.
   const findClaude = deps.resolveClaudePath ?? resolveClaudePath;
+  const findCodex = deps.resolveCodexPath ?? resolveCodexPath;
   const verbose = flags.verbose === true || env.CHORUS_VERBOSE === "1";
 
   // Resolve the agent backend (default claude-code). An unknown --agent /
@@ -410,10 +495,12 @@ export async function runDaemon(flags = {}, deps = {}) {
   if (typeof pf === "number") return pf;
   const { creds, identity, permissionMode } = pf;
 
-  // Detect the claude executable (non-fatal): the daemon still subscribes when
-  // it's missing; a wake surfaces the error visibly when one arrives. The
-  // resolved path (or absence) is shown in the banner below.
-  const claudePath = findClaude();
+  // Detect the SELECTED backend's executable (non-fatal): the daemon still
+  // subscribes when it's missing; a wake surfaces the error visibly when one
+  // arrives. The resolved path (or absence) is shown in the banner below. codex
+  // → resolveCodexPath, otherwise resolveClaudePath — so a `--agent codex` run
+  // probes (and the banner reports) `codex`, not `claude`.
+  const cliPath = agentType === "codex" ? findCodex() : findClaude();
 
   // The daemon.json the layered config readers (credentials, sigint timeout, cwds)
   // consult. Surfacing its absolute path + presence in the banner makes it obvious
@@ -432,7 +519,7 @@ export async function runDaemon(flags = {}, deps = {}) {
         permissionMode,
         credentialSource: creds.source,
         agentType,
-        claudePath,
+        cliPath,
         connection: "connecting…",
         configPath,
         configExists,
@@ -445,6 +532,14 @@ export async function runDaemon(flags = {}, deps = {}) {
   if (permissionMode === "yolo") {
     errLog(`[Chorus] ${yoloWarningLine()}`);
   }
+  // A missing backend binary is non-fatal (the daemon still subscribes), but the
+  // banner row alone is easy to miss in a systemd journal — emit one loud ⚠ line
+  // on stderr so the operator sees it at startup, not only when a wake fails. The
+  // warning names the SELECTED backend (claude / CHORUS_CLAUDE_PATH or codex /
+  // CHORUS_CODEX_PATH).
+  if (cliPath === null) {
+    errLog(`[Chorus] ${agentNotFoundWarningLine(agentType)}`);
+  }
 
   // Surface the served paths so an operator sees a multi-path daemon at a glance.
   // A single `[undefined]` (the default) prints the process cwd it falls back to.
@@ -476,8 +571,32 @@ export async function runDaemon(flags = {}, deps = {}) {
   await daemon.start();
   log("[Chorus] daemon running. Waiting for task dispatches (Ctrl+C to stop).");
 
-  // Keep the process alive for the long-lived SSE subscription.
-  await (deps.waitForever ?? (() => new Promise(() => {})))();
+  // Keep the process alive for the long-lived SSE subscription, but exit non-zero if
+  // EVERY declared path turns out to be already served by a live daemon
+  // (add-daemon-connection-conflict-skip, Q3). `daemon.allConflict` settles only in
+  // that all-paths-conflicted case; otherwise we wait forever on the subscription. A
+  // sentinel distinguishes the two so a waitForever that never settles can't be mistaken
+  // for the conflict exit.
+  const ALL_CONFLICT = Symbol("all-conflict");
+  const waitForever = deps.waitForever ?? (() => new Promise(() => {}));
+  // `daemon.allConflict` is present on the real buildDaemon output; guard for injected
+  // test fakes that don't provide it (those never settle the conflict branch). A
+  // never-settling fallback keeps the race purely waitForever-driven in that case.
+  const allConflictSignal =
+    daemon.allConflict ?? new Promise(() => {});
+  const outcome = await Promise.race([
+    waitForever().then(() => 0),
+    allConflictSignal.then(() => ALL_CONFLICT),
+  ]);
+  if (outcome === ALL_CONFLICT) {
+    const n = servedPaths.length;
+    errLog(
+      `[Chorus] all ${n} declared ${n === 1 ? "path is" : "paths are"} already served by a live daemon — nothing to do. ` +
+        `Stop the other daemon(s) or remove the conflicting path(s), then restart.`
+    );
+    await daemon.stop();
+    return 1;
+  }
   return 0;
 }
 

package/cli/login.mjs

@@ -3,7 +3,7 @@
 // ~/.chorus/daemon.json (0600). On validation failure, nothing is written.
 // Plain ESM; the only dependency is the in-repo MCP SDK (via chorus-client).
 
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { createInterface } from "node:readline";
 
@@ -49,56 +49,99 @@ export function prompt(query, opts = {}) {
 }
 
 /**
- * Persist credentials + identity to the login file with owner-only perms.
+ * Field-level merge update of the login file (`~/.chorus/daemon.json`) — the
+ * single read → merge → write(0600) helper every config writer routes through.
+ *
+ * Reads any existing file, shallow-merges `partial` over it (partial keys win,
+ * every other pre-existing field is preserved), and writes the result back with
+ * owner-only permissions. A shallow merge is correct because every field is a
+ * scalar or a flat array (`cwds`) — there are no nested objects to deep-merge.
  *
- * Writing the file with a fresh credential object intentionally OMITS any
- * `yoloAckAt` that a previous file carried — a credential change (re-login)
- * clears the yolo acknowledgement, so the next yolo TTY start re-confirms once
- * (daemon-permission-mode spec). To preserve an existing ack across an
- * unrelated rewrite, the caller must read it first and pass it in `data`.
+ * The write is atomic: the JSON is written to a sibling `<path>.tmp` at 0600 and
+ * then `rename()`d over the target, so a crash mid-write never truncates the
+ * live file. A missing / unreadable / malformed existing file is treated as an
+ * empty object (defensive parse), so a re-login still produces a valid file
+ * rather than aborting on a corrupt one.
  *
- * @param {{ url: string, apiKey: string, agentUuid: string, agentName: string, yoloAckAt?: string }} data
- * @param {{ path?: string, write?: (p: string, c: string, o: object) => void, mkdir?: (p: string, o: object) => void }} [deps]
+ * Because writes now merge, NO field is ever silently dropped — in particular a
+ * `chorus login` preserves any pre-existing `cwds` / `yoloAckAt` /
+ * `sigintTimeoutMs` (daemon-config-field-merge change; supersedes the prior
+ * "credential change clears the yolo acknowledgement" behavior).
+ *
+ * @param {Record<string, unknown>} partial  The fields to set/overwrite.
+ * @param {{
+ *   path?: string,
+ *   read?: (p: string) => string,
+ *   write?: (p: string, c: string, o: object) => void,
+ *   mkdir?: (p: string, o: object) => void,
+ *   rename?: (from: string, to: string) => void,
+ * }} [deps]
+ * @returns {string} the file path written
  */
-export function writeLoginFile(data, deps = {}) {
+export function updateDaemonConfig(partial, deps = {}) {
   const path = deps.path ?? loginFilePath();
+  const read = deps.read ?? ((p) => readFileSync(p, "utf8"));
   const write = deps.write ?? writeFileSync;
   const mkdir = deps.mkdir ?? mkdirSync;
+  const rename = deps.rename ?? renameSync;
+
+  // Defensive read: missing / unreadable / malformed → start from empty so a
+  // re-login over a corrupt file still writes a valid one (no silent abort).
+  let current = {};
+  try {
+    const parsed = JSON.parse(read(path));
+    // Only a plain object is a valid config; arrays / scalars → start fresh.
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) current = parsed;
+  } catch {
+    // treat as empty
+  }
+
+  const merged = { ...current, ...partial };
   mkdir(dirname(path), { recursive: true });
-  write(path, JSON.stringify(data, null, 2) + "\n", { mode: 0o600 });
+  // Atomic write: temp file (0600) in the same dir, then rename over target.
+  const tmp = `${path}.tmp`;
+  write(tmp, JSON.stringify(merged, null, 2) + "\n", { mode: 0o600 });
+  rename(tmp, path);
   return path;
 }
 
 /**
- * Record (or refresh) the yolo acknowledgement in the existing login file,
- * preserving the credentials already on disk. Reads the current file, merges
- * `yoloAckAt`, and rewrites with 0600. Used by the daemon after an interactive
- * TTY yolo confirmation — it does NOT touch url/apiKey/identity.
+ * Persist credentials + identity to the login file with owner-only perms.
+ *
+ * Thin wrapper over {@link updateDaemonConfig}: it field-merges the given
+ * credential/identity fields over any existing file, so every OTHER pre-existing
+ * field (`cwds`, `yoloAckAt`, `sigintTimeoutMs`, …) is preserved across a
+ * `chorus login` or a daemon-start credential completion. It no longer omits
+ * `yoloAckAt` — a credential write never discards the recorded yolo ack.
+ *
+ * The `deps` seams (`path`, `write`, `mkdir`) are kept for callers/tests that
+ * inject IO; `write` is the low-level `(path, content, opts)` writer.
+ *
+ * @param {{ url: string, apiKey: string, agentUuid: string, agentName: string }} data
+ * @param {{ path?: string, write?: (p: string, c: string, o: object) => void, mkdir?: (p: string, o: object) => void, read?: (p: string) => string, rename?: (from: string, to: string) => void }} [deps]
+ */
+export function writeLoginFile(data, deps = {}) {
+  return updateDaemonConfig(data, deps);
+}
+
+/**
+ * Record (or refresh) the yolo acknowledgement in the login file, preserving
+ * everything already on disk. Delegates to {@link updateDaemonConfig}, which
+ * reads the current file, merges `yoloAckAt`, and rewrites with 0600. Used by
+ * the daemon after an interactive TTY yolo confirmation — it does NOT touch
+ * url/apiKey/identity.
  *
- * No-silent-errors: a read/parse failure is surfaced to the caller (throws), so
- * the daemon can log it rather than silently losing the ack.
+ * A TTY user whose credentials come from env / flags has no login file yet, but
+ * the ack must still persist (else they'd re-confirm yolo on every start). A
+ * file carrying only `yoloAckAt` is harmless — resolveCredentials simply falls
+ * through it.
  *
  * @param {string} yoloAckAt  ISO-8601 timestamp of the confirmation.
- * @param {{ path?: string, read?: (p: string) => string, write?: typeof writeLoginFile }} [deps]
+ * @param {{ path?: string, read?: (p: string) => string, write?: (p: string, c: string, o: object) => void, mkdir?: (p: string, o: object) => void, rename?: (from: string, to: string) => void }} [deps]
  * @returns {string} the file path written
  */
 export function recordYoloAck(yoloAckAt, deps = {}) {
-  const path = deps.path ?? loginFilePath();
-  const read = deps.read ?? ((p) => readFileSync(p, "utf8"));
-  const write = deps.write ?? writeLoginFile;
-  // Start from the existing file when present, else an empty object: a TTY user
-  // whose credentials come from env / flags has no login file yet, but the ack
-  // must still persist (else they'd re-confirm yolo on every start). A file
-  // carrying only `yoloAckAt` is harmless — resolveCredentials simply falls
-  // through it, and a later `chorus login` overwrites (clearing the ack).
-  let current = {};
-  try {
-    const parsed = JSON.parse(read(path));
-    if (parsed && typeof parsed === "object") current = parsed;
-  } catch {
-    // missing / unreadable / malformed → treat as empty (start fresh)
-  }
-  return write({ ...current, yoloAckAt }, { path });
+  return updateDaemonConfig({ yoloAckAt }, deps);
 }
 
 /**

package/cli/spawner-select.mjs

@@ -0,0 +1,30 @@
+// cli/spawner-select.mjs
+// Backend selection seam: maps the resolved agent type (daemon-agent.mjs) to a
+// concrete Spawner instance. This is the ONLY place the daemon branches on the
+// backend — the wake pipeline above it (queue, waker, directed delivery, headless
+// guard, reporters) stays backend-agnostic and drives whichever spawner is
+// injected purely through the shared wake(...) contract.
+//
+// The function is TOTAL: resolveAgentType has already rejected unknown values
+// before this runs, so an unrecognized type here is not a user error path — we
+// fall back to the safe default (claude-code) rather than throw.
+
+import { ClaudeSpawner } from "./claude-spawner.mjs";
+import { CodexSpawner } from "./codex-spawner.mjs";
+
+/**
+ * Construct the spawner backend for `agentType`.
+ * @param {string} agentType  "claude-code" | "codex" (already validated upstream).
+ * @param {{ logger?: any, permissionMode?: "chorus"|"yolo", creds?: { url: string, apiKey: string } }} [opts]
+ * @returns {import("./codex-spawner.mjs").Spawner}
+ */
+export function selectSpawner(agentType, opts = {}) {
+  const { logger, permissionMode, creds } = opts;
+  if (agentType === "codex") {
+    return new CodexSpawner({ logger, permissionMode, creds });
+  }
+  // Default / "claude-code": construction byte-identical to the prior daemon
+  // (ClaudeSpawner takes only { logger, permissionMode } — creds are not used by
+  // the Claude backend, which gets its key via the --mcp-config file).
+  return new ClaudeSpawner({ logger, permissionMode });
+}

package/cli/sse-listener.mjs

@@ -69,6 +69,13 @@ const PROCESS_STARTED_AT = new Date();
  *   wake: the control event is forked here BEFORE `onEvent`, so the router / WakeQueue
  *   never sees it and it can never spawn a new Claude. The handler verifies the target
  *   connection + entity and interrupts the running subprocess (see control-handler.mjs).
+ * @property {(event: Record<string, unknown>) => void} [onConflict]  Called for a
+ *   `type:"connection_conflict"` data event (add-daemon-connection-conflict-skip): the
+ *   server refused to register THIS cwd because a live different-process daemon already
+ *   holds the same (agent, host, cwd). Like `control`, it is forked BEFORE `onEvent` so
+ *   it can NEVER reach the router / WakeQueue — a conflict is not a wake. The daemon's
+ *   handler warns and permanently tears down this cwd's listener (it does not reconnect).
+ *   The event carries `{ host, cwd }` of the conflicting identity.
  * @property {() => Promise<void>} [onReconnect]  Called after a reconnect so the
  *   caller can back-fill notifications missed during the gap.
  * @property {string} [cwd]  The working directory THIS connection serves (T3 — 单
@@ -91,6 +98,7 @@ export class SseListener {
     this.onEvent = opts.onEvent;
     this.onConnectionId = opts.onConnectionId ?? (() => {});
     this.onControl = opts.onControl ?? (() => {});
+    this.onConflict = opts.onConflict ?? (() => {});
     this.onReconnect = opts.onReconnect ?? (async () => {});
     /** @type {string|null} The connection this stream registered as (once reported). */
     this.connectionUuid = null;
@@ -108,8 +116,14 @@ export class SseListener {
     // cwd is supplied the daemon is single-path: report the process cwd (the directory
     // it was launched from), identical to today / an old daemon (HARD-1).
     this.cwd = opts.cwd ?? process.cwd();
+    // The daemon backend driving this connection (daemon-agent-selection): the
+    // server registers the row's `clientType` from this self-report, so a
+    // `--agent codex` daemon shows as `codex` instead of mislabelling itself
+    // `claude_code`. Defaults to claude_code (the default backend / an old
+    // single-backend daemon that never sets it).
+    this.clientType = opts.clientType ?? "claude_code";
     const params = new URLSearchParams({
-      clientType: "claude_code",
+      clientType: this.clientType,
       clientVersion: CLI_VERSION,
       host: hostname(),
       cwd: this.cwd,
@@ -255,6 +269,20 @@ export class SseListener {
           }
           continue;
         }
+        // Connection conflict (add-daemon-connection-conflict-skip): the server refused
+        // to register THIS cwd because a live different-process daemon already holds the
+        // same (agent, host, cwd). Like `control`, fork it to onConflict and `continue`
+        // — it MUST NEVER fall through to onEvent (the router / WakeQueue), or a conflict
+        // would be mistaken for a wake and could spawn a subprocess. A conflict is not a
+        // wake; the daemon's handler warns and tears down this cwd's listener.
+        if (event && event.type === "connection_conflict") {
+          try {
+            this.onConflict(event);
+          } catch (err) {
+            this.logger.warn(`[Chorus] onConflict callback error: ${err}`);
+          }
+          continue;
+        }
         this.onEvent(event);
       }
     }

package/cli/upload-hooks.mjs

@@ -145,24 +145,84 @@ export function mergeUploadHooks(...args) {
 // top-level type — otherwise a tool-result-only user message would leak. The server
 // ingest stores ONLY `user`/`assistant` text (see /api/daemon/transcript), so this
 // filter mirrors exactly what the server will persist.
+//
+// Harness-injected synthetic content: when the model loads a skill, the skill's full
+// markdown body is delivered as a SYNTHETIC user turn. On the live stream-json stdout
+// (verified against Claude Code CLI 2.1.195 by capturing real `claude -p
+// --output-format stream-json --verbose` output) that envelope is
+// `{ type:"user", isSynthetic:true, message:{ content:[{type:"text", text:"Base
+// directory for this skill: …"}] } }`. Because it's a plain `text` block, the
+// block-level filter alone would KEEP it and leak the whole skill body to Chorus, so
+// we drop `type:"user"` envelopes flagged `isSynthetic:true` outright. ⚠️ FIELD NAME:
+// the live stream marks this `isSynthetic`; the on-disk transcript JSONL
+// (~/.claude/projects/.../*.jsonl, which the daemon does NOT read) marks the SAME
+// message `isMeta` — keying on `isMeta` here would be a silent no-op. Genuine human
+// instructions and the agent's own replies never carry `isSynthetic`, so this is a
+// purely structural match (no size/content heuristic) and cannot drop real content.
+// MCP-server instructions, CLAUDE.md context, and the deferred-tool listing are folded
+// into the dropped `type:"system"` init envelope and never reach this filter. Scope is
+// the Claude Code dialect only — the codex (`item.completed`) path is unaffected.
 
 /** Top-level stream-json envelope types that carry a conversation message. */
 const CONVERSATION_TYPES = new Set(["user", "assistant"]);
 
 /**
- * Extract the plain user/assistant TEXT from one Claude Code stream-json object,
- * dropping everything that is not a conversation text block (system/result
- * envelopes, thinking, tool_use, tool_result). Returns null when the object is not a
- * keepable conversation message (so the caller can skip it). Never throws — a shape
- * it doesn't recognize yields null rather than an error (defensive against CLI drift).
+ * Remove `<system-reminder>…</system-reminder>` spans from a retained text block
+ * (defense-in-depth for harness-injected reminders that ride inside a kept text
+ * block). Structural tag match — not a size/content heuristic. Non-reminder text is
+ * left untouched; a message that is only a reminder collapses to empty and is then
+ * dropped by the caller's emptiness check.
+ * @param {string} s
+ * @returns {string}
+ */
+function stripSystemReminders(s) {
+  return s.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "");
+}
+
+/**
+ * Extract the plain user/assistant TEXT from one stream object emitted by EITHER
+ * backend's headless stream, dropping everything that is not a conversation text
+ * block. Returns null when the object is not a keepable conversation message (so
+ * the caller can skip it). Never throws — a shape it doesn't recognize yields null
+ * rather than an error (defensive against CLI drift).
+ *
+ * Two stream dialects are recognized (their top-level shapes are disjoint, so no
+ * backend flag is needed):
+ *  - Claude Code stream-json: `{ type: "user"|"assistant", message: { content … } }`.
+ *  - codex `codex exec --json`: conversation/tool output rides on `item.completed`
+ *    events discriminated by `item.type`; assistant text is an `agent_message`
+ *    item with a top-level `item.text` (verified against codex-cli 0.142.3). codex
+ *    does NOT echo the user prompt (the chat UI renders that from the turn's
+ *    promptText), and `reasoning` / `command_execution` / lifecycle envelopes are
+ *    not conversation text — all dropped.
  *
- * @param {any} obj  One parsed stream-json NDJSON object.
+ * @param {any} obj  One parsed stream NDJSON object.
  * @returns {{ role: "user"|"assistant", text: string } | null}
  */
 export function extractTranscriptText(obj) {
   if (!obj || typeof obj !== "object") return null;
+
+  // ── codex `codex exec --json` dialect ──
+  // Only `item.completed` carries finished output; an `agent_message` item is the
+  // assistant's conversation text. Everything else (reasoning, command_execution,
+  // file_change, thread.started/turn.* lifecycle) is not user/assistant text.
+  if (obj.type === "item.completed") {
+    const item = obj.item;
+    if (!item || typeof item !== "object" || item.type !== "agent_message") return null;
+    const itemText = typeof item.text === "string" ? item.text : "";
+    if (!itemText.trim()) return null;
+    return { role: "assistant", text: itemText };
+  }
+
+  // ── Claude Code stream-json dialect ──
   if (!CONVERSATION_TYPES.has(obj.type)) return null;
 
+  // Drop harness-injected synthetic content (e.g. a loaded skill body). Claude Code
+  // marks these user turns `isSynthetic:true` on the live stream (NOT the on-disk
+  // `isMeta` field). Gated on `type:"user"` so a synthetic *assistant* envelope, if one
+  // ever appears, is still treated as real assistant text. Structural match only.
+  if (obj.type === "user" && obj.isSynthetic === true) return null;
+
   const message = obj.message;
   if (!message || typeof message !== "object") return null;
   // The persisted role is the message's role; fall back to the envelope type (they
@@ -190,8 +250,13 @@ export function extractTranscriptText(obj) {
     return null;
   }
 
-  // A message with no text (e.g. a user message that was purely a tool_result, or an
-  // assistant message that was purely tool_use/thinking) is dropped — nothing to store.
+  // Strip any wrapped <system-reminder> spans (defense-in-depth) before deciding
+  // emptiness, so a reminder-only message collapses to nothing and is dropped.
+  text = stripSystemReminders(text);
+
+  // A message with no text (e.g. a user message that was purely a tool_result, an
+  // assistant message that was purely tool_use/thinking, or text that was only a
+  // system-reminder) is dropped — nothing to store.
   if (!text.trim()) return null;
   return { role, text };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chorus-aidlc/chorus",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "The Agent Harness for AI-Human Collaboration — session lifecycle, task state, sub-agent orchestration, observability, and failure recovery",
   "homepage": "https://github.com/Chorus-AIDLC/Chorus",
   "repository": {

package/.next/standalone/.next/server/chunks/3371.js

@@ -1 +0,0 @@
-exports.id=3371,exports.ids=[3371],exports.modules={2978:(a,b,c)=>{Promise.resolve().then(c.bind(c,69187))},18151:(a,b,c)=>{Promise.resolve().then(c.t.bind(c,29723,23)),Promise.resolve().then(c.t.bind(c,31706,23)),Promise.resolve().then(c.t.bind(c,75324,23)),Promise.resolve().then(c.t.bind(c,20227,23)),Promise.resolve().then(c.t.bind(c,2931,23)),Promise.resolve().then(c.t.bind(c,17531,23)),Promise.resolve().then(c.t.bind(c,69357,23)),Promise.resolve().then(c.t.bind(c,69442,23)),Promise.resolve().then(c.t.bind(c,99875,23))},18421:(a,b,c)=>{var d={"./en.json":[50920,920],"./zh.json":[86113,6113]};function e(a){if(!c.o(d,a))return Promise.resolve().then(()=>{var b=Error("Cannot find module '"+a+"'");throw b.code="MODULE_NOT_FOUND",b});var b=d[a],e=b[0];return c.e(b[1]).then(()=>c.t(e,19))}e.keys=()=>Object.keys(d),e.id=18421,a.exports=e},21130:(a,b,c)=>{Promise.resolve().then(c.bind(c,58857))},21865:(a,b,c)=>{"use strict";c.d(b,{HB:()=>e,JK:()=>h,XQ:()=>g,bN:()=>i,vh:()=>f});var d=c(99582);function e(a){let b=function(a){let b=process.env.NEXTAUTH_URL||"http://localhost:8637";return{authority:a.issuer,client_id:a.clientId,redirect_uri:`${b}/login/callback`,post_logout_redirect_uri:`${b}/login`,response_type:"code",scope:"openid profile email",automaticSilentRenew:!1,silent_redirect_uri:`${b}/login/silent-refresh`,accessTokenExpiringNotificationTimeInSeconds:60,userStore:void 0,extraQueryParams:{company:a.companyUuid}}}(a);return new d.$5(b)}function f(a){}function g(){return null}function h(){}function i(a){return{sub:a.profile.sub,email:a.profile.email,name:a.profile.name,picture:a.profile.picture,accessToken:a.access_token,refreshToken:a.refresh_token,expiresAt:a.expires_at,idToken:a.id_token}}},32376:()=>{},33367:(a,b,c)=>{"use strict";c.r(b),c.d(b,{default:()=>e});var d=c(10948);let e=async a=>[{type:"image/x-icon",sizes:"256x256",url:(0,d.fillMetadataSegment)(".",await a.params,"favicon.ico")+""}]},35198:(a,b,c)=>{"use strict";c.d(b,{BT:()=>i,Wu:()=>j,ZB:()=>h,Zp:()=>f,aR:()=>g});var d=c(10837);c(21968);var e=c(96307);function f({className:a,...b}){return(0,d.jsx)("div",{"data-slot":"card",className:(0,e.cn)("bg-card text-card-foreground flex flex-col gap-6 rounded-xl border py-6 shadow-sm",a),...b})}function g({className:a,...b}){return(0,d.jsx)("div",{"data-slot":"card-header",className:(0,e.cn)("@container/card-header grid auto-rows-min grid-rows-[auto_auto] items-start gap-2 px-6 has-data-[slot=card-action]:grid-cols-[1fr_auto] [.border-b]:pb-6",a),...b})}function h({className:a,...b}){return(0,d.jsx)("div",{"data-slot":"card-title",className:(0,e.cn)("leading-none font-semibold",a),...b})}function i({className:a,...b}){return(0,d.jsx)("div",{"data-slot":"card-description",className:(0,e.cn)("text-muted-foreground text-sm",a),...b})}function j({className:a,...b}){return(0,d.jsx)("div",{"data-slot":"card-content",className:(0,e.cn)("px-6",a),...b})}},40340:(a,b,c)=>{"use strict";c.r(b),c.d(b,{default:()=>k,metadata:()=>j});var d=c(10023),e=c(28103),f=c.n(e),g=c(85355),h=c.n(g),i=c(69187);c(32376);let j={title:{default:"Chorus",template:"%s | Chorus"},description:"AI Agent & Human collaboration platform for the AI-Driven Development Lifecycle",openGraph:{title:"Chorus",description:"AI Agent & Human collaboration platform for the AI-Driven Development Lifecycle",type:"website",siteName:"Chorus"}};function k({children:a}){return(0,d.jsx)("html",{lang:"en",children:(0,d.jsx)("body",{className:`${f().variable} ${h().variable} antialiased`,children:(0,d.jsx)(i.LocaleProvider,{children:a})})})}},42424:(a,b,c)=>{"use strict";c.d(b,{$:()=>i});var d=c(10837);c(21968);var e=c(35973),f=c(11156),g=c(96307);let h=(0,e.F)("inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium cursor-pointer transition-all disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4 shrink-0 [&_svg]:shrink-0 outline-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive",{variants:{variant:{default:"bg-primary text-primary-foreground hover:bg-primary/90",destructive:"bg-destructive text-white hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60",outline:"border bg-background shadow-xs hover:bg-accent hover:text-accent-foreground dark:bg-input/30 dark:border-input dark:hover:bg-input/50",secondary:"bg-secondary text-secondary-foreground hover:bg-secondary/80",ghost:"hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50",link:"text-primary underline-offset-4 hover:underline"},size:{default:"h-9 px-4 py-2 has-[>svg]:px-3",xs:"h-6 gap-1 rounded-md px-2 text-xs has-[>svg]:px-1.5 [&_svg:not([class*='size-'])]:size-3",sm:"h-8 rounded-md gap-1.5 px-3 has-[>svg]:px-2.5",lg:"h-10 rounded-md px-6 has-[>svg]:px-4",icon:"size-9","icon-xs":"size-6 rounded-md [&_svg:not([class*='size-'])]:size-3","icon-sm":"size-8","icon-lg":"size-10"}},defaultVariants:{variant:"default",size:"default"}});function i({className:a,variant:b="default",size:c="default",asChild:e=!1,...i}){let j=e?f.bL:"button";return(0,d.jsx)(j,{"data-slot":"button","data-variant":b,"data-size":c,className:(0,g.cn)(h({variant:b,size:c,className:a})),...i})}},48415:(a,b,c)=>{Promise.resolve().then(c.t.bind(c,16885,23)),Promise.resolve().then(c.t.bind(c,30892,23)),Promise.resolve().then(c.t.bind(c,89410,23)),Promise.resolve().then(c.t.bind(c,99349,23)),Promise.resolve().then(c.t.bind(c,41105,23)),Promise.resolve().then(c.t.bind(c,89065,23)),Promise.resolve().then(c.t.bind(c,403,23)),Promise.resolve().then(c.t.bind(c,33532,23)),Promise.resolve().then(c.bind(c,41905))},54722:(a,b,c)=>{"use strict";c.d(b,{q:()=>g});let d={debug:0,info:1,warn:2,error:3},e=process.env.NEXT_PUBLIC_LOG_LEVEL||"warn";function f(a){return d[a]>=d[e]}let g={debug:(a,...b)=>{f("debug")&&console.debug(`[Chorus] ${a}`,...b)},info:(a,...b)=>{f("info")&&console.info(`[Chorus] ${a}`,...b)},warn:(a,...b)=>{f("warn")&&console.warn(`[Chorus] ${a}`,...b)},error:(a,...b)=>{f("error")&&console.error(`[Chorus] ${a}`,...b)}}},58857:(a,b,c)=>{"use strict";c.d(b,{LocaleProvider:()=>j,Y:()=>i});var d=c(10837),e=c(21968),f=c(13256),g=c(97553);c(54722);let h=(0,e.createContext)(null);function i(){let a=(0,e.useContext)(h);if(!a)throw Error("useLocale must be used within LocaleProvider");return a}function j({children:a}){let[b,c]=(0,e.useState)(g.q),[i,j]=(0,e.useState)(null),[k,l]=(0,e.useState)(!1),m=(0,e.useCallback)(a=>{c(a),localStorage.setItem("chorus-locale",a),document.cookie=`chorus-locale=${a};path=/;max-age=31536000;SameSite=Lax`,document.documentElement.lang=a},[]);return k&&i?(0,d.jsx)(h.Provider,{value:{locale:b,setLocale:m},children:(0,d.jsx)(f.A,{locale:b,messages:i,children:a})}):null}},69187:(a,b,c)=>{"use strict";c.d(b,{LocaleProvider:()=>e});var d=c(37143);(0,d.registerClientReference)(function(){throw Error("Attempted to call useLocale() from the server but useLocale is on the client. It's not possible to invoke a client function from the server, it can only be rendered as a Component or passed to props of a Client Component.")},"/home/ubuntu/dev/ai-pm/src/contexts/locale-context.tsx","useLocale");let e=(0,d.registerClientReference)(function(){throw Error("Attempted to call LocaleProvider() from the server but LocaleProvider is on the client. It's not possible to invoke a client function from the server, it can only be rendered as a Component or passed to props of a Client Component.")},"/home/ubuntu/dev/ai-pm/src/contexts/locale-context.tsx","LocaleProvider")},93524:(a,b,c)=>{"use strict";c.d(b,{OX:()=>l,aK:()=>k,dv:()=>f,hj:()=>g,ri:()=>n,tm:()=>m,vN:()=>i,w9:()=>h});var d=c(21865),e=c(54722);function f(){return null}function g(a){return(0,d.vh)(a),(0,d.HB)(a)}function h(){}async function i(){let a=f();if(!a)return null;try{return await a.getUser()}catch{return null}}async function j(){let a=await i();return a?a.access_token:null}async function k(a,b){try{return(await fetch("/api/auth/sync-token",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({accessToken:a,refreshToken:b})})).ok}catch{return e.q.error("Failed to sync token to cookie"),!1}}async function l(){try{await fetch("/api/keepalive",{method:"GET",credentials:"same-origin",cache:"no-store"})}catch{}}async function m(a,b={}){let c=await j(),d=new Headers(b.headers);c&&d.set("Authorization",`Bearer ${c}`);let e=await fetch(a,{...b,headers:d});if(401===e.status)if(f());else try{if((await fetch("/api/auth/refresh",{method:"POST"})).ok)return d.delete("Authorization"),fetch(a,{...b,headers:d})}catch{}return e}async function n(){try{await fetch("/api/auth/logout",{method:"POST"})}catch{}let a=f();if(a)try{await a.removeUser()}catch{}h(),(0,d.JK)()}},96307:(a,b,c)=>{"use strict";c.d(b,{cn:()=>f});var d=c(25335),e=c(30393);function f(...a){return(0,e.QP)((0,d.$)(a))}},97553:(a,b,c)=>{"use strict";c.d(b,{AL:()=>g,IB:()=>d,L$:()=>f,q:()=>e});let d=["en","zh"],e="en",f={en:"English",zh:"中文"};function g(){if("undefined"==typeof navigator)return e;let a=navigator.language.split("-")[0];return d.includes(a)?a:e}}};