@chorus-aidlc/chorus 0.16.3 → 0.17.0

package/cli/dsh-spawner.mjs

@@ -0,0 +1,445 @@
+// 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;
+    // Identity profile — the dsh doc-mirror wrapper passes this to `chorus mcp
+    // --agent` (resolving the key from ~/.chorus/daemon.json). dsh scrubs
+    // credential-shaped env from tool subprocesses; the profile is not a secret,
+    // and the wrapper also reads it from $DSH_HOME/.env, so url/apiKey remain the
+    // reliable fallback when it doesn't survive.
+    if (this.creds?.agentUuid || this.creds?.agentName)
+      childEnv.CHORUS_AGENT_PROFILE = this.creds.agentUuid || this.creds.agentName;
+
+    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/init/adapters.mjs

@@ -0,0 +1,137 @@
+// cli/init/adapters.mjs
+// The per-agent adapters `chorus init` configures. One descriptor per supported
+// coding-agent harness; buildAdapter() turns each into an AgentAdapter
+// (contracts.mjs). Detection is shared (cli/init/detect.mjs); the plugin-install
+// mechanism (descriptor.install) is added by the plugin-install task — until
+// then installPlugin reports "unsupported" rather than guessing a command.
+//
+// LAYOUT PROVENANCE (binary + config dir), so future edits don't drift into
+// LLM-guessed paths (verified against each agent's real CLI / install-*.sh):
+//   - claude   : bin `claude`;   dir ~/.claude              (this machine + docs/CONNECT_CLAUDE_CODE.md)
+//   - codex    : bin `codex`;    dir ~/.codex               (public/install-codex.sh: CODEX_HOME=$HOME/.codex)
+//   - kiro     : bin `kiro`;     dir ~/.kiro                (public/install-kiro.sh: ~/.kiro global)
+//   - opencode : bin `opencode`; dir ~/.config/opencode     (public/install-opencode.sh: OPENCODE_CONFIG_DIR)
+//   - openclaw : bin `openclaw`; dir ~/.openclaw|~/.config/openclaw  (NOT independently verified — probe both; see NOTE)
+//   - pi       : bin `pi`;       dir ~/.pi|~/.config/pi       (NOT independently verified — probe both; see NOTE)
+//   - dsh      : bin `dsh`;      dir $DSH_HOME|~/.dsh         ($DSH_HOME per dsh integration; see NOTE)
+//
+// NOTE: openclaw / pi / dsh config-dir specifics were not verifiable on this
+// build host (their CLIs/config were not all present); the descriptors probe the
+// most likely locations. A wrong config-dir guess only weakens the *config-dir*
+// half of the dual signal (the binary-on-PATH half still detects them) and never
+// blocks selection — undetected agents remain selectable. The plugin-install
+// task must still verify each install command against the real CLI.
+
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { detectSignals } from "./detect.mjs";
+import { OUTCOME_ACTIONS } from "./contracts.mjs";
+import { CHORUS_PLUGIN_ID, CHORUS_MARKETPLACE_NAME, CHORUS_MARKETPLACE_SOURCE } from "./chorus-plugin-consts.mjs";
+import {
+  installClaude,
+  installCodex,
+  installOpencode,
+  installDsh,
+  installOpenclaw,
+  installKiro,
+  readCodexInstallState,
+  readOpencodeInstallState,
+  readDshInstallState,
+  readOpenclawInstallState,
+  readKiroInstallState,
+  guided,
+  GUIDED_MESSAGES,
+} from "./install-methods.mjs";
+
+// Re-export the shared marketplace identifiers from their canonical home so
+// existing importers of these names from adapters.mjs keep working.
+export { CHORUS_PLUGIN_ID, CHORUS_MARKETPLACE_NAME, CHORUS_MARKETPLACE_SOURCE };
+
+/** Read + JSON-parse a file, or null on any error. Never throws. */
+function readJsonSafe(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Claude Code install-state reader (verified against CC 2.1.235 on-disk layout):
+ * `~/.claude/plugins/installed_plugins.json` (v2 keyed by `<plugin>@<marketplace>`)
+ * and `known_marketplaces.json`. Read-only — never hand-writes these files.
+ * @param {{ home?: string, readJson?: (p: string) => any }} [deps]
+ * @returns {{ marketplaceRegistered: boolean, pluginInstalled: boolean, version?: string }}
+ */
+export function readClaudeInstallState({ home = homedir(), readJson = readJsonSafe } = {}) {
+  const pluginsDir = join(home, ".claude", "plugins");
+  const installed = readJson(join(pluginsDir, "installed_plugins.json"));
+  const markets = readJson(join(pluginsDir, "known_marketplaces.json"));
+
+  const marketplaceRegistered = !!(markets && typeof markets === "object" && markets[CHORUS_MARKETPLACE_NAME]);
+
+  let pluginInstalled = false;
+  let version;
+  const entries = installed && typeof installed === "object" ? installed.plugins?.[CHORUS_PLUGIN_ID] : null;
+  if (Array.isArray(entries) && entries.length > 0) {
+    pluginInstalled = true;
+    version = entries[0]?.version;
+  }
+  return { marketplaceRegistered, pluginInstalled, version };
+}
+
+/**
+ * The supported-agent descriptors. `install` / `readState` are optional hooks the
+ * plugin-install task fills in per agent; absent ⇒ generic behavior.
+ * @type {Array<{
+ *   id: string, displayName: string, binaries: string[], configDirs: string[],
+ *   readState?: (deps: object) => object, install?: (ctx: object) => object,
+ * }>}
+ */
+export const AGENT_DESCRIPTORS = [
+  { id: "claude", displayName: "Claude Code", binaries: ["claude"], configDirs: ["~/.claude"], readState: readClaudeInstallState, install: installClaude },
+  { id: "codex", displayName: "Codex CLI", binaries: ["codex"], configDirs: ["~/.codex"], readState: readCodexInstallState, install: installCodex },
+  { id: "kiro", displayName: "Kiro CLI", binaries: ["kiro"], configDirs: ["~/.kiro"], readState: readKiroInstallState, install: installKiro },
+  { id: "opencode", displayName: "opencode", binaries: ["opencode"], configDirs: ["~/.config/opencode", "~/.opencode"], readState: readOpencodeInstallState, install: installOpencode },
+  { id: "openclaw", displayName: "OpenClaw", binaries: ["openclaw"], configDirs: ["~/.openclaw", "~/.config/openclaw"], readState: readOpenclawInstallState, install: installOpenclaw },
+  { id: "pi", displayName: "Pi", binaries: ["pi"], configDirs: ["~/.pi", "~/.config/pi"], install: guided("pi", GUIDED_MESSAGES.pi) },
+  { id: "dsh", displayName: "DeepSeek Harness (dsh)", binaries: ["dsh"], configDirs: ["$DSH_HOME", "~/.dsh"], readState: readDshInstallState, install: installDsh },
+];
+
+/**
+ * Build an AgentAdapter from a descriptor.
+ * @param {typeof AGENT_DESCRIPTORS[number]} d
+ * @returns {import("./contracts.mjs").AgentAdapter}
+ */
+export function buildAdapter(d) {
+  return {
+    id: d.id,
+    displayName: d.displayName,
+    detect: (env = process.env) => detectSignals(d, { env }),
+    readInstallState: (deps = {}) => {
+      const base = typeof d.readState === "function"
+        ? d.readState(deps)
+        : { marketplaceRegistered: false, pluginInstalled: false };
+      // `supported` = a REAL automated install path exists for this agent. A
+      // `guided()` fallback also returns a function (so `typeof d.install ===
+      // "function"` alone would report every fallback agent as supported — the
+      // pre-existing latent bug); guided installers are tagged `.guided === true`,
+      // so exclude them here. Real installers (claude/codex/opencode + dsh/openclaw/
+      // kiro) → true; guided (pi) → false.
+      return { supported: typeof d.install === "function" && d.install.guided !== true, ...base };
+    },
+    installPlugin: (ctx = {}) =>
+      typeof d.install === "function"
+        ? d.install(ctx)
+        : {
+            stepId: "plugin-install",
+            agentId: d.id,
+            action: OUTCOME_ACTIONS.UNSUPPORTED,
+            detail: `no automated plugin install for ${d.displayName} yet — configure manually`,
+          },
+  };
+}
+
+/** All supported adapters, built from the descriptors. */
+export const ADAPTERS = AGENT_DESCRIPTORS.map(buildAdapter);

package/cli/init/agent-type-map.mjs

@@ -0,0 +1,60 @@
+// cli/init/agent-type-map.mjs
+// The single translation between a `chorus init` adapter selection id (see
+// cli/init/adapters.mjs — "claude" | "codex" | "kiro" | "opencode" | "openclaw" |
+// "pi" | "dsh") and the daemon's agentType vocabulary (cli/daemon-agent.mjs
+// KNOWN_AGENTS). It lives in ONE place so the credential-seed step (which writes
+// each selected agent's daemon.json agents[] entry) and the daemon-setup step
+// (which gates auto-start on whether any selected agent is wakeable) can never
+// disagree about how a selection maps to a backend.
+//
+// Two rules the callers rely on:
+//   1. The init id "claude" is NOT the daemon agentType — it renames to
+//      "claude-code" EXPLICITLY here. No caller ever passes the raw init id
+//      through to daemon.json; every write goes through agentTypeForSelection.
+//   2. Any selection the daemon cannot wake as a first-class backend
+//      (opencode / openclaw / pi, and dsh while its harness is dormant/offline)
+//      maps to the non-wakeable "offline" classification. Its key is still parked
+//      in agents[] for the `chorus mcp` proxy, but the daemon builds no spawner
+//      and dispatches no wake (spawner-select.mjs fail-closes on "offline").
+//
+// Fail-closed by default: an unknown / unmapped id maps to "offline" rather than a
+// wakeable backend, so a future adapter added without a mapping is never silently
+// woken as claude-code.
+
+/**
+ * Selection id → daemon agentType. Only claude/codex/kiro are wakeable backends;
+ * everything else is classified offline. `dsh` maps to offline because the dsh
+ * harness is de-advertised (offline) — re-map it here to bring it back online.
+ * @type {Readonly<Record<string, string>>}
+ */
+export const SELECTION_TO_AGENT_TYPE = Object.freeze({
+  claude: "claude-code", // explicit rename — never pass the init id "claude" through verbatim
+  codex: "codex",
+  kiro: "kiro",
+  opencode: "offline",
+  openclaw: "offline",
+  pi: "offline",
+  dsh: "offline",
+});
+
+/**
+ * Map a `chorus init` selection id to the daemon agentType written into
+ * daemon.json `agents[]`. Unknown ids fail closed to "offline" (never a wakeable
+ * default), so an agent is only ever woken when its backend is explicitly known.
+ * @param {string} selectionId
+ * @returns {string} a KNOWN_AGENTS agentType ("claude-code" | "codex" | "kiro" | "offline")
+ */
+export function agentTypeForSelection(selectionId) {
+  return SELECTION_TO_AGENT_TYPE[selectionId] ?? "offline";
+}
+
+/**
+ * Whether a daemon agentType is one the daemon can actually wake. "offline" is the
+ * one non-wakeable classification; every other value the init mapping produces
+ * (claude-code / codex / kiro) is wakeable.
+ * @param {string} agentType
+ * @returns {boolean}
+ */
+export function isWakeableAgentType(agentType) {
+  return agentType !== "offline";
+}

package/cli/init/chorus-plugin-consts.mjs

@@ -0,0 +1,16 @@
+// cli/init/chorus-plugin-consts.mjs
+// Canonical Chorus plugin/marketplace identifiers, shared by the adapters and the
+// per-agent install methods. Kept in its own module so adapters.mjs and
+// install-methods.mjs can both import them without a circular dependency.
+
+/** Plugin selector used by marketplace-based agents (Claude Code, Codex). */
+export const CHORUS_PLUGIN_ID = "chorus@chorus-plugins";
+/** Marketplace name as it appears in agents' on-disk state. */
+export const CHORUS_MARKETPLACE_NAME = "chorus-plugins";
+/**
+ * Remote marketplace source (owner decision: each agent's NATIVE REMOTE
+ * marketplace, not a local bundle). Overridable per invocation via
+ * CHORUS_MARKETPLACE_SOURCE. Accepted by `claude plugin marketplace add`
+ * (URL/path/repo). Codex prefers the `owner/repo` slug — see installCodex.
+ */
+export const CHORUS_MARKETPLACE_SOURCE = "https://github.com/Chorus-AIDLC/Chorus";