@chorus-aidlc/chorus 0.16.4 → 0.17.1

package/cli/daemon.mjs

@@ -31,6 +31,7 @@ import {
   yoloWarningLine,
 } from "./daemon-permission-mode.mjs";
 import { resolveAgentType, backendClientType } from "./daemon-agent.mjs";
+import { isWakeableAgentType } from "./init/agent-type-map.mjs";
 import { formatBanner, agentNotFoundWarningLine } from "./daemon-banner.mjs";
 import { ChorusClient, validateAndFetchIdentity } from "./chorus-client.mjs";
 import { SseListener } from "./sse-listener.mjs";
@@ -75,6 +76,7 @@ import {
   uninstallService,
   systemctlUser,
   journalctlUser,
+  launchctl,
   resolveServicePaths,
   SERVICE_NAME,
 } from "./daemon-service.mjs";
@@ -633,6 +635,27 @@ export function buildMultiAgentDaemon(agentConfigs, deps = {}) {
 
   const agents = agentConfigs
     .map((cfg, i) => {
+      // Offline agents are proxy-only: their key is parked in daemon.json solely so
+      // `chorus mcp` can act under that identity (it reads the file directly, not via
+      // this runtime). The daemon-multi-agent spec says the daemon SHALL NOT construct
+      // a spawner, dispatch wakes, OR register it as a wakeable connection. Building a
+      // runtime here would open an SSE stream that self-reports a connection — so we
+      // SKIP the offline agent entirely (no runtime, no connection, no self-report),
+      // which is what closes the T4-review registration gap. Returning null (kept in
+      // step with a build failure) preserves the original index `i` for the per-agent
+      // injected-dep alignment below (map keeps the index; the filter drops the null).
+      // Skip = not woken: an offline backend (can't be woken) OR a wakeable backend
+      // the operator opted out of (`daemonWake: false`). Both get the same proxy-only
+      // treatment (no runtime/SSE/connection); the key stays in daemon.json for
+      // `chorus mcp`. `daemonWake` absent/true ⇒ woken (back-compat with entries that
+      // predate the field).
+      if (cfg.agentType === "offline" || cfg.daemonWake === false) {
+        const why = cfg.agentType === "offline" ? "offline backend" : "daemon waking disabled (daemonWake:false)";
+        logger.info?.(
+          `[Chorus] agent ${cfg.label}: ${why} — proxy-only key, no wakeable connection registered`,
+        );
+        return null;
+      }
       // Per-agent deps: cfg fields drive the per-agent runtime; injectable fakes are
       // indexed per agent. `cwd` (singular) is cleared so a caller's single value can
       // never leak across agents — each agent's `cwds` is authoritative.
@@ -655,7 +678,13 @@ export function buildMultiAgentDaemon(agentConfigs, deps = {}) {
           : deps.makeSseListener,
       };
       try {
-        return { cfg, daemon: build({ url: cfg.url, apiKey: cfg.apiKey }, agentDeps) };
+        return {
+          cfg,
+          daemon: build(
+            { url: cfg.url, apiKey: cfg.apiKey, agentUuid: cfg.agentUuid, agentName: cfg.agentName },
+            agentDeps,
+          ),
+        };
       } catch (err) {
         logger.error?.(
           `[Chorus] agent ${cfg.label}: failed to build runtime — skipping ` +
@@ -667,6 +696,33 @@ export function buildMultiAgentDaemon(agentConfigs, deps = {}) {
     .filter(Boolean);
 
   if (agents.length === 0) {
+    // Distinguish "all offline" (nothing wakeable to serve — not an error) from
+    // "every wakeable runtime threw" (a real build failure). An all-offline config
+    // is a legitimate proxy-only setup: return an idle no-op daemon so the process
+    // stays up (its offline keys remain available to `chorus mcp`) rather than
+    // crashing with a misleading "all runtimes failed" error.
+    const anyWakeable = agentConfigs.some(
+      (cfg) => isWakeableAgentType(cfg.agentType) && cfg.daemonWake !== false,
+    );
+    if (!anyWakeable) {
+      logger.warn?.(
+        "[Chorus] all configured agents are offline — no daemon-wakeable backend to serve. " +
+          "Offline keys remain in daemon.json for `chorus mcp`; the daemon has nothing to wake.",
+      );
+      return {
+        agents: [],
+        connections: [],
+        // No wakeable connection was registered, so there are no back-compat aliases.
+        waker: undefined,
+        router: undefined,
+        sseListener: undefined,
+        // Never settles: an idle daemon simply waits (it registered no connection, so
+        // it can never be "all-conflicted"). runDaemon keeps it alive on waitForever.
+        allConflict: new Promise(() => {}),
+        async start() {},
+        async stop() {},
+      };
+    }
     throw new Error("buildMultiAgentDaemon: all agent runtimes failed to build");
   }
 
@@ -783,6 +839,7 @@ export async function runDaemon(flags = {}, deps = {}) {
     uninstallService,
     systemctlUser,
     journalctlUser,
+    launchctl,
     resolveServicePaths: () => resolveServicePaths(env),
   };
   // The preflight dep bundle — built from the same seams runDaemon resolved, so
@@ -860,6 +917,11 @@ export async function runDaemon(flags = {}, deps = {}) {
     for (const cfg of agentConfigs) {
       try {
         const id = await validate({ url: cfg.url, apiKey: cfg.apiKey });
+        // The validated identity is authoritative for the CHORUS_AGENT_PROFILE the
+        // spawner exports — fill from it when daemon.json omitted the field
+        // (resolveAgentConfigs already normalized these to a trimmed string | undefined).
+        cfg.agentUuid = cfg.agentUuid ?? id.uuid;
+        cfg.agentName = cfg.agentName ?? id.name;
         okConfigs.push(cfg);
         log(
           `[Chorus] agent ${cfg.label}: ${id.name} (${id.uuid}) — ${cfg.agentType}, ` +
@@ -998,7 +1060,11 @@ export async function runDaemon(flags = {}, deps = {}) {
   }
   log(`[Chorus] browse roots: ${browseRoots.join(", ")} (discovery only; no connections created)`);
 
-  const daemon = build(creds, {
+  const daemon = build(
+    // Export this agent's identity as CHORUS_AGENT_PROFILE in the woken session
+    // (the validated identity is authoritative; creds may already carry it).
+    { ...creds, agentUuid: creds.agentUuid ?? identity.uuid, agentName: creds.agentName ?? identity.name },
+    {
     logger: { info: log, warn: errLog, error: errLog },
     permissionMode,
     agentType,
@@ -1118,11 +1184,13 @@ export async function preflight(ctx) {
 /**
  * Dispatch a daemon lifecycle subcommand. Two families:
  *   - install / uninstall — manage the boot-autostart supervisor service
- *     (systemd --user on Linux; a printed template on macOS/Windows).
+ *     (systemd --user on Linux; launchd LaunchAgent on macOS; a printed template
+ *     on Windows/other).
  *   - status / stop / restart / logs — when a supervisor unit is installed and
- *     active, DELEGATE to it (systemctl / journalctl) so a supervised daemon is
- *     never misreported as "not running"; otherwise operate on the
- *     pidfile/logfile-managed `-d` background daemon exactly as before.
+ *     active, DELEGATE to it (systemctl / journalctl on Linux, launchctl on
+ *     macOS) so a supervised daemon is never misreported as "not running";
+ *     otherwise operate on the pidfile/logfile-managed `-d` background daemon
+ *     exactly as before.
  * Each reports clearly (no silent failure). `restart` performs
  * stop-then-detached-start on the pidfile path.
  * @returns {Promise<number>} exit code
@@ -1239,21 +1307,26 @@ export async function handleLifecycleAction(action, { log, errLog, lifecycle, se
       for (const s of r.steps) log(`[Chorus]   ${s}`);
       log(`[Chorus] it will now start automatically at login. Manage it with:`);
       log(`[Chorus]   chorus daemon status | stop | restart | logs`);
-      // A --user service only survives logout with lingering enabled; and a
-      // separately-started `chorus daemon -d` would hold the same paths and make
-      // this service exit-and-retry. Surface both so neither is a silent gotcha.
-      log(`[Chorus] to keep it running after you log out: loginctl enable-linger "$USER"`);
-      log(`[Chorus] if you previously ran 'chorus daemon -d', stop it first ('chorus daemon stop') so it doesn't hold the same paths.`);
+      if (r.platform === "linux") {
+        // A --user service only survives logout with lingering enabled; and a
+        // separately-started `chorus daemon -d` would hold the same paths and make
+        // this service exit-and-retry. Surface both so neither is a silent gotcha.
+        log(`[Chorus] to keep it running after you log out: loginctl enable-linger "$USER"`);
+        log(`[Chorus] if you previously ran 'chorus daemon -d', stop it first ('chorus daemon stop') so it doesn't hold the same paths.`);
+      } else if (r.platform === "darwin") {
+        log(`[Chorus] if you previously ran 'chorus daemon -d', stop it first ('chorus daemon stop') so it doesn't hold the same paths.`);
+      }
       return 0;
     }
-    if (r.platform === "linux") {
-      // Linux install actually failed (write / systemctl error) — surface it.
+    if (r.platform === "linux" || r.platform === "darwin") {
+      // A real install (systemd/launchd) actually failed — surface it, never a
+      // silent success or a misleading "not supported" message.
       errLog(`[Chorus] service install failed: ${r.error}`);
       for (const s of r.steps) errLog(`[Chorus]   (did: ${s})`);
       return 1;
     }
-    // macOS / Windows: not auto-installed by design — print the template + steps.
-    log(`[Chorus] automatic install is Linux-only. To run the daemon as a service on this platform:`);
+    // Windows / other: no first-class auto-install — print the template + steps.
+    log(`[Chorus] automatic install is not supported on this platform. To run the daemon as a service:`);
     for (const s of r.steps) log(`[Chorus]   ${s}`);
     log("");
     log(r.unitText);
@@ -1261,7 +1334,7 @@ export async function handleLifecycleAction(action, { log, errLog, lifecycle, se
   }
   if (action === "uninstall") {
     const r = svc.uninstallService();
-    if (r.platform === "linux") {
+    if (r.platform === "linux" || r.platform === "darwin") {
       if (r.error) {
         errLog(`[Chorus] service uninstall failed: ${r.error}`);
         return 1;
@@ -1274,22 +1347,32 @@ export async function handleLifecycleAction(action, { log, errLog, lifecycle, se
       }
       return 0;
     }
-    log(`[Chorus] automatic uninstall is Linux-only. To remove the service on this platform:`);
+    log(`[Chorus] automatic uninstall is not supported on this platform. To remove the service:`);
     for (const s of r.steps) log(`[Chorus]   ${s}`);
     return 0;
   }
 
   // For the control verbs, prefer a live supervisor unit over the pidfile.
+  // A supervisor is systemd (Linux) or launchd (macOS); both delegate the verbs
+  // to their service manager so a supervised daemon is never misreported as "not
+  // running" via the pidfile.
   const sup = svc.detectSupervisor();
-  const supervised = sup.kind === "systemd" && sup.installed;
+  const systemd = sup.kind === "systemd" && sup.installed;
+  const launchd = sup.kind === "launchd" && sup.installed;
 
   if (action === "status") {
-    if (supervised) {
+    if (systemd) {
       log(`[Chorus] daemon is managed by systemd (${SERVICE_NAME}.service) — ${sup.active ? "active" : "installed but NOT active"}.`);
       const r = svc.systemctlUser(["status", "--no-pager", `${SERVICE_NAME}.service`]);
       if (r.stdout) log(r.stdout.trimEnd());
       return sup.active ? 0 : 1;
     }
+    if (launchd) {
+      log(`[Chorus] daemon is managed by launchd (${sup.label}) — ${sup.active ? "loaded" : "installed but NOT loaded"}.`);
+      const r = svc.launchctl(["list", sup.label]);
+      if (r.stdout) log(r.stdout.trimEnd());
+      return sup.active ? 0 : 1;
+    }
     const s = lifecycle.isRunning();
     if (s.running) log(`[Chorus] daemon is running (pid ${s.pid}).`);
     else if (s.stale) log(`[Chorus] daemon is NOT running (stale pidfile for pid ${s.pid}).`);
@@ -1297,7 +1380,7 @@ export async function handleLifecycleAction(action, { log, errLog, lifecycle, se
     return 0;
   }
   if (action === "logs") {
-    if (supervised) {
+    if (systemd) {
       const r = svc.journalctlUser(["-u", `${SERVICE_NAME}.service`, "--no-pager", "-n", "200"]);
       if (r.status !== 0 && !r.stdout) {
         errLog(`[Chorus] could not read the service journal: ${r.stderr.trim() || `exit ${r.status}`}`);
@@ -1306,6 +1389,8 @@ export async function handleLifecycleAction(action, { log, errLog, lifecycle, se
       log(r.stdout.trimEnd());
       return 0;
     }
+    // launchd (and the pidfile path) both log to ~/.chorus/daemon.log — the plist
+    // routes stdout/stderr there — so the pidfile logfile reader serves both.
     const r = lifecycle.readLog();
     if (!r.ok) {
       errLog(`[Chorus] ${r.message}`);
@@ -1315,7 +1400,7 @@ export async function handleLifecycleAction(action, { log, errLog, lifecycle, se
     return 0;
   }
   if (action === "stop") {
-    if (supervised) {
+    if (systemd) {
       const r = svc.systemctlUser(["stop", `${SERVICE_NAME}.service`]);
       if (r.status === 0) {
         log(`[Chorus] stopped the daemon service (systemctl --user stop ${SERVICE_NAME}.service).`);
@@ -1325,6 +1410,16 @@ export async function handleLifecycleAction(action, { log, errLog, lifecycle, se
       errLog(`[Chorus] failed to stop the service: ${r.stderr.trim() || `exit ${r.status}`}`);
       return 1;
     }
+    if (launchd) {
+      const r = svc.launchctl(["unload", sup.plistPath]);
+      if (r.status === 0) {
+        log(`[Chorus] stopped the daemon service (launchctl unload ${sup.plistPath}).`);
+        log(`[Chorus] note: it will load again at next login. To disable: chorus daemon uninstall`);
+        return 0;
+      }
+      errLog(`[Chorus] failed to stop the service: ${r.stderr.trim() || `exit ${r.status}`}`);
+      return 1;
+    }
     // --force: unconditional pidfile cleanup for stuck states the identity
     // probe cannot resolve. Threaded from the parsed client flags.
     const r = lifecycle.stopDaemon({ force: pfDeps?.flags?.force === true });
@@ -1336,7 +1431,7 @@ export async function handleLifecycleAction(action, { log, errLog, lifecycle, se
     return ok ? 0 : 1;
   }
   if (action === "restart") {
-    if (supervised) {
+    if (systemd) {
       const r = svc.systemctlUser(["restart", `${SERVICE_NAME}.service`]);
       if (r.status === 0) {
         log(`[Chorus] restarted the daemon service (systemctl --user restart ${SERVICE_NAME}.service).`);
@@ -1345,6 +1440,17 @@ export async function handleLifecycleAction(action, { log, errLog, lifecycle, se
       errLog(`[Chorus] failed to restart the service: ${r.stderr.trim() || `exit ${r.status}`}`);
       return 1;
     }
+    if (launchd) {
+      // launchd has no atomic restart — unload then load the same plist.
+      svc.launchctl(["unload", sup.plistPath]);
+      const r = svc.launchctl(["load", sup.plistPath]);
+      if (r.status === 0) {
+        log(`[Chorus] restarted the daemon service (launchctl unload+load ${sup.plistPath}).`);
+        return 0;
+      }
+      errLog(`[Chorus] failed to restart the service: ${r.stderr.trim() || `exit ${r.status}`}`);
+      return 1;
+    }
     const r = lifecycle.stopDaemon();
     log(`[Chorus] ${r.message}`);
     // Start a fresh detached instance regardless of whether one was running.

package/cli/dsh-spawner.mjs

@@ -187,6 +187,13 @@ export class DshSpawner {
     };
     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;

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";