@chorus-aidlc/chorus 0.16.2 → 0.16.4

package/cli/dsh-spawner.mjs

@@ -0,0 +1,438 @@
+// External DeepSeek Harness SDK runtime bridge. One fresh JSON-RPC runtime and
+// session are created per wake; no dsh session state is persisted by Chorus.
+
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { statSync } from "node:fs";
+import { win32 as pathWin32, posix as pathPosix } from "node:path";
+import { prepareManagedDshConfig } from "./dsh-managed-config.mjs";
+
+const NOOP_LOGGER = { info() {}, warn() {}, error() {} };
+export const DEFAULT_DSH_TIMEOUT_MS = 30 * 60 * 1000;
+export const DEFAULT_DSH_SHUTDOWN_TIMEOUT_MS = 5_000;
+
+function nonEmpty(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+function positiveInt(value, fallback) {
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function isFile(path) {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+
+/** Resolve the external SDK runtime. CHORUS_DSH_PATH overrides PATH. */
+export function resolveDshPath(deps = {}) {
+  const env = deps.env ?? process.env;
+  const platform = deps.platform ?? process.platform;
+  const fileProbe = deps.isFile ?? isFile;
+  const override = nonEmpty(env.CHORUS_DSH_PATH);
+  if (override && fileProbe(override)) return override;
+
+  const windows = platform === "win32";
+  const path = windows ? pathWin32 : pathPosix;
+  const names = windows
+    ? ["dsh-jsonrpc-agent.cmd", "dsh-jsonrpc-agent.exe", "dsh-jsonrpc-agent"]
+    : ["dsh-jsonrpc-agent"];
+  const dirs = (env.PATH || env.Path || "").split(path.delimiter).filter(Boolean);
+  for (const dir of dirs) {
+    for (const name of names) {
+      const candidate = path.join(dir, name);
+      if (fileProbe(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
+/** Resolve the required Cordis composition without placing it in argv. */
+export function resolveDshConfig(env = process.env) {
+  return nonEmpty(env.CHORUS_DSH_CONFIG) ?? nonEmpty(env.DSH_CORDIS_CONFIG);
+}
+
+/** Windows npm command shims need cmd.exe while retaining argv isolation. */
+export function resolveDshSpawnCommand(dshPath, platform = process.platform, env = process.env) {
+  const lower = dshPath.toLowerCase();
+  if (platform === "win32" && (lower.endsWith(".cmd") || lower.endsWith(".bat"))) {
+    return {
+      command: env.ComSpec || env.COMSPEC || "cmd.exe",
+      argv: ["/d", "/s", "/c", dshPath],
+    };
+  }
+  return { command: dshPath, argv: [] };
+}
+
+function tokenCount(value) {
+  return Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+
+/** Add one upstream TokenUsage object into the per-wake disjoint totals. */
+export function addDshUsage(total, usage) {
+  if (!usage || typeof usage !== "object") return total;
+  for (const [source, target] of [
+    ["inputTokens", "inputTokens"],
+    ["outputTokens", "outputTokens"],
+    ["cacheWriteTokens", "cacheCreationTokens"],
+    ["cacheReadTokens", "cacheReadTokens"],
+  ]) {
+    const count = tokenCount(usage[source]);
+    if (count === null) continue;
+    total[target] = (total[target] ?? 0) + count;
+  }
+  return total;
+}
+
+function hasVisibleAssistantContent(data) {
+  const content = data?.message?.content;
+  return Array.isArray(content) && content.length > 0;
+}
+
+function containsReceipt(event, messageId) {
+  if (event?.type !== "agent/inbox/spliced" || !Array.isArray(event?.data?.inserted)) return false;
+  return event.data.inserted.some((message) => message && message.id === messageId);
+}
+
+function deferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+function errorText(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function withTimeout(promise, timeoutMs, message) {
+  let timer;
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+      timer.unref?.();
+    }),
+  ]).finally(() => clearTimeout(timer));
+}
+
+export class DshSpawner {
+  constructor(opts = {}) {
+    this.sessionDecision = { probeIsAuthoritative: false };
+    this.dshPath = opts.dshPath ?? null;
+    this.spawnImpl = opts.spawnImpl ?? spawn;
+    this.resolveDshPathFn = opts.resolveDshPathFn ?? resolveDshPath;
+    this.uuidFn = opts.uuidFn ?? randomUUID;
+    this.logger = opts.logger ?? NOOP_LOGGER;
+    this.creds = opts.creds ?? null;
+    this.platform = opts.platform ?? process.platform;
+    this.env = opts.env ?? process.env;
+    this.bundleVersion = opts.bundleVersion ?? null;
+    this.prepareManagedConfigFn = opts.prepareManagedConfigFn ?? prepareManagedDshConfig;
+    this.timeoutMs = opts.timeoutMs ?? positiveInt(this.env.CHORUS_DSH_TIMEOUT_MS, DEFAULT_DSH_TIMEOUT_MS);
+    this.shutdownTimeoutMs =
+      opts.shutdownTimeoutMs ??
+      positiveInt(this.env.CHORUS_DSH_SHUTDOWN_TIMEOUT_MS, DEFAULT_DSH_SHUTDOWN_TIMEOUT_MS);
+  }
+
+  async wake({ prompt, sessionId: anchor, cwd, onMessage, onChild }) {
+    let dshPath = this.dshPath ?? this.resolveDshPathFn({ env: this.env, platform: this.platform });
+    let config = resolveDshConfig(this.env);
+    const result = (backendSessionId, exitCode) => ({
+      sessionId: backendSessionId || anchor || "",
+      backendSessionId: backendSessionId || null,
+      exitCode,
+      isNew: true,
+    });
+
+    if (!dshPath) {
+      this.logger.error(
+        "[Chorus] cannot locate `dsh-jsonrpc-agent`; install it or set CHORUS_DSH_PATH",
+      );
+      return result(null, null);
+    }
+    if (!config) {
+      try {
+        const managed = await this.prepareManagedConfigFn({
+          env: this.env,
+          bundleVersion: this.bundleVersion,
+          dshPath,
+          creds: this.creds,
+        });
+        config = managed.configPath;
+        dshPath = managed.runtimePath ?? dshPath;
+      } catch (error) {
+        this.logger.error(`[Chorus] cannot prepare managed dsh config: ${errorText(error)}`);
+        return result(null, null);
+      }
+    }
+
+    const dshSessionId = `chorus-${this.uuidFn().replaceAll("-", "")}`;
+    const provider =
+      nonEmpty(this.env.CHORUS_DSH_PROVIDER) ?? nonEmpty(this.env.DSH_PROVIDER) ?? "deepseek-official";
+    const model =
+      nonEmpty(this.env.CHORUS_DSH_MODEL) ?? nonEmpty(this.env.DSH_MODEL) ?? "deepseek-v4-flash";
+    const childEnv = {
+      ...this.env,
+      CHORUS_DAEMON_HEADLESS: "1",
+      DSH_CORDIS_CONFIG: config,
+      DSH_CWD: cwd || process.cwd(),
+    };
+    if (this.creds?.url) childEnv.CHORUS_URL = this.creds.url;
+    if (this.creds?.apiKey) childEnv.CHORUS_API_KEY = this.creds.apiKey;
+
+    const { command, argv } = resolveDshSpawnCommand(dshPath, this.platform, childEnv);
+    let child;
+    try {
+      child = this.spawnImpl(command, argv, {
+        cwd: cwd || undefined,
+        env: childEnv,
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: false,
+        detached: this.platform !== "win32",
+        windowsHide: true,
+      });
+    } catch (error) {
+      this.logger.error(`[Chorus] failed to start dsh runtime: ${errorText(error)}`);
+      return result(dshSessionId, null);
+    }
+
+    try {
+      onChild?.(child);
+    } catch (error) {
+      this.logger.warn(`[Chorus] onChild handler threw: ${errorText(error)}`);
+    }
+
+    child.stdout?.setEncoding?.("utf8");
+    child.stderr?.setEncoding?.("utf8");
+    child.stdin?.on?.("error", () => {});
+
+    const closed = deferred();
+    const failed = deferred();
+    // A rejected failure promise is raced below; attaching this handler prevents
+    // a process-exit rejection from becoming unhandled during successful setup.
+    failed.promise.catch(() => {});
+    let exitCode;
+    let closeSeen = false;
+    let protocolDone = false;
+    let stdoutBuffer = "";
+    let stderrBuffer = "";
+    let serial = 0;
+    const pending = new Map();
+    const notifications = [];
+    let notificationCursor = 0;
+    let messageId = null;
+    let receiptSeen = false;
+    const idle = deferred();
+    idle.promise.catch(() => {});
+    const usage = {
+      inputTokens: null,
+      outputTokens: null,
+      cacheCreationTokens: null,
+      cacheReadTokens: null,
+    };
+
+    const fail = (message) => {
+      if (protocolDone) return;
+      protocolDone = true;
+      const error = message instanceof Error ? message : new Error(String(message));
+      for (const waiter of pending.values()) waiter.reject(error);
+      pending.clear();
+      idle.reject(error);
+      failed.reject(error);
+    };
+
+    const emit = (frame) => {
+      try {
+        onMessage?.(frame);
+      } catch (error) {
+        this.logger.warn(`[Chorus] onMessage handler threw: ${errorText(error)}`);
+      }
+    };
+
+    const processNotifications = () => {
+      if (!messageId || protocolDone) return;
+      while (notificationCursor < notifications.length) {
+        const notification = notifications[notificationCursor++];
+        const params = notification.params;
+        if (params?.sessionId !== dshSessionId) continue;
+        if (!receiptSeen) {
+          if (notification.method === "session.event" && containsReceipt(params.event, messageId)) {
+            receiptSeen = true;
+          }
+          continue;
+        }
+        if (notification.method === "session.event") {
+          const event = params.event;
+          if (!event || typeof event !== "object" || typeof event.type !== "string") {
+            fail("dsh session.event carried a malformed event envelope");
+            return;
+          }
+          if (event.type === "assistant/message") addDshUsage(usage, event.data?.usage);
+          if (event.type === "user/message" || (event.type === "assistant/message" && hasVisibleAssistantContent(event.data))) {
+            emit({ type: event.type, session_id: dshSessionId, data: event.data });
+          }
+        } else if (notification.method === "session.status" && params.status === "idle") {
+          idle.resolve();
+          return;
+        }
+      }
+    };
+
+    const handleFrame = (frame) => {
+      if (!frame || typeof frame !== "object" || frame.jsonrpc !== "2.0") {
+        fail("dsh runtime emitted a malformed JSON-RPC frame");
+        return;
+      }
+      if ((typeof frame.id === "string" || typeof frame.id === "number") && !frame.method) {
+        const waiter = pending.get(frame.id);
+        if (!waiter) return;
+        pending.delete(frame.id);
+        if (frame.error && typeof frame.error === "object") {
+          waiter.reject(
+            new Error(
+              `dsh JSON-RPC error ${frame.error.code ?? ""}: ${frame.error.message ?? "unknown error"}`,
+            ),
+          );
+        } else {
+          waiter.resolve(frame.result);
+        }
+        return;
+      }
+      if (typeof frame.method === "string" && frame.id === undefined) {
+        notifications.push({
+          method: frame.method,
+          params: frame.params && typeof frame.params === "object" && !Array.isArray(frame.params)
+            ? frame.params
+            : {},
+        });
+        processNotifications();
+      }
+    };
+
+    child.stdout?.on?.("data", (chunk) => {
+      stdoutBuffer += String(chunk);
+      for (;;) {
+        const newline = stdoutBuffer.indexOf("\n");
+        if (newline < 0) break;
+        const line = stdoutBuffer.slice(0, newline).trim();
+        stdoutBuffer = stdoutBuffer.slice(newline + 1);
+        if (!line) continue;
+        try {
+          handleFrame(JSON.parse(line));
+        } catch {
+          fail("dsh runtime emitted malformed JSON on stdout");
+        }
+      }
+    });
+    child.stderr?.on?.("data", (chunk) => {
+      stderrBuffer += String(chunk);
+      for (;;) {
+        const newline = stderrBuffer.indexOf("\n");
+        if (newline < 0) break;
+        const line = stderrBuffer.slice(0, newline).trim();
+        stderrBuffer = stderrBuffer.slice(newline + 1);
+        if (line) this.logger.warn(`[dsh] ${line}`);
+      }
+    });
+    child.on?.("error", (error) => fail(`dsh runtime process error: ${errorText(error)}`));
+    child.on?.("close", (code) => {
+      closeSeen = true;
+      exitCode = code;
+      if (stderrBuffer.trim()) this.logger.warn(`[dsh] ${stderrBuffer.trim()}`);
+      if (!protocolDone) fail(`dsh runtime exited before protocol completion (code ${code})`);
+      closed.resolve(code);
+    });
+
+    const request = (method, params = {}) => {
+      const id = `chorus_${++serial}`;
+      return new Promise((resolve, reject) => {
+        pending.set(id, { resolve, reject });
+        try {
+          child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}\n`);
+        } catch (error) {
+          pending.delete(id);
+          reject(error);
+        }
+      });
+    };
+
+    const stopRuntime = async () => {
+      if (closeSeen) return;
+      try {
+        child.stdin?.end?.();
+      } catch {}
+      try {
+        await withTimeout(closed.promise, this.shutdownTimeoutMs, "dsh runtime did not exit after stdin closed");
+      } catch {
+        try {
+          child.kill?.("SIGTERM");
+        } catch {}
+      }
+    };
+
+    try {
+      const initialize = await withTimeout(
+        Promise.race([
+          request("initialize", { cwd: cwd || process.cwd(), provider, model }),
+          failed.promise,
+        ]),
+        this.shutdownTimeoutMs,
+        "dsh initialize timed out",
+      );
+      if (initialize?.serverInfo?.name !== "deepseek-harness-sdk-runtime") {
+        throw new Error("dsh initialize returned an unexpected server identity");
+      }
+
+      const promptResult = await withTimeout(
+        Promise.race([
+          request("session/prompt", {
+            sessionId: dshSessionId,
+            contentBlocks: [{ type: "text", text: String(prompt ?? "") }],
+          }),
+          failed.promise,
+        ]),
+        this.shutdownTimeoutMs,
+        "dsh session/prompt timed out",
+      );
+      if (!nonEmpty(promptResult?.messageId)) {
+        throw new Error("dsh session/prompt returned no messageId");
+      }
+      messageId = promptResult.messageId;
+      processNotifications();
+
+      await withTimeout(
+        Promise.race([idle.promise, failed.promise]),
+        this.timeoutMs,
+        `dsh turn timed out after ${this.timeoutMs}ms waiting for root idle`,
+      );
+      emit({
+        type: "dsh.turn.completed",
+        session_id: dshSessionId,
+        usage: { ...usage, model, source: "dsh" },
+      });
+
+      await withTimeout(
+        Promise.race([request("shutdown"), failed.promise]),
+        this.shutdownTimeoutMs,
+        "dsh shutdown timed out",
+      );
+      protocolDone = true;
+      child.stdin?.end?.();
+      await withTimeout(closed.promise, this.shutdownTimeoutMs, "dsh runtime did not exit after shutdown");
+      return result(dshSessionId, exitCode);
+    } catch (error) {
+      this.logger.error(`[Chorus] dsh wake failed: ${errorText(error)}`);
+      protocolDone = true;
+      await stopRuntime();
+      return result(dshSessionId, typeof exitCode === "number" && exitCode !== 0 ? exitCode : null);
+    }
+  }
+}

package/cli/login.mjs

@@ -9,6 +9,7 @@ import { createInterface } from "node:readline";
 
 import { loginFilePath } from "./credentials.mjs";
 import { validateAndFetchIdentity } from "./chorus-client.mjs";
+import { promptAgentBackend } from "./agent-backend-prompt.mjs";
 
 /**
  * Prompt for a line of input. When `mask` is true, typed characters are not
@@ -219,12 +220,21 @@ export function appendAgentConfig(agentObj, deps = {}) {
  * single flat credential — so one daemon can serve several agents. On an invalid
  * key, or a duplicate, nothing is written.
  *
+ * The agent backend (agent type) is captured too: an explicit `--agent` wins,
+ * otherwise an interactive menu is offered on a TTY (skipped on a non-TTY so a
+ * scripted login never blocks). No choice → nothing is written for the backend
+ * (the `--add` entry omits `agentType`; the single-agent config omits the
+ * top-level `agent`), so it inherits the daemon default — never a literal
+ * `claude-code`. See {@link promptAgentBackend}.
+ *
  * @param {{ url?: string, apiKey?: string, agent?: string, add?: boolean }} flags
  * @param {{
  *   validate?: typeof validateAndFetchIdentity,
  *   write?: typeof writeLoginFile,
  *   appendAgent?: typeof appendAgentConfig,
  *   prompt?: typeof prompt,
+ *   promptBackend?: typeof promptAgentBackend,
+ *   isTTY?: boolean,
  *   log?: (m: string) => void,
  *   errLog?: (m: string) => void,
  * }} [deps]
@@ -235,6 +245,8 @@ export async function runLogin(flags = {}, deps = {}) {
   const write = deps.write ?? writeLoginFile;
   const appendAgent = deps.appendAgent ?? appendAgentConfig;
   const ask = deps.prompt ?? prompt;
+  const promptBackend = deps.promptBackend ?? promptAgentBackend;
+  const isTTY = deps.isTTY ?? Boolean(process.stdin.isTTY);
   const log = deps.log ?? ((m) => process.stdout.write(m + "\n"));
   const errLog = deps.errLog ?? ((m) => process.stderr.write(m + "\n"));
 
@@ -259,10 +271,16 @@ export async function runLogin(flags = {}, deps = {}) {
     return 1;
   }
 
+  // Which agent backend should this agent use? Explicit --agent wins; otherwise
+  // offer the interactive menu on a TTY. `undefined` = no explicit choice → we
+  // write NO backend key so it inherits the daemon default (never claude-code).
+  let agentType = nonEmpty(flags.agent);
+  if (!agentType) agentType = await promptBackend({ ask, log, isTTY });
+
   // --add: append as an additional agent (multi-agent) instead of overwriting.
   if (flags.add) {
     const agentObj = { url, apiKey, agentUuid: identity.uuid, agentName: identity.name };
-    if (nonEmpty(flags.agent)) agentObj.agentType = nonEmpty(flags.agent);
+    if (agentType) agentObj.agentType = agentType;
     const res = appendAgent(agentObj);
     if (!res.ok) {
       errLog(
@@ -270,13 +288,17 @@ export async function runLogin(flags = {}, deps = {}) {
       );
       return 1;
     }
-    log(`Added agent ${identity.name} (${identity.uuid}) as agents[${res.index}] in ${res.path}.`);
+    const backendNote = agentType ? ` — backend: ${agentType}` : "";
+    log(`Added agent ${identity.name} (${identity.uuid}) as agents[${res.index}] in ${res.path}${backendNote}.`);
     log(`This daemon now serves ${res.agents.length} agent(s).`);
     return 0;
   }
 
-  const path = write({ url, apiKey, agentUuid: identity.uuid, agentName: identity.name });
-  log(`Logged in as ${identity.name} (${identity.uuid}).`);
+  const loginData = { url, apiKey, agentUuid: identity.uuid, agentName: identity.name };
+  if (agentType) loginData.agent = agentType;
+  const path = write(loginData);
+  const backendNote = agentType ? ` — backend: ${agentType}` : "";
+  log(`Logged in as ${identity.name} (${identity.uuid})${backendNote}.`);
   log(`Credentials saved to ${path}.`);
   return 0;
 }

package/cli/prompts.mjs

@@ -320,10 +320,20 @@ function buildPromptBody(n) {
       );
     }
     case "idea_claimed":
+      // The assignment ALREADY set you as the assignee, so there is nothing to claim —
+      // chorus_claim_idea would throw (AlreadyClaimedError, and a hard "Cannot claim an
+      // elaborated Idea" for the elaborated-backfill case). Do NOT emit a claim
+      // instruction here (a prompt test asserts the literal never appears). Instead tell
+      // the already-assigned agent to review and advance from the idea's CURRENT stage,
+      // stopping at the human proposal/verify gates. Names the assigner via n.actorName /
+      // n.actorType (already on the notification — no server change). Mirrored in the
+      // OpenClaw twin handleIdeaClaimed (event-router.ts) — KEEP THE TWO WORDINGS IN SYNC.
       return (
-        `[Chorus] Idea '${n.entityTitle}' was assigned to you (ideaUuid: ${n.entityUuid}, ` +
-        `projectUuid: ${n.projectUuid}). Use chorus_get_idea to review it, then claim it ` +
-        `(chorus_claim_idea) to begin elaboration.\n${mentionGuidance(n, "idea")}`
+        `[Chorus] Idea '${n.entityTitle}' was assigned to you by ${n.actorName} (${n.actorType}) ` +
+        `(ideaUuid: ${n.entityUuid}, projectUuid: ${n.projectUuid}). You are now the assignee — no need ` +
+        `to claim it. Use chorus_get_idea to review it, then advance it from its CURRENT stage: if it is ` +
+        `still elaborating, run or continue elaboration; if it is already elaborated, author the proposal. ` +
+        `Stop at the human proposal/verify gates and never merge automatically.\n${mentionGuidance(n, "idea")}`
       );
     case "task_reopened":
       return (

package/cli/spawner-select.mjs

@@ -11,11 +11,12 @@
 
 import { ClaudeSpawner } from "./claude-spawner.mjs";
 import { CodexSpawner } from "./codex-spawner.mjs";
+import { DshSpawner } from "./dsh-spawner.mjs";
 import { KiroSpawner } from "./kiro-spawner.mjs";
 
 /**
  * Construct the spawner backend for `agentType`.
- * @param {string} agentType  "claude-code" | "codex" | "kiro" (already validated upstream).
+ * @param {string} agentType  "claude-code" | "codex" | "kiro" | "dsh" (already validated upstream).
  * @param {{ logger?: any, permissionMode?: "chorus"|"yolo", creds?: { url: string, apiKey: string } }} [opts]
  * @returns {import("./codex-spawner.mjs").Spawner}
  */
@@ -27,5 +28,13 @@ export function selectSpawner(agentType, opts = {}) {
   if (agentType === "kiro") {
     return new KiroSpawner({ logger, permissionMode, creds });
   }
+  if (agentType === "dsh") {
+    return new DshSpawner({
+      logger,
+      creds,
+      bundleVersion: opts.bundleVersion,
+      prepareManagedConfigFn: opts.prepareManagedConfigFn,
+    });
+  }
   return new ClaudeSpawner({ logger, permissionMode, creds });
 }

package/cli/turn-reporter.mjs

@@ -52,7 +52,7 @@ export const TURN_INTERRUPT_REASONS = new Set([
  *   logger?: { info(m:string):void, warn(m:string):void, error(m:string):void },
  *   fetchImpl?: typeof fetch,             Injectable for tests.
  * }} opts
- * @returns {(params: { sessionId: string, status: "running"|"ended"|"interrupted", entityType?: string|null, entityUuid?: string|null, interruptedReason?: "user"|"crash"|"shutdown"|"invalid_path"|null, transcriptRelayError?: string|null, usage?: import("./upload-hooks.mjs").TokenUsage|null, coalescedCount?: number }) => Promise<void>}
+ * @returns {(params: { sessionId: string, turnUuid?: string|null, status: "running"|"ended"|"interrupted", entityType?: string|null, entityUuid?: string|null, interruptedReason?: "user"|"crash"|"shutdown"|"invalid_path"|null, transcriptRelayError?: string|null, usage?: import("./upload-hooks.mjs").TokenUsage|null, coalescedCount?: number }) => Promise<import("./daemon-rest-client.mjs").DaemonRestResult|undefined>}
  */
 export function createTurnReporter(opts) {
   const logger = opts.logger ?? NOOP_LOGGER;
@@ -69,6 +69,7 @@ export function createTurnReporter(opts) {
 
   return async function advanceTurn({
     sessionId,
+    turnUuid,
     status,
     entityType,
     entityUuid,
@@ -101,8 +102,9 @@ export function createTurnReporter(opts) {
     // entityType/entityUuid only when both are present, and transcriptRelayError only when
     // truthy (fix #444 follow-up) — and logs the failure cause on a network error / non-2xx.
     // We swallow the structured result so a failed report can never crash the wake path.
-    await client.turnAdvance({
+    const result = await client.turnAdvance({
       sessionId,
+      turnUuid,
       status,
       entityType,
       entityUuid,
@@ -116,5 +118,6 @@ export function createTurnReporter(opts) {
       // client sends it only on the → running edge and only when > 1 (a single wake omits it).
       coalescedCount,
     });
+    return result;
   };
 }

package/cli/upload-hooks.mjs

@@ -235,6 +235,7 @@ export const CLAUDE_CODE_USAGE_SOURCE = "claude_code";
  * daemon's Codex client type (`"codex"`, per cli/daemon-agent.mjs `backendClientType`)
  * so persisted usage is attributable to the right backend / connection. */
 export const CODEX_USAGE_SOURCE = "codex";
+export const DSH_USAGE_SOURCE = "dsh";
 
 /**
  * Coerce a value to a non-negative integer token count, or null. Guards against a
@@ -363,6 +364,21 @@ export function extractCodexTurnUsage(obj) {
   };
 }
 
+/** Extract the normalized terminal usage frame emitted by DshSpawner. */
+export function extractDshTurnUsage(obj) {
+  if (!obj || typeof obj !== "object" || obj.type !== "dsh.turn.completed") return null;
+  const usage = obj.usage;
+  if (!usage || typeof usage !== "object") return null;
+  return {
+    inputTokens: toTokenInt(usage.inputTokens),
+    outputTokens: toTokenInt(usage.outputTokens),
+    cacheCreationTokens: toTokenInt(usage.cacheCreationTokens),
+    cacheReadTokens: toTokenInt(usage.cacheReadTokens),
+    model: typeof usage.model === "string" && usage.model.trim() ? usage.model : null,
+    source: DSH_USAGE_SOURCE,
+  };
+}
+
 /**
  * Remove `<system-reminder>…</system-reminder>` spans from a retained text block
  * (defense-in-depth for harness-injected reminders that ride inside a kept text
@@ -399,6 +415,17 @@ function stripSystemReminders(s) {
 export function extractTranscriptText(obj) {
   if (!obj || typeof obj !== "object") return null;
 
+  // ── DeepSeek Harness committed session-event dialect ──
+  if (obj.type === "user/message" || obj.type === "assistant/message") {
+    const data = obj.data;
+    const message = data && typeof data === "object" ? data.message : null;
+    if (!message || typeof message !== "object") return null;
+    return extractTranscriptText({
+      type: obj.type === "user/message" ? "user" : "assistant",
+      message,
+    });
+  }
+
   // ── 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,
@@ -659,7 +686,10 @@ export function createTranscriptUploadHooks(opts) {
       // no-op on the vast majority of lines and never touches the transcript path. Guarded
       // so a malformed frame can never break transcript relay (no-silent: warn).
       try {
-        const usage = extractTurnUsage(message) ?? extractCodexTurnUsage(message);
+        const usage =
+          extractTurnUsage(message) ??
+          extractCodexTurnUsage(message) ??
+          extractDshTurnUsage(message);
         if (usage) lastUsage = usage;
       } catch (err) {
         logger.warn(`[Chorus] token usage extract failed: ${err}`);