duaer-spec 0.15.0 → 0.16.0

package/.duaer/active-job.json

@@ -1,6 +1,6 @@
 {
-  "featureDir": ".duaer/specs/055-release-015",
-  "branch": "feat/release-015",
-  "worktree": ".worktree/feat-release-015",
-  "status": "active"
+  "featureDir": ".duaer/specs/060-release-016",
+  "branch": "feat/release-016",
+  "worktree": ".worktree/feat-release-016",
+  "status": "accepted"
 }

package/.duaer/memory/testing.md

@@ -41,8 +41,13 @@ Covers without a paid LLM:
 3. `/api/validate` pass and `/api/validate/fix` via an in-process mock
    OpenAI-compatible server
 
-Does **not** cover: real model quality, Terminal CLI launch, or full revise
-dispatch. Those stay manual E2E catalog rows or future suites.
+Also run `npm test` (includes revise-reliability contract tests: Brief
+snapshot/rollback helpers + source markers for `PREEMPT_FAILED` / longer
+client timeout).
+
+Does **not** cover: real model quality, live Terminal CLI launch against a
+real Cursor/Claude session. Those stay manual E2E catalog rows (E2E-055) or
+future suites.
 
 ## Opt-in (still need an explicit ask or Spec note)
 

package/.duaer/specs/056-revise-reliability/delivery.json

@@ -0,0 +1,13 @@
+{
+  "status": "accepted",
+  "summary": "Revise dispatch: honest preempt, Brief rollback on launch fail, structured retryable errors, terminal status line, longer client wait.",
+  "verification": {
+    "levels": ["L0", "L3"],
+    "commands": [
+      "node --check bin/duaer-live.mjs",
+      "npm run test:live",
+      "node --test test/revise-reliability.test.mjs"
+    ],
+    "notes": "E2E-055 manual for live Terminal preempt path."
+  }
+}

package/.duaer/specs/056-revise-reliability/spec.md

@@ -0,0 +1,44 @@
+# Feature Specification: Revise round reliability
+
+**Feature Branch**: `feat/revise-reliability`
+
+**Created**: 2026-09-17
+
+**Status**: Active
+
+## Goal
+
+Revise dispatch is **observable**, **retryable**, and failures are **readable**:
+confirm → Terminal enqueue must not report success when preempt failed; Brief
+mutations must not stick after a failed launch; client timeout matches server
+budgets; status exposes Terminal busy/queue; UI keeps dispatch unlocked when
+retryable.
+
+## In scope
+
+- Honest preempt outcome (no false preempted / false HTTP 200)
+- Rollback Brief writes if launch/enqueue fails
+- Structured revise errors (`code`, `retryable`) + UI copy
+- Align client `/api/revise` abort with recreate/init budgets (~3 min)
+- `/api/status` includes `terminal: { busy, queueDepth, runnerHealthy }`
+- Minimal status/hint line; extend L3 smoke for error shape / rollback unit
+
+## Out of scope
+
+- Desk layout / column redesign
+- Full Playwright Terminal automation
+- Paid live LLM quality
+
+## Acceptance
+
+1. When preempt cannot clear leftover agents, `/api/revise` fails with
+   `PREEMPT_FAILED` and does **not** lock the revise card
+2. Failed launch does not leave a new Revision block in Brief (rollback)
+3. Client wait ≥ worst-case recreate path; timeout message mentions retry
+4. Status poll shows terminal busy/queue when revising
+5. `npm run test:live` still passes; new smoke/unit covers rollback or error codes
+
+## Assumptions
+
+- Worktree: `.worktree/feat-revise-reliability`
+- Brief: `.duaer/specs/056-revise-reliability/`

package/.duaer/specs/056-revise-reliability/tasks.md

@@ -0,0 +1,10 @@
+# Tasks: Revise round reliability
+
+**Brief**: `.duaer/specs/056-revise-reliability/`
+
+## Checklist
+
+- [x] Honest preempt + PREEMPT_FAILED; Brief rollback on launch fail
+- [x] Structured errors on `/api/revise`; status.terminal
+- [x] UI: longer timeout, retryable unlock, terminal line, i18n
+- [x] L3 / unit smoke; docs; accept; merge develop

package/.duaer/specs/057-progress-accepted/delivery.json

@@ -0,0 +1,9 @@
+{
+  "status": "accepted",
+  "summary": "On delivery accepted, progress shows N/N and reconciles unchecked tasks.md boxes.",
+  "verification": {
+    "levels": ["L0", "L3"],
+    "commands": ["npm test"],
+    "notes": "E2E-056."
+  }
+}

package/.duaer/specs/057-progress-accepted/spec.md

@@ -0,0 +1,42 @@
+# Feature Specification: Progress sync when delivery accepted
+
+**Feature Branch**: `fix/progress-accepted`
+
+**Created**: 2026-09-17
+
+**Status**: Active
+
+## Goal
+
+Task progress must not show `0/N · delivery accepted · 工单完成`. When
+`delivery.json` is `accepted`, the desk treats tasks as complete (done ===
+total) and reconciles unchecked boxes in `tasks.md` when safe.
+
+## Problem
+
+`dispatchStatus` only rewrites `progress.current` on accept; `done` stays at
+the unchecked count. Agents often stamp `delivery.json` without flipping every
+`- [ ]` to `- [x]`, so 任务跟进 shows a contradictory `0/3 · …工单完成`.
+
+## In scope
+
+- Normalize progress when accepted: `done = total`, all task rows `done: true`
+- Reconcile `tasks.md` unchecked boxes to `[x]` once when accepted (idempotent)
+- Unit/smoke coverage; short README/CHANGELOG/E2E note
+
+## Out of scope
+
+- Changing how agents are prompted (except if a one-line reminder helps)
+- Progress column layout redesign
+
+## Acceptance
+
+1. Accepted delivery never surfaces `done < total` with an “工单完成 /
+   delivery accepted” current line
+2. Unchecked tasks in Brief are marked `[x]` after status observes accept
+3. `npm test` / `npm run test:live` pass
+
+## Assumptions
+
+- Worktree: `.worktree/fix-progress-accepted`
+- Brief: `.duaer/specs/057-progress-accepted/`

package/.duaer/specs/057-progress-accepted/tasks.md

@@ -0,0 +1,8 @@
+# Tasks: Progress sync when delivery accepted
+
+**Brief**: `.duaer/specs/057-progress-accepted/`
+
+## Checklist
+
+- [x] Normalize progress on accept; reconcile tasks.md
+- [x] Tests + docs; accept; merge develop

package/.duaer/specs/058-revise-progress-track/delivery.json

@@ -0,0 +1,13 @@
+{
+  "status": "accepted",
+  "acceptedAt": "2026-09-17T09:50:00.000Z",
+  "summary": "Revise-round progress scopes to Revision N / R{n}-* tasks; lagging accepted + busy Terminal no longer freezes on 工单完成.",
+  "verification": {
+    "levels": ["L0", "L1", "L3"],
+    "commands": [
+      "node --check bin/duaer-live.mjs",
+      "npm test"
+    ],
+    "result": "pass (14 tests)"
+  }
+}

package/.duaer/specs/058-revise-progress-track/spec.md

@@ -0,0 +1,48 @@
+# Feature Specification: Track revise-round task progress
+
+**Feature Branch**: `fix/revise-progress-track`
+
+**Created**: 2026-09-17
+
+**Status**: Accepted
+
+## Goal
+
+After **Confirm revise and dispatch**, 任务跟进 shows **this revision’s**
+checklist and updates as work starts — not the prior dispatch’s completed
+`T001…` pile, and not a frozen “delivery accepted · 工单完成” while Terminal
+is already running the revise.
+
+## Problem
+
+Progress parses the whole `tasks.md`. After revise, old tasks stay `[x]` so
+the bar looks finished (or accepted-normalized to N/N) while the new `R{n}-*`
+round has started. Live `revisionCount` can lag; status may still say
+`accepted`, so the wrong run-block is updated and revise work looks untracked.
+
+## In scope
+
+- Scope progress to dispatch (pre-Revision section) vs active `Revision N`
+- Infer active revision from job / delivery / tasks.md headers and `R{n}` ids
+- While revising (or Terminal busy with open `R{n}` tasks), do not force
+  accept-complete progress
+- Persist inferred `revisionCount` onto the live job when missing
+- Tests + CHANGELOG / E2E note
+
+## Out of scope
+
+- Layout / column redesign
+- Changing revise launch / preempt behavior
+
+## Acceptance
+
+1. After Confirm revise, progress shows only this revision’s tasks (e.g. `0/3`
+   then rising), under the Revision N run block
+2. While revise is active, status is not stuck on `delivery accepted · 工单完成`
+3. When revise delivery accepts, that revision shows `N/N · …完成`
+4. `npm test` passes
+
+## Assumptions
+
+- Worktree: `.worktree/fix-revise-progress-track`
+- Brief: `.duaer/specs/058-revise-progress-track/`

package/.duaer/specs/058-revise-progress-track/tasks.md

@@ -0,0 +1,9 @@
+# Tasks: Track revise-round task progress
+
+**Brief**: `.duaer/specs/058-revise-progress-track/`
+
+## Checklist
+
+- [x] Scope parseTasksProgress by revision; infer active revision
+- [x] Revising / busy Terminal skips accept-complete normalize
+- [x] Tests + docs; merge develop

package/.duaer/specs/059-revise-preempt-order/delivery.json

@@ -0,0 +1,13 @@
+{
+  "status": "accepted",
+  "acceptedAt": "2026-09-17T10:05:00.000Z",
+  "summary": "priorAccepted revise preempts leftovers before enqueue so Confirm revise no longer returns PREEMPT_FAILED while the revise Agent is already running.",
+  "verification": {
+    "levels": ["L0", "L1", "L3"],
+    "commands": [
+      "node --check bin/duaer-live.mjs",
+      "npm test"
+    ],
+    "result": "pass (14 tests)"
+  }
+}

package/.duaer/specs/059-revise-preempt-order/spec.md

@@ -0,0 +1,47 @@
+# Feature Specification: Honest revise preempt (enqueue after clear)
+
+**Feature Branch**: `fix/revise-preempt-order`
+
+**Created**: 2026-09-17
+
+**Status**: Accepted
+
+## Goal
+
+After Confirm revise, either the revise Agent is launched and the desk
+reports success, or preempt truly failed and nothing was started — never
+“Could not preempt…” while Terminal is already running the revise job.
+
+## Problem
+
+`launchInTerminal` enqueues the revise job **before** preempt. Within the
+post-preempt wait, the runner starts the new Agent; status then sees
+`busy && agentsLeft > 0` and throws `PREEMPT_FAILED`. The API rolls back
+Brief while the queued revise Agent keeps working — UI error, work already
+underway; retries kill that Agent.
+
+## In scope
+
+- Preempt leftover agents **before** enqueueing the revise Terminal job
+- Fail `PREEMPT_FAILED` only when prior agents remain (nothing queued yet)
+- Do not treat the newly started revise Agent as a preempt failure
+- Tests + CHANGELOG / E2E note
+
+## Out of scope
+
+- Progress scoping (058)
+- Changing when priorAccepted revise preempts vs waits
+
+## Acceptance
+
+1. priorAccepted revise: preempt clears leftovers, then enqueue; HTTP 200
+2. If leftover agents cannot be cleared, `PREEMPT_FAILED` and **no** new
+   Terminal job for that attempt
+3. Desk does not show preempt failure while revise Agent is already running
+   from that same Confirm tap
+4. `npm test` passes
+
+## Assumptions
+
+- Worktree: `.worktree/fix-revise-preempt-order`
+- Brief: `.duaer/specs/059-revise-preempt-order/`

package/.duaer/specs/059-revise-preempt-order/tasks.md

@@ -0,0 +1,8 @@
+# Tasks: Honest revise preempt (enqueue after clear)
+
+**Brief**: `.duaer/specs/059-revise-preempt-order/`
+
+## Checklist
+
+- [x] Preempt before enqueue; fail only on leftover prior agents
+- [x] Tests + docs; merge develop

package/.duaer/specs/060-release-016/delivery.json

@@ -0,0 +1,10 @@
+{
+  "status": "accepted",
+  "acceptedAt": "2026-09-18T00:00:00.000Z",
+  "summary": "Release 0.16.0: honest revise preempt, revise progress scope, accept progress sync.",
+  "verification": {
+    "levels": ["L0", "L1", "L3"],
+    "commands": ["npm test"],
+    "result": "pass (14 tests)"
+  }
+}

package/.duaer/specs/060-release-016/spec.md

@@ -0,0 +1,24 @@
+# Feature Specification: Release 0.16.0
+
+**Feature Branch**: `feat/release-016`
+
+**Created**: 2026-09-18
+
+**Status**: Accepted
+
+## Goal
+
+Ship **0.16.0** to `main` + npm: revise reliability (honest preempt order),
+revise-round progress tracking, and accept progress sync.
+
+## Acceptance
+
+1. `package.json` version `0.16.0`; CHANGELOG dated section; Unreleased cleared
+2. `main` tagged `v0.16.0`; GitHub Release; npm `latest` is `0.16.0`
+3. `npm test` passes before promote
+
+## Assumptions
+
+- Worktree: `.worktree/feat-release-016`
+- Brief: `.duaer/specs/060-release-016/`
+- User ask「发版」authorizes push + promote `develop` → `main`

package/.duaer/specs/060-release-016/tasks.md

@@ -0,0 +1,4 @@
+# Tasks: Release 0.16.0
+
+- [x] Bump 0.16.0 + CHANGELOG + light README notes
+- [x] Verify `npm test`; merge develop; promote main; tag + npm

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## Unreleased
+
+## 0.16.0 — 2026-09-18
+
+### Honest revise preempt
+
+- priorAccepted revise preempts leftover Agents **before** enqueueing the new
+  Terminal job (no false `PREEMPT_FAILED` while the revise Agent already runs)
+- `PREEMPT_FAILED` only when leftovers remain — nothing queued for that attempt
+
+### Revise progress tracking
+
+- After Confirm revise, task progress scopes to the active `Revision N` checklist
+  (not the prior dispatch’s completed `T*` pile)
+- While revise is active (or Terminal is busy on open `R{n}` work), status does
+  not freeze on the accepted “job complete” label
+- Live `revisionCount` is inferred from Brief/`tasks.md` when the job stamp lags
+
+### Progress sync when delivery accepted
+
+- When `delivery.json` is `accepted`, task progress shows `N/N` (not `0/N` with
+  an accepted label)
+- Unchecked `tasks.md` boxes are reconciled to `[x]` on status poll after accept
+
+### Revise round reliability
+
+- Honest Terminal preempt: no false `preempted` / HTTP 200 when agents still run (`PREEMPT_FAILED`, retryable)
+- Rollback Brief `spec.md` / `tasks.md` / `delivery.json` if revise launch fails
+- `/api/status` includes `terminal: { busy, queueDepth, runnerHealthy }`; desk shows the line
+- Client revise wait raised to ~3 minutes; structured error codes + keep Confirm revise unlocked on failure
+- Stuck revising (busy Terminal, no task progress) resurfaces **Revise again**
+
 ## 0.15.0 — 2026-09-17
 
 ### Live desk L3 smoke

package/README.md

@@ -77,7 +77,7 @@ mock LLM — no paid API).
 3. Choose a **CLI** digital employee: **Cursor Agent** or **Claude Code** (install Cursor CLI if needed: `curl https://cursor.com/install -fsS | bash`)  
 4. Edit the start command (must begin with `Duaer`) → dispatch creates `.worktree/feat-*` and opens **Terminal** to run the CLI  
 5. Watch progress in the right column (`tasks.md`); when `delivery.json` is `accepted`, open **View product** (`preview.url` or auto-detected `index.html`)  
-6. If the result is not right: click **Continue improving (left chat)**, clarify why and what to change, confirm the revise card (same validate gate), then the desk relaunches with `agent --continue` / `claude --continue` on the same worktree  
+6. If the result is not right: click **Continue improving (left chat)**, clarify why and what to change, confirm the revise card (same validate gate), then the desk relaunches on the same worktree (preempt leftover Agents before enqueueing revise). Progress tracks this revision’s `R{n}-*` tasks. Failed launch rolls back the Brief Revision and keeps **Confirm revise** available; status shows Terminal busy/queue.  
 7. If the job needs hosting / a public URL, deploy with **GitHub CLI (`gh`) + Actions** (Pages template under `.duaer/templates/deploy-github-pages.yml`; see [`docs/agent/deploy-github.md`](docs/agent/deploy-github.md))
 
 Worktree id ≠ Brief folder name — use `.worktree/feat-<name>/`, Brief under `.duaer/specs/<nnn-slug>/` inside that worktree.

package/README.zh-CN.md

@@ -75,7 +75,7 @@ duaer live
 3. 只选 **CLI 数字员工**：**Cursor Agent** 或 **Claude Code**（未装 Cursor 时页面会提示：`curl https://cursor.com/install -fsS | bash`）  
 4. 编辑「启动命令」（须以 `Duaer` 开头）→ 派工建 `.worktree/feat-*`，并打开 **Terminal** 跑对应 CLI  
 5. 右侧进度列轮询 `tasks.md`；`delivery.json` 为 `accepted` 后出现 **查看成品**（`preview.url`，或自动发现 `index.html`）  
-6. 成品不满意：点 **继续改进（左侧对话）**，说清原因与期望，确认改进卡（同样须校验通过）后，用 Terminal `agent --continue` / `claude --continue` 续派（`POST /api/revise`）  
+6. 成品不满意：点 **继续改进（左侧对话）**，说清原因与期望，确认改进卡（同样须校验通过）后续派（先清残留 Agent 再入队）。进度跟本轮 `R{n}-*` 任务。启动失败会回滚本轮 Brief Revision，并可再点「再派一版」；状态行显示 Terminal 忙闲/队列。  
 7. 若需求需要上线 / 公网访问：默认用 **GitHub CLI（`gh`）+ Actions** 自动化部署（静态站可参考 `.duaer/templates/deploy-github-pages.yml`；说明见英文 [`docs/agent/deploy-github.md`](docs/agent/deploy-github.md)）
 
 ### 文档语言

package/bin/duaer-live.mjs

@@ -1908,12 +1908,51 @@ function preemptBusyTerminalJob(queueDir, { worktreePath = null, logPath = null
   }
   return {
     preempted: killed.length > 0,
-    reason: killed.join(",") || "signal-attempted",
+    reason: killed.length > 0 ? killed.join(",") : "signal-attempted",
     killed,
     agentPids: agentTargets.map((t) => t.pid),
   };
 }
 
+class LaunchGateError extends Error {
+  constructor(message, { code = "LAUNCH_FAILED", retryable = true, detail = null } = {}) {
+    super(message);
+    this.name = "LaunchGateError";
+    this.code = code;
+    this.retryable = Boolean(retryable);
+    this.detail = detail;
+  }
+}
+
+function snapshotTextFile(filePath) {
+  if (!fs.existsSync(filePath)) return { exists: false, content: "" };
+  return { exists: true, content: fs.readFileSync(filePath, "utf8") };
+}
+
+function restoreTextFile(filePath, snap) {
+  if (!snap?.exists) {
+    if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+    return;
+  }
+  fs.writeFileSync(filePath, snap.content, "utf8");
+}
+
+function terminalQueueSnapshot(worktreePath) {
+  if (!worktreePath || !fs.existsSync(worktreePath)) {
+    return {
+      busy: false,
+      queueDepth: 0,
+      runnerHealthy: false,
+    };
+  }
+  const qdir = terminalQueueDir(worktreePath);
+  return {
+    busy: isTerminalRunnerBusy(qdir),
+    queueDepth: countQueuedJobs(qdir),
+    runnerHealthy: isTerminalRunnerHealthy(qdir),
+  };
+}
+
 function terminalJobsDir(queueDir) {
   return path.join(queueDir, "jobs");
 }
@@ -1978,30 +2017,65 @@ function launchInTerminal({
   if (key && fs.existsSync(key)) {
     const qdir = terminalQueueDir(key);
     fs.mkdirSync(qdir, { recursive: true });
-    const jobPath = enqueueTerminalJob(qdir, commandLine);
-    let queuedCount = countQueuedJobs(qdir);
 
     if (isTerminalRunnerHealthy(qdir)) {
       let busy = isTerminalRunnerBusy(qdir);
       let preempted = false;
+      let pre = null;
       // After accept, leftover first-agent must not block revise forever.
+      // Preempt *before* enqueue so the new revise Agent is never mistaken
+      // for a leftover (false PREEMPT_FAILED while work already started).
       if (busy && preemptBusy) {
-        const pre = preemptBusyTerminalJob(qdir, {
+        pre = preemptBusyTerminalJob(qdir, {
           worktreePath: cwd,
           logPath,
         });
-        preempted = Boolean(pre.preempted || pre.reason === "signal-attempted");
-        busy = isTerminalRunnerBusy(qdir);
-        queuedCount = countQueuedJobs(qdir);
-        try {
-          fs.writeFileSync(
-            path.join(qdir, "wake"),
-            `${path.basename(jobPath)}\n`,
+        preempted = Array.isArray(pre.killed) && pre.killed.length > 0;
+        let agentsLeft = cwd ? listWorktreeAgentPids(cwd).length : 0;
+        for (let i = 0; i < 10 && agentsLeft > 0; i += 1) {
+          sleepBriefMs(200);
+          if (i === 4 || i === 8) {
+            preemptBusyTerminalJob(qdir, {
+              worktreePath: cwd,
+              logPath,
+            });
+          }
+          agentsLeft = cwd ? listWorktreeAgentPids(cwd).length : 0;
+        }
+        if (agentsLeft > 0) {
+          throw new LaunchGateError(
+            "无法抢占仍在运行的 Agent。请结束该 worktree 的 Terminal 任务后重试续派。",
+            {
+              code: "PREEMPT_FAILED",
+              retryable: true,
+              detail: {
+                busy: isTerminalRunnerBusy(qdir),
+                agentsLeft,
+                killed: pre?.killed || [],
+                reason: pre?.reason || null,
+                enqueued: false,
+              },
+            },
           );
-        } catch {
-          // ignore
+        }
+        // Best-effort: let runner drop running.cmd before we queue revise.
+        for (let i = 0; i < 10; i += 1) {
+          if (!isTerminalRunnerBusy(qdir)) break;
+          sleepBriefMs(150);
         }
       }
+
+      const jobPath = enqueueTerminalJob(qdir, commandLine);
+      const queuedCount = countQueuedJobs(qdir);
+      busy = isTerminalRunnerBusy(qdir);
+      try {
+        fs.writeFileSync(
+          path.join(qdir, "wake"),
+          `${path.basename(jobPath)}\n`,
+        );
+      } catch {
+        // ignore
+      }
       const pid = readRunnerPid(qdir);
       appendLaunchLog(
         logPath,
@@ -2021,6 +2095,7 @@ function launchInTerminal({
     }
 
     // Stale/dead PID or pre-heartbeat runner: do not claim reuse
+    const jobPath = enqueueTerminalJob(qdir, commandLine);
     const stalePid = readRunnerPid(qdir);
     if (stalePid != null) {
       appendLaunchLog(
@@ -3022,10 +3097,11 @@ async function reviseDispatchedJob({
   const specPath = path.join(dispatch.featureDir, "spec.md");
   const tasksPath = path.join(dispatch.featureDir, "tasks.md");
   const deliveryPath = path.join(dispatch.featureDir, "delivery.json");
+  const snapSpec = snapshotTextFile(specPath);
+  const snapTasks = snapshotTextFile(tasksPath);
+  const snapDelivery = snapshotTextFile(deliveryPath);
 
-  let specMd = fs.existsSync(specPath)
-    ? fs.readFileSync(specPath, "utf8")
-    : "";
+  let specMd = snapSpec.exists ? snapSpec.content : "";
   specMd = specMd.replace(/\*\*Status\*\*:\s*.+$/m, `**Status**: Revising (r${revN})`);
   if (!/\*\*Status\*\*:/.test(specMd)) {
     specMd = `${specMd.trim()}\n\n**Status**: Revising (r${revN})\n`;
@@ -3047,9 +3123,7 @@ ${reasonLine || text}
 `;
   fs.writeFileSync(specPath, `${specMd.trim()}\n${revisionBlock}\n`, "utf8");
 
-  let tasksMd = fs.existsSync(tasksPath)
-    ? fs.readFileSync(tasksPath, "utf8")
-    : "# Tasks\n\n";
+  let tasksMd = snapTasks.exists ? snapTasks.content : "# Tasks\n\n";
   const taskBlock = `
 - [ ] R${revN}-1 Apply revision: ${restated.change.replace(/\n/g, " ").slice(0, 160)}
 - [ ] R${revN}-2 Verify against revision acceptance
@@ -3062,9 +3136,9 @@ ${reasonLine || text}
   );
 
   let prevDelivery = null;
-  if (fs.existsSync(deliveryPath)) {
+  if (snapDelivery.exists) {
     try {
-      prevDelivery = JSON.parse(fs.readFileSync(deliveryPath, "utf8"));
+      prevDelivery = JSON.parse(snapDelivery.content);
     } catch {
       prevDelivery = null;
     }
@@ -3093,11 +3167,23 @@ ${reasonLine || text}
     chosen = detected.agents[0]?.id || "";
   }
   if (!chosen) {
-    throw new Error("未检测到可用 CLI（Cursor Agent / Claude Code）");
+    restoreTextFile(specPath, snapSpec);
+    restoreTextFile(tasksPath, snapTasks);
+    restoreTextFile(deliveryPath, snapDelivery);
+    throw new LaunchGateError("未检测到可用 CLI（Cursor Agent / Claude Code）", {
+      code: "NO_AGENT",
+      retryable: true,
+    });
   }
   const ok = detected.agents.some((a) => a.id === chosen && a.available);
   if (!ok) {
-    throw new Error(`未安装启动器：${chosen}`);
+    restoreTextFile(specPath, snapSpec);
+    restoreTextFile(tasksPath, snapTasks);
+    restoreTextFile(deliveryPath, snapDelivery);
+    throw new LaunchGateError(`未安装启动器：${chosen}`, {
+      code: "AGENT_MISSING",
+      retryable: true,
+    });
   }
 
   // After accepted delivery (or recreated worktree), do not use --continue:
@@ -3153,17 +3239,37 @@ ${restated.keep}
     logPath,
     `\n—— revise r${revN} ${now} (continue=${continueSession} recreated=${recreated} priorAccepted=${priorAccepted}) ——\n${restated.summary}\n`,
   );
-  const launch = launchAgent({
-    agentId: chosen,
-    worktreePath: dispatch.worktreePath,
-    agentPrompt,
-    logPath,
-    featureDir: dispatch.featureDir,
-    continueSession,
-    // Revise after accept/recreate must not wait forever behind leftover agent.
-    reviseLaunch: true,
-    // preempt only when !continueSession (priorAccepted || recreated) — see launchAgent
-  });
+
+  let launch;
+  try {
+    launch = launchAgent({
+      agentId: chosen,
+      worktreePath: dispatch.worktreePath,
+      agentPrompt,
+      logPath,
+      featureDir: dispatch.featureDir,
+      continueSession,
+      // Revise after accept/recreate must not wait forever behind leftover agent.
+      reviseLaunch: true,
+      // preempt only when !continueSession (priorAccepted || recreated) — see launchAgent
+    });
+  } catch (err) {
+    restoreTextFile(specPath, snapSpec);
+    restoreTextFile(tasksPath, snapTasks);
+    restoreTextFile(deliveryPath, snapDelivery);
+    if (err?.code === "PREEMPT_FAILED" || err?.name === "LaunchGateError") {
+      throw err;
+    }
+    const wrapped = new LaunchGateError(
+      err instanceof Error ? err.message : "续派启动失败",
+      {
+        code: err?.code === "CHILD_TIMEOUT" ? "CHILD_TIMEOUT" : "LAUNCH_FAILED",
+        retryable: true,
+        detail: { cause: err?.code || err?.name || null },
+      },
+    );
+    throw wrapped;
+  }
   rememberPreferredAgent(chosen);
 
   const nextDispatch = {
@@ -3214,15 +3320,53 @@ function extractSection(md, title) {
   return m ? m[1].trim() : "";
 }
 
-function parseTasksProgress(tasksMd) {
+function inferRevisionFromTasksMd(tasksMd) {
+  let max = 0;
+  for (const line of String(tasksMd || "").split(/\r?\n/)) {
+    const header = line.match(/^##\s+Revision\s+(\d+)\b/i);
+    if (header) max = Math.max(max, Number(header[1]) || 0);
+    const item = line.match(/^\s*[-*]\s+\[[ xX]\]\s+R(\d+)(?:[-.\s]|$)/i);
+    if (item) max = Math.max(max, Number(item[1]) || 0);
+  }
+  return max;
+}
+
+function tasksMdScope(tasksMd, revision = 0) {
+  const raw = String(tasksMd || "");
+  const rev = Number(revision) || 0;
+  if (rev > 0) {
+    const section = raw.match(
+      new RegExp(
+        `##\\s+Revision\\s+${rev}\\b[^\\n]*\\n([\\s\\S]*?)(?=\\n##\\s+Revision\\s+\\d+|$)`,
+        "i",
+      ),
+    );
+    if (section) return section[1];
+    // Fallback: only checkbox lines for this revision id (R1-1 / R1-01 / R1 …)
+    return raw
+      .split(/\r?\n/)
+      .filter((line) =>
+        new RegExp(`^\\s*[-*]\\s+\\[[ xX]\\]\\s+R${rev}(?:[-.\\s]|$)`, "i").test(
+          line,
+        ),
+      )
+      .join("\n");
+  }
+  // Dispatch scope: everything before the first Revision section
+  const cut = raw.search(/\n##\s+Revision\s+\d+\b/i);
+  return cut >= 0 ? raw.slice(0, cut) : raw;
+}
+
+function parseTasksProgress(tasksMd, { revision = 0 } = {}) {
   const tasks = [];
-  const lines = String(tasksMd || "").split(/\r?\n/);
+  const scope = tasksMdScope(tasksMd, revision);
+  const lines = String(scope || "").split(/\r?\n/);
   for (const line of lines) {
     const m = line.match(/^\s*[-*]\s+\[([ xX])\]\s+(.+?)\s*$/);
     if (!m) continue;
     const done = m[1].toLowerCase() === "x";
     const text = m[2].trim();
-    const idMatch = text.match(/^(T\d+)\b/i);
+    const idMatch = text.match(/^(T\d+|R\d+[-\w]*)\b/i);
     tasks.push({
       id: idMatch ? idMatch[1].toUpperCase() : `S${tasks.length + 1}`,
       text,
@@ -3233,17 +3377,69 @@ function parseTasksProgress(tasksMd) {
   const doneCount = tasks.filter((t) => t.done).length;
   const next = tasks.find((t) => !t.done) || null;
   let current = "暂无任务清单";
-  if (total === 0) current = "暂无任务清单";
-  else if (!next) current = "任务已全部勾选 · 等待 delivery accepted";
-  else current = `进行中：${next.text}`;
+  if (total === 0) {
+    current =
+      Number(revision) > 0
+        ? `Revision ${revision} · 等待任务清单`
+        : "暂无任务清单";
+  } else if (!next) {
+    current =
+      Number(revision) > 0
+        ? `Revision ${revision} · 任务已全部勾选 · 等待 delivery accepted`
+        : "任务已全部勾选 · 等待 delivery accepted";
+  } else {
+    current = `进行中：${next.text}`;
+  }
   return {
     total,
     done: doneCount,
     current,
     tasks,
+    revision: Number(revision) || 0,
   };
 }
 
+/** When delivery is accepted, never show 0/N · 工单完成 — treat checklist as complete. */
+function progressForAcceptedDelivery(progress, { worktreeExists = true } = {}) {
+  const base =
+    progress && typeof progress === "object"
+      ? progress
+      : { total: 0, done: 0, current: "", tasks: [] };
+  const tasks = Array.isArray(base.tasks)
+    ? base.tasks.map((t) => ({ ...t, done: true }))
+    : [];
+  const total = Number(base.total) || tasks.length;
+  return {
+    ...base,
+    total,
+    done: total,
+    tasks,
+    current: worktreeExists
+      ? "delivery accepted · 工单完成"
+      : "delivery accepted · 已合入 develop（worktree 已清理）",
+  };
+}
+
+/** Idempotent: flip remaining `- [ ]` to `- [x]` once delivery is accepted. */
+function reconcileTasksMdOnAccept(tasksPath) {
+  if (!tasksPath || !fs.existsSync(tasksPath)) return false;
+  let raw;
+  try {
+    raw = fs.readFileSync(tasksPath, "utf8");
+  } catch {
+    return false;
+  }
+  if (!/^\s*[-*]\s+\[\s\]\s+/m.test(raw)) return false;
+  const next = raw.replace(/^(\s*[-*]\s+)\[\s\](\s+)/gm, "$1[x]$2");
+  if (next === raw) return false;
+  try {
+    fs.writeFileSync(tasksPath, next, "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function readLogTail(logPath, maxLines = 12) {
   if (!logPath || !fs.existsSync(logPath)) return [];
   try {
@@ -3406,12 +3602,12 @@ function dispatchStatus(jobId) {
     }
   }
   const tasksPath = featureDir ? path.join(featureDir, "tasks.md") : null;
-  let progress = parseTasksProgress("");
+  let tasksRaw = "";
   if (tasksPath && fs.existsSync(tasksPath)) {
     try {
-      progress = parseTasksProgress(fs.readFileSync(tasksPath, "utf8"));
+      tasksRaw = fs.readFileSync(tasksPath, "utf8");
     } catch {
-      progress = parseTasksProgress("");
+      tasksRaw = "";
     }
   }
   const logPath =
@@ -3419,13 +3615,61 @@ function dispatchStatus(jobId) {
     (featureDir ? path.join(featureDir, "agent-launch.log") : null);
   const logTail = logPath ? readLogTail(logPath) : [];
   const worktreeExists = roots.worktreeExists;
-  const accepted = delivery?.status === "accepted";
-  if (accepted && progress.total > 0) {
+  const terminal = terminalQueueSnapshot(dispatch.worktreePath);
+  const inferredFromTasks = inferRevisionFromTasksMd(tasksRaw);
+  const revisionHint = Math.max(
+    Number(live.job.revisionCount || 0),
+    Number(delivery?.revision || 0),
+    inferredFromTasks,
+  );
+  const revProgressHint =
+    revisionHint > 0
+      ? parseTasksProgress(tasksRaw, { revision: revisionHint })
+      : null;
+  const hasOpenRevWork =
+    Boolean(revProgressHint) &&
+    revProgressHint.total > 0 &&
+    revProgressHint.done < revProgressHint.total;
+  // First-dispatch delivery is also "open" — only treat as revise when a
+  // Revision N already exists (job / delivery / tasks.md), or Terminal is
+  // busy on open R{n} work while status still lags on accepted.
+  const deliveryAccepted = delivery?.status === "accepted";
+  const deliveryOpen = delivery?.status === "open";
+  const activelyRevising =
+    (!deliveryAccepted && live.job.status === "revising") ||
+    (revisionHint > 0 && deliveryOpen) ||
+    (hasOpenRevWork &&
+      (terminal.busy || Number(terminal.queueDepth || 0) > 0));
+  const activeRevision =
+    revisionHint > 0 &&
+    (activelyRevising ||
+      Number(live.job.revisionCount || 0) > 0 ||
+      Number(delivery?.revision || 0) > 0 ||
+      inferredFromTasks > 0)
+      ? revisionHint
+      : 0;
+
+  let progress = parseTasksProgress(tasksRaw, {
+    revision: activeRevision > 0 ? activeRevision : 0,
+  });
+  const accepted = deliveryAccepted && !activelyRevising;
+  if (accepted) {
+    if (tasksPath) reconcileTasksMdOnAccept(tasksPath);
+    if (tasksPath && fs.existsSync(tasksPath)) {
+      try {
+        tasksRaw = fs.readFileSync(tasksPath, "utf8");
+      } catch {
+        // keep
+      }
+    }
+    progress = parseTasksProgress(tasksRaw, {
+      revision: activeRevision > 0 ? activeRevision : 0,
+    });
+    progress = progressForAcceptedDelivery(progress, { worktreeExists });
+  } else if (activelyRevising && progress.total === 0 && activeRevision > 0) {
     progress = {
       ...progress,
-      current: worktreeExists
-        ? "delivery accepted · 工单完成"
-        : "delivery accepted · 已合入 develop（worktree 已清理）",
+      current: `Revision ${activeRevision} · 已续派，等待任务勾选…`,
     };
   } else if (!worktreeExists && roots.source === "primary") {
     progress = {
@@ -3435,6 +3679,36 @@ function dispatchStatus(jobId) {
         "worktree 已清理；成品与 Brief 在产品仓 develop",
     };
   }
+
+  // Keep live job revisionCount in sync when Brief/tasks already show Revision N
+  if (
+    activeRevision > Number(live.job.revisionCount || 0) ||
+    (activelyRevising && live.job.status !== "revising")
+  ) {
+    try {
+      const nextJob = {
+        ...live.job,
+        revisionCount: Math.max(
+          Number(live.job.revisionCount || 0),
+          activeRevision,
+        ),
+        status: activelyRevising
+          ? "revising"
+          : accepted
+            ? "accepted"
+            : live.job.status,
+      };
+      fs.writeFileSync(
+        live.jobPath,
+        `${JSON.stringify(nextJob, null, 2)}\n`,
+        "utf8",
+      );
+      live.job = nextJob;
+    } catch {
+      // ignore
+    }
+  }
+
   const preview = resolvePreview({
     delivery: delivery || { status: "open" },
     worktreePath: roots.root,
@@ -3443,8 +3717,10 @@ function dispatchStatus(jobId) {
   // Only after accept (or during a revise round). Not while first dispatch is still in progress.
   const showPreview =
     accepted ||
+    activelyRevising ||
     live.job.status === "revising" ||
-    Number(live.job.revisionCount || 0) > 0;
+    Number(live.job.revisionCount || 0) > 0 ||
+    activeRevision > 0;
 
   // Persist accepted status when handoff moved Brief to primary
   if (accepted && live.job.status !== "accepted" && roots.source === "primary") {
@@ -3455,6 +3731,7 @@ function dispatchStatus(jobId) {
         `${JSON.stringify(nextJob, null, 2)}\n`,
         "utf8",
       );
+      live.job = nextJob;
     } catch {
       // ignore
     }
@@ -3463,12 +3740,20 @@ function dispatchStatus(jobId) {
   const canRevise =
     Boolean(dispatch.repoPath && fs.existsSync(dispatch.repoPath)) &&
     (accepted ||
+      activelyRevising ||
       live.job.status === "revising" ||
-      Number(live.job.revisionCount || 0) > 0);
+      Number(live.job.revisionCount || 0) > 0 ||
+      activeRevision > 0);
+
+  const statusOut = activelyRevising
+    ? "revising"
+    : accepted
+      ? "accepted"
+      : live.job.status;
 
   return {
     jobId: live.id,
-    status: accepted ? "accepted" : live.job.status,
+    status: statusOut,
     dispatch: {
       ...dispatch,
       worktreeExists,
@@ -3480,8 +3765,13 @@ function dispatchStatus(jobId) {
     logTail,
     preview: showPreview ? preview : null,
     canRevise,
-    revision: live.job.revisionCount || 0,
+    revision: Math.max(
+      Number(live.job.revisionCount || 0),
+      activeRevision,
+      Number(delivery?.revision || 0),
+    ),
     handoffCleaned: !worktreeExists && roots.source === "primary",
+    terminal,
   };
 }
 
@@ -3932,6 +4222,8 @@ async function handleApi(req, res) {
         send(res, 422, {
           ok: false,
           passed: false,
+          code: "VALIDATE_GATE",
+          retryable: true,
           error: err.message,
           summary: review.summary || err.message,
           issues: review.issues || [],
@@ -3944,8 +4236,28 @@ async function handleApi(req, res) {
         });
         return;
       }
-      send(res, err?.code === "CHILD_TIMEOUT" ? 504 : 400, {
+      const code =
+        err?.code === "PREEMPT_FAILED"
+          ? "PREEMPT_FAILED"
+          : err?.code === "CHILD_TIMEOUT"
+            ? "CHILD_TIMEOUT"
+            : err?.code === "NO_AGENT" || err?.code === "AGENT_MISSING"
+              ? err.code
+              : err?.name === "LaunchGateError"
+                ? err.code || "LAUNCH_FAILED"
+                : err?.code || "REVISE_FAILED";
+      const status =
+        code === "CHILD_TIMEOUT"
+          ? 504
+          : code === "PREEMPT_FAILED"
+            ? 409
+            : 400;
+      send(res, status, {
+        ok: false,
+        code,
+        retryable: err?.retryable !== false,
         error: err instanceof Error ? err.message : "revise failed",
+        detail: err?.detail || undefined,
       });
     }
     return;

package/docs/agent/e2e-test-plan.md

@@ -67,6 +67,10 @@ the table for their app.
 | E2E-052 | Confirm column wider than chat; requirements (and revise) fields fully expanded without inner scroll; structured paragraphs/lists display with click-to-edit | manual |
 | E2E-053 | Full-screen desk (no 1440 shell cap); chat column ~50px wider than prior confirm-wide min; confirm still wider than chat | manual |
 | E2E-054 | Live L3 smoke: `npm run test:live` covers desk shell markers + validate fail/pass + validate/fix via mock LLM (no paid API) | `npm run test:live` |
+| E2E-055 | Revise reliability: preempt failure returns `PREEMPT_FAILED` without locking card; failed launch rolls back Brief Revision; status shows Terminal busy/queue; retry stays available | `npm test` + manual |
+| E2E-056 | Progress on accept: status never shows `0/N · delivery accepted`; unchecked tasks reconciled to `[x]` | `npm test` |
+| E2E-057 | After Confirm revise, progress tracks this revision’s `R{n}-*` tasks (not prior T* / frozen accepted); busy Terminal + lagging revisionCount still scopes correctly | `npm test` + manual |
+| E2E-058 | priorAccepted revise: preempt clears leftovers then enqueue; false `PREEMPT_FAILED` must not appear while that revise Agent is already running; hard fail leaves nothing queued | `npm test` + manual |
 | E2E-041 | Busy Terminal runner: revise/re-dispatch queues (`pending.cmd`), waits (no interrupt); API `queued`/`busy`/`reused`; UI does not claim agent already started | manual |
 | E2E-007 | Request worktrees use `.worktree/<id>`; `.worktree/` gitignored | manual |
 | E2E-008 | Docs require main+develop+feat+fix and typed go-live flows | manual |
@@ -128,3 +132,6 @@ the table for their app.
 | E2E-039 | `038-revise-enqueue-style` | honest enqueue + dark revise card |
 | E2E-040 | `039-desk-scroll-sync` | left/right viewport sync |
 | E2E-041 | `040-terminal-queue-wait` | busy queue wait + honest API/UI |
+| E2E-056 | `057-progress-accepted` | accept never shows 0/N |
+| E2E-057 | `058-revise-progress-track` | revise scopes R{n} progress |
+| E2E-058 | `059-revise-preempt-order` | preempt before enqueue |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "duaer-spec",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "Digital employees for Cursor, Claude, Codex, Copilot, Windsurf, Cline, Continue, Gemini, Aider",
   "type": "module",
   "bin": {

package/web/live-dev/app.js

@@ -36,6 +36,8 @@ const state = {
   mode: "specify", // specify | revise
   /** After a successful revise: right card stays locked 改进卡. */
   reviseLocked: false,
+  /** Revising but Terminal busy with no task progress — offer retry CTA. */
+  reviseStuckHint: false,
   lastRevision: null, // { revision, change, keep, acceptance, reason }
   originalCard: null, // snapshot after first confirm
   lastStatus: null,
@@ -612,7 +614,9 @@ function syncReviseDispatchButton(ready) {
   const accepted = state.lastDeliveryAccepted || status === "accepted";
   const revising = status === "revising";
   if (el.reviseHint) {
-    if (revising && !dialoguing) {
+    if (revising && state.reviseStuckHint && !dialoguing) {
+      el.reviseHint.textContent = t("revise.hintStuck");
+    } else if (revising && !dialoguing) {
       el.reviseHint.textContent = t("revise.hintRevising");
     } else if (state.reviseLocked && !dialoguing) {
       el.reviseHint.textContent = t("revise.hintLocked");
@@ -629,7 +633,8 @@ function syncReviseDispatchButton(ready) {
     }
   }
   if (el.startReviseChat || el.startReviseChatAlt) {
-    const showCta = !dialoguing && accepted && !revising;
+    const showCta =
+      !dialoguing && accepted && (!revising || state.reviseStuckHint);
     const previewVisible = el.previewPanel && !el.previewPanel.hidden;
     if (el.startReviseChat) {
       el.startReviseChat.hidden = !(showCta && previewVisible);
@@ -2204,7 +2209,8 @@ async function confirmReviseAndDispatch() {
       agentId: state.agentId,
     };
     const ac = new AbortController();
-    const timer = setTimeout(() => ac.abort(), 90000);
+    // Cover recreate (git ≤60s) + optional duaer init (≤120s) + validate/launch headroom.
+    const timer = setTimeout(() => ac.abort(), 180000);
     const res = await fetch("/api/revise", {
       method: "POST",
       headers: { "content-type": "application/json" },
@@ -2218,10 +2224,13 @@ async function confirmReviseAndDispatch() {
       data = rawText ? JSON.parse(rawText) : {};
     } catch {
       const snippet = String(rawText || "").replace(/\s+/g, " ").slice(0, 180);
-      throw new Error(
-        snippet
-          ? `HTTP ${res.status}: ${snippet}`
-          : `HTTP ${res.status} ${t("err.revise")}`,
+      throw Object.assign(
+        new Error(
+          snippet
+            ? `HTTP ${res.status}: ${snippet}`
+            : `HTTP ${res.status} ${t("err.revise")}`,
+        ),
+        { retryable: true },
       );
     }
     if (res.status === 422 || data.passed === false) {
@@ -2238,7 +2247,12 @@ async function confirmReviseAndDispatch() {
       syncConfirmEnabled();
       return;
     }
-    if (!res.ok) throw new Error(data.error || `HTTP ${res.status} ${t("err.revise")}`);
+    if (!res.ok) {
+      const err = new Error(reviseErrorMessage(data, res.status));
+      err.retryable = data.retryable !== false;
+      err.code = data.code || "";
+      throw err;
+    }
     resetValidateGate();
     const restated = data.restated
       ? t("bot.reviseRestate", {
@@ -2273,23 +2287,49 @@ async function confirmReviseAndDispatch() {
     }
     startStatusPoll();
   } catch (err) {
-    const msg =
-      err?.name === "AbortError"
-        ? t("err.timeout")
-        : err instanceof Error
-          ? err.message
-          : t("err.revise");
+    const timedOut = err?.name === "AbortError";
+    const msg = timedOut
+      ? t("err.reviseTimeout")
+      : err instanceof Error
+        ? err.message
+        : t("err.revise");
+    const retryable = timedOut || err?.retryable !== false;
     if (el.reviseErr) {
       el.reviseErr.hidden = false;
-      el.reviseErr.textContent = msg;
+      el.reviseErr.textContent = retryable
+        ? `${msg} ${t("err.retryableHint")}`
+        : msg;
     }
     addBubble("bot", msg);
+    // Keep card unlocked so Confirm revise stays available.
+    state.reviseLocked = false;
+    setReviseFieldsReadonly(false);
   } finally {
     state.reviseDispatching = false;
     syncConfirmEnabled();
   }
 }
 
+function reviseErrorMessage(data, status) {
+  const code = String(data?.code || "").trim();
+  if (code) {
+    const keyed = t(`err.code.${code}`);
+    if (keyed && keyed !== `err.code.${code}`) return keyed;
+  }
+  return data?.error || `HTTP ${status} ${t("err.revise")}`;
+}
+
+function formatTerminalStatus(term) {
+  if (!term || typeof term !== "object") return "";
+  if (!term.runnerHealthy) return t("status.terminalDown");
+  const parts = [
+    term.busy ? t("status.terminalBusy") : t("status.terminalIdle"),
+  ];
+  const depth = Number(term.queueDepth || 0);
+  if (depth > 0) parts.push(t("status.terminalQueue", { n: depth }));
+  return parts.join(" · ");
+}
+
 function startStatusPoll() {
   if (state.statusTimer) clearInterval(state.statusTimer);
   let acceptedNotified = false;
@@ -2317,6 +2357,25 @@ function startStatusPoll() {
             ? t("status.worktreeGone")
             : "",
       });
+      const termLine = formatTerminalStatus(data.terminal);
+      if (termLine) {
+        el.dispatchStatus.textContent = `${el.dispatchStatus.textContent} · ${t(
+          "status.terminalLine",
+          { state: termLine },
+        )}`;
+      }
+      // If revising but Terminal is stuck busy with no progress, keep「再改一版」visible.
+      if (
+        data.status === "revising" &&
+        data.terminal?.busy &&
+        data.terminal?.runnerHealthy &&
+        !(data.progress?.done > 0)
+      ) {
+        state.reviseStuckHint = true;
+      } else {
+        state.reviseStuckHint = false;
+      }
+      renderRevisePanel(data);
       if (data.status === "accepted" && data.delivery?.status === "accepted") {
         el.dispatchStatus.textContent = t("status.acceptedRevise", { rev });
         if (!acceptedNotified || data.revision !== lastRevision) {

package/web/live-dev/i18n.js

@@ -112,6 +112,8 @@ const zhCN = {
   "revise.hintEnqueue": "正在送入同一 Terminal（不新开窗口）…",
   "revise.hintLocked": "本轮改进卡（下方）已确认。改完验收后若仍不满意，再点「再改一版」。",
   "revise.hintRevising": "数字员工改写中。可继续「查看成品」；验收后再点「再改一版」。",
+  "revise.hintStuck":
+    "Terminal 仍忙且尚无任务进度。可结束旧任务后点「再改一版」重试续派。",
   "bot.ready":
     "模型已就绪。随便说你想做什么；我会多轮问清，右侧是确认卡。确认前不会改你的业务仓库。",
   "bot.cardReady": "右侧确认卡可再改。满意后点「需求无误，开始干活」。",
@@ -222,6 +224,20 @@ const zhCN = {
   "err.reviseKickoff": "改进对话启动失败",
   "err.confirm": "确认失败",
   "err.timeout": "超时。请刷新重试；若 Agent 已打开可在 Terminal 里继续。",
+  "err.reviseTimeout":
+    "续派超时（约 3 分钟）。Brief 未写入本轮 Revision 时可直接再点「再派一版」；若 Terminal 已有任务请在窗口里继续。",
+  "err.code.PREEMPT_FAILED":
+    "无法抢占仍在运行的 Agent。请结束该 worktree 的 Terminal 任务后，再点「再派一版」。",
+  "err.code.CHILD_TIMEOUT": "子进程超时被中止。请重试续派；若 git/init 卡住请检查仓库与钩子。",
+  "err.code.LAUNCH_FAILED": "续派启动失败。可直接再点「再派一版」重试。",
+  "err.code.NO_AGENT": "未检测到可用 CLI。请安装 Cursor Agent 或 Claude Code 后重试。",
+  "err.code.AGENT_MISSING": "所选 CLI 未安装。请安装后重试。",
+  "err.retryableHint": "可以再试一次。",
+  "status.terminalLine": "Terminal：{state}",
+  "status.terminalBusy": "忙碌中",
+  "status.terminalIdle": "空闲",
+  "status.terminalQueue": "队列 {n}",
+  "status.terminalDown": "无 runner",
   "err.installAgent": "请先安装：{cmd}",
   "err.needAgent": "请先安装所选 CLI",
   "err.needAgentAlt": "请先安装对应 CLI",
@@ -342,6 +358,8 @@ const en = {
     "This revise card is locked. After accept, tap Revise again if needed.",
   "revise.hintRevising":
     "Employee is revising. You can View product; Revise again after accept.",
+  "revise.hintStuck":
+    "Terminal is still busy with no task progress. Stop the old job, then tap Revise again to retry.",
   "bot.ready":
     "Model ready. Tell me what you want; I will clarify in chat. The confirm card is on the right. Nothing touches your product repo until you confirm.",
   "bot.cardReady":
@@ -453,6 +471,21 @@ const en = {
   "err.reviseKickoff": "Could not start revise chat",
   "err.confirm": "Confirm failed",
   "err.timeout": "Timed out. Refresh; if the Agent is open, continue in Terminal.",
+  "err.reviseTimeout":
+    "Revise timed out (~3 min). If this Revision was not written, tap Confirm revise again; if Terminal already has a job, continue there.",
+  "err.code.PREEMPT_FAILED":
+    "Could not preempt a running Agent. Stop that worktree Terminal job, then tap Confirm revise again.",
+  "err.code.CHILD_TIMEOUT":
+    "A child process timed out. Retry revise; check git hooks if checkout/init stalls.",
+  "err.code.LAUNCH_FAILED": "Revise launch failed. Tap Confirm revise to retry.",
+  "err.code.NO_AGENT": "No CLI found. Install Cursor Agent or Claude Code, then retry.",
+  "err.code.AGENT_MISSING": "Selected CLI is not installed. Install it, then retry.",
+  "err.retryableHint": "You can retry.",
+  "status.terminalLine": "Terminal: {state}",
+  "status.terminalBusy": "busy",
+  "status.terminalIdle": "idle",
+  "status.terminalQueue": "queue {n}",
+  "status.terminalDown": "no runner",
   "err.installAgent": "Install first: {cmd}",
   "err.needAgent": "Install the selected CLI first",
   "err.needAgentAlt": "Install the matching CLI first",