@chorus-aidlc/chorus 0.11.1 → 0.12.1

package/README.md

@@ -36,6 +36,8 @@ The labels under each stage are the **permissions** an actor needs at that stage
 
 ## What's New
 
+**[v0.12.0](https://chorus-ai.dev/blog/chorus-v0.12.0-release/)** — Addressable daemon instances: one `chorus daemon` can serve multiple working directories (`--cwd`), and each `(agent, host, cwd)` becomes an individually visible, individually targetable instance across presence, @-mention, and assignment. Pin an instance once on an idea and its proposals, tasks, and wakes inherit it; pinned wakes are delivered to exactly that instance instead of broadcast. Comment @-mentions render as live online-status badges, and comments switch to cursor-based infinite scroll.
+
 **[v0.11.0](https://chorus-ai.dev/blog/chorus-v0.11.0-release/)** — The Chorus Daemon: `chorus daemon` turns your machine into a resident agent runtime that wakes a local Claude Code on each dispatch. An Agent Connections surface gives live observability and control — streaming transcripts, instruction injection, and interrupt / resume — and a "Verify Elaborate" button wakes the assigned agent to write the proposal.
 
 **[v0.10.0](https://chorus-ai.dev/blog/chorus-v0.10.0-release/)** — Single-parent idea lineage: an idea may derive a child or be attached under another, forming a forest. The relation is intentionally weak — a parent surfaces a read-only "+N derived" rollup and does not constrain any child's elaboration, proposal, or task flow. Idea browsing consolidates onto the Dashboard (a three-way Ideas / Lineage / Stats view switch with an adaptive default); the standalone Idea List page is retired and its URLs 308-redirect to the Dashboard.
@@ -46,18 +48,6 @@ The labels under each stage are the **permissions** an actor needs at that stage
 
 **[v0.8.0](https://chorus-ai.dev/blog/chorus-v0.8.0-release/)** — OpenSpec-aware mode (Claude Code): auto-activates when an `openspec/` directory and the `openspec` CLI are both present, adds `/opsx/{explore,propose,apply,archive}` and a post-verify archive-trigger hook.
 
-**[v0.7.0](https://chorus-ai.dev/blog/chorus-v0.7.0-release/)** — Fine-grained agent permissions: 5 resources × 3 actions grid replaces the PM/Developer/Admin three-way choice, with presets + a Custom option for free combination.
-
-**[v0.6.7](https://chorus-ai.dev/blog/chorus-v0.6.7-release/)** — Chorus plugin for Codex CLI (one-command installer), workspace picker when one email belongs to multiple Companies, per-client connect guides.
-
-**[v0.6.6](https://chorus-ai.dev/blog/chorus-v0.6.6-release/)** — npm one-click install (`npx @chorus-aidlc/chorus`), document export (MD/PDF/Word), proposal revoke, faster agent checkin with work status at a glance.
-
-**[v0.6.2](https://chorus-ai.dev/blog/chorus-v0.6.2-release/)** — Embedded PGlite mode (zero-dependency deployment), structured logging with Pino, stateless MCP for horizontal scaling, default port changed to 8637.
-
-**[v0.6.1](https://chorus-ai.dev/blog/chorus-v0.6.1-release/)** — `/yolo` skill: full-auto AI-DLC pipeline (Idea → Proposal → Execute → Verify) with Agent Team parallel execution.
-
-**[v0.6.0](https://chorus-ai.dev/blog/chorus-v0.6.0-release/)** — IdeaTracker dashboard, independent review agents (proposal-reviewer + task-reviewer), real-time agent presence indicators, cross-column Kanban animation.
-
 > Full changelog: [CHANGELOG.md](CHANGELOG.md)
 
 ---
@@ -106,7 +96,7 @@ DATABASE_URL=postgresql://user:pass@host:5432/chorus chorus
 
 The `chorus daemon` connects your local machine to a remote Chorus server as an agent runtime and executes tasks assigned by Chorus.
 
-> **Current version:** Only **Claude Code** is supported. Support for other agent CLIs (Codex, Copilot, etc.) is planned for future releases.
+> **Agent backends:** **Claude Code** (default) and **Codex** are supported — select with `--agent codex` (or `CHORUS_AGENT=codex`). Support for other agent CLIs (Copilot, etc.) is planned for future releases.
 
 ```bash
 chorus login                     # Authenticate (opens browser)
@@ -120,17 +110,61 @@ chorus daemon logs               # View daemon logs
 
 **Key features:**
 
-- **Claude Code integration** — Auto-detects `claude` CLI on your PATH
+- **Claude Code & Codex backends** — Auto-detects the `claude` (or `codex`) CLI on your PATH; pick with `--agent codex`
 - **Background mode** — Run with `-d` flag; manage with `stop/restart/logs`
 - **Permission modes** — Default is full access (yolo); use `--chorus-only` to restrict to Chorus MCP tools only
+- **Multi-path** — Serve several working directories from one daemon with repeatable `--cwd` (see below)
 - **Interactive setup** — Prompts for credentials on first start if not already configured
 
 The daemon requires authentication. Run `chorus login` first, or it will prompt for credentials interactively on first start (if running in a terminal).
 
+#### Serve multiple working directories
+
+One daemon can serve several local working directories at once — each declared path registers as an independent connection (its own session + wake loop) under the same agent. A path is **just** a directory the daemon serves; it carries no project binding.
+
+```bash
+chorus daemon --cwd ~/work/repo-a --cwd ~/work/repo-b   # repeatable flag
+CHORUS_DAEMON_CWDS="~/work/repo-a:~/work/repo-b" chorus daemon   # or env (`:`- or `,`-separated)
+```
+
+With no `--cwd`, the daemon serves the single directory it was launched from.
+
+#### Configuration file — `~/.chorus/daemon.json`
+
+`chorus login` writes credentials here (mode `0600`). You can also add daemon tunables to the **same** file. Every field is optional; flags and environment variables always take precedence over the file.
+
+```json
+{
+  "url": "https://chorus.example.com",
+  "apiKey": "cho_xxxxxxxxxxxxxxxxxxxxxxxx",
+  "agentUuid": "00000000-0000-0000-0000-000000000000",
+  "agentName": "My Daemon Agent",
+  "cwds": ["~/work/repo-a", "~/work/repo-b"],
+  "sigintTimeoutMs": 10000
+}
+```
+
+| Field | Type | Written by / used for | Precedence (highest first) |
+|-------|------|-----------------------|----------------------------|
+| `url` | string | Remote Chorus server URL | `--url` flag → `CHORUS_URL` → file |
+| `apiKey` | string | Agent API key (`cho_…`) | `--api-key` flag → `CHORUS_API_KEY` → file |
+| `agentUuid` / `agentName` | string | Authenticated identity (recorded at login) | written by `chorus login` |
+| `cwds` | string[] | Working directories the daemon serves (multi-path) | `--cwd` flag(s) → `CHORUS_DAEMON_CWDS` → file → launch dir |
+| `sigintTimeoutMs` | number | Grace window (ms) after SIGINT before a forceful kill (default `10000`) | `--sigint-timeout` flag → `CHORUS_DAEMON_SIGINT_TIMEOUT` → file → `10000` |
+| `yoloAckAt` | string | Internal — timestamp of a TTY yolo confirmation (managed automatically) | — |
+
+On startup the daemon banner prints the **exact `daemon.json` path it read** (and whether the file exists), so you always know which file to edit.
+
 ---
 
 ## Screenshots
 
+### Remote Agent Wake — Dispatch to a Directory, Watch It Run
+
+![Remote Agent Wake](docs/images/agent-daemon-wake.gif)
+
+Assign an idea to a specific directory on a remote agent, then open the conversation and watch the local Claude Code pick up the work and run in real time — no terminal, no manual resume.
+
 ### Proposal — AI Agent Generates Plans in Real Time
 
 ![Proposal Presence](docs/images/proposal-presence.gif)
@@ -257,7 +291,7 @@ A Cmd+K command palette for searching across all 6 entity types (Tasks, Ideas, P
 | Agent Integration | MCP SDK 1.26 (HTTP Streamable Transport) |
 | Auth | OIDC + PKCE / API Key / SuperAdmin |
 | i18n | next-intl (en, zh) |
-| Deployment | [Docker Hub](https://hub.docker.com/repository/docker/chorusaidlc/chorus-app/general) / Docker Compose / AWS CDK |
+| Deployment | [Docker Hub](https://hub.docker.com/r/chorusaidlc/chorus-app) / Docker Compose / AWS CDK |
 
 ---
 

package/README.zh.md

@@ -27,6 +27,8 @@ Idea ──> Proposal ──> [Document + Task DAG] ──> Execute ──> Veri
 
 ## 最近更新
 
+**[v0.12.0](https://chorus-ai.dev/zh/blog/chorus-v0.12.0-release/)** — 可寻址的 daemon 实例：一个 `chorus daemon` 可同时守多个工作目录（`--cwd`），每一个 `(agent, 主机, 目录)` 都成为一个能单独看见、单独点名的实例，贯穿 presence、@-mention 与任务指派。在想法上钉一次实例，其下的提案、任务与唤醒都会继承；带钉的唤醒被精确投递到那个实例，而非全员广播。评论区的 Agent @-mention 渲染为实时在线状态徽章，评论列表改为游标式无限滚动。
+
 **[v0.11.0](https://chorus-ai.dev/zh/blog/chorus-v0.11.0-release/)** — Chorus Daemon：`chorus daemon` 将本机变为常驻 Agent 运行时，在每次派发时唤起本地 Claude Code。Agent Connections 界面提供实时可观测与控制：流式 transcript、指令注入、打断 / 恢复；新增"完成细化"按钮，唤起被指派的 Agent 撰写提案。
 
 **[v0.10.0](https://chorus-ai.dev/zh/blog/chorus-v0.10.0-release/)** — 单父想法血缘：一条想法可派生子想法或挂靠至另一条之下，构成森林结构。该关联为弱关联，父想法仅呈现只读的 "+N derived" 汇总，不约束子想法的细化、提案与任务流程。想法浏览统一收敛至 Dashboard（Ideas / Lineage / Stats 三档视图切换，支持自适应默认）；独立的 Idea List 页面下线，原 URL 经 308 重定向至 Dashboard。
@@ -37,18 +39,6 @@ Idea ──> Proposal ──> [Document + Task DAG] ──> Execute ──> Veri
 
 **[v0.8.0](https://chorus-ai.dev/zh/blog/chorus-v0.8.0-release/)** — OpenSpec-aware 模式（仅 Claude Code）：当仓库下同时存在 `openspec/` 目录和 `openspec` CLI 时自动启用，新增 `/opsx/{explore,propose,apply,archive}` 与 task verify 后的 archive-trigger 钩子。
 
-**[v0.7.0](https://chorus-ai.dev/zh/blog/chorus-v0.7.0-release/)** — 细粒度 Agent 权限：5 类资源 × 3 个动作组成的网格，取代 PM / Developer / Admin 三选一。保留原有预设，新增 Custom 选项自由组合。
-
-**[v0.6.7](https://chorus-ai.dev/zh/blog/chorus-v0.6.7-release/)** — Codex CLI 版 Chorus 插件（一条命令装完）、同一邮箱属于多个 Company 时的工作区选择器、每种客户端的接入文档。
-
-**[v0.6.6](https://chorus-ai.dev/zh/blog/chorus-v0.6.6-release/)** — npm 一键安装（`npx @chorus-aidlc/chorus`）、文档导出（MD/PDF/Word）、Proposal 撤回、优化 Agent Checkin 快速获取工作状态。
-
-**[v0.6.2](https://chorus-ai.dev/zh/blog/chorus-v0.6.2-release/)** — 嵌入式 PGlite 模式（零依赖部署）、Pino 结构化日志、无状态 MCP 支持水平扩展、默认端口改为 8637。
-
-**[v0.6.1](https://chorus-ai.dev/zh/blog/chorus-v0.6.1-release/)** — `/yolo` 技能：全自动 AI-DLC 流水线（Idea → Proposal → Execute → Verify），支持 Agent Team 并行执行。
-
-**[v0.6.0](https://chorus-ai.dev/zh/blog/chorus-v0.6.0-release/)** — IdeaTracker 面板、独立审阅 Agent（proposal-reviewer + task-reviewer）、实时 Agent Presence 指示器、跨列 Kanban 动画。
-
 > 完整更新日志：[CHANGELOG.md](CHANGELOG.md)
 
 ---
@@ -97,7 +87,7 @@ DATABASE_URL=postgresql://user:pass@host:5432/chorus chorus
 
 `chorus daemon` 将你的本地机器作为 Agent 运行时连接到远程 Chorus 服务器并执行 Chorus 分配的任务。
 
-> **当前版本：** 仅支持 **Claude Code**。对其他 Agent CLI（Codex、Copilot 等）的支持计划在未来版本中实现。
+> **Agent 后端：** 支持 **Claude Code**（默认）和 **Codex**，用 `--agent codex`（或 `CHORUS_AGENT=codex`）切换。对其他 Agent CLI（Copilot 等）的支持计划在未来版本中实现。
 
 ```bash
 chorus login                     # 认证（打开浏览器）
@@ -111,17 +101,61 @@ chorus daemon logs               # 查看 daemon 日志
 
 **主要特性：**
 
-- **Claude Code 集成** — 自动检测 PATH 中的 `claude` CLI
+- **Claude Code 与 Codex 后端** — 自动检测 PATH 中的 `claude`（或 `codex`）CLI；用 `--agent codex` 选择
 - **后台模式** — 使用 `-d` 标志后台运行；用 `stop/restart/logs` 管理
 - **权限模式** — 默认完全访问（yolo）；使用 `--chorus-only` 限制为仅 Chorus MCP 工具
+- **多路径** — 用可重复的 `--cwd` 让单个 daemon 同时服务多个工作目录（见下文）
 - **交互式设置** — 首次启动时如未配置凭证会提示输入
 
 daemon 需要先认证。首次使用请先运行 `chorus login`，或者 daemon 会在首次启动时交互式提示输入凭证（如果在终端中运行）。
 
+#### 服务多个工作目录
+
+一个 daemon 可以同时服务多个本地工作目录——每个声明的路径会注册为一条独立连接（各自拥有会话与唤起循环），归属同一个 Agent。路径**仅仅**是 daemon 服务的目录，不携带任何项目绑定。
+
+```bash
+chorus daemon --cwd ~/work/repo-a --cwd ~/work/repo-b   # 可重复传入
+CHORUS_DAEMON_CWDS="~/work/repo-a:~/work/repo-b" chorus daemon   # 或用环境变量（`:` 或 `,` 分隔）
+```
+
+不传 `--cwd` 时，daemon 只服务它的启动目录这一个路径。
+
+#### 配置文件 —— `~/.chorus/daemon.json`
+
+`chorus login` 会把凭证写入此文件（权限 `0600`）。你也可以把 daemon 的调优项写进**同一个**文件。所有字段都是可选的；命令行参数和环境变量的优先级始终高于文件。
+
+```json
+{
+  "url": "https://chorus.example.com",
+  "apiKey": "cho_xxxxxxxxxxxxxxxxxxxxxxxx",
+  "agentUuid": "00000000-0000-0000-0000-000000000000",
+  "agentName": "My Daemon Agent",
+  "cwds": ["~/work/repo-a", "~/work/repo-b"],
+  "sigintTimeoutMs": 10000
+}
+```
+
+| 字段 | 类型 | 写入方 / 用途 | 优先级（从高到低） |
+|------|------|---------------|--------------------|
+| `url` | string | 远程 Chorus 服务器 URL | `--url` 参数 → `CHORUS_URL` → 文件 |
+| `apiKey` | string | Agent API Key（`cho_…`） | `--api-key` 参数 → `CHORUS_API_KEY` → 文件 |
+| `agentUuid` / `agentName` | string | 认证身份（登录时记录） | 由 `chorus login` 写入 |
+| `cwds` | string[] | daemon 服务的工作目录（多路径） | `--cwd` 参数 → `CHORUS_DAEMON_CWDS` → 文件 → 启动目录 |
+| `sigintTimeoutMs` | number | SIGINT 后强制结束前的宽限窗口（毫秒，默认 `10000`） | `--sigint-timeout` 参数 → `CHORUS_DAEMON_SIGINT_TIMEOUT` → 文件 → `10000` |
+| `yoloAckAt` | string | 内部字段——TTY 下 yolo 确认的时间戳（自动管理） | — |
+
+daemon 启动时的横幅会打印它**实际读取的 `daemon.json` 路径**（以及该文件是否存在），让你随时清楚该编辑哪个文件。
+
 ---
 
 ## 界面预览
 
+### 远程唤醒 Agent——派活到指定目录，实时看它跑
+
+![远程唤醒 Agent](docs/images/agent-daemon-wake.gif)
+
+把一条想法派给远程 Agent 的某个目录，打开对话窗口，就能实时看到本地的 Claude Code 接活、开跑，全程不用碰终端，也不用手动 resume。
+
 ### Proposal——AI Agent 实时生成计划
 
 ![Proposal Presence](docs/images/proposal-presence.gif)
@@ -248,7 +282,7 @@ Cmd+K 命令面板，支持跨 6 种实体类型搜索。支持范围筛选（
 | Agent 集成 | MCP SDK 1.26 (HTTP Streamable Transport) |
 | 认证 | OIDC + PKCE / API Key / SuperAdmin |
 | i18n | next-intl (en, zh) |
-| 部署 | [Docker Hub](https://hub.docker.com/repository/docker/chorusaidlc/chorus-app/general) / Docker Compose / AWS CDK |
+| 部署 | [Docker Hub](https://hub.docker.com/r/chorusaidlc/chorus-app) / Docker Compose / AWS CDK |
 
 ---
 

package/chorus.mjs

@@ -34,6 +34,10 @@ import {
   daemonHelpText,
   loginHelpText,
 } from "./cli/client-args.mjs";
+// Server-only signal-handler installer, guarded so a client subcommand
+// (`chorus daemon` / `chorus login`) never registers the server's handlers.
+// Pure module → unit-testable without this entry's import-time side effects.
+import { installServerSignalHandlers } from "./cli/server-signal-handlers.mjs";
 
 /** Read the package version once for help/version output. */
 function pkgVersion() {
@@ -159,10 +163,13 @@ ENVIRONMENT VARIABLES
 DAEMON / LOGIN (client mode)
   --url <url>              Remote Chorus server URL      (env: CHORUS_URL)
   --api-key <cho_...>      Agent API key                 (env: CHORUS_API_KEY)
-  --yolo                   Give the woken Claude FULL permissions             (env: CHORUS_YOLO=1)
+  --chorus-only            Restrict the woken Claude to Chorus MCP tools only  (env: CHORUS_CHORUS_ONLY=1)
+                           (comment/claim/report/status — no Bash / file edits).
+                           Opt out of the default full-autonomy posture.
+  --yolo                   Full autonomy for the woken Claude — the DEFAULT     (env: CHORUS_YOLO=1)
                            (--dangerously-skip-permissions: Bash, file writes,
-                           any command). Default is Chorus-MCP-tools-only.
-  --sigint-timeout <ms>    Grace window after SIGINT before a forceful kill   (env: CHORUS_DAEMON_SIGINT_TIMEOUT)
+                           any command). Already on unless --chorus-only is set.
+  --sigint-timeout <ms>    Grace window after SIGINT before a forceful kill    (env: CHORUS_DAEMON_SIGINT_TIMEOUT)
                            when an interrupt is received (default: 10000).
                            Also configurable via ~/.chorus/daemon.json sigintTimeoutMs.
 
@@ -170,9 +177,9 @@ DAEMON / LOGIN (client mode)
   ~/.chorus/daemon.json (from 'chorus login') > Claude Code plugin config.
 
   The daemon spawns the local 'claude' CLI headlessly per task dispatch; it must
-  be on PATH. Override with CHORUS_CLAUDE_PATH. By default the woken Claude may
-  use only Chorus MCP tools (comment/claim/report/status) — pass --yolo for full
-  autonomy (real code-writing AI-DLC), which is dangerous: run it sandboxed.
+  be on PATH. Override with CHORUS_CLAUDE_PATH. By default the woken Claude runs
+  with FULL autonomy (real code-writing AI-DLC), which is dangerous: run it
+  sandboxed, or pass --chorus-only to restrict it to Chorus MCP tools.
 
 EXAMPLES
   chorus                                     # Embedded PGlite (default)
@@ -180,8 +187,8 @@ EXAMPLES
   chorus --data-dir /var/lib/chorus          # Custom data directory
   DATABASE_URL=postgres://... chorus --use-pglite=false   # External PostgreSQL
   chorus login                               # Interactive: validate key, save credentials
-  chorus daemon                              # Connect & wake local Claude Code (Chorus tools only)
-  chorus daemon --yolo                       # Full autonomy: woken Claude can run Bash / edit files
+  chorus daemon                              # Connect & wake local Claude Code (full autonomy by default)
+  chorus daemon --chorus-only                # Restrict the woken Claude to Chorus MCP tools only
   CHORUS_URL=https://... CHORUS_API_KEY=cho_... chorus daemon
 `);
   process.exit(0);
@@ -451,12 +458,21 @@ function shutdown() {
   }
 }
 
-process.on("SIGINT", shutdown);
-process.on("SIGTERM", shutdown);
-process.on("exit", () => {
-  if (pgliteProcess && !pgliteProcess.killed) {
-    pgliteProcess.kill("SIGKILL");
-  }
+// Install the server's SIGINT/SIGTERM/exit handlers ONLY on the server launch
+// path. On a client subcommand (`chorus daemon` / `chorus login`) this installs
+// nothing, so the daemon's OWN graceful shutdown handler is the sole signal
+// disposition — otherwise the server's handler (registered first) would pre-empt
+// it with a synchronous `process.exit(0)`, leaving the daemon to disconnect
+// non-gracefully (stale presence) and printing a misleading bare "Shutting down...".
+installServerSignalHandlers({
+  isSubcommand,
+  processRef: process,
+  shutdown,
+  cleanupExit: () => {
+    if (pgliteProcess && !pgliteProcess.killed) {
+      pgliteProcess.kill("SIGKILL");
+    }
+  },
 });
 
 // ---------------------------------------------------------------------------

package/cli/client-args.mjs

@@ -28,10 +28,16 @@ export const KNOWN_AGENTS = new Set(["claude-code"]);
  * "false" (important for layered env/flag precedence downstream).
  *
  * @param {string[]} argv
+ * The new repeatable `--cwd <path>` (space + `=`) declares a working directory the
+ * daemon serves; repeating it (`--cwd a --cwd b`) declares the SET of paths for the
+ * single-daemon multi-path engine (T3). It is collected into a `cwd: string[]` array
+ * preserving order; absent ⇒ `cwd` is unset (the layered resolver then falls back to
+ * env / config / the process cwd). It is JUST a path list — no project binding.
+ *
  * @returns {{
  *   url?: string, apiKey?: string, yolo?: boolean, sigintTimeout?: string,
  *   agent?: string, chorusOnly?: boolean, verbose?: boolean, detach?: boolean,
- *   help?: boolean,
+ *   cwd?: string[], help?: boolean,
  * }}
  */
 export function parseClientFlags(argv) {
@@ -47,6 +53,11 @@ export function parseClientFlags(argv) {
     else if (a.startsWith("--sigint-timeout=")) out.sigintTimeout = a.slice("--sigint-timeout=".length);
     else if (a === "--agent") out.agent = argv[i + 1];
     else if (a.startsWith("--agent=")) out.agent = a.slice("--agent=".length);
+    else if (a === "--cwd" || a.startsWith("--cwd=")) {
+      // Repeatable: collect every --cwd into an ordered array (the cwd SET).
+      const value = a === "--cwd" ? argv[i + 1] : a.slice("--cwd=".length);
+      if (typeof value === "string") (out.cwd ??= []).push(value);
+    }
     else if (a === "--chorus-only") out.chorusOnly = true;
     else if (a === "--verbose") out.verbose = true;
     else if (a === "-d" || a === "--detach") out.detach = true;
@@ -96,13 +107,18 @@ OPTIONS
   --url <url>              Remote Chorus server URL            (env: CHORUS_URL)
   --api-key <cho_...>      Agent API key                       (env: CHORUS_API_KEY)
   --agent <type>           Local agent backend to wake         (env: CHORUS_AGENT)
-                           (default: claude-code; only claude-code is implemented)
+                           (claude-code | codex; default: claude-code)
   --yolo                   Full autonomy for the woken agent   (env: CHORUS_YOLO=1)
                            (--dangerously-skip-permissions: Bash, file writes, any
                            command). This is the DEFAULT permission mode.
   --chorus-only            Restrict the woken agent to Chorus  (env: CHORUS_CHORUS_ONLY=1)
                            MCP tools only (no Bash / file edits) — reclaims the
                            safe posture from the default yolo.
+  --cwd <path>             A working directory the daemon serves. Repeatable —
+                           (env: CHORUS_DAEMON_CWDS) each --cwd registers an independent
+                           connection for that path, so one daemon can serve several
+                           local paths at once. Default: the directory it was launched
+                           from. (Also configurable as "cwds":[…] in ~/.chorus/daemon.json.)
   -d, --detach             Run detached in the background (pidfile + logfile)
   --verbose                More detailed per-wake logging
   --sigint-timeout <ms>    Grace window after SIGINT before a forceful kill

package/cli/codex-session-map.mjs

@@ -0,0 +1,117 @@
+// cli/codex-session-map.mjs
+// Daemon-local persistence of the Codex `anchor → thread_id` map. Codex GENERATES
+// its own thread id (unlike Claude, which accepts a client-supplied --session-id),
+// so to make a wake resumable across daemon restarts we record the generated id
+// keyed by the Chorus session anchor (direct idea uuid, or the entity uuid for an
+// ad-hoc session) and `codex exec resume <thread_id>` on the next wake.
+//
+// The store is a single JSON object `{ "<anchor>": "<thread_id>" }` at
+// ~/.chorus/codex-sessions.json (same dir family as daemon.json). The anchor is a
+// globally-unique Chorus uuid, so one flat file is safe across the daemon's
+// multiple path-connections.
+//
+// CONTRACT: this is best-effort and MUST NEVER throw into the wake path. Any
+// read/parse/write/rename failure degrades to "no mapping → next wake starts
+// fresh" with a visible log (no-silent-errors). IO is injectable for tests.
+
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+const NOOP_LOGGER = { info() {}, warn() {}, error() {} };
+
+/** Absolute path to the Codex session-id map, alongside ~/.chorus/daemon.json. */
+export function codexSessionMapPath() {
+  return join(homedir(), ".chorus", "codex-sessions.json");
+}
+
+/** A non-empty trimmed string, or null. */
+function nonEmpty(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+
+/**
+ * Read the whole map as a plain object. Missing / unreadable / malformed file →
+ * `{}` (never throws). A non-object JSON value (array / scalar) is also treated
+ * as empty.
+ * @param {string} path
+ * @param {(p: string) => string} read
+ * @param {{warn(m:string):void}} logger
+ * @returns {Record<string, unknown>}
+ */
+function readMap(path, read, logger) {
+  let raw;
+  try {
+    raw = read(path);
+  } catch (err) {
+    // ENOENT is the normal "no map yet" case — silent. Other read errors warn.
+    if (!(err && err.code === "ENOENT")) {
+      logger.warn(`[Chorus] codex-session-map: read failed (${err}) — treating as empty`);
+    }
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+    logger.warn("[Chorus] codex-session-map: file is not a JSON object — treating as empty");
+    return {};
+  } catch (err) {
+    logger.warn(`[Chorus] codex-session-map: corrupt JSON (${err}) — treating as empty`);
+    return {};
+  }
+}
+
+/**
+ * Look up the Codex thread id recorded for `anchor`, or null when there is none
+ * (no file, no entry, or a non-string entry). Never throws.
+ * @param {string} anchor
+ * @param {{ path?: string, read?: (p: string) => string, logger?: any }} [deps]
+ * @returns {string | null}
+ */
+export function getThreadId(anchor, deps = {}) {
+  const a = nonEmpty(anchor);
+  if (!a) return null;
+  const path = deps.path ?? codexSessionMapPath();
+  const read = deps.read ?? ((p) => readFileSync(p, "utf8"));
+  const logger = deps.logger ?? NOOP_LOGGER;
+  const map = readMap(path, read, logger);
+  return nonEmpty(map[a]);
+}
+
+/**
+ * Record `anchor → threadId`, preserving every other entry. Atomic (temp file +
+ * rename). Best-effort: a blank anchor/threadId is ignored (no write), and any
+ * IO failure is logged and swallowed — it never throws into the wake path.
+ * @param {string} anchor
+ * @param {string} threadId
+ * @param {{ path?: string, read?: (p: string) => string,
+ *           write?: (p: string, c: string, o?: object) => void,
+ *           mkdir?: (p: string, o?: object) => void,
+ *           rename?: (from: string, to: string) => void, logger?: any }} [deps]
+ * @returns {void}
+ */
+export function setThreadId(anchor, threadId, deps = {}) {
+  const a = nonEmpty(anchor);
+  const t = nonEmpty(threadId);
+  if (!a || !t) return; // nothing meaningful to persist
+  const path = deps.path ?? codexSessionMapPath();
+  const read = deps.read ?? ((p) => readFileSync(p, "utf8"));
+  const write = deps.write ?? writeFileSync;
+  const mkdir = deps.mkdir ?? mkdirSync;
+  const rename = deps.rename ?? renameSync;
+  const logger = deps.logger ?? NOOP_LOGGER;
+
+  try {
+    const map = readMap(path, read, logger);
+    map[a] = t;
+    mkdir(dirname(path), { recursive: true });
+    // Atomic write: temp file (0600) in the same dir, then rename over target,
+    // so a crash mid-write never truncates the live map.
+    const tmp = `${path}.tmp`;
+    write(tmp, JSON.stringify(map, null, 2) + "\n", { mode: 0o600 });
+    rename(tmp, path);
+  } catch (err) {
+    // Best-effort: a failed persist just means the next wake starts fresh.
+    logger.warn(`[Chorus] codex-session-map: failed to persist ${a}→${t} (${err}) — wake will start fresh next time`);
+  }
+}