@chorus-aidlc/chorus 0.15.1 → 0.16.2

package/cli/credentials.mjs

@@ -70,6 +70,47 @@ export function readYoloAck(deps = {}) {
   return file ? nonEmpty(file.yoloAckAt) ?? null : null;
 }
 
+/**
+ * Resolve the DEFAULT url + apiKey layer (per-field, non-throwing) for the
+ * multi-agent config. Unlike `resolveCredentials` (which needs a COMPLETE pair
+ * and throws when none resolves), this resolves each field independently and
+ * returns `undefined` for any field no source supplies. It is the "top-level
+ * defaults" layer that each `agents[]` entry merges over: an agent that omits
+ * `url` inherits this default `url`, an agent that omits `apiKey` inherits this
+ * default `apiKey` (rarely useful, but symmetric with every other default).
+ *
+ * Same source order as `resolveCredentials`, applied per field:
+ *   flag > env > login file (top-level) > plugin fallback.
+ *
+ * @param {{ url?: string, apiKey?: string }} flags
+ * @param {ResolveDeps} [deps]
+ * @returns {{ url: string | undefined, apiKey: string | undefined }}
+ */
+export function resolveCredentialDefaults(flags = {}, deps = {}) {
+  const env = deps.env ?? process.env;
+  const readJson = deps.readJson ?? readJsonSafe;
+  const loginPath = deps.loginPath ?? loginFilePath();
+  const settingsPath = deps.settingsPath ?? claudeSettingsPath();
+
+  const file = readJson(loginPath);
+  const settings = readJson(settingsPath);
+  const pluginEnv =
+    settings && typeof settings.env === "object" && settings.env !== null
+      ? /** @type {Record<string, unknown>} */ (settings.env)
+      : null;
+
+  const pick = (flagVal, envKey, fileKey) =>
+    nonEmpty(flagVal) ??
+    nonEmpty(env[envKey]) ??
+    (file ? nonEmpty(file[fileKey]) : undefined) ??
+    (pluginEnv ? nonEmpty(pluginEnv[envKey]) : undefined);
+
+  return {
+    url: pick(flags.url, "CHORUS_URL", "url"),
+    apiKey: pick(flags.apiKey, "CHORUS_API_KEY", "apiKey"),
+  };
+}
+
 /**
  * @typedef {Object} ResolvedCredentials
  * @property {string} url

package/cli/daemon-config.mjs

@@ -15,11 +15,21 @@
 import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { isAbsolute, resolve as resolvePath } from "node:path";
-import { loginFilePath } from "./credentials.mjs";
+import { loginFilePath, resolveCredentials, resolveCredentialDefaults } from "./credentials.mjs";
+import { resolveAgentType, KNOWN_AGENTS } from "./daemon-agent.mjs";
+import { resolvePermissionMode } from "./daemon-permission-mode.mjs";
 
 /** Built-in default escalation window (ms) — matches the spec's 10 seconds. */
 export const DEFAULT_SIGINT_TIMEOUT_MS = 10_000;
 
+/**
+ * Built-in default per-agent wake concurrency. This was the process-wide
+ * hardcoded WakeQueue cap (`maxConcurrency ?? 4` in daemon.mjs) before it became
+ * a per-agent, configurable value — kept at 4 so an agent that specifies no
+ * `maxConcurrency` behaves exactly as the daemon did before.
+ */
+export const DEFAULT_MAX_CONCURRENCY = 4;
+
 /**
  * Coerce a value to a positive finite integer of milliseconds, or undefined when it
  * is absent / not a usable number. Accepts a number or a numeric string (env vars
@@ -235,3 +245,194 @@ export function resolveBrowseRoots(flags = {}, deps = {}) {
     : [];
   return fromFile.length ? fromFile : [normalizeCwd(home, home)];
 }
+
+// ===== Multi-agent config (daemon-multi-agent — N independent agents per daemon) =====
+//
+// One daemon process may serve a LIST of fully-independent agents, each with its
+// own credentials + working directories + backend + permission mode + concurrency.
+// `resolveAgentConfigs` returns that list as `AgentConfig[]`, every field already
+// merged with its default. Two shapes are supported:
+//
+//   1. `~/.chorus/daemon.json` has a non-empty `agents: [ … ]` array → one
+//      AgentConfig per entry, each entry's fields merged OVER the top-level
+//      defaults (per-agent value wins; an omitted field inherits the default).
+//   2. No `agents[]` (or empty) → exactly ONE AgentConfig synthesized from the
+//      existing flat resolution (resolveCredentials + resolveDaemonCwds +
+//      resolveAgentType + sigint + browseRoots). This is byte-for-byte the
+//      daemon's current single-agent behavior — old installs run unchanged, and
+//      flags / env still resolve this single agent's fields.
+//
+// Validation is strict and visible: a missing apiKey, an unresolvable url, an
+// unknown agentType, or an invalid permissionMode THROWS an Error naming the
+// offending agent. The daemon's top-level error handler turns that into a
+// non-zero exit — the resolver never silently drops or falls back to a default
+// agent (matching resolveCredentials' throw-on-nothing contract).
+
+/** A non-empty trimmed string, or undefined. */
+function nonEmptyStr(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+/**
+ * True iff `~/.chorus/daemon.json` declares a non-empty `agents[]` with at least
+ * one object entry — i.e. the daemon should run in multi-agent mode. Lets the
+ * daemon pick the multi-agent startup path (bypassing the flat single-credential
+ * preflight) without duplicating the file read. Never throws.
+ * @param {{ readJson?: (p: string) => (Record<string, unknown>|null), loginPath?: string }} [deps]
+ * @returns {boolean}
+ */
+export function hasConfiguredAgents(deps = {}) {
+  const readJson = deps.readJson ?? readJsonSafe;
+  const loginPath = deps.loginPath ?? loginFilePath();
+  const file = readJson(loginPath);
+  return Boolean(
+    file && Array.isArray(file.agents) && file.agents.some((a) => a && typeof a === "object"),
+  );
+}
+
+/**
+ * Coerce to a positive finite integer (count), or undefined. Accepts number or
+ * numeric string; rejects 0, negatives, NaN, Infinity. Used for maxConcurrency.
+ * @param {unknown} value @returns {number | undefined}
+ */
+function positiveInt(value) {
+  if (value === undefined || value === null || value === "") return undefined;
+  const n = typeof value === "number" ? value : Number(String(value).trim());
+  if (!Number.isFinite(n) || n <= 0) return undefined;
+  return Math.floor(n);
+}
+
+/**
+ * @typedef {Object} AgentConfig  One fully-resolved agent runtime config.
+ * @property {string} url                       Chorus server URL for this agent.
+ * @property {string} apiKey                    This agent's `cho_` API key.
+ * @property {string} agentType                 Backend: claude-code | codex | kiro.
+ * @property {Array<string|undefined>} cwds     Served paths (`undefined` ⇒ process cwd).
+ * @property {"yolo"|"chorus"} permissionMode   Woken-agent permission posture.
+ * @property {number} maxConcurrency            This agent's wake-queue cap.
+ * @property {number} sigintTimeoutMs           Interrupt escalation window (ms).
+ * @property {string[]} browseRoots             Directory-discovery allowlist.
+ * @property {string} label                     Diagnostic label ("agent" or "agents[i]").
+ */
+
+/**
+ * Resolve the list of agents this daemon serves. See the block comment above.
+ *
+ * @param {{ url?: string, apiKey?: string, agent?: string, cwd?: string|string[],
+ *           browseRoot?: string|string[], sigintTimeout?: number|string,
+ *           chorusOnly?: boolean, yolo?: boolean }} [flags]
+ * @param {{
+ *   env?: Record<string, string|undefined>,
+ *   readJson?: (path: string) => (Record<string, unknown>|null),
+ *   loginPath?: string,
+ *   settingsPath?: string,
+ *   home?: string,
+ *   permissionMode?: "yolo"|"chorus",   // pre-resolved global posture (else computed)
+ * }} [deps]
+ * @returns {AgentConfig[]}  Non-empty list; throws on an invalid agent entry.
+ */
+export function resolveAgentConfigs(flags = {}, deps = {}) {
+  const env = deps.env ?? process.env;
+  const readJson = deps.readJson ?? readJsonSafe;
+  const loginPath = deps.loginPath ?? loginFilePath();
+  const home = deps.home ?? homedir();
+  const file = readJson(loginPath);
+
+  // Global default permission posture; a per-agent `permissionMode` overrides it.
+  // needConfirm/hasAck is vestigial, so isTTY/hasAck do not affect the resolved mode.
+  const defaultPermissionMode =
+    deps.permissionMode ??
+    resolvePermissionMode(flags, env, { isTTY: false, hasAck: false }).mode;
+
+  const agentEntries =
+    file && Array.isArray(file.agents)
+      ? file.agents.filter((a) => a && typeof a === "object")
+      : [];
+
+  // ---- Back-compat: no agents[] → exactly one agent from flat resolution ----
+  if (agentEntries.length === 0) {
+    const creds = resolveCredentials(flags, deps); // throws if no complete pair (today's behavior)
+    const at = resolveAgentType(flags, env, deps);
+    if (!at.ok) throw new Error(at.error);
+    return [
+      {
+        url: creds.url,
+        apiKey: creds.apiKey,
+        agentType: at.agent,
+        cwds: resolveDaemonCwds(flags, deps),
+        permissionMode: defaultPermissionMode,
+        maxConcurrency: positiveInt(file?.maxConcurrency) ?? DEFAULT_MAX_CONCURRENCY,
+        sigintTimeoutMs: resolveSigintTimeoutMs(flags, deps),
+        browseRoots: resolveBrowseRoots(flags, deps),
+        label: "agent",
+      },
+    ];
+  }
+
+  // ---- Multi-agent: each entry merged over the top-level defaults ----
+  const credDefaults = resolveCredentialDefaults(flags, deps);
+  const defaultCwds = resolveDaemonCwds(flags, deps);
+  const defaultAgentType = resolveAgentType(flags, env, deps); // top-level default (may be {ok:false} if top-level `agent` is garbage)
+  const defaultSigint = resolveSigintTimeoutMs(flags, deps);
+  const defaultBrowseRoots = resolveBrowseRoots(flags, deps);
+  const defaultMaxConcurrency = positiveInt(file?.maxConcurrency) ?? DEFAULT_MAX_CONCURRENCY;
+
+  return agentEntries.map((entry, i) => {
+    const label = nonEmptyStr(entry.label) ?? nonEmptyStr(entry.name) ?? `agents[${i}]`;
+
+    const url = nonEmptyStr(entry.url) ?? credDefaults.url;
+    const apiKey = nonEmptyStr(entry.apiKey) ?? credDefaults.apiKey;
+    if (!apiKey) {
+      throw new Error(`Agent ${label}: missing apiKey (no per-agent apiKey and no top-level default).`);
+    }
+    if (!url) {
+      throw new Error(`Agent ${label}: missing/unresolvable url (no per-agent url and no top-level default).`);
+    }
+
+    // agentType: per-agent value, else the top-level default (which must itself be valid).
+    let agentType;
+    if (nonEmptyStr(entry.agentType)) {
+      agentType = nonEmptyStr(entry.agentType);
+    } else if (defaultAgentType.ok) {
+      agentType = defaultAgentType.agent;
+    } else {
+      throw new Error(
+        `Agent ${label}: no agentType and the top-level agent default is invalid (${defaultAgentType.error}).`,
+      );
+    }
+    if (!KNOWN_AGENTS.includes(agentType)) {
+      throw new Error(
+        `Agent ${label}: unknown agentType "${agentType}". Accepted: ${KNOWN_AGENTS.join(", ")}.`,
+      );
+    }
+
+    // permissionMode: per-agent override (yolo|chorus only), else global posture.
+    let permissionMode = defaultPermissionMode;
+    if (entry.permissionMode !== undefined) {
+      const pm = nonEmptyStr(entry.permissionMode);
+      if (pm !== "yolo" && pm !== "chorus") {
+        throw new Error(
+          `Agent ${label}: invalid permissionMode "${entry.permissionMode}". Accepted: yolo, chorus.`,
+        );
+      }
+      permissionMode = pm;
+    }
+
+    // cwds: per-agent list (cleaned); an empty/blank list degrades to [undefined]
+    // (serve the process cwd). Omitted → inherit the top-level default set.
+    let cwds;
+    if (entry.cwds !== undefined) {
+      const cleaned = cleanCwdList(entry.cwds, home);
+      cwds = cleaned.length ? cleaned : [undefined];
+    } else {
+      cwds = defaultCwds;
+    }
+
+    const maxConcurrency = positiveInt(entry.maxConcurrency) ?? defaultMaxConcurrency;
+    const sigintTimeoutMs = positiveIntMs(entry.sigintTimeoutMs) ?? defaultSigint;
+    const browseRoots =
+      entry.browseRoots !== undefined ? cleanCwdList(entry.browseRoots, home) : defaultBrowseRoots;
+
+    return { url, apiKey, agentType, cwds, permissionMode, maxConcurrency, sigintTimeoutMs, browseRoots, label };
+  });
+}

package/cli/daemon-install-config.mjs

@@ -23,7 +23,7 @@
 
 import { homedir } from "node:os";
 import { resolveCredentials, loginFilePath } from "./credentials.mjs";
-import { updateDaemonConfig, prompt as defaultPrompt } from "./login.mjs";
+import { updateDaemonConfig, appendAgentConfig, prompt as defaultPrompt } from "./login.mjs";
 import { validateAndFetchIdentity } from "./chorus-client.mjs";
 import { normalizeCwd, cleanCwdList } from "./daemon-config.mjs";
 import { KNOWN_AGENTS, DEFAULT_AGENT } from "./daemon-agent.mjs";
@@ -132,6 +132,43 @@ export async function resolveInstallCredentials(flags = {}, env = {}, opts = {})
   //    field-merge writer preserves cwds / yoloAckAt / sigintTimeoutMs.
   writeConfig({ url, apiKey, agentUuid: identity.uuid, agentName: identity.name });
   log(`[Chorus] credentials saved for ${identity.name} (${identity.uuid}).`);
+
+  // Multi-agent (daemon-multi-agent): with `--add` on a TTY, offer to add more
+  // agents in the same run. Each additional key is validated then APPENDED to
+  // agents[] (the first agent above is folded into agents[0] on the first
+  // append). Opt-in via --add so a plain install prompts for nothing extra;
+  // never runs on a non-TTY / --yes / skip run. Hand-editing daemon.json remains
+  // fully supported regardless.
+  if (isTTY && !skip && flags.add === true) {
+    const appendAgent = opts.appendAgent ?? appendAgentConfig;
+    // Bound the loop so a stuck/looping prompt can never spin forever.
+    for (let added = 0; added < 32; added += 1) {
+      const more = nonEmpty(await ask("Add another agent? [y/N]: "));
+      if (!more || !/^y(es)?$/i.test(more)) break;
+      const u = nonEmpty(await ask("  Chorus URL: "));
+      const k = nonEmpty(await ask("  Chorus API key (cho_...): ", { mask: true }));
+      if (!u || !k) {
+        errLog("[Chorus] both a URL and an API key are required — skipping this agent.");
+        continue;
+      }
+      let id;
+      try {
+        id = await validate({ url: u, apiKey: k });
+      } catch (err) {
+        errLog(
+          `[Chorus] validation failed: ${err instanceof Error ? err.message : String(err)} — this agent was NOT added.`,
+        );
+        continue;
+      }
+      const res = appendAgent({ url: u, apiKey: k, agentUuid: id.uuid, agentName: id.name });
+      if (!res.ok) {
+        errLog(`[Chorus] agent ${id.name} (${id.uuid}) is already configured — skipping.`);
+        continue;
+      }
+      log(`[Chorus] added agent ${id.name} (${id.uuid}) — this daemon now serves ${res.agents.length} agents.`);
+    }
+  }
+
   return { ok: true, creds: { url, apiKey }, identity };
 }
 

package/cli/daemon-rest-client.mjs

@@ -7,7 +7,8 @@
 // The five operations and their EXACT server payload shapes (verified against
 // src/app/api/daemon/*/route.ts — the server is NOT changed by this work):
 //   turnAdvance      → POST /api/daemon/turn-advance
-//                      { connectionUuid, sessionId, status, entityType?, entityUuid? }
+//                      { connectionUuid, sessionId, status, entityType?, entityUuid?,
+//                        coalescedCount? }
 //   transcript       → POST /api/daemon/transcript
 //                      { sessionId, messages: [{ role, text }] }
 //   executionState   → POST /api/daemon/execution-state
@@ -70,7 +71,7 @@ const NOOP_LOGGER = { info() {}, warn() {}, error() {} };
  *   logger?: { info(m:string):void, warn(m:string):void, error(m:string):void },
  * }} opts
  * @returns {{
- *   turnAdvance: (p: { sessionId: string, backendSessionId?: string|null, status: string, entityType?: string|null, entityUuid?: string|null }) => Promise<DaemonRestResult>,
+ *   turnAdvance: (p: { sessionId: string, backendSessionId?: string|null, status: string, entityType?: string|null, entityUuid?: string|null, coalescedCount?: number }) => Promise<DaemonRestResult>,
  *   transcript: (p: { sessionId: string, messages: Array<{ role: string, text: string }> }) => Promise<DaemonRestResult>,
  *   executionState: (p: { executions: Array<Record<string, unknown>> }) => Promise<DaemonRestResult>,
  *   reportInterrupt: (p: { entityType: string, entityUuid: string, reason: string }) => Promise<DaemonRestResult>,
@@ -147,7 +148,7 @@ export function createDaemonRestClient(opts) {
      * the turn's usage. Both ride the terminal edge only. Requires the connectionUuid (the
      * server addresses the turn against a connection the agent owns).
      */
-    async turnAdvance({ sessionId, status, entityType, entityUuid, interruptedReason, transcriptRelayError, usage, backendSessionId }) {
+    async turnAdvance({ sessionId, status, entityType, entityUuid, interruptedReason, transcriptRelayError, usage, backendSessionId, coalescedCount }) {
       const connectionUuid = getConnectionUuid();
       if (!connectionUuid) {
         const error = `cannot advance turn for session ${sessionId} → ${status} — no connection uuid yet`;
@@ -173,6 +174,13 @@ export function createDaemonRestClient(opts) {
         // The whole normalized TokenUsage object, nested under `usage`, only on a terminal edge.
         ...(usage && isTerminal ? { usage } : {}),
         ...(backendSessionId && isTerminal ? { backendSessionId } : {}),
+        // Coalesced-wake count (add-daemon-wake-coalescing): meaningful ONLY on the → running
+        // edge, where the server settles the next (count − 1) same-session pending turns to
+        // `merged`. Sent only when a real batch coalesced (> 1); a single wake (default 1)
+        // omits it so the wire — and every existing turn-advance test — stays byte-identical.
+        ...(status === "running" && typeof coalescedCount === "number" && coalescedCount > 1
+          ? { coalescedCount }
+          : {}),
       };
       return post(
         "turn-advance",