cofluxd 0.14.0 → 0.15.0

package/cofluxd.mjs

@@ -945,10 +945,14 @@ async function cmdHook() {
 // 不需要任何凭证：daemon 用调用方 pid 反查进程树确认它属于哪个会话，树外一律拒。
 // local-first（plan 094）：send/read/wait/notify/progress 在 daemon 本地闭环，不经中心；只有
 // new/list/ports 由 daemon 代问中心（Task 要落库广播、预览 URL 由中心生成）。
+// 跟随 cwd（plan 102）：请求都带 process.cwd()，agent 挪进同设备另一个 coflux 工作区后，这些
+// 命令就对那个工作区办事（notify/progress/ports 除外，它们挂在本会话上，与工作区无关）。
 // 与 `hook` 子命令的约定**相反**：这些命令必须写 stdout——输出就是给 agent 读的返回值。
 // 也刻意不做自动重试：terminal new 有副作用，重试会开出两个终端，失败就把错误交给 agent。
 
 const AGENT_TIMEOUT_MS = 30_000;
+/** 调用方能收窄单次 `/agent` 等待的下限；再低就只够覆盖 node 自己的启动，等于必然超时。 */
+const MIN_AGENT_TIMEOUT_MS = 200;
 const DEFAULT_READ_LINES = 200;
 // wait 的循环必须在 CLI 侧：单次 agentPost 有 25 秒的 loopback 应答上限。默认 30 分钟——编码任务
 // 常跑很久；轮询走 terminal.status（daemon 本地账本直接答，不经中心），3 秒一次对本机 loopback
@@ -956,6 +960,24 @@ const DEFAULT_READ_LINES = 200;
 const DEFAULT_WAIT_TIMEOUT_S = 1800;
 const WAIT_POLL_MS = 3000;
 
+// 每条请求都带调用方 cwd（plan 102）：agent 可以经 `/cd` 或 EnterWorktree 把活着的会话挪进同
+// 设备的另一个 coflux 工作区，daemon 据此把本次请求的**目标**解析到 cwd 所在的工作区（会话的
+// 归属工作区不变）。目录被删掉时 process.cwd() 会抛，按"报不出来"处理，daemon 退回归属工作区。
+function callerCwd() {
+  try { return process.cwd(); } catch { return ""; }
+}
+
+// 调用方可以用 COFLUX_AGENT_TIMEOUT_MS 收窄单次请求的等待上限（plan 104）。默认 30 秒是为
+// agent 定的——它等得起；hook 脚本等不起：宿主按秒杀 hook（SessionStart 只给几秒），而经中心的
+// 动作最坏要等 daemon 的 20 秒中心超时。被宿主杀在半路比拿不到答案坏得多（连坐标块都印不出来），
+// 所以这类调用方自报一个更小的预算，到点干净失败、让脚本走回退。
+// 只允许收窄不允许放宽：上限仍是 AGENT_TIMEOUT_MS，畸形值一律按默认处理。
+function agentTimeoutMs() {
+  const raw = Number(process.env.COFLUX_AGENT_TIMEOUT_MS);
+  if (!Number.isFinite(raw) || raw <= 0) return AGENT_TIMEOUT_MS;
+  return Math.min(Math.max(Math.floor(raw), MIN_AGENT_TIMEOUT_MS), AGENT_TIMEOUT_MS);
+}
+
 async function agentPost(body) {
   const portResult = localGatewayPort();
   if (!portResult.ok) die(portResult.error);
@@ -964,8 +986,8 @@ async function agentPost(body) {
     res = await fetch(`http://127.0.0.1:${portResult.port}/agent`, {
       method: "POST",
       headers: { "content-type": "application/json" },
-      body: JSON.stringify({ ...body, pid: process.pid, ppid: process.ppid }),
-      signal: AbortSignal.timeout(AGENT_TIMEOUT_MS),
+      body: JSON.stringify({ ...body, pid: process.pid, ppid: process.ppid, cwd: callerCwd() }),
+      signal: AbortSignal.timeout(agentTimeoutMs()),
     });
   } catch (error) {
     die(`连不上本机 daemon：${error?.message || error}（daemon 没在跑？先看 cofluxd status）`);
@@ -1071,6 +1093,55 @@ async function cmdProgress() {
   console.log("已更新进度（显示在工作区卡片上，被下一条覆盖）");
 }
 
+// 「我在哪」与「跟着我搬」（plan 102 / 103）。三条都打一行 JSON，字段稳定——插件脚本按它比对，
+// agent 也直接读。
+//
+//   cofluxd workspace                 只读：cwd 所在的有效工作区 + 本终端的归属工作区
+//   cofluxd workspace locate [path]   把本终端的**归属**搬到 path 所属的工作区（未登记先登记）
+//   cofluxd workspace forget <path>   该 worktree 已被删掉：其下终端搬回主工作区、记录消失
+//
+// locate/forget 是插件在 SessionStart / PostToolUse(EnterWorktree|ExitWorktree) / WorktreeRemove
+// 上调的，同样零凭证（daemon 按进程树认身份）。daemon 旧到不认识这两个动作时它会回
+// 「未知 action …」，agentPost 原样报错并非零退出——脚本据此静默放弃，不干扰会话。
+async function cmdWorkspace() {
+  const sub = positionals[1];
+  if (!sub) {
+    const result = await agentPost({ action: "workspace.current" });
+    return void console.log(JSON.stringify({
+      workspaceId: result.workspaceId,
+      path: result.path,
+      owningWorkspaceId: result.owningWorkspaceId,
+      moved: Boolean(result.moved),
+    }));
+  }
+  if (sub === "locate") {
+    // 路径缺省取调用方 cwd；插件脚本一律显式传 hook 载荷里的 cwd（hook 在会话当前目录执行，
+    // 与载荷里的 cwd 未必相同）。
+    const path = positionals[2] || callerCwd();
+    if (!path) die("workspace locate 需要 <path>（取不到当前目录）");
+    const result = await agentPost({ action: "workspace.locate", path });
+    return void console.log(JSON.stringify({
+      workspaceId: result.workspaceId,
+      path: result.path,
+      branch: result.branch,
+      created: Boolean(result.created),
+      moved: Boolean(result.moved),
+    }));
+  }
+  if (sub === "forget") {
+    const path = positionals[2];
+    if (!path) die("workspace forget 需要 <path>（被删掉的 worktree 目录）");
+    const result = await agentPost({ action: "workspace.forget", path });
+    return void console.log(JSON.stringify({
+      workspaceId: result.workspaceId,
+      fallbackWorkspaceId: result.fallbackWorkspaceId,
+      movedTerminals: result.movedTerminals ?? 0,
+      removed: Boolean(result.removed),
+    }));
+  }
+  die(`workspace 的子命令只有 locate | forget（不带子命令 = 报出我在哪）`);
+}
+
 async function cmdPorts() {
   const { ports } = await agentPost({ action: "ports" });
   if (!ports.length) return void console.log("本工作区暂无监听端口");
@@ -1110,6 +1181,20 @@ const HELP = `cofluxd —— coflux daemon 管理
   cofluxd notify "<一句话>"  叫人：工作区在侧栏转为「等待交互」并显示这句话
   cofluxd progress "<一句话>"  播报进度：显示在工作区卡片上，被下一条覆盖（不打扰用户）
   cofluxd ports           列出本工作区的监听端口及可直接打开的预览 URL
+  cofluxd workspace       一行 JSON 报出「我在哪」：workspaceId（cwd 所在的有效工作区，本地命令
+                          都落在它上面）、path、owningWorkspaceId（本终端此刻归属哪个工作区）、
+                          moved。用 /cd 挪进另一个 coflux 工作区后用它确认目标，调 MCP 时也传这个
+                          workspaceId
+  cofluxd workspace locate [path]
+                          把本终端的**归属**搬到 path（缺省=当前目录）所属的工作区：进入/离开
+                          worktree 后 coflux 跟着走，未登记的同仓库 worktree 先登记出一个子工作区。
+                          插件自动调，一般不用手敲
+  cofluxd workspace forget <path>
+                          该 worktree 已被删掉：其下所有终端搬回项目主工作区、工作区记录消失
+                          （不执行 git worktree remove）
+
+agent 命令的环境变量：COFLUX_AGENT_TIMEOUT_MS 收窄单次请求的等待上限（默认 30000，只能调小），
+供有硬超时的 hook 脚本用——到点干净失败，好过被宿主杀在半路。
 
 up flags: --server <ws://.../daemon>  --name <名>  --shell <路径>
 通用: --version <vX|latest>(不传时 up 沿用已有二进制，update 默认 latest)  --bin-dir <dir>(用本地 cargo 产物)  --no-start
@@ -1147,7 +1232,7 @@ let cmd = positionals[0];
 if (values.help || cmd === "help") { console.log(HELP); process.exit(0); }
 if (!cmd) cmd = fs.existsSync(SETTINGS) ? "status" : "up"; // 首次裸跑 → 引导
 
-const handlers = { up: cmdUp, update: cmdUpdate, restart: cmdRestart, down: cmdDown, status: cmdStatus, doctor: cmdDoctor, fda: cmdFda, logs: cmdLogs, uninstall: cmdUninstall, hook: cmdHook, terminal: cmdTerminal, notify: cmdNotify, progress: cmdProgress, ports: cmdPorts };
+const handlers = { up: cmdUp, update: cmdUpdate, restart: cmdRestart, down: cmdDown, status: cmdStatus, doctor: cmdDoctor, fda: cmdFda, logs: cmdLogs, uninstall: cmdUninstall, hook: cmdHook, terminal: cmdTerminal, notify: cmdNotify, progress: cmdProgress, ports: cmdPorts, workspace: cmdWorkspace };
 const h = handlers[cmd];
 if (!h) die(`未知命令: ${cmd}${MIGRATED[cmd] ? `\n${MIGRATED[cmd]}` : ""}\n\n${HELP}`);
 await h(values);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cofluxd",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "coflux daemon 管理 CLI：装/起/停/升级 Rust daemon（supervisor + worker）",
   "type": "module",
   "bin": {

package/skills/coflux/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: coflux
-description: When you run inside a coflux terminal, this skill documents the local cofluxd commands that open terminals the user can watch and take over from the coflux web/mobile app, report progress, call the user and hand out preview URLs, plus the center MCP for reaching other workspaces and devices. Your coordinates (device / project / workspace / terminal) arrive in a <coflux-session> block at session start, or via the COFLUX_* environment variables. Inside your own workspace always use the zero-credential local cofluxd commands (open, read, wait, send, report progress, call the user, get preview URLs); use the center's coflux MCP only to leave this workspace (child workspaces, other workspaces or devices). Use when the user should be able to watch, step into or stop a command (interactive steps, dev servers, a job they are waiting on), when the user has to decide something, when you want to hand the user a clickable preview URL, or when you need an isolated child workspace for parallel work.
+description: When you run inside a coflux terminal, this skill documents the local cofluxd commands that open terminals the user can watch and take over from the coflux web/mobile app, report progress, call the user and hand out preview URLs, plus the center MCP for reaching other workspaces and devices. Your coordinates (device / project / workspace / terminal) arrive in a <coflux-session> block at session start, or via the COFLUX_* environment variables. For the workspace your cwd is in always use the zero-credential local cofluxd commands (open, read, wait, send, report progress, call the user, get preview URLs); use the center's coflux MCP only to reach beyond it (child workspaces, other workspaces or devices). Use when the user should be able to watch, step into or stop a command (interactive steps, dev servers, a job they are waiting on), when the user has to decide something, when you want to hand the user a clickable preview URL, or when you need an isolated child workspace for parallel work.
 ---
 
 # Working inside coflux
@@ -10,12 +10,12 @@ machines from a browser or a phone and take over at any time. This skill gives y
 user can see and take over, a progress line and a call button on the workspace card, preview URLs,
 and a way to operate the other workspaces and devices under the account when you need to.
 
-Two tracks, one rule: **whatever closes locally uses local commands; only leaving this
-workspace goes through MCP.**
+Two tracks, one rule: **whatever closes locally uses local commands; only reaching beyond the
+workspace you are in goes through MCP.**
 
 | Track | Credentials | Reach | Use for |
 |---|---|---|---|
-| Local commands `cofluxd terminal/progress/notify/ports` | none (the daemon identifies you by process tree) | **the workspace you are in** | open, read, wait, send, report progress, call the user, preview URLs: the default, fastest, no network dependency |
+| Local commands `cofluxd terminal/progress/notify/ports` | none (the daemon identifies you by process tree) | **the workspace your cwd is in** | open, read, wait, send, report progress, call the user, preview URLs: the default, fastest, no network dependency |
 | Center MCP `coflux` | one OAuth authorization by the user in the host | **the whole account**: every device, project, workspace and terminal | child workspaces (git worktrees), cross-workspace / cross-device access, joining from outside coflux |
 
 Of the local commands, `send`/`read`/`wait`/`notify`/`progress` complete entirely inside the
@@ -42,7 +42,7 @@ env | grep '^COFLUX_'
   |---|---|
   | `COFLUX_DEVICE_ID` | id of the device you run on (the id in `list_devices`) |
   | `COFLUX_PROJECT_ID` | owning project id; empty string for a directory workspace without a repository |
-  | `COFLUX_WORKSPACE_ID` | owning workspace id (the id in `list_workspaces`) |
+  | `COFLUX_WORKSPACE_ID` | the workspace this terminal was **opened** in (the id in `list_workspaces`). The variable is frozen when the terminal starts; the workspace the terminal *belongs to* can still change — see below. `cofluxd workspace` is the authority |
   | `COFLUX_TASK_ID` | id of this terminal (the taskId / terminalId used by local commands and `read_terminal`) |
   | `COFLUX_SESSION_ID` | id of this PTY session |
   | `COFLUX_MCP_URL` | the center's MCP URL; the user configures MCP with it |
@@ -53,6 +53,73 @@ env | grep '^COFLUX_'
   this machine's daemon has not been upgraded: tell the user to run `cofluxd update && cofluxd restart`;
   after reopening the terminal the variables and the local commands are there.
 
+### Two workspaces to keep apart: owning and effective
+
+- **Owning workspace** = the workspace this terminal **belongs to**: what the user's sidebar shows it
+  under, what its turn state, branch and diff stats are attributed to. It starts out as
+  `COFLUX_WORKSPACE_ID` and moves with you when you enter or leave a git worktree (below).
+- **Effective workspace** = the workspace **your current working directory is inside**. This is what
+  every local command acts on.
+
+They are the same until your cwd wanders off. A plain `cd <path>` moves a *live* session — same
+conversation, no restart — and a coflux child workspace is a normal registered git worktree, so a
+session whose terminal belongs to workspace A can end up working inside workspace B. From that
+moment, in B:
+
+- `cofluxd terminal new` opens the terminal **in B**, under B in the user's sidebar, running in B's
+  directory, counting against B's terminal cap;
+- `cofluxd terminal list` lists B's terminals, and A's terminals answer `read` / `wait` / `send`
+  with "not in this workspace or does not exist" (`cd` back to A to reach them again);
+- MCP calls need **B's** id as `workspaceId`;
+- the terminal itself stays under A, and `progress`, `notify` and `ports` still belong to it,
+  whatever your cwd is; `COFLUX_TASK_ID` and `COFLUX_SESSION_ID` never change.
+
+If your cwd is outside every coflux workspace (say `/tmp`), local commands fall back to the owning
+workspace.
+
+A terminal opened before the daemon was upgraded is the one case with no owning workspace at all:
+its local commands are refused with "predates the daemon upgrade" whatever your cwd is, because the
+daemon never guesses ownership from a directory. Open a new terminal.
+
+### coflux follows you into a git worktree
+
+`EnterWorktree` switches this live session into a git worktree (its own, or an existing one you point
+it at), `ExitWorktree` switches back, and resuming a session that had entered one puts you straight
+back in it. **coflux comes along**: the terminal's *owning* workspace moves to the workspace that
+worktree is, and if coflux has never seen that worktree it registers it as a child workspace of this
+project first — a new card appears in the user's sidebar, with its branch and diff stats. Nothing is
+interrupted: same terminal, same PTY, same conversation, and the user keeps watching it where it now
+lives. When Claude Code cleans up its own worktree on exit, that workspace's terminals move back to
+the project's main workspace and the record disappears by itself.
+
+So, after entering or leaving a worktree, owning **and** effective are both the new workspace: pass
+its id to MCP tools and everything local already acts on it. The plugin drops the new id next to the
+tool result, and `cofluxd workspace` always tells you. Two things stay behind on purpose:
+
+- `COFLUX_WORKSPACE_ID` (and the id in the `<coflux-session>` block from earlier in this session)
+  still names where the terminal was *opened*; it is frozen when the PTY starts and cannot be
+  rewritten. Never reuse it after a move.
+- The shell inside this terminal keeps its own directory. That is only about the shell; it does not
+  affect where your work is attributed.
+
+Nothing happens when coflux cannot follow, and nothing is blocked either: another repository, a
+directory that is not a git repository, a terminal opened in a directory workspace (no project), or
+a daemon that is down or too old — the session just carries on with the ownership it had.
+
+### Ask where you are
+
+```sh
+cofluxd workspace
+{"workspaceId":"ws-b","path":"/Users/me/.coflux/worktrees/ws-b","owningWorkspaceId":"ws-a","moved":true}
+```
+
+One line of JSON: `workspaceId` (+ `path`) is the **effective** workspace, `owningWorkspaceId` is the
+workspace this terminal belongs to right now, and `moved` says whether they differ. With the plugin
+installed you also get a `<coflux-session-moved>` block at the start of every prompt while the two
+differ — but that block only arrives with the **next** user prompt. **About to call an MCP tool right
+after a `cd`? Run `cofluxd workspace` first** and use the `workspaceId` it prints; do not reuse
+`COFLUX_WORKSPACE_ID`.
+
 ## When to open a terminal
 
 A coflux terminal is a process the user can see: a titled entry in their sidebar that they can
@@ -81,7 +148,8 @@ cofluxd terminal new --title="Debug shell"                                 # ses
 ```
 
 `--title` is the name the user sees in the sidebar; **name it properly**: "Run unit tests",
-"Start dev server", never "terminal 1". Either kind runs in the current workspace directory.
+"Start dev server", never "terminal 1". Either kind runs in the directory of the workspace your cwd
+is in (which is not always the one this terminal was opened in — see "owning and effective").
 
 Always write `--cmd=<value>` and `--title=<value>` with the `=`, never separated by a space: a
 value that starts with `-` is otherwise taken for another option and the call fails outright.
@@ -121,7 +189,7 @@ workspace as you).
 ### See how far it got
 
 ```sh
-cofluxd terminal list                      # every terminal in this workspace: id, state, exit code, title
+cofluxd terminal list                      # every terminal in the workspace your cwd is in: id, state, exit code, title
 cofluxd terminal read <taskId>             # a terminal's content (plain text, last 200 lines by default)
 cofluxd terminal read <taskId> --lines 50
 ```
@@ -223,16 +291,17 @@ server, use it to get the URL and tell the user directly; they click it and nobo
 
 Errors are one readable sentence; do what they say: "not inside a coflux terminal" = you are not
 in a coflux session; "terminal is not in this workspace or does not exist" = check the id with
-`list`; "predates the daemon upgrade" = that terminal was opened before the daemon upgrade, open a
-new one; a `new` without `--cmd` refused for a missing command = this machine's daemon is older
+`list`, and if you moved into another workspace that is exactly what a terminal of the other one
+looks like (`cofluxd workspace` to confirm, `cd` back to reach it); "predates the daemon upgrade" =
+that terminal was opened before the daemon upgrade, open a new one; a `new` without `--cmd` refused for a missing command = this machine's daemon is older
 than session terminals, tell the user to run `cofluxd update && cofluxd restart` (or pass a command
 and use a job terminal); "daemon is not connected to the center" only appears on
 `new`/`list`/`ports`, retry once it reconnects.
 
 ## Center MCP: leaving this workspace
 
-Local commands only see the workspace you are in. Use the MCP server named `coflux` in the host
-**only** for these:
+Local commands only see the workspace your cwd is in. Use the MCP server named `coflux` in the
+host **only** for these:
 
 - **Open an isolated child workspace to work in parallel**: `create_workspace` (project id from
   `$COFLUX_PROJECT_ID`) really runs `git worktree add` on the device; then `create_terminal` runs
@@ -242,11 +311,14 @@ Local commands only see the workspace you are in. Use the MCP server named `cofl
   `read_terminal` / `send_terminal_input`.
 - **Join everything under the account when you are not inside a coflux terminal** (for example
   Claude Code the user started on their own machine).
-- **Never run `git worktree add` yourself**: inside a coflux project the plugin blocks
-  `git worktree add|remove|move` and points you to `create_workspace` / `remove_workspace`; a
-  worktree you create is invisible to the user and cannot host a terminal.
-
-Do not detour through MCP for work inside this workspace: that is an extra round trip to the
+- **Deleting a workspace**: `remove_workspace` (it closes that workspace's terminals first, then
+  removes the worktree and the record). Inside a coflux project the plugin blocks
+  `git worktree remove|move` run by hand, because that leaves an orphan workspace record in the user's
+  sidebar. Creating a worktree is *not* blocked — coflux follows you into it (see above) — and Claude
+  Code's own worktrees need no cleanup from you at all.
+
+Do not detour through MCP for work inside the workspace you are in — including one you moved into
+with `cd` or EnterWorktree, where the local commands follow you: that is an extra round trip to the
 center, while a local command does it in one step.
 
 ### When MCP is not configured
@@ -268,8 +340,9 @@ it is set up, keep doing the work inside this workspace with local commands.
 
 The tool list and each tool's contract (parameters, limits, what an error means) come from the
 MCP server itself: read the tool descriptions in the host, they are the source of truth and this
-file does not repeat them. Take ids from the `COFLUX_*` variables first; for anything outside this
-workspace, find ids with the `list_*` tools.
+file does not repeat them. Take ids from the `COFLUX_*` variables first — except the workspace id
+after you moved, which comes from `cofluxd workspace` (or the `<coflux-session-moved>` block); for
+anything outside the workspace you are in, find ids with the `list_*` tools.
 
 The local-command disciplines apply to MCP just the same: `read_terminal` before
 `send_terminal_input`, stop when refused because the user is taking over (communicate with
@@ -282,8 +355,8 @@ The local-command disciplines apply to MCP just the same: `read_terminal` before
 - You can open, read, wait and type, but **typing is a restricted write with humans first**: you
   cannot write into a terminal the user is taking over (you are refused explicitly), and the user
   taking over at any time displaces you. Do not fight a human for a terminal.
-- Local commands only see **the workspace you are in**; other workspaces and other machines go
-  through MCP and are limited to the same account.
+- Local commands only see **the workspace your cwd is in** (`cofluxd workspace` says which one);
+  other workspaces and other machines go through MCP and are limited to the same account.
 - A workspace has a cap on concurrently live terminals (default 8, including the user's own).
   On hitting the cap, `list` first: usually some finished terminals were never collected. If the
   user really filled it up, `notify` them instead of forcing it.
@@ -291,4 +364,7 @@ The local-command disciplines apply to MCP just the same: `read_terminal` before
   user see" is their whole point. `send`/`read`/`wait`/`notify`/`progress` do not depend on the
   center. When disconnected they fail loudly rather than degrade silently.
 - `COFLUX_*` variables exist only in PTYs opened by coflux; exporting or changing them yourself
-  has no effect, the center only trusts the ids it issued.
+  has no effect, the center only trusts the ids it issued. `COFLUX_WORKSPACE_ID` always means the
+  workspace this terminal was **opened** in and goes stale the moment coflux follows you into a
+  worktree; both "where does this terminal belong now" and "where am I acting" come from
+  `cofluxd workspace`.