@runfusion/fusion 0.50.0 → 0.51.0

package/dist/bin.js

@@ -566,6 +566,20 @@ var init_mcp_config = __esm({
   }
 });
 
+// ../core/src/task-helpers.ts
+function getPrimaryPrInfo(task) {
+  return task.prInfos?.[0] ?? task.prInfo;
+}
+function taskHasManualOpenPullRequest(task) {
+  const prs = task.prInfos ?? (task.prInfo ? [task.prInfo] : []);
+  return prs.some((pr2) => pr2.manual === true && (pr2.status === "open" || pr2.status === "draft"));
+}
+var init_task_helpers = __esm({
+  "../core/src/task-helpers.ts"() {
+    "use strict";
+  }
+});
+
 // ../core/src/task-merge.ts
 function isFusionSiblingBranch(branch) {
   return FUSION_SIBLING_BRANCH_RE.test(branch);
@@ -574,7 +588,7 @@ function resolveEffectiveAutoMerge(task, settings) {
   return task.autoMerge ?? settings.autoMerge;
 }
 function allowsAutoMergeProcessing(task, settings) {
-  return settings.autoMerge !== false || task.autoMerge === true;
+  return (settings.autoMerge !== false || task.autoMerge === true) && !taskHasManualOpenPullRequest(task);
 }
 function resolveEffectiveGroupAutoMerge(group, settings) {
   return group.autoMerge ?? settings.autoMerge;
@@ -690,6 +704,7 @@ var FUSION_SIBLING_BRANCH_RE, HARD_BLOCKING_TASK_STATUSES, SCHEDULER_TRANSIENT_S
 var init_task_merge = __esm({
   "../core/src/task-merge.ts"() {
     "use strict";
+    init_task_helpers();
     FUSION_SIBLING_BRANCH_RE = /^fusion\/fn-/i;
     HARD_BLOCKING_TASK_STATUSES = /* @__PURE__ */ new Set([
       "failed",
@@ -1246,6 +1261,8 @@ var init_settings_schema = __esm({
       testCommand: void 0,
       buildCommand: void 0,
       recycleWorktrees: false,
+      showWorktreeGrouping: false,
+      openTasksInRightSidebar: false,
       executorAllowSiblingBranchRename: false,
       worktreeNaming: "random",
       worktrunk: {
@@ -1413,6 +1430,8 @@ var init_settings_schema = __esm({
       titleSummarizerModelId: void 0,
       titleSummarizerFallbackProvider: void 0,
       titleSummarizerFallbackModelId: void 0,
+      prTitlePromptInstructions: void 0,
+      prDescriptionPromptInstructions: void 0,
       scripts: void 0,
       setupScript: void 0,
       insightExtractionEnabled: false,
@@ -4613,19 +4632,21 @@ The tool prevents your session from being killed by the inactivity watchdog duri
 - Run **workspace-scoped non-test gates** (\`pnpm lint\`, \`pnpm build\`, and typecheck commands from root) when required for completion, but keep test verification targeted unless explicit task/workflow instructions require a full run.
 - If you need to run \`pnpm install\` (e.g. you added a new package), use \`fn_run_verification\` with \`scope: "workspace"\` and \`timeoutSec: 600\`.
 - If a verification command times out, do NOT blindly retry \u2014 investigate. Check for hung subprocesses, infinite test loops, or tests waiting on missing dependencies. Use \`node_modules/.modules.yaml\` presence to confirm bootstrap.`;
-    FAST_TRIAGE_PROMPT_TEXT = `You are a task specification agent for "fn", an AI-orchestrated task board. This task is running in **fast mode** \u2014 produce a lean, executable PROMPT.md without heavyweight review scoring or subtask analysis.
+    FAST_TRIAGE_PROMPT_TEXT = `You are a task specification agent for "fn". This task is running in **fast mode**.
 
-## Your Role
-You are a fast-path spec writer. Keep output lean but executable, with enough precision that an executor can run immediately.
-
-Your job: turn a rough task description into a focused PROMPT.md another agent can execute autonomously.
+Write a lean, executable PROMPT.md quickly. Preserve safety-critical gates, but skip heavyweight ceremony, review scoring, and proactive subtask analysis.
 
-## What you produce
-Write a complete PROMPT.md specification to the given path using the write tool.
+## Fast-mode priorities
+- Read only the source/docs needed to make the spec precise.
+- Keep prose brief; use concrete file paths, commands, and expected outcomes.
+- Do not expand scope. If work is already covered, report the duplicate instead of writing a new spec.
+- Keep the selected workflow unchanged unless the user explicitly requested a workflow for this task.
 
-## PROMPT.md Format
+## Duplicate check
+Before writing a spec, call \`fn_task_list\` for active work, then call \`fn_task_search\` with 2-4 targeted keyword phrases from the title/description, such as file paths, symptoms, and symbols. For any likely match in \`done\` or \`archived\`, call \`fn_task_show\` and inspect it before deciding. If an existing task covers the same work, do not write PROMPT.md; write exactly \`DUPLICATE: {existing-task-id}\`.
 
-Follow this structure exactly:
+## Required PROMPT.md shape
+Write a real PROMPT.md to the requested path using the write tool:
 
 \`\`\`markdown
 # Task: {ID} - {Name}
@@ -4634,205 +4655,69 @@ Follow this structure exactly:
 **Size:** {S | M}
 
 ## Mission
-
-{One paragraph: what to build and why it matters}
-
-## Surface Enumeration
-
-{Required for bug-fix tasks and UI-affordance add/remove tasks (adding, removing, or restructuring icons, buttons, chevrons/arrows, toggles, badges, menu entries, click targets): a checklist enumerating every surface the fixed invariant must hold across. Include every provider/bridge for streaming and agent paths; desktop AND mobile breakpoints; empty/undefined/duplicate/populated data states; and every hook/component/module that shares the affected logic. For UI-affordance add/remove tasks, enumerate every component that renders the affordance by searching the codebase for the icon/class/testid \u2014 not just the component the user pointed at. Explicitly check for leftover shells after removal (empty buttons, orphaned click targets, now-unused wrappers, dangling aria-labels) across both desktop and mobile breakpoints. Use the canonical checklist in docs/testing.md as the starting point.}
-
-## Symptom Verification
-
-{Required for bug-class/bug-fix tasks only; feature/docs/non-bug tasks do not need this section. Use the exact heading \`## Symptom Verification\` and include: (1) **Original symptom** \u2014 what the user/issue reported was broken; (2) **Exact reproduction** \u2014 the precise steps, inputs, fixture, or automated repro that triggered the failure; (3) **Assertion it is gone** \u2014 the executor's final verification must reproduce that original failure condition and assert it no longer occurs via a real automated test. Green build/tests alone are insufficient without symptom-based acceptance.}
+{One short paragraph describing the outcome and why it matters.}
 
 ## Dependencies
-
 - **None**
-{OR}
-- **Task:** {ID} ({what must be complete first})
+{or list concrete task dependencies after inspecting them with fn_task_show.}
 
 ## Context to Read First
-
-{List the minimal, specific files needed for implementation}
+- \`specific/file-or-doc.md\` \u2014 why it matters
 
 ## File Scope
-
-{List exact files/directories expected to change}
-
-- \`path/to/file.ext\`
-- \`path/to/directory/*\`
+- \`expected/file/or/directory\`
 
 ## Steps
-
-> Optional: a step heading may carry a \`(depends: N,M)\` annotation listing the 1-indexed
-> step numbers it depends on \u2014 e.g. \`### Step 3 (depends: 1): Title\`. Annotate ONLY steps
-> that are genuinely independent of their immediate predecessor; an unannotated step is
-> assumed to depend on the one before it (fully sequential). Be conservative \u2014 only mark a
-> step independent when it truly does not read or modify the prior step's output.
-
 ### Step 0: Preflight
+- [ ] Confirm required context, dependencies, and paths.
 
-- [ ] Required files and paths exist
-- [ ] Dependencies satisfied
-
-### Step 1: {Implementation step name}
+### Step 1: {Outcome-oriented implementation step}
+- [ ] {Specific verifiable outcome.}
+- [ ] {Specific verifiable outcome.}
 
-- [ ] {Specific, verifiable outcome}
-- [ ] {Specific, verifiable outcome}
-- [ ] Run targeted tests for changed files, asserting the invariant across all known surfaces (enumerate every provider/bridge, desktop + mobile breakpoints, and empty/undefined/populated data states)
+### Step N-1: Testing & Verification
+- [ ] Run targeted real automated tests in the project test runner; typecheck/build/manual checks do not replace tests.
+- [ ] Run lint/typecheck/build commands required by the task or repo.
 
-For bug-fix and UI-affordance add/remove tasks, paste and fill in this checklist in the \`## Surface Enumeration\` section:
-- [ ] Providers / bridges / execution paths touched by the invariant
-- [ ] Desktop + mobile breakpoints / platforms that exercise the behavior
-- [ ] Empty / undefined / duplicate / populated data states
-- [ ] Shared hooks / components / modules / helpers reusing the logic
-- [ ] Every component that renders the affordance (search the codebase for the icon/class/testid, not just the one the user pointed at)
-- [ ] Leftover shells after removal \u2014 empty buttons, orphaned click targets, now-unused wrappers, dangling aria-labels \u2014 are explicitly checked and fixed/hidden
-
-For bug-class/bug-fix tasks, add and fill in the exact \`## Symptom Verification\` section:
-- [ ] **Original symptom** \u2014 what the user/issue reported was broken
-- [ ] **Exact reproduction** \u2014 the precise steps, inputs, fixture, or automated repro that triggered the failure
-- [ ] **Assertion it is gone** \u2014 final verification reproduces the original failure condition and asserts it no longer occurs via a real automated test; green build/tests alone are insufficient
-
-**Artifacts:**
-- \`path/to/file\` (new | modified)
-
-### Step {N-1}: Testing & Verification
-
-> ZERO failures allowed for checks required by this task's quality gates. Run impacted/package-scoped verification first. Do NOT run the full workspace test suite (\`pnpm test:full\`, \`pnpm verify:workspace\`, or whole-package \`pnpm --filter <pkg> test\`) as routine or final-integration verification \u2014 a full run is allowed ONLY when the task or workflow explicitly requires it.
-> If keeping lint/tests/build/typecheck green requires edits outside the initial File Scope, make those fixes as part of this task.
-
-- [ ] Run lint check (\`pnpm lint\`)
-- [ ] Run impacted tests
-- [ ] Run project typecheck if available
-- [ ] Build passes
-
-### Step {N}: Documentation & Delivery
-
-- [ ] Update relevant documentation
-- [ ] Save documentation deliverables as task documents via \`fn_task_document_write\` (key="docs", content=...)
-- [ ] Create out-of-scope follow-up tasks via \`fn_task_create\` when needed
+### Step N: Documentation & Delivery
+- [ ] Update required docs/changesets/task documents.
+- [ ] Create follow-up tasks for out-of-scope findings.
 
 ## Documentation Requirements
-
 **Must Update:**
-- \`path/to/doc.md\` \u2014 {what to add/change}
+- \`path/to/doc-or-changeset.md\` \u2014 required update, or **None**
 
 **Check If Affected:**
-- \`path/to/doc.md\` \u2014 {update if relevant}
+- \`path/to/doc.md\` \u2014 update if impacted
 
 ## Completion Criteria
-
-- [ ] All steps complete
-- [ ] Lint passing
-- [ ] All tests passing
-- [ ] Typecheck passing (if available)
-- [ ] Documentation updated
+- [ ] Implementation outcomes complete
+- [ ] Required automated tests, lint/typecheck/build pass
+- [ ] Documentation/delivery complete
 
 ## Git Commit Convention
-
-Commits at step boundaries. All commits include the task ID:
-
-- **Step completion:** \`feat({ID}): complete Step N \u2014 <short summary>\` (the \`<short summary>\` is required \u2014 use a concrete 5\u201310 word description)
-- **Bug fixes:** \`fix({ID}): description\` (short, concrete summary required)
-- **Tests:** \`test({ID}): description\` (short, concrete summary required)
-
-Good examples:
-- \`feat(FN-1234): complete Step 2 \u2014 add retry guard for workflow step timeouts\`
-- \`test(FN-1234): add regression tests for paused-session cleanup\`
-
-Bad example:
-- \`feat(FN-1234): complete Step 2\`
+- Use task ID-prefixed conventional commits, e.g. \`feat({ID}): complete Step 1 \u2014 concrete summary\`.
 
 ## Do NOT
-
-- Expand task scope
-- Skip tests
-- Refuse necessary fixes just because they touch files outside the initial File Scope
-- Commit without the task ID prefix
-- Remove, delete, or gut modules, settings, interfaces, exports, or test files outside the File Scope
-- Remove features as "cleanup" \u2014 if something seems unused, create a task via \`fn_task_create\`
-
-## Changeset Requirements
-
-If this task REMOVES existing functionality (deleting modules, settings, API endpoints, or exports), a changeset file is REQUIRED:
-- Create \`.changeset/{task-id}-removal.md\` explaining what was removed and why
-- This is mandatory for any net-negative change (more deletions than additions to existing files)
+- Expand scope, skip tests, weaken acceptance, or delete/gut unrelated modules/features.
 \`\`\`
 
-## Testing requirements
-- Require real automated tests with assertions that run in the project's test runner
-- Typecheck/build/manual checks are not tests and cannot replace tests
-- For bug fixes and UI-affordance add/remove tasks, the spec MUST include a \`## Surface Enumeration\` section. During self-review via \`fn_review_spec()\`, treat a missing section on a bug-fix or UI-affordance add/remove spec as a blocking REVISE.
-- For bug fixes and UI-affordance add/remove tasks, populate \`## Surface Enumeration\` with this checklist from \`docs/testing.md\`: providers/bridges/execution paths; desktop + mobile breakpoints/platforms; empty/undefined/duplicate/populated data states; shared hooks/components/modules/helpers; every component that renders the affordance; leftover shells after removal.
-- For bug fixes and UI-affordance add/remove tasks, regression tests must assert the invariant across all known surfaces \u2014 enumerate every provider/bridge, desktop + mobile breakpoints, empty/undefined/populated data states, and for UI-affordance changes every component rendering the affordance plus leftover shells after removal \u2014 not just the reported repro (see FN-5787/FN-5789/FN-5803, FN-5751, and FN-6115/FN-6118/FN-6123)
-- For bug-class/bug-fix tasks, the spec MUST include a \`## Symptom Verification\` section with **Original symptom**, **Exact reproduction**, and **Assertion it is gone**. The final verification step must perform symptom-based acceptance: reproduce the original failure and prove it is gone with a real automated test. Green build/tests alone are insufficient. Feature/docs/non-bug tasks are not required to carry \`## Symptom Verification\`.
-- Include targeted tests in implementation steps and bounded/changed-scoped quality-gate runs in final verification; never run the full workspace test suite unless the task explicitly requires it
+## Bug and UI-affordance gates
+- For bug-fix or UI-affordance add/remove tasks, include \`## Surface Enumeration\` and tersely enumerate affected surfaces: providers/bridges, desktop/mobile, empty/undefined/duplicate/populated states, shared hooks/components/modules, all affordance renderers, and leftover shells after removal.
+- For bug-class tasks, include \`## Symptom Verification\` with **Original symptom**, **Exact reproduction**, and **Assertion it is gone**; final verification must reproduce the original failure and assert it no longer occurs with a real automated test.
 
-## Duplicate check
-Before writing a spec, call \`fn_task_list\` to find existing active tasks, then call \`fn_task_search\` with 2-4 distinct keyword phrases from the task title and description (for example file paths, error symptoms, and symbol names).
-For any likely match in \`done\` or \`archived\`, call \`fn_task_show\` to inspect details before deciding.
-If an existing task already covers the same work, do NOT write a PROMPT.md. Instead write exactly:
-\`DUPLICATE: {existing-task-id}\`
-
-## Dependency awareness
-When adding a dependency in \`## Dependencies\`, first call \`fn_task_show\` for that task and read its PROMPT.md.
-Use that context to align file paths, APIs, assumptions, and completion expectations. If the dependency has no PROMPT.md yet, note that explicitly.
-
-## Decision-only task flag (noCommitsExpected)
-When ALL of the following are true, include this metadata line in the header block after Size:
-
-- Add this exact line: **No commits expected:** true
-
-Set it only when all of these conditions hold:
-- Title/mission starts with decision verbs like "Decide", "Evaluate", "Verify", "Confirm", "Audit", "Review whether", or "Investigate and report", OR is an operational routing/coordination task whose only outcome is assigning/routing existing work or recording an intentional no-route/no-owner decision
-- Acceptance criteria are strictly observational (record findings, routing evidence, no-route/no-owner state, log a decision, update task log/docs) with no required code/config/file mutations
-- Task description explicitly says things like "no code changes expected", "no source files expected", "no product-source changes", or "the deliverable is the recorded decision"
-
-Anti-heuristics (bias to false-negative when ambiguous):
-- SET: Decide whether FN-XYZ needs a fix
-- SET: Assign ready implementation task to active owner, or record no-route state (no source files expected)
-- LEAVE UNSET: Investigate FN-XYZ
-- LEAVE UNSET: Investigate FN-XYZ and fix if needed
-- LEAVE UNSET: Investigate and fix routing if needed
-
-If an executor later proves an ordinary implementation task is already satisfied on HEAD, it may close without fabricating a commit by calling \`fn_task_done\` with a leading verified no-op/duplicate sentinel summary: \`PREMISE STALE:\`, \`NO-OP:\`, \`NOOP:\`, \`DUPLICATE: FN-NNNN ...\`, or \`REDUNDANT:\`. This does not weaken ordinary tasks: zero-commit completions without one of these leading sentinels still fail the no-commits invariant.
-
-## Guidelines
-- Read relevant source files before writing the spec
-- Be specific: reference concrete files, modules, and commands from this repo
-- Keep steps outcome-focused with 2\u20134 checkboxes per step
-- Keep file scope realistic: include tests and integration touchpoints likely required for green quality gates
-- Always include Testing & Verification and Documentation & Delivery steps
-- Keep fast-mode scope lean and executable; do not add heavyweight review scoring or subtask-analysis sections
-
-## Project commands
-When the user prompt includes explicit test/build commands, use those exact commands in the generated spec.
-
-<!--
-FNXC:WorkflowRouting 2026-06-22-17:24:
-Fast triage must keep tasks on the project default workflow unless the user explicitly asked for a specific workflow or the agent created the task. The no-commits header remains a PROMPT.md marker only; it is not permission to select a lightweight workflow automatically.
--->
-## Workflow Routing
-Keep the project default workflow (\`builtin:coding\`) unless the user explicitly requested a specific workflow for this task or subtask, or you created that task yourself. Do NOT call \`fn_workflow_select\` or pass \`workflow_id\` to \`fn_task_create\` just because a task looks like investigation, audit, research, coordination, decision-only work, or coding work. If the user explicitly asks for a workflow, call \`fn_workflow_list\` to discover valid IDs, then use \`fn_workflow_select\` for the current task or pass \`workflow_id\` to \`fn_task_create\` for the requested subtask. When you create a task via \`fn_task_create\` or \`fn_delegate_task\`, you may select that created task's workflow with \`workflow_id\` at create time or \`fn_workflow_select\` afterward; do not move a task you did not create unless the user asked. For investigation/audit/research, operational routing/coordination, or decision-only tasks that meet the no-commits criteria above, still include \`**No commits expected:** true\` in the PROMPT.md header when appropriate; that header marker does not change the workflow.
-
-## Task Artifact Location for Forensic / Reconciliation Tasks
-
-For audit/forensic/historical reconciliation tasks that target a different task ID, explicitly state in generated PROMPT.md context/scope that authoritative artifacts and DB state are at project root, not the worktree.
-- Target-task files live at \`<rootDir>/.fusion/tasks/{TARGET_ID}/\` (\`task.json\`, \`PROMPT.md\`, \`attachments/\`, logs).
-- Task DB truth lives at \`<rootDir>/.fusion/fusion.db\` (SQLite/WAL) and should be accessed via \`TaskStore\`/task tools, not direct SQL edits.
-- \`.fusion/\` is gitignored: fresh worktrees from \`main\` do not contain other tasks' \`.fusion/tasks/{TARGET_ID}/\` or \`.fusion/fusion.db\`; worktree-local \`.fusion/\` is running-task scratch/session state only.
-
-## Spec Review
-
-After writing the PROMPT.md, call \`fn_review_spec()\` to confirm the spec.
-
-Fast-mode specs are auto-approved \u2014 the review tool will return APPROVE immediately without spawning an independent reviewer. You do NOT need to wait for or iterate on review feedback.
+## Testing requirements
+- Every implementation spec needs a Testing & Verification step with real automated tests and bounded commands.
+- Prefer changed-file/package-scoped tests; do not require full workspace suites unless the user/task explicitly requires them.
+- If the user supplied exact test/build commands, include those exact commands.
 
-Never reference a \`.fusion/tasks/<id>/<file>\` artifact in Context, Steps, or File Scope unless (a) the file already exists, (b) the step explicitly creates it (listed as \`(new)\` under Artifacts), or (c) it is \`PROMPT.md\` / \`task.json\` / \`attachments/*\` for a sibling task. Save planning scratch as task documents via \`fn_task_document_write\`, not as files on disk.
+## Safety and workflow rules
+- Never kill port 4040; use a random/free port for test servers.
+- Do not call workflow-selection tools unless the user explicitly requested a workflow for this task, or you are selecting a workflow for a task you created.
+- Do not cite task-local \`.fusion/tasks/<id>/<file>\` paths unless the file exists, is PROMPT.md/task.json/attachments for a sibling task, or the spec creates it. Save scratch notes with \`fn_task_document_write\`.
 
 ## Output
-Write the PROMPT.md directly using the write tool, then call \`fn_review_spec()\` to confirm.`;
+Write PROMPT.md directly, then call \`fn_review_spec()\`. Fast-mode specs auto-approve, but the call is still required.`;
     TRIAGE_PROMPT_TEXT = `You are a task specification agent for "fn", an AI-orchestrated task board.
 
 ## Your Role
@@ -10725,6 +10610,18 @@ function defaultColumnForLinearNode(node) {
   if (seam === "merge") return "in-review";
   return "todo";
 }
+function canonicalBuiltinWorkflowColumns() {
+  if (BUILTIN_CODING_WORKFLOW_IR.version !== "v2") {
+    throw new Error("builtin coding workflow must be v2 to provide canonical columns");
+  }
+  return BUILTIN_CODING_WORKFLOW_IR.columns.map((column) => ({
+    ...column,
+    traits: column.traits.map((trait) => ({
+      ...trait,
+      config: trait.config ? { ...trait.config } : void 0
+    }))
+  }));
+}
 function linear(spec) {
   const nodes = [
     { id: "start", kind: "start" },
@@ -10744,14 +10641,16 @@ function linear(spec) {
   nodes.forEach((node, i) => {
     layout[node.id] = { x: 60 + i * 170, y: 160 };
   });
-  const hasV2OnlyNode = nodes.some((node) => !V1_LINEAR_NODE_KINDS.has(node.kind));
-  const ir2 = hasV2OnlyNode ? parseWorkflowIr({
+  const ir2 = parseWorkflowIr({
     version: "v2",
     name: spec.name,
-    columns: DEFAULT_WORKFLOW_COLUMN_IDS.map((id) => ({ id, name: id, traits: [] })),
+    columns: canonicalBuiltinWorkflowColumns(),
     nodes: nodes.map((node) => node.column ? node : { ...node, column: defaultColumnForLinearNode(node) }),
     edges
-  }) : parseWorkflowIr({ version: "v1", name: spec.name, nodes, edges });
+  });
+  if (ir2.version !== "v2" || !ir2.columns.find((column) => column.id === "todo")?.traits.some((trait) => trait.trait === "hold")) {
+    throw new Error(`linear built-in workflow '${spec.id}' must synthesize a hold-capacity todo column`);
+  }
   if (ir2.version === "v2") {
     ir2.settings = BUILTIN_WORKFLOW_SETTINGS;
   }
@@ -10771,7 +10670,7 @@ function linear(spec) {
 function getBuiltinWorkflow(id) {
   return BUILTIN_BY_ID.get(id);
 }
-var BUILTIN_WORKFLOW_ID_PREFIX, PLUGIN_GATED_BUILTIN_WORKFLOWS, BUILTIN_TS, V1_LINEAR_NODE_KINDS, BUILTIN_WORKFLOWS, BUILTIN_BY_ID;
+var BUILTIN_WORKFLOW_ID_PREFIX, PLUGIN_GATED_BUILTIN_WORKFLOWS, BUILTIN_TS, BUILTIN_WORKFLOWS, BUILTIN_BY_ID;
 var init_builtin_workflows = __esm({
   "../core/src/builtin-workflows.ts"() {
     "use strict";
@@ -10788,7 +10687,6 @@ var init_builtin_workflows = __esm({
       ["builtin:compound-engineering", "fusion-plugin-compound-engineering"]
     ]);
     BUILTIN_TS = "2026-01-01T00:00:00.000Z";
-    V1_LINEAR_NODE_KINDS = /* @__PURE__ */ new Set(["start", "prompt", "script", "gate", "end"]);
     BUILTIN_WORKFLOWS = [
       {
         id: "builtin:coding",
@@ -11302,6 +11200,21 @@ function setRunningAgentCountSource(fn2) {
 function getRunningAgentCountSource() {
   return runningAgentCountSource;
 }
+function isRunningAgentTask(task) {
+  if (task.column === "in-progress") {
+    return true;
+  }
+  if (task.column === "triage") {
+    return task.status === "planning" && !task.paused;
+  }
+  if (task.column === "in-review") {
+    return ACTIVE_IN_REVIEW_AGENT_STATUSES.has(String(task.status ?? "")) && !task.paused;
+  }
+  return false;
+}
+function countRunningAgentTasks(tasks) {
+  return tasks.filter(isRunningAgentTask).length;
+}
 function deriveRunningAgentCounts(perProject) {
   const projectsActive = {};
   let currentlyActive = 0;
@@ -11314,10 +11227,11 @@ function deriveRunningAgentCounts(perProject) {
   }
   return { currentlyActive, projectsActive };
 }
-var runningAgentCountSource;
+var ACTIVE_IN_REVIEW_AGENT_STATUSES, runningAgentCountSource;
 var init_live_agent_count = __esm({
   "../core/src/live-agent-count.ts"() {
     "use strict";
+    ACTIVE_IN_REVIEW_AGENT_STATUSES = /* @__PURE__ */ new Set(["merging", "merging-pr", "merging-fix", "reviewing", "fixing"]);
   }
 });
 
@@ -47780,6 +47694,35 @@ var init_automation_store = __esm({
           return schedule;
         });
       }
+      /**
+       * Atomically claim one due schedule occurrence before execution.
+       *
+       * FNXC:Automations 2026-06-27-00:00:
+       * Claiming advances nextRunAt before executing the schedule so concurrent CronRunner pollers, overlapping scopes, and separate engine processes sharing one SQLite DB cannot double-fire the same due window. The conditional UPDATE is the cross-process claim boundary; losers observe zero changed rows and skip execution.
+       */
+      async claimDueSchedule(id, expectedNextRunAt) {
+        return this.withScheduleLock(id, async () => {
+          const row = this.db.prepare(
+            "SELECT id, cronExpression, enabled, nextRunAt FROM automations WHERE id = ?"
+          ).get(id);
+          if (!row || row.enabled !== 1 || !row.nextRunAt) {
+            return false;
+          }
+          const nextRunAt = this.computeNextRun(row.cronExpression);
+          const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          const result = this.db.prepare(`
+        UPDATE automations
+        SET nextRunAt = ?, updatedAt = ?
+        WHERE id = ? AND enabled = 1 AND nextRunAt = ?
+      `).run(nextRunAt, updatedAt, id, expectedNextRunAt);
+          const changes = typeof result.changes === "bigint" ? Number(result.changes) : result.changes;
+          if (changes === 1) {
+            this.db.bumpLastModified();
+            return true;
+          }
+          return false;
+        });
+      }
       /**
        * Record a run result for a schedule. Updates lastRunAt, lastRunResult,
        * nextRunAt, runCount, and appends to runHistory.
@@ -54602,20 +54545,10 @@ ${TASK_UPSERT_SQL_ASSIGNMENTS}
           throw new Error("Feedback is required and cannot be empty");
         }
         const now = (/* @__PURE__ */ new Date()).toISOString();
-        let sourceLabel;
-        if (sourceTask.title?.trim()) {
-          sourceLabel = sourceTask.title.trim();
-        } else {
-          const firstLine = sourceTask.description.split("\n").map((line) => line.trim()).find((line) => line.length > 0);
-          sourceLabel = firstLine ? firstLine.replace(/\s+/g, " ") : sourceTask.id;
-        }
+        const normalizedFeedback = feedback.trim().replace(/\s+/g, " ");
+        const refinementTitle = `${id}: ${normalizedFeedback}`.slice(0, MAX_TITLE_LENGTH).trim();
         return this.createTaskWithDistributedReservation({ description: feedback.trim() }, {
           createTaskWithId: async (newId, reservationCommit) => {
-            const normalizedTitle = normalizeTitleForTaskId(`Refinement: ${sourceLabel}`, newId);
-            if (normalizedTitle.changed) {
-              const removed = extractTaskIdTokens(`Refinement: ${sourceLabel}`).filter((token) => token !== newId.toUpperCase());
-              storeLog.log(`[title-id-drift] normalized title for ${newId}: removed=[${removed.join(",")}]`);
-            }
             const sourceGithubLinked = sourceTask.githubTracking?.enabled === true || Boolean(sourceTask.githubTracking?.issue);
             const refinementGithubTracking = sourceGithubLinked ? {
               enabled: true,
@@ -54624,7 +54557,7 @@ ${TASK_UPSERT_SQL_ASSIGNMENTS}
             const newTask = {
               id: newId,
               lineageId: generateTaskLineageId(),
-              title: normalizedTitle.title ?? "Refinement",
+              title: refinementTitle,
               description: `${feedback.trim()}
 
 Refines: ${id}`,
@@ -60872,6 +60805,9 @@ ${newTask.description}
       /**
        * FNXC:ArtifactRegistry 2026-06-19-22:04:
        * Register multi-type agent/user/system artifacts in SQLite while writing binary payloads to disk. Task-scoped binaries use `.fusion/tasks/{taskId}/artifacts/`; task-less binaries use `.fusion/artifacts/`, and both store only a relative `artifacts/<file>` uri in the row.
+       *
+       * FNXC:ArtifactRegistry 2026-06-27-00:00:
+       * Successful registry writes emit `artifact:registered` as the authoritative live-update signal. Dashboard inbox notifications remain best-effort discovery messages, so already-open artifact lists must not depend on message delivery to invalidate their SWR cache.
        */
       async registerArtifact(input) {
         const id = randomUUID15();
@@ -60899,7 +60835,9 @@ ${newTask.description}
             throw error2;
           }
         };
-        return input.taskId ? this.withTaskLock(input.taskId, register) : register();
+        const artifact = input.taskId ? await this.withTaskLock(input.taskId, register) : await register();
+        this.emit("artifact:registered", artifact);
+        return artifact;
       }
       /**
        * FNXC:ArtifactRegistry 2026-06-19-22:04:
@@ -64156,6 +64094,51 @@ var init_retry_storm_error = __esm({
 });
 
 // ../core/src/agent-token-usage.ts
+function aggregateTaskTokenTotalsByAgentLink(db) {
+  const rows = db.prepare(`
+    SELECT
+      id AS taskId,
+      assignedAgentId,
+      sourceAgentId,
+      checkedOutBy,
+      tokenUsageInputTokens AS inputTokens,
+      tokenUsageCachedTokens AS cachedTokens,
+      tokenUsageCacheWriteTokens AS cacheWriteTokens,
+      tokenUsageOutputTokens AS outputTokens,
+      tokenUsageTotalTokens AS totalTokens
+    FROM tasks
+    WHERE tokenUsageInputTokens IS NOT NULL
+       OR tokenUsageCachedTokens IS NOT NULL
+       OR tokenUsageCacheWriteTokens IS NOT NULL
+       OR tokenUsageOutputTokens IS NOT NULL
+       OR tokenUsageTotalTokens IS NOT NULL
+  `).all();
+  const totalsByAgentId = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const agentIds = new Set([row.assignedAgentId, row.sourceAgentId, row.checkedOutBy].filter((value) => Boolean(value)));
+    for (const agentId of agentIds) {
+      const existing = totalsByAgentId.get(agentId) ?? createTaskTokenTotals();
+      existing.inputTokens += row.inputTokens ?? 0;
+      existing.cachedTokens += row.cachedTokens ?? 0;
+      existing.cacheWriteTokens += row.cacheWriteTokens ?? 0;
+      existing.outputTokens += row.outputTokens ?? 0;
+      existing.totalTokens += row.totalTokens ?? (row.inputTokens ?? 0) + (row.cachedTokens ?? 0) + (row.cacheWriteTokens ?? 0) + (row.outputTokens ?? 0);
+      existing.nTasks += 1;
+      totalsByAgentId.set(agentId, existing);
+    }
+  }
+  return totalsByAgentId;
+}
+function createTaskTokenTotals() {
+  return {
+    inputTokens: 0,
+    cachedTokens: 0,
+    cacheWriteTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+    nTasks: 0
+  };
+}
 async function aggregateAgentTokenUsage({
   taskStore,
   agentStore,
@@ -64163,7 +64146,7 @@ async function aggregateAgentTokenUsage({
   now = /* @__PURE__ */ new Date()
 }) {
   const agent = await agentStore.getAgent(agentId);
-  if (!agent || isEphemeralAgent(agent)) {
+  if (!agent) {
     return null;
   }
   const tasks = await taskStore.listTasks({ slim: true, includeArchived: true });
@@ -64223,7 +64206,6 @@ function finalizeWindowSummary(summary) {
 var init_agent_token_usage = __esm({
   "../core/src/agent-token-usage.ts"() {
     "use strict";
-    init_types();
   }
 });
 
@@ -66137,16 +66119,6 @@ var init_otel_metrics = __esm({
   }
 });
 
-// ../core/src/task-helpers.ts
-function getPrimaryPrInfo(task) {
-  return task.prInfos?.[0] ?? task.prInfo;
-}
-var init_task_helpers = __esm({
-  "../core/src/task-helpers.ts"() {
-    "use strict";
-  }
-});
-
 // ../core/src/manual-retry-reset.ts
 function buildAutoPauseClearPatch(task) {
   if (task.paused === true && task.userPaused !== true && task.pausedReason === IN_REVIEW_STALL_DEADLOCK_PAUSE_REASON) {
@@ -88162,6 +88134,7 @@ __export(src_exports, {
   aggregatePluginActivations: () => aggregatePluginActivations,
   aggregateProductivityAnalytics: () => aggregateProductivityAnalytics,
   aggregateSignalsAnalytics: () => aggregateSignalsAnalytics,
+  aggregateTaskTokenTotalsByAgentLink: () => aggregateTaskTokenTotalsByAgentLink,
   aggregateTeamAnalytics: () => aggregateTeamAnalytics,
   aggregateTokenAnalytics: () => aggregateTokenAnalytics,
   aggregateToolAnalytics: () => aggregateToolAnalytics,
@@ -88252,6 +88225,7 @@ __export(src_exports, {
   countDualAcceptDisagreements: () => countDualAcceptDisagreements,
   countInterventions: () => countInterventions,
   countRecentIdenticalStallEntries: () => countRecentIdenticalStallEntries,
+  countRunningAgentTasks: () => countRunningAgentTasks,
   countUsageEventsBy: () => countUsageEventsBy,
   createActivityLogSnapshot: () => createActivityLogSnapshot,
   createAgentRunSnapshot: () => createAgentRunSnapshot,
@@ -88454,6 +88428,7 @@ __export(src_exports, {
   isResearchExperimentalEnabled: () => isResearchExperimentalEnabled,
   isRetryableMeshWriteFailure: () => isRetryableMeshWriteFailure,
   isRunRecord: () => isRunRecord,
+  isRunningAgentTask: () => isRunningAgentTask,
   isSandboxExperimentalEnabled: () => isSandboxExperimentalEnabled,
   isSecretAccessPolicy: () => isSecretAccessPolicy,
   isSecretScope: () => isSecretScope,
@@ -88715,6 +88690,7 @@ __export(src_exports, {
   syncMemoryBackupRoutine: () => syncMemoryBackupRoutine,
   syncMemoryDreamsAutomation: () => syncMemoryDreamsAutomation,
   syncScheduledEvalBatchAutomation: () => syncScheduledEvalBatchAutomation,
+  taskHasManualOpenPullRequest: () => taskHasManualOpenPullRequest,
   taskMatchesReplicatedCreate: () => taskMatchesReplicatedCreate,
   toJson: () => toJson,
   toJsonNullable: () => toJsonNullable,
@@ -88875,7 +88851,6 @@ var init_src = __esm({
     init_stalled_review_detector();
     init_task_id_integrity();
     init_task_title_id_drift();
-    init_task_helpers();
     init_manual_retry_reset();
     init_task_lineage();
     init_distributed_task_id();
@@ -88895,6 +88870,7 @@ var init_src = __esm({
     init_blocker_fanout();
     init_capacity();
     init_dependency_blocked_todo_report();
+    init_task_helpers();
     init_task_merge();
     init_branch_group_completion();
     init_pr_entity();
@@ -90580,6 +90556,11 @@ var init_gating_classifications = __esm({
       "fn_task_done",
       "fn_heartbeat_done",
       "fn_memory_append",
+      /**
+       * FNXC:ToolGovernance 2026-06-28-00:00:
+       * FN-7191 requires permanent agents to call fn_ask_question directly without an approval gate. The tool only posts a structured question to the user's inbox, so it has the same trust level as fn_send_message and must be positively recognized in both gate paths.
+       */
+      "fn_ask_question",
       "fn_send_message",
       "fn_read_messages",
       "fn_post_room_message",
@@ -90621,6 +90602,11 @@ var init_gating_classifications = __esm({
       "fn_agent_show",
       "fn_agent_org_chart",
       "fn_workflow_list",
+      /**
+       * FNXC:ToolGovernance 2026-06-28-00:00:
+       * FN-7191 requires fn_ask_question to bypass permanent-agent approval gates like other user-messaging coordination tools; membership here makes the action gate classify it as exempt/allow even under locked-down policies.
+       */
+      "fn_ask_question",
       "fn_send_message",
       "fn_post_room_message",
       "fn_memory_append",
@@ -91508,7 +91494,7 @@ var init_hold_release = __esm({
 
 // ../engine/src/concurrency.ts
 function persistedTopLevelAgentSlots(tasks) {
-  return tasks.filter((task) => task.column === "in-progress" || task.column === "triage" && task.status === "planning" && !task.paused || task.column === "in-review" && ["merging", "reviewing", "fixing"].includes(String(task.status ?? ""))).length;
+  return countRunningAgentTasks(tasks);
 }
 function recoverIdleSemaphoreLeakCandidate(params) {
   const {
@@ -91535,10 +91521,11 @@ function recoverIdleSemaphoreLeakCandidate(params) {
     reconciliation: semaphore.reconcileActiveCount(0)
   };
 }
-var concurrencyLog, PRIORITY_MERGE, PRIORITY_EXECUTE, PRIORITY_SPECIFY, IDLE_SEMAPHORE_LEAK_REPAIR_MS, AgentSemaphore;
+var concurrencyLog, PRIORITY_MERGE, PRIORITY_EXECUTE, PRIORITY_SPECIFY, IDLE_SEMAPHORE_LEAK_REPAIR_MS, AgentSemaphore, ScopedAgentSemaphore;
 var init_concurrency = __esm({
   "../engine/src/concurrency.ts"() {
     "use strict";
+    init_src();
     init_logger2();
     concurrencyLog = createLogger2("concurrency");
     PRIORITY_MERGE = 2;
@@ -91689,13 +91676,21 @@ var init_concurrency = __esm({
        * deadlock that would occur if both parent and child needed a queued slot.
        */
       async runNested(fn2) {
-        this._active++;
+        this.acquireNestedSlot();
         try {
           return await fn2();
         } finally {
-          this.returnSlot("runNested");
+          this.releaseNestedSlot();
         }
       }
+      /** Reserve a nested helper-agent slot without queueing. */
+      acquireNestedSlot() {
+        this._active++;
+      }
+      /** Return a nested helper-agent slot. */
+      releaseNestedSlot() {
+        this.returnSlot("runNested");
+      }
       /**
        * FNXC:Scheduler-Concurrency 2026-06-13-19:58:
        * FN-6423 requires excess slot returns to remain observable without corrupting scheduler capacity accounting. Clamp the active slot count at zero and warn once so a release leak cannot surface as negative `activeCount` or a negative `semaphore used=` diagnostic.
@@ -91744,6 +91739,95 @@ var init_concurrency = __esm({
         return bestIdx;
       }
     };
+    ScopedAgentSemaphore = class extends AgentSemaphore {
+      delegate;
+      _held = 0;
+      constructor(delegate) {
+        super(() => delegate.limit);
+        this.delegate = delegate;
+      }
+      /** Number of slots this scope currently owns in the delegated semaphore. */
+      get heldCount() {
+        return this._held;
+      }
+      /** Shared-pool active count, preserving scheduler/metrics semantics. */
+      get activeCount() {
+        return this.delegate.activeCount;
+      }
+      get waitingCount() {
+        return this.delegate.waitingCount;
+      }
+      get availableCount() {
+        return this.delegate.availableCount;
+      }
+      get limit() {
+        return this.delegate.limit;
+      }
+      snapshot() {
+        return this.delegate.snapshot();
+      }
+      reconcileActiveCount(maxActive) {
+        const bounded = Math.max(0, Math.floor(maxActive));
+        const before = this._held;
+        if (before > bounded) {
+          const returned = before - bounded;
+          this._held = bounded;
+          for (let i = 0; i < returned; i++) {
+            this.delegate.release();
+          }
+        }
+        return { before, after: this._held, changed: before !== this._held };
+      }
+      async acquire(priority = 0) {
+        await this.delegate.acquire(priority);
+        this._held++;
+      }
+      tryAcquire() {
+        const acquired = this.delegate.tryAcquire();
+        if (acquired) this._held++;
+        return acquired;
+      }
+      release() {
+        if (this._held <= 0) return;
+        this._held--;
+        this.delegate.release();
+      }
+      async run(fn2, priority = 0) {
+        await this.acquire(priority);
+        try {
+          return await fn2();
+        } finally {
+          this.release();
+        }
+      }
+      async runNested(fn2) {
+        this.delegate.acquireNestedSlot();
+        this._held++;
+        try {
+          return await fn2();
+        } finally {
+          if (this._held > 0) {
+            this._held--;
+            this.delegate.releaseNestedSlot();
+          }
+        }
+      }
+      /**
+       * Return every slot still attributed to this scope.
+       *
+       * Late normal releases from already-aborted agents become no-ops because the
+       * scope's held count is zeroed before returning residual slots to the pool.
+       */
+      returnAllHeldSlots() {
+        const residual = this._held;
+        if (residual <= 0) return 0;
+        this._held = 0;
+        for (let i = 0; i < residual; i++) {
+          this.delegate.release();
+        }
+        return residual;
+      }
+    };
   }
 });
 
@@ -162550,7 +162634,7 @@ ${isRevision ? "1. Review the existing specification and user feedback carefully
 
 Use the write tool to write the specification file.${commandsSection}${completionDocumentationSection}${memorySection}${attachmentsSection}${userCommentsSection}`;
 }
-var TriageProcessor, IMAGE_MIME_TYPES, TEXT_INLINE_LIMIT;
+var TRIAGE_STUCK_RESUME_LOG_ACTION, TRIAGE_STUCK_RESUME_FEEDBACK, TriageProcessor, IMAGE_MIME_TYPES, TEXT_INLINE_LIMIT;
 var init_triage = __esm({
   "../engine/src/triage.ts"() {
     "use strict";
@@ -162582,6 +162666,8 @@ var init_triage = __esm({
     init_run_audit();
     init_goal_injection_diagnostics();
     init_session_token_usage();
+    TRIAGE_STUCK_RESUME_LOG_ACTION = "Triage stuck re-queue will resume existing planning draft";
+    TRIAGE_STUCK_RESUME_FEEDBACK = "The previous triage session was killed by the stuck-task detector after writing a non-empty planning draft. Resume from the existing draft below: preserve useful structure and decisions, fill gaps, and continue toward review instead of restarting planning from scratch.";
     TriageProcessor = class _TriageProcessor {
       /**
        * @param store — Task store instance (also used to listen for `settings:updated` events)
@@ -162892,6 +162978,106 @@ var init_triage = __esm({
         });
         return true;
       }
+      async readNonEmptyPromptDraft(taskId, context) {
+        const promptPath = join49(this.rootDir, ".fusion", "tasks", taskId, "PROMPT.md");
+        const written = await readFile22(promptPath, "utf-8").catch((err) => {
+          const msg = err instanceof Error ? err.message : String(err);
+          planLog.warn(`${taskId}: failed to read PROMPT.md during ${context} (${promptPath}): ${msg}`);
+          return "";
+        });
+        return written.trim().length > 0 ? written : void 0;
+      }
+      async readNonEmptyPlanDocument(taskId, context) {
+        const readTaskDocument = this.store.getTaskDocument;
+        if (typeof readTaskDocument !== "function") {
+          return void 0;
+        }
+        const document2 = await readTaskDocument.call(this.store, taskId, "plan").catch((err) => {
+          const msg = err instanceof Error ? err.message : String(err);
+          planLog.warn(`${taskId}: failed to read plan task document during ${context}: ${msg}`);
+          return null;
+        });
+        const content = typeof document2?.content === "string" ? document2.content : "";
+        return content.trim().length > 0 ? content : void 0;
+      }
+      async readNonEmptyPlanningDraft(taskId, context) {
+        const promptDraft = await this.readNonEmptyPromptDraft(taskId, context);
+        if (promptDraft) {
+          return { content: promptDraft, source: "prompt" };
+        }
+        const planDocument = await this.readNonEmptyPlanDocument(taskId, context);
+        return planDocument ? { content: planDocument, source: "plan-document" } : void 0;
+      }
+      async handleStuckAbortRequeue(task, context) {
+        const freshTask = await this.store.getTask(task.id).catch((err) => {
+          const msg = err instanceof Error ? err.message : String(err);
+          planLog.warn(`${task.id}: failed to refresh task during stuck-detector ${context} cleanup: ${msg}`);
+          return task;
+        });
+        if (hasLatestSpecReviewApproval2(freshTask)) {
+          const recovered = await this.recoverApprovedTask(freshTask).catch((err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            planLog.warn(`${task.id}: approved-spec recovery failed during stuck-detector ${context} cleanup: ${msg}`);
+            return false;
+          });
+          if (recovered) {
+            return;
+          }
+        }
+        const maxStuckSettings = await this.store.getSettings().catch((err) => {
+          const msg = err instanceof Error ? err.message : String(err);
+          planLog.warn(`${task.id}: failed to read maxStuckKills during stuck-detector ${context} cleanup, using default 6: ${msg}`);
+          return {};
+        });
+        const maxKills = Math.max(1, maxStuckSettings.maxStuckKills ?? 6);
+        const nextStuckKillCount = (freshTask.stuckKillCount ?? task.stuckKillCount ?? 0) + 1;
+        const draft = await this.readNonEmptyPlanningDraft(task.id, `stuck-detector ${context} cleanup`);
+        if (nextStuckKillCount >= maxKills) {
+          const exhaustedError = `STUCK_LOOP_EXHAUSTED: triage stuck detector killed ${task.id} ${nextStuckKillCount}/${maxKills} times without planning completion; task paused for manual intervention.`;
+          planLog.error(exhaustedError);
+          await this.store.logEntry(task.id, exhaustedError).catch((err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            planLog.warn(`${task.id}: failed to log stuck-loop exhaustion: ${msg}`);
+          });
+          await this.store.updateTask(task.id, {
+            stuckKillCount: nextStuckKillCount,
+            status: "failed",
+            error: exhaustedError,
+            paused: true,
+            pausedReason: "stuck-loop-exhausted-manual-intervention-required",
+            pausedByAgentId: "triage"
+          }).catch((err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            planLog.warn(`${task.id}: failed to persist stuck-loop exhaustion during stuck-detector ${context} cleanup: ${msg}`);
+          });
+          return;
+        }
+        if (draft) {
+          const sourceLabel = draft.source === "prompt" ? "PROMPT.md draft" : "plan task document";
+          planLog.log(`${task.id} killed by stuck detector \u2014 requeueing to resume existing ${sourceLabel} (${nextStuckKillCount}/${maxKills})`);
+          await this.store.logEntry(task.id, TRIAGE_STUCK_RESUME_LOG_ACTION, TRIAGE_STUCK_RESUME_FEEDBACK).catch((err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            planLog.warn(`${task.id}: failed to log stuck-resume feedback: ${msg}`);
+          });
+          await this.store.updateTask(task.id, {
+            status: "needs-replan",
+            stuckKillCount: nextStuckKillCount
+          }).catch((err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            planLog.warn(`${task.id}: failed to restore status to 'needs-replan' during stuck-detector ${context} cleanup: ${msg}`);
+          });
+          return;
+        }
+        planLog.log(`${task.id} killed by stuck detector \u2014 clearing status for cold retry (${nextStuckKillCount}/${maxKills})`);
+        const restoreStatus = (freshTask.status ?? task.status) === "needs-replan" ? "needs-replan" : null;
+        await this.store.updateTask(task.id, {
+          status: restoreStatus,
+          stuckKillCount: nextStuckKillCount
+        }).catch((err) => {
+          const msg = err instanceof Error ? err.message : String(err);
+          planLog.warn(`${task.id}: failed to restore status to '${restoreStatus}' during stuck-detector ${context} cleanup: ${msg}`);
+        });
+      }
       /**
        * If `newIntervalMs` differs from the currently active timer, restart
        * the `setInterval` so the new cadence takes effect immediately.
@@ -163250,9 +163436,16 @@ You are ${assignedAgent.name}${assignedAgent.title?.trim() ? `, ${assignedAgent.
               let feedback;
               if (isReplan) {
                 const feedbackLogEntry = [...task.log].reverse().find(
-                  (entry) => entry.action === "User comment requested re-specification of planned task" || entry.action === "User comment invalidated spec approval \u2014 task needs re-specification" || entry.action === "AI spec revision requested"
+                  (entry) => entry.action === "User comment requested re-specification of planned task" || entry.action === "User comment invalidated spec approval \u2014 task needs re-specification" || entry.action === "AI spec revision requested" || entry.action === TRIAGE_STUCK_RESUME_LOG_ACTION
                 );
                 feedback = feedbackLogEntry?.outcome;
+                if (feedbackLogEntry?.action === TRIAGE_STUCK_RESUME_LOG_ACTION) {
+                  const planningDraft = await this.readNonEmptyPlanningDraft(task.id, "stuck-resume replan seed");
+                  existingPrompt = planningDraft?.content;
+                  if (!existingPrompt) {
+                    feedback = void 0;
+                  }
+                }
                 if (!feedback) {
                   const latestUserComment = [...detail.comments || []].reverse().find((comment) => comment.author === "user");
                   feedback = latestUserComment?.text;
@@ -163287,12 +163480,7 @@ You are ${assignedAgent.name}${assignedAgent.title?.trim() ? `, ${assignedAgent.
               }
               if (this.stuckAborted.has(task.id)) {
                 this.stuckAborted.delete(task.id);
-                planLog.log(`${task.id} killed by stuck detector \u2014 clearing status for retry`);
-                const restoreStatus = task.status === "needs-replan" ? "needs-replan" : null;
-                await this.store.updateTask(task.id, { status: restoreStatus }).catch((err) => {
-                  const msg = err instanceof Error ? err.message : String(err);
-                  planLog.warn(`${task.id}: failed to restore status to '${restoreStatus}' during stuck-detector abort cleanup: ${msg}`);
-                });
+                await this.handleStuckAbortRequeue(task, "in-loop");
                 return;
               }
               if (createdSubtasksRef.current.length > 0) {
@@ -163541,12 +163729,7 @@ You are ${assignedAgent.name}${assignedAgent.title?.trim() ? `, ${assignedAgent.
             });
           } else if (this.stuckAborted.has(task.id)) {
             this.stuckAborted.delete(task.id);
-            planLog.log(`${task.id} killed by stuck detector \u2014 clearing status for retry`);
-            const restoreStatus = task.status === "needs-replan" ? "needs-replan" : null;
-            await this.store.updateTask(task.id, { status: restoreStatus }).catch((err2) => {
-              const msg = err2 instanceof Error ? err2.message : String(err2);
-              planLog.warn(`${task.id}: failed to restore status to '${restoreStatus}' during stuck-detector error cleanup: ${msg}`);
-            });
+            await this.handleStuckAbortRequeue(task, "catch");
           } else {
             if (this.options.usageLimitPauser && isUsageLimitError(errorMessage2)) {
               await this.options.usageLimitPauser.onUsageLimitHit(
@@ -176798,9 +176981,7 @@ ${summary}`,
                   } else {
                     const settings2 = await this.store.getSettings();
                     const preserveProgress = settings2.preserveProgressOnStuckRequeue !== false;
-                    if (!preserveProgress) {
-                      await this.resetStepsIfWorkLost(latestTask);
-                    }
+                    await this.resetStepsIfWorkLost(latestTask);
                     if (worktreePath && existsSync47(worktreePath)) {
                       try {
                         await removeWorktree({
@@ -178148,9 +178329,7 @@ ${summary}`,
                 } else {
                   const settings2 = await this.store.getSettings();
                   const preserveProgress = settings2.preserveProgressOnStuckRequeue !== false;
-                  if (!preserveProgress) {
-                    await this.resetStepsIfWorkLost(latestTask);
-                  }
+                  await this.resetStepsIfWorkLost(latestTask);
                   if (worktreePath && existsSync47(worktreePath)) {
                     try {
                       await removeWorktree({
@@ -179495,28 +179674,48 @@ Take a different approach. Do NOT repeat the rejected strategy. Re-read the step
         await this.store.logEntry(taskId, "Execution stopped \u2014 work discarded, moved to triage for re-planning");
       }
       /**
-       * Re-open the last non-pending step so a revision/failure handler gives the
-       * executor exactly one pending slot to re-enter through. Returns the index
-       * and name of the step that was flipped to `pending`, or null when there
-       * was nothing to re-open.
+       * Re-open the implementation-bearing slice of work for a revision/failure
+       * handler. Returns the earliest reopened step and all reopened indexes, or
+       * null when there was nothing to re-open.
        */
       async reopenLastStepForRevision(taskId, task) {
         const steps = task.steps;
         if (steps.length === 0) return null;
-        let targetIndex = -1;
+        let lastNonPendingIndex = -1;
         for (let i = steps.length - 1; i >= 0; i--) {
           if (steps[i].status !== "pending") {
-            targetIndex = i;
+            lastNonPendingIndex = i;
             break;
           }
         }
-        if (targetIndex === -1) {
+        if (lastNonPendingIndex === -1) {
           await this.store.updateTask(taskId, { currentStep: 0 });
           return null;
         }
-        await this.store.updateStep(taskId, targetIndex, "pending");
-        await this.store.updateTask(taskId, { currentStep: targetIndex });
-        return { index: targetIndex, name: steps[targetIndex].name };
+        const isTerminalVerificationOrDeliveryStep = (name) => /(^|[^a-z])(testing|verification|documentation|delivery)([^a-z]|$)/i.test(name);
+        const resetIndexes = /* @__PURE__ */ new Set([lastNonPendingIndex]);
+        if (isTerminalVerificationOrDeliveryStep(steps[lastNonPendingIndex].name)) {
+          let cursor = lastNonPendingIndex;
+          while (cursor >= 0 && isTerminalVerificationOrDeliveryStep(steps[cursor].name)) {
+            resetIndexes.add(cursor);
+            cursor--;
+          }
+          while (cursor >= 0 && steps[cursor].status === "pending") {
+            cursor--;
+          }
+          if (cursor >= 0) {
+            resetIndexes.add(cursor);
+          }
+        }
+        const indexes = [...resetIndexes].sort((a, b2) => a - b2);
+        for (const index2 of indexes) {
+          if (steps[index2].status !== "pending") {
+            await this.store.updateStep(taskId, index2, "pending");
+          }
+        }
+        const currentStep = indexes[0] ?? lastNonPendingIndex;
+        await this.store.updateTask(taskId, { currentStep });
+        return { index: currentStep, name: steps[currentStep].name, indexes };
       }
       /**
        * Run deterministic verification (test + build commands) in the task's worktree.
@@ -182080,39 +182279,45 @@ Review the work done in this worktree and evaluate it against the criteria in yo
           const mergeBase = mergeBaseStdout.trim();
           const branchHead = branchHeadStdout.trim();
           if (mergeBase === branchHead) {
-            executorLog.warn(
-              `${task.id} branch has no unique commits \u2014 resetting ${completedSteps.length} step(s) to pending`
+            await this.resetLostWorkStepProgress(task, completedSteps.length, "branch had no commits");
+          }
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          executorLog.warn(
+            `${task.id}: unable to prove surviving branch commits before worktree removal \u2014 resetting ${completedSteps.length} step(s) to pending: ${msg}`
+          );
+          await this.resetLostWorkStepProgress(task, completedSteps.length, `git proof failed: ${msg}`);
+        }
+      }
+      async resetLostWorkStepProgress(task, completedStepCount, reason) {
+        executorLog.warn(
+          `${task.id} ${reason} \u2014 resetting ${completedStepCount} step(s) to pending`
+        );
+        for (let i = 0; i < task.steps.length; i++) {
+          if (task.steps[i].status === "done" || task.steps[i].status === "in-progress") {
+            await this.store.updateStep(task.id, i, "pending");
+          }
+        }
+        const refreshedTask = await this.store.getTask(task.id);
+        const prevCurrentStep = refreshedTask.currentStep;
+        if (refreshedTask.steps.length > 0) {
+          const firstPendingStep = refreshedTask.steps.findIndex((s3) => s3.status === "pending");
+          const newCurrentStep = firstPendingStep >= 0 ? firstPendingStep : 0;
+          if (newCurrentStep !== prevCurrentStep) {
+            await this.store.updateTask(task.id, { currentStep: newCurrentStep });
+            executorLog.log(
+              `${task.id}: reset currentStep to ${newCurrentStep} after lost-work reset (was ${prevCurrentStep})`
             );
-            for (let i = 0; i < task.steps.length; i++) {
-              if (task.steps[i].status === "done" || task.steps[i].status === "in-progress") {
-                await this.store.updateStep(task.id, i, "pending");
-              }
-            }
-            const refreshedTask = await this.store.getTask(task.id);
-            const prevCurrentStep = refreshedTask.currentStep;
-            if (refreshedTask.steps.length > 0) {
-              const firstPendingStep = refreshedTask.steps.findIndex((s3) => s3.status === "pending");
-              const newCurrentStep = firstPendingStep >= 0 ? firstPendingStep : 0;
-              if (newCurrentStep !== prevCurrentStep) {
-                await this.store.updateTask(task.id, { currentStep: newCurrentStep });
-                executorLog.log(
-                  `${task.id}: reset currentStep to ${newCurrentStep} after lost-work reset (was ${prevCurrentStep})`
-                );
-                await this.store.logEntry(
-                  task.id,
-                  `Reset currentStep to ${newCurrentStep} after lost-work step reset (was ${prevCurrentStep})`
-                );
-              }
-            }
             await this.store.logEntry(
               task.id,
-              `Reset ${completedSteps.length} step(s) to pending \u2014 branch had no commits (uncommitted work lost with worktree)`
+              `Reset currentStep to ${newCurrentStep} after lost-work step reset (was ${prevCurrentStep})`
             );
           }
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          executorLog.warn(`${task.id}: step-reset-on-work-lost failed (non-fatal, steps keep current status): ${msg}`);
         }
+        await this.store.logEntry(
+          task.id,
+          `Reset ${completedStepCount} step(s) to pending \u2014 ${reason} (uncommitted work lost with worktree)`
+        );
       }
       /**
        * Mark a task as stuck-aborted so the executor's error handling
@@ -182175,9 +182380,7 @@ Review the work done in this worktree and evaluate it against the criteria in yo
               });
               await this.awaitAbortInFlightTaskWork(taskId, "force-requeue after stuck-kill unwind timeout");
               this.clearPausedAborted(taskId);
-              if (!preserveProgress) {
-                await this.resetStepsIfWorkLost(latestTask);
-              }
+              await this.resetStepsIfWorkLost(latestTask);
               let cleanupFailed = false;
               if (worktreePath && existsSync47(worktreePath)) {
                 try {
@@ -187466,6 +187669,7 @@ var init_agent_reflection = __esm({
     init_logger2();
     init_pi();
     init_mcp_resolution();
+    init_run_audit();
     reflectionLog = createLogger2("reflection");
     REFLECTION_SYSTEM_PROMPT = `You are an autonomous performance analyst reviewing an AI agent's recent execution history.
 
@@ -187504,11 +187708,22 @@ Rules:
         this.modelId = options.modelId;
       }
       async generateReflection(agentId, trigger, options = {}) {
+        const runContext = {
+          runId: generateSyntheticRunId("reflection", agentId),
+          agentId,
+          ...options.taskId ? { taskId: options.taskId } : {},
+          phase: "reflection",
+          source: trigger
+        };
+        const auditor = createRunAuditor(this.taskStore, runContext);
         try {
           const context = await this.buildReflectionContext(agentId);
           const recentRuns = await this.agentStore.getRecentRuns(agentId, DEFAULT_OUTCOME_LIMIT);
           if (context.recentOutcomes.length === 0 && recentRuns.length === 0) {
             reflectionLog.log(`Skipping reflection for ${agentId}: no recent tasks or heartbeat runs`);
+            await this.emitReflectionAudit(auditor, "reflection:skipped", agentId, trigger, options, {
+              reason: "no-history"
+            });
             return null;
           }
           let responseText = "";
@@ -187538,7 +187753,7 @@ Rules:
           }
           const parsed = this.parseReflectionResponse(responseText);
           const metrics = this.buildReflectionMetrics(context.recentOutcomes, context.performanceSummary, recentRuns);
-          return await this.reflectionStore.createReflection({
+          const reflection = await this.reflectionStore.createReflection({
             agentId,
             trigger,
             triggerDetail: options.triggerDetail,
@@ -187548,11 +187763,42 @@ Rules:
             suggestedImprovements: parsed.suggestedImprovements,
             summary: parsed.summary
           });
+          await this.emitReflectionAudit(auditor, "reflection:generated", agentId, trigger, options, {
+            reflectionId: reflection.id,
+            ...metrics.tasksCompleted !== void 0 ? { tasksCompleted: metrics.tasksCompleted } : {},
+            ...metrics.tasksFailed !== void 0 ? { tasksFailed: metrics.tasksFailed } : {},
+            ...metrics.avgDurationMs !== void 0 ? { avgDurationMs: metrics.avgDurationMs } : {},
+            commonErrorCount: metrics.commonErrors?.length ?? 0,
+            insightCount: parsed.insights.length,
+            suggestedImprovementCount: parsed.suggestedImprovements.length
+          });
+          return reflection;
         } catch (error2) {
+          await this.emitReflectionAudit(auditor, "reflection:failed", agentId, trigger, options, {
+            errorClass: error2 instanceof Error ? error2.name : typeof error2
+          });
           reflectionLog.error(`Failed to generate reflection for ${agentId}: ${error2.message}`);
           return null;
         }
       }
+      async emitReflectionAudit(auditor, type, agentId, trigger, options, metadata) {
+        try {
+          await auditor.database({
+            type,
+            target: agentId,
+            metadata: {
+              agentId,
+              trigger,
+              ...options.taskId ? { taskId: options.taskId } : {},
+              ...metadata
+            }
+          });
+        } catch (auditError) {
+          reflectionLog.warn(
+            `Failed to record reflection telemetry for ${agentId}: ${auditError instanceof Error ? auditError.message : String(auditError)}`
+          );
+        }
+      }
       async buildReflectionContext(agentId) {
         const [agentRecord, recentOutcomes, performanceSummaryRaw, latestReflection] = await Promise.all([
           this.agentStore.getAgent(agentId),
@@ -188654,6 +188900,8 @@ Your job:
 - Surface the blocker concretely with fn_task_log.
 - Chase the dependency: comment on the blocking task, send a message to the responsible agent, or ping an owner.
 - Look for unblocking work you can spawn or delegate right now.
+- Do NOT call fn_task_pause to handle a failed or blocked task. Pausing is reserved for explicit user requests for manual control.
+- If the task needs recovery, create/delegate focused follow-up work with fn_task_create or fn_delegate_task, log the needed operator action, or let the task surface as failed.
 - Pivot to other relevant coordination work if the blocker cannot be immediately resolved.
 
 **If your bound task is not blocked:**
@@ -188690,8 +188938,8 @@ Prefer fn_delegate_task when immediate ownership by a specific agent materially
 
 ## Common Patterns
 
-- **Blocked task:** log the concrete blocker, chase the dependency via fn_send_message, create a narrowly scoped unblocker task if needed.
-- **Stuck task with no blockedBy:** log the observation and create a follow-up task to investigate the root cause.
+- **Blocked task:** log the concrete blocker, chase the dependency via fn_send_message, create a narrowly scoped unblocker task if needed; do not pause it unless the user explicitly requested manual control.
+- **Stuck task with no blockedBy:** log the observation and create a follow-up task to investigate the root cause; do not use fn_task_pause as failure handling.
 - **Completed task with follow-up risk:** create explicit follow-up task(s) for residual risk instead of burying notes in a long log.
 - **New user/agent comments:** summarize what changed, identify required action, and route via task creation/delegation.
 - **Dependency drift:** log the mismatch and create reconciliation tasks with clear dependencies.
@@ -188783,6 +189031,7 @@ If unsure who should do the work, prefer fn_task_create and let scheduler routin
 
 ## Common Patterns
 
+- **Failed or blocked task:** do NOT call fn_task_pause to handle the failure or blocker. Pausing is reserved for explicit user requests for manual control; instead surface the blocker through available task or message context, create/delegate follow-up work, or let the task surface as failed.
 - **Unowned risk discovered:** create one focused task with concrete acceptance language.
 - **Known specialist needed:** list agents, then delegate to matching role/capability.
 - **Repeated confusion across runs:** append a concise memory entry so future agents avoid the same mistake.
@@ -194311,12 +194560,21 @@ var init_cron_runner = __esm({
               log24.log(`Skipping ${schedule.name} (${schedule.id}) \u2014 belongs to ${scheduleScope} scope, not polling`);
               continue;
             }
-            log24.log(`Executing ${schedule.name} (${schedule.id}) [scope: ${scheduleScope}]`);
             const currentSettings = await this.store.getSettings();
             if (currentSettings.globalPause || currentSettings.enginePaused) {
               log24.log("Pause detected mid-tick \u2014 stopping schedule execution");
               break;
             }
+            if (!schedule.nextRunAt) {
+              log24.warn(`Skipping ${schedule.name} (${schedule.id}) \u2014 missing nextRunAt for due claim`);
+              continue;
+            }
+            const claimed = await this.automationStore.claimDueSchedule(schedule.id, schedule.nextRunAt);
+            if (!claimed) {
+              log24.log(`Skipping ${schedule.name} (${schedule.id}) \u2014 claim lost to another poller`);
+              continue;
+            }
+            log24.log(`Executing ${schedule.name} (${schedule.id}) [scope: ${scheduleScope}]`);
             await this.executeSchedule(schedule);
           }
         } catch (err) {
@@ -199306,6 +199564,7 @@ var init_in_process_runtime = __esm({
       executor;
       worktreePool;
       globalSemaphore;
+      projectSemaphore;
       stuckTaskDetector;
       /**
        * Per-project CLI Agent Executor runtime bundle (PTY manager + telemetry hub +
@@ -199453,6 +199712,7 @@ var init_in_process_runtime = __esm({
               this.centralCore.on("concurrency:changed", this.concurrencyChangedListener);
             }
           }
+          this.projectSemaphore = new ScopedAgentSemaphore(this.globalSemaphore);
           await yieldEventLoop4();
           let agentStoreForReflection;
           try {
@@ -199512,7 +199772,7 @@ var init_in_process_runtime = __esm({
           this.scheduler = new Scheduler(this.taskStore, {
             maxConcurrent: this.config.maxConcurrent,
             maxWorktrees: this.config.maxWorktrees,
-            semaphore: this.globalSemaphore,
+            semaphore: this.projectSemaphore,
             agentStore: this.agentStore,
             hasActiveAgentExecution: (agentId) => this.heartbeatMonitor?.getTrackedAgents().includes(agentId) ?? false,
             missionStore,
@@ -199609,7 +199869,7 @@ var init_in_process_runtime = __esm({
           const prNodeGithubOps = this.config.prNodeGithubOps;
           const workflowAuthoritativeDriverRef = {};
           const executorOptions = {
-            semaphore: this.globalSemaphore,
+            semaphore: this.projectSemaphore,
             pool: this.worktreePool,
             usageLimitPauser: this.usageLimitPauser,
             stuckTaskDetector: this.stuckTaskDetector,
@@ -199807,7 +200067,7 @@ var init_in_process_runtime = __esm({
             this.taskStore,
             this.config.workingDirectory,
             {
-              semaphore: this.globalSemaphore,
+              semaphore: this.projectSemaphore,
               stuckTaskDetector: this.stuckTaskDetector,
               agentStore: this.agentStore,
               pluginRunner: this.pluginRunner,
@@ -200106,6 +200366,12 @@ var init_in_process_runtime = __esm({
               `post-abort drain timeout: shutdown reached with ${finalMetrics.inFlightTasks} tasks still in-flight`
             );
           }
+          const returnedResidualSlots = this.projectSemaphore?.returnAllHeldSlots() ?? 0;
+          if (returnedResidualSlots > 0) {
+            runtimeLog.warn(
+              `Returned ${returnedResidualSlots} residual global concurrency slot(s) after project stop drain`
+            );
+          }
           if (this.pluginRunner) {
             await this.pluginRunner.shutdown();
             runtimeLog.log("PluginRunner shutdown complete");
@@ -204641,7 +204907,7 @@ ${detail}`
                 }
               } else {
                 runtimeLog.log(`${hasManualResolver ? "Manual" : "Auto"}-merge merging ${taskId}...`);
-                const semaphore = this.runtime.globalSemaphore;
+                const semaphore = this.runtime.projectSemaphore ?? this.runtime.globalSemaphore;
                 const pool = this.runtime.worktreePool;
                 const agentStore = this.runtime.agentStore;
                 const usageLimitPauser = this.runtime.usageLimitPauser;
@@ -214800,6 +215066,12 @@ data: ${JSON.stringify(stripTaskListHeavyFields(task))}
       send(`event: task:merged
 data: ${JSON.stringify(stripTaskEventHeavyFields(result))}
 
+`);
+    };
+    const onArtifactRegistered = (artifact) => {
+      send(`event: artifact:registered
+data: ${JSON.stringify(artifact)}
+
 `);
     };
     const onResearchRunCreated = (run2) => {
@@ -215238,6 +215510,7 @@ data: ${JSON.stringify(data)}
       store.off("task:updated", onUpdated);
       store.off("task:deleted", onDeleted);
       store.off("task:merged", onMerged);
+      store.off("artifact:registered", onArtifactRegistered);
       if (missionStore) {
         missionStore.off("mission:created", onMissionCreated);
         missionStore.off("mission:updated", onMissionUpdated);
@@ -215341,6 +215614,7 @@ data: ${JSON.stringify(data)}
     store.on("task:updated", onUpdated);
     store.on("task:deleted", onDeleted);
     store.on("task:merged", onMerged);
+    store.on("artifact:registered", onArtifactRegistered);
     if (missionStore) {
       missionStore.on("mission:created", onMissionCreated);
       missionStore.on("mission:updated", onMissionUpdated);
@@ -215707,7 +215981,7 @@ function listRegisteredProjectStores() {
 }
 async function countRunningAgentsInStore(store) {
   const tasks = await store.listTasks({ slim: true });
-  return tasks.filter((task) => task.column === "in-progress" || task.column === "triage" && task.status === "planning" && !task.paused).length;
+  return countRunningAgentTasks(tasks);
 }
 async function countRunningAgentsInRegisteredProjectStores(projectIds) {
   const requestedProjectIds = new Set(projectIds);
@@ -215730,6 +216004,7 @@ var storeCache, pendingCreations, initializedProjects, projectRegisteredListener
 var init_project_store_resolver = __esm({
   "../dashboard/src/project-store-resolver.ts"() {
     "use strict";
+    init_src();
     storeCache = /* @__PURE__ */ new Map();
     pendingCreations = /* @__PURE__ */ new Map();
     initializedProjects = /* @__PURE__ */ new Set();
@@ -223105,6 +223380,15 @@ async function generatePrMetadata(input) {
     const templateExists = await raceWithAbort(access10(templatePath).then(() => true).catch(() => false), combinedSignal);
     const template = templateExists ? await raceWithAbort(readFile27(templatePath, "utf8"), combinedSignal) : "";
     const model = resolveTitleSummarizerSettingsModel(settings);
+    const systemPrompt = [PR_METADATA_SYSTEM_PROMPT];
+    const titleGuidance = settings.prTitlePromptInstructions?.trim();
+    const descriptionGuidance = settings.prDescriptionPromptInstructions?.trim();
+    if (titleGuidance) {
+      systemPrompt.push(`Title guidance: ${titleGuidance}`);
+    }
+    if (descriptionGuidance) {
+      systemPrompt.push(`Description guidance: ${descriptionGuidance}`);
+    }
     const mcpServers = (await raceWithAbort(resolveMcpServersForStore(store ?? {}), combinedSignal)).servers;
     let aiText = "";
     const { session } = await raceWithAbort(createFnAgent2({
@@ -223117,26 +223401,27 @@ async function generatePrMetadata(input) {
       mcpServers,
       defaultProvider: model.provider,
       defaultModelId: model.modelId,
-      systemPrompt: [
-        "Generate GitHub PR metadata.",
-        "Respond with strict JSON only.",
-        "Schema: {title, summary, changes, testing, linkedTask}"
-      ].join("\n"),
+      systemPrompt: systemPrompt.join("\n"),
       onText: (delta) => {
         aiText += delta;
       }
     }), combinedSignal);
     try {
       const contextPrompt = [
+        "Source-of-truth guidance:",
+        "- Ground the PR title, summary, changes, and testing in the commit log and diff stat below.",
+        "- Use task title, task description, and task prompt only to clarify intent when the git evidence supports it.",
+        "- Omit speculation; when evidence for testing or a change is absent, say so instead of inventing details.",
+        "- Return only strict JSON matching the required schema.",
         `Task ID: ${task.id}`,
         `Task title: ${task.title}`,
         `Task description: ${task.description ?? ""}`,
         `Base branch: ${baseBranch}`,
-        "Commit log:",
+        "Commit log (source of truth):",
         logOut || "(none)",
-        "Diff stat:",
+        "Diff stat (source of truth):",
         diffStatOut || "(none)",
-        "Task prompt:",
+        "Task prompt (supporting context):",
         promptContent || "(none)"
       ].join("\n\n");
       throwIfAborted3(combinedSignal);
@@ -223169,7 +223454,7 @@ async function generatePrMetadata(input) {
     }
   }
 }
-var execAsync36, PR_METADATA_TIMEOUT_MS;
+var execAsync36, PR_METADATA_TIMEOUT_MS, PR_METADATA_SYSTEM_PROMPT;
 var init_pr_metadata_generator = __esm({
   "../dashboard/src/pr-metadata-generator.ts"() {
     "use strict";
@@ -223177,6 +223462,17 @@ var init_pr_metadata_generator = __esm({
     init_src4();
     execAsync36 = promisify55(execCb);
     PR_METADATA_TIMEOUT_MS = 6e4;
+    PR_METADATA_SYSTEM_PROMPT = [
+      "You generate GitHub pull request metadata for Fusion tasks.",
+      "Respond with STRICT JSON ONLY: no markdown fences, no commentary, no prose outside the JSON object.",
+      'Use exactly this schema: {"title": string, "summary": string, "changes": string, "testing": string, "linkedTask": string}.',
+      "Title: concise imperative conventional-commit style, at most 72 characters, no trailing period, with a scope when the change clearly suggests one.",
+      "Summary: 1-3 short plain-sentence paragraphs explaining what changed and why; be specific and avoid marketing fluff.",
+      "Changes: a tight markdown bullet list of concrete, verifiable changes supported by the commit log or diff stat; do not speculate.",
+      "Testing: markdown bullets naming actual verification shown in the evidence; if no testing evidence exists, say '- Not provided.' or '- Not run (not provided).'.",
+      "LinkedTask: set to the task ID exactly as provided.",
+      "Ground every field in the commit log and diff stat first, then use the task title, task description, and task prompt only as supporting context."
+    ].join("\n");
   }
 });
 
@@ -225199,6 +225495,7 @@ async function mergeTaskPr(scopedStore, task, token, explicitMethod, runIdPrefix
       ...mergedPrInfo,
       autoMergeOnGreen: task.prInfo.autoMergeOnGreen,
       autoMergeStrategy: task.prInfo.autoMergeStrategy,
+      manual: task.prInfo.manual,
       lastMergeError: void 0,
       lastMergeErrorAt: void 0,
       draft: mergedPrInfo.draft ?? mergedPrInfo.isDraft
@@ -225285,6 +225582,7 @@ async function refreshPrInBackground(store, taskId, currentPrInfos, token, optio
         autoMergeStrategy: prior?.autoMergeStrategy,
         lastMergeError: prior?.lastMergeError,
         lastMergeErrorAt: prior?.lastMergeErrorAt,
+        manual: prior?.manual,
         draft: mergeStatus.prInfo.draft ?? mergeStatus.prInfo.isDraft,
         lastCheckedAt: (/* @__PURE__ */ new Date()).toISOString(),
         lastReviewDecision: reviewSnapshot.decision
@@ -226969,7 +227267,7 @@ ${body}`;
     for (const match of matchingTasks) {
       if (match.resourceType === "pr") {
         const current = match.current;
-        const next = { ...badgeData, lastCheckedAt: checkedAt };
+        const next = { ...current, ...badgeData, manual: current.manual, lastCheckedAt: checkedAt };
         const changed = hasPrBadgeFieldsChanged(current, badgeData);
         if (changed || current.lastCheckedAt !== checkedAt) {
           await scopedStore.updatePrInfo(match.id, next);
@@ -227135,7 +227433,9 @@ ${body}`;
               continue;
             }
             const updatedPrInfo = {
+              ...task.prInfo,
               ...prInfo,
+              manual: task.prInfo.manual,
               lastCheckedAt: refreshedAt
             };
             await scopedStore.updatePrInfo(taskId, updatedPrInfo);
@@ -227218,10 +227518,10 @@ ${body}`;
       const existingPr = await client.findPrForBranch({ head: branchName, state: "all", owner, repo });
       let prInfo;
       if (existingPr) {
-        prInfo = existingPr;
+        prInfo = { ...existingPr, manual: true };
       } else {
         await runGitCommand2(["push", "-u", "origin", branchName], scopedStore.getRootDir(), 6e4);
-        prInfo = await client.createPr({
+        const createdPrInfo = await client.createPr({
           owner,
           repo,
           title: prTitle,
@@ -227229,6 +227529,7 @@ ${body}`;
           head: branchName,
           base
         });
+        prInfo = { ...createdPrInfo, manual: true };
       }
       if (existingPrs.length > 0) {
         await scopedStore.addPrInfo(task.id, prInfo);
@@ -227620,6 +227921,7 @@ ${body}`;
             autoMergeStrategy: priorPr.autoMergeStrategy,
             lastMergeError: priorPr.lastMergeError,
             lastMergeErrorAt: priorPr.lastMergeErrorAt,
+            manual: priorPr.manual,
             draft: mergeStatus.prInfo.draft ?? mergeStatus.prInfo.isDraft,
             lastCheckedAt: (/* @__PURE__ */ new Date()).toISOString(),
             lastReviewDecision: reviewSnapshot.decision
@@ -228719,6 +229021,39 @@ function registerTaskWorkflowRoutes(ctx, deps) {
     resolveSelfHealingManager: _resolveSelfHealingManager
   } = deps;
   const TASK_DETAIL_ACTIVITY_LOG_LIMIT2 = taskDetailActivityLogLimit;
+  async function reengageInReviewTaskForUserComment(scopedStore, task, wake) {
+    if (task.column !== "in-review") {
+      return { task, reengaged: false, suppressedReason: "not-in-review" };
+    }
+    if (task.sessionFile) {
+      return { task, reengaged: false, suppressedReason: "live-session" };
+    }
+    const activePrEntity = scopedStore.getActivePrEntityBySource?.("task", task.id) ?? (task.branchContext?.groupId ? scopedStore.getActivePrEntityBySource?.("branch-group", task.branchContext.groupId) : null);
+    if (isBackwardMoveBlockedByOpenPr({
+      fromIndex: COLUMNS.indexOf(task.column),
+      toIndex: COLUMNS.indexOf("in-progress"),
+      activePrEntity
+    })) {
+      await scopedStore.logEntry(
+        task.id,
+        "In-review user comment re-engagement suppressed",
+        PR_OPEN_BLOCKS_MOVE_BACK_MESSAGE
+      );
+      return { task, reengaged: false, suppressedReason: "blocking-pr" };
+    }
+    await scopedStore.updateTask(task.id, {
+      status: null,
+      error: null,
+      sessionFile: null
+    });
+    const lastDoneStep = [...task.steps ?? []].map((step, index2) => ({ step, index: index2 })).reverse().find(({ step }) => step.status === "done" || step.status === "in-progress");
+    if (lastDoneStep) {
+      await scopedStore.updateStep(task.id, lastDoneStep.index, "pending");
+    }
+    const reengagedTask = await scopedStore.moveTask(task.id, "in-progress", { preserveProgress: true });
+    await triggerCommentWakeForAssignedAgent(scopedStore, reengagedTask, wake);
+    return { task: reengagedTask, reengaged: true };
+  }
   router.get("/tasks/merge-advance-events", async (req, res) => {
     try {
       const { store: scopedStore } = await getProjectContext3(req);
@@ -230266,17 +230601,26 @@ ${normalizedDescription}`;
       if (author !== void 0 && typeof author !== "string") {
         throw badRequest("author must be a string");
       }
-      const task = await scopedStore.addTaskComment(req.params.id, text, author?.trim() || "user");
+      const normalizedAuthor = author?.trim() || "user";
+      const task = await scopedStore.addTaskComment(req.params.id, text, normalizedAuthor);
       const newCommentId = task.comments?.at(-1)?.id;
-      void triggerCommentWakeForAssignedAgent(scopedStore, task, {
+      const wake = {
         triggeringCommentType: "task",
         triggeringCommentIds: newCommentId ? [newCommentId] : void 0,
         triggerDetail: "task-comment"
-      }).catch((error2) => {
-        runtimeLogger.warn(
-          `failed to trigger task-comment heartbeat for ${task.id}: ${error2 instanceof Error ? error2.message : String(error2)}`
-        );
-      });
+      };
+      if (normalizedAuthor === "user") {
+        if (task.column === "in-review" && !task.sessionFile) {
+          const { task: reengagedTask } = await reengageInReviewTaskForUserComment(scopedStore, task, wake);
+          res.json(reengagedTask);
+          return;
+        }
+        void triggerCommentWakeForAssignedAgent(scopedStore, task, wake).catch((error2) => {
+          runtimeLogger.warn(
+            `failed to trigger task-comment heartbeat for ${task.id}: ${error2 instanceof Error ? error2.message : String(error2)}`
+          );
+        });
+      }
       res.json(task);
     } catch (err) {
       if (err instanceof ApiError) {
@@ -230549,11 +230893,17 @@ ${normalizedDescription}`;
       }
       const task = await scopedStore.addSteeringComment(req.params.id, text, "user");
       const newSteeringCommentId = task.steeringComments?.at(-1)?.id;
-      void triggerCommentWakeForAssignedAgent(scopedStore, task, {
+      const wake = {
         triggeringCommentType: "steering",
         triggeringCommentIds: newSteeringCommentId ? [newSteeringCommentId] : void 0,
         triggerDetail: "steering-comment"
-      }).catch((error2) => {
+      };
+      if (task.column === "in-review" && !task.sessionFile) {
+        const { task: reengagedTask } = await reengageInReviewTaskForUserComment(scopedStore, task, wake);
+        res.json(reengagedTask);
+        return;
+      }
+      void triggerCommentWakeForAssignedAgent(scopedStore, task, wake).catch((error2) => {
         runtimeLogger.warn(
           `failed to trigger steering-comment heartbeat for ${task.id}: ${error2 instanceof Error ? error2.message : String(error2)}`
         );
@@ -231101,26 +231451,57 @@ ${normalizedDescription}`;
       if (unsupportedSource) {
         throw badRequest(`Unsupported review source: ${String(unsupportedSource.source)}`);
       }
-      if (!task.reviewState) {
-        throw badRequest("Task has no reviewState payload");
-      }
+      let canonicalReviewData;
+      if (task.prInfo) {
+        const badgeParsed = parseGitHubBadgeUrl(task.prInfo.url);
+        const repoInfo = getCurrentRepo(scopedStore.getRootDir());
+        const owner = badgeParsed?.owner ?? repoInfo?.owner;
+        const repo = badgeParsed?.repo ?? repoInfo?.repo;
+        if (!owner || !repo) {
+          throw badRequest("Could not determine GitHub repository for PR review fetch");
+        }
+        canonicalReviewData = await new GitHubClient(options?.githubToken ?? process.env.GITHUB_TOKEN).getPrReviewDetails(owner, repo, task.prInfo.number);
+      } else {
+        canonicalReviewData = await buildDirectTaskReviewData(task, scopedStore);
+      }
+      const canonicalReviewItems = canonicalReviewData.items.map((item) => ({
+        id: item.itemId,
+        body: item.body,
+        summary: item.title,
+        author: { login: item.author },
+        createdAt: item.createdAt ?? canonicalReviewData.fetchedAt ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+        updatedAt: item.updatedAt ?? void 0,
+        path: item.filePath,
+        line: item.line,
+        threadId: item.threadId,
+        htmlUrl: item.url,
+        state: item.reviewState ?? void 0,
+        isResolved: item.isResolved,
+        source: item.sourceMode === "reviewer-agent" ? "reviewer-agent" : "github-pr"
+      }));
+      const reviewState = {
+        source: canonicalReviewData.mode,
+        summary: canonicalReviewData.summary ?? task.reviewState?.summary,
+        items: canonicalReviewItems,
+        addressing: task.reviewState?.addressing ?? [],
+        lastRefreshedAt: task.reviewState?.lastRefreshedAt ?? canonicalReviewData.fetchedAt ?? void 0,
+        refreshSource: task.reviewState?.refreshSource,
+        refreshStatus: task.reviewState?.refreshStatus,
+        refreshError: task.reviewState?.refreshError
+      };
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const selectedSet = new Set(selectedItems.map((item) => item.id));
-      const sourceById = new Map(selectedItems.map((item) => [item.id, item.source]));
-      const reviewSourceMismatch = task.reviewState.items.find((item) => {
-        const selectedSource = sourceById.get(item.id);
-        if (!selectedSource || !task.reviewState) return false;
-        const expectedSource = task.reviewState.source === "pull-request" ? "pr-review" : "reviewer-agent";
-        return selectedSource !== expectedSource;
-      });
+      const canonicalIds = new Set(reviewState.items.map((item) => item.id));
+      const expectedSource = canonicalReviewData.mode === "pull-request" ? "pr-review" : "reviewer-agent";
+      const reviewSourceMismatch = selectedItems.find((item) => canonicalIds.has(item.id) && item.source !== expectedSource);
       if (reviewSourceMismatch) {
         throw badRequest("Selected review source does not match task review mode");
       }
-      const matchedItems = task.reviewState.items.filter((item) => selectedSet.has(item.id));
-      if (matchedItems.length !== selectedSet.size) {
+      const hasUnknownSelection = selectedItems.some((item) => !canonicalIds.has(item.id));
+      if (hasUnknownSelection) {
         throw badRequest("selectedItems must reference existing review items");
       }
-      const modeSummary = `${task.reviewState.source === "pull-request" ? "pull-request" : "reviewer-agent"} \xB7 ${selectedItems.length} selected item(s)`;
+      const modeSummary = `${reviewState.source === "pull-request" ? "pull-request" : "reviewer-agent"} \xB7 ${selectedItems.length} selected item(s)`;
       const steeringItems = selectedItems.map((item, index2) => {
         const location = item.filePath ? `${item.filePath}${typeof item.lineNumber === "number" ? `:${item.lineNumber}` : ""}` : void 0;
         const snippetSource = item.body.trim() || item.summary.trim();
@@ -231129,9 +231510,9 @@ ${normalizedDescription}`;
         return `${index2 + 1}. source: ${item.source}${location ? ` | location: ${location}` : ""} | "${snippet}"${urlSuffix}`;
       });
       const steeringText = ["Selected review feedback to address", modeSummary, ...steeringItems].join("\n");
-      const priorAddressingById = new Map(task.reviewState.addressing.map((record2) => [record2.itemId, record2]));
+      const priorAddressingById = new Map(reviewState.addressing.map((record2) => [record2.itemId, record2]));
       const nextAddressing = [
-        ...task.reviewState.addressing.filter((record2) => !selectedSet.has(record2.itemId)),
+        ...reviewState.addressing.filter((record2) => !selectedSet.has(record2.itemId)),
         ...selectedItems.map((item) => {
           const existing = priorAddressingById.get(item.id);
           return {
@@ -231144,7 +231525,7 @@ ${normalizedDescription}`;
             stale: false,
             snapshot: {
               itemId: item.id,
-              sourceMode: task.reviewState?.source ?? "pull-request",
+              sourceMode: reviewState.source,
               source: item.source,
               summary: item.summary,
               body: item.body,
@@ -231158,15 +231539,60 @@ ${normalizedDescription}`;
           };
         })
       ];
-      const reviewState = {
-        ...task.reviewState,
+      const nextReviewState = {
+        ...reviewState,
         addressing: nextAddressing
       };
-      await scopedStore.updateTask(task.id, { reviewState });
+      await scopedStore.updateTask(task.id, { reviewState: nextReviewState });
       let steeringCommentId = null;
       const steeringComment = await scopedStore.addSteeringComment(task.id, steeringText, "user");
       steeringCommentId = steeringComment.id;
       let updatedTask = await scopedStore.getTask(task.id);
+      if (task.column === "in-review") {
+        updatedTask = (await reengageInReviewTaskForUserComment(scopedStore, updatedTask, {
+          triggeringCommentType: "steering",
+          triggeringCommentIds: steeringCommentId ? [steeringCommentId] : void 0,
+          triggerDetail: "review-address"
+        })).task;
+      } else {
+        const hasActiveSession = Boolean(updatedTask.sessionFile);
+        if (steeringCommentId && updatedTask.column === "in-progress" && updatedTask.assignedAgentId && !hasActiveSession) {
+          await triggerCommentWakeForAssignedAgent(scopedStore, updatedTask, {
+            triggeringCommentType: "steering",
+            triggeringCommentIds: [steeringCommentId],
+            triggerDetail: "review-address"
+          });
+        }
+      }
+      await scopedStore.logEntry(task.id, "Same-task review revision requested", `${selectedItems.length} item(s) submitted from review tab`);
+      res.json({ task: updatedTask, reviewState: nextReviewState });
+    } catch (err) {
+      if (err instanceof ApiError) {
+        throw err;
+      }
+      rethrowAsApiError9(err);
+    }
+  });
+  router.post("/tasks/:id/pr/address-feedback", async (req, res) => {
+    try {
+      const { store: scopedStore } = await getProjectContext3(req);
+      const task = await scopedStore.getTask(req.params.id);
+      const prInfo = task.prInfo ?? task.prInfos?.[0];
+      if (!prInfo) {
+        throw badRequest("Task must have a linked pull request before PR feedback can be addressed");
+      }
+      if (task.column !== "in-review" && task.column !== "in-progress") {
+        throw badRequest("PR feedback can only be addressed for in-review or in-progress tasks");
+      }
+      const prLabel = `PR #${prInfo.number}`;
+      const steeringText = [
+        ADDRESS_PR_FEEDBACK_PROMPT,
+        "If the compound-engineering skill is unavailable, inspect the linked pull request, evaluate each unresolved review thread, fix valid issues, reply with what changed or why no change was made, and resolve threads that are fully addressed.",
+        `Context: ${prLabel} ${prInfo.url}`
+      ].join("\n\n");
+      const steeringComment = await scopedStore.addSteeringComment(task.id, steeringText, "user");
+      const steeringCommentId = steeringComment.id;
+      let updatedTask = await scopedStore.getTask(task.id);
       if (task.column === "in-review") {
         await scopedStore.updateTask(task.id, {
           status: null,
@@ -231180,15 +231606,15 @@ ${normalizedDescription}`;
         updatedTask = await scopedStore.moveTask(task.id, "in-progress", { preserveProgress: true });
       }
       const hasActiveSession = Boolean(updatedTask.sessionFile);
-      if (steeringCommentId && updatedTask.column === "in-progress" && updatedTask.assignedAgentId && !hasActiveSession) {
+      if (updatedTask.column === "in-progress" && updatedTask.assignedAgentId && !hasActiveSession) {
         await triggerCommentWakeForAssignedAgent(scopedStore, updatedTask, {
           triggeringCommentType: "steering",
           triggeringCommentIds: [steeringCommentId],
-          triggerDetail: "review-address"
+          triggerDetail: "pr-address-feedback"
         });
       }
-      await scopedStore.logEntry(task.id, "Same-task review revision requested", `${selectedItems.length} item(s) submitted from review tab`);
-      res.json({ task: updatedTask, reviewState });
+      await scopedStore.logEntry(task.id, "Address PR feedback requested", `${prLabel} queued via ce-resolve-pr-feedback skill prompt`);
+      res.json({ task: updatedTask });
     } catch (err) {
       if (err instanceof ApiError) {
         throw err;
@@ -231370,7 +231796,7 @@ ${normalizedDescription}`;
     }
   });
 }
-var REVIEW_BLOCK_RE, REVIEW_VERDICT_RE, REVIEW_STEP_RE, DUPLICATE_STOPWORDS, ARTIFACT_TYPES, __fingerprintCreateLocksForTests, RESET_TASK_FIELDS, RESET_DRIFT_CORRECTION_FIELDS;
+var REVIEW_BLOCK_RE, REVIEW_VERDICT_RE, REVIEW_STEP_RE, DUPLICATE_STOPWORDS, ARTIFACT_TYPES, ADDRESS_PR_FEEDBACK_PROMPT, __fingerprintCreateLocksForTests, RESET_TASK_FIELDS, RESET_DRIFT_CORRECTION_FIELDS;
 var init_register_task_workflow_routes = __esm({
   "../dashboard/src/routes/register-task-workflow-routes.ts"() {
     "use strict";
@@ -231388,6 +231814,7 @@ var init_register_task_workflow_routes = __esm({
     REVIEW_STEP_RE = /^(plan|code) review Step (\d+): (APPROVE|REVISE|RETHINK|UNAVAILABLE)\b/i;
     DUPLICATE_STOPWORDS = /* @__PURE__ */ new Set(["a", "an", "the", "and", "or", "of", "to", "for", "in", "is", "on", "with", "fn"]);
     ARTIFACT_TYPES = /* @__PURE__ */ new Set(["document", "image", "video", "audio", "other"]);
+    ADDRESS_PR_FEEDBACK_PROMPT = "Run /ce-resolve-pr-feedback to resolve open PR review feedback: evaluate each thread, fix valid issues, and reply.";
     __fingerprintCreateLocksForTests = deterministicGuardLocks;
     RESET_TASK_FIELDS = {
       worktree: null,
@@ -271981,9 +272408,7 @@ var init_register_project_routes = __esm({
             const tasks = await projectStore.listTasks({ slim: true });
             const activeCols = /* @__PURE__ */ new Set(["triage", "todo", "in-progress", "in-review"]);
             const activeTaskCount = tasks.filter((t) => activeCols.has(t.column)).length;
-            const inFlightAgentCount = tasks.filter(
-              (t) => t.column === "in-progress" || t.column === "triage" && t.status === "planning" && !t.paused
-            ).length;
+            const inFlightAgentCount = countRunningAgentTasks(tasks);
             const totalTasksCompleted = tasks.filter((t) => t.column === "done" || t.column === "archived").length;
             const centralHealth = await central.getProjectHealth(req.params.id);
             const healthBase = centralHealth ?? {
@@ -279234,6 +279659,29 @@ function isCompatibleDefaultHeartbeatPath(path10, agent) {
   const safeId2 = agent.id.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
   return new RegExp(`^\\.fusion/agents/[^/]+-${safeId2}/HEARTBEAT\\.md$`).test(trimmed);
 }
+function withTaskDerivedTokenTotals(agents, scopedStore) {
+  try {
+    const tokenTotalsByAgentId = aggregateTaskTokenTotalsByAgentLink(scopedStore.getDatabase());
+    return agents.map((agent) => {
+      const storedInputTokens = agent.totalInputTokens ?? 0;
+      const storedOutputTokens = agent.totalOutputTokens ?? 0;
+      if (storedInputTokens > 0 || storedOutputTokens > 0) {
+        return agent;
+      }
+      const taskTotals = tokenTotalsByAgentId.get(agent.id);
+      if (!taskTotals || taskTotals.inputTokens <= 0 && taskTotals.outputTokens <= 0) {
+        return agent;
+      }
+      return {
+        ...agent,
+        totalInputTokens: taskTotals.inputTokens,
+        totalOutputTokens: taskTotals.outputTokens
+      };
+    });
+  } catch {
+    return agents;
+  }
+}
 function withPendingApprovalCounts(agents, scopedStore) {
   try {
     const approvalStore = new ApprovalRequestStore(scopedStore.getDatabase());
@@ -279270,7 +279718,8 @@ function registerAgentCoreListCreateRoutes(ctx, deps) {
       await agentStore.init();
       const agents = await agentStore.listAgents(filter2);
       const sanitizedAgents = await sanitizeAgentTaskLinks(agents, scopedStore);
-      res.json(withPendingApprovalCounts(sanitizedAgents, scopedStore));
+      const agentsWithTokenTotals = withTaskDerivedTokenTotals(sanitizedAgents, scopedStore);
+      res.json(withPendingApprovalCounts(agentsWithTokenTotals, scopedStore));
     } catch (err) {
       if (err instanceof ApiError) {
         throw err;
@@ -280384,16 +280833,13 @@ function registerAgentRuntimeRoutes(ctx, deps) {
   router.get("/agents/:id/token-usage", async (req, res) => {
     try {
       const { store: scopedStore } = await getProjectContext3(req);
-      const { AgentStore: AgentStore2, aggregateAgentTokenUsage: aggregateAgentTokenUsage2, isEphemeralAgent: isEphemeralAgent2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+      const { AgentStore: AgentStore2, aggregateAgentTokenUsage: aggregateAgentTokenUsage2 } = await Promise.resolve().then(() => (init_src(), src_exports));
       const agentStore = new AgentStore2({ rootDir: scopedStore.getFusionDir() });
       await agentStore.init();
       const agent = await agentStore.getAgent(req.params.id);
       if (!agent) {
         throw notFound("Agent not found");
       }
-      if (isEphemeralAgent2(agent)) {
-        throw badRequest("Token usage is not available for ephemeral agents");
-      }
       const summary = await aggregateAgentTokenUsage2({
         taskStore: scopedStore,
         agentStore,
@@ -317168,6 +317614,7 @@ var init_log_sink = __esm({
     DashboardLogSink = class {
       tui = null;
       isTTY;
+      silenced = false;
       originalConsole = null;
       constructor(tui) {
         this.tui = tui ?? null;
@@ -317177,7 +317624,26 @@ var init_log_sink = __esm({
         this.tui = tui;
         this.isTTY = true;
       }
+      /*
+      FNXC:DashboardShutdown 2026-06-28-00:00:
+      Quit teardown spilled engine/mesh/dev-server log lines onto the user's
+      restored shell — after `q`, dispose() called releaseConsole() (re-pointing
+      console.* at the real terminal) and then tui.stop() left the alt-screen, so
+      every subsequent slow-teardown log painted over the recovered prompt. That
+      read as "the TUI keeps rendering after I get my terminal back."
+      silence() makes the sink — and console.* — drop everything from here to
+      process exit. It is irreversible by design; only shutdown calls it.
+      */
+      silence() {
+        this.silenced = true;
+        const noop3 = () => {
+        };
+        console.log = noop3;
+        console.warn = noop3;
+        console.error = noop3;
+      }
       log(message, prefix) {
+        if (this.silenced) return;
         const line = prefix ? `[${prefix}] ${message}` : message;
         if (this.tui && this.isTTY) {
           this.tui.log(message, prefix);
@@ -317188,6 +317654,7 @@ var init_log_sink = __esm({
         }
       }
       warn(message, prefix) {
+        if (this.silenced) return;
         const line = prefix ? `[${prefix}] ${message}` : message;
         if (this.tui && this.isTTY) {
           this.tui.warn(message, prefix);
@@ -317198,6 +317665,7 @@ var init_log_sink = __esm({
         }
       }
       error(message, prefix) {
+        if (this.silenced) return;
         const line = prefix ? `[${prefix}] ${message}` : message;
         if (this.tui && this.isTTY) {
           this.tui.error(message, prefix);
@@ -317954,7 +318422,7 @@ async function runDashboard(port, opts = {}) {
   let currentShutdownStep = null;
   function armHardExitWatchdog() {
     setTimeout(() => {
-      if (currentShutdownStep) {
+      if (currentShutdownStep && process.env.FUSION_DEBUG_SHUTDOWN) {
         process.stderr.write(
           `fusion: graceful shutdown stalled on "${currentShutdownStep}" after ${SHUTDOWN_HARD_EXIT_GRACE_MS}ms \u2014 forcing exit
 `
@@ -317972,10 +318440,9 @@ async function runDashboard(port, opts = {}) {
     try {
       await fn2();
       const ms2 = Date.now() - startedAt;
-      if (debug) process.stderr.write(`fusion: shutdown step: ${label} done in ${ms2}ms
-`);
-      else if (ms2 >= SHUTDOWN_STEP_SLOW_MS) {
-        process.stderr.write(`fusion: slow shutdown step: ${label} took ${ms2}ms
+      if (debug) {
+        const slow = ms2 >= SHUTDOWN_STEP_SLOW_MS ? " (slow)" : "";
+        process.stderr.write(`fusion: shutdown step: ${label} done in ${ms2}ms${slow}
 `);
       }
     } catch (err) {
@@ -318334,7 +318801,7 @@ async function runDashboard(port, opts = {}) {
       tuiRefreshDebounceTimer = null;
     }
     if (tui) {
-      logSink.releaseConsole();
+      logSink.silence();
       void tui.stop();
     }
     for (const { target, event, handler } of handlers) {
@@ -325897,23 +326364,19 @@ async function getTaskCounts(projectPath) {
     for (const col of COLUMNS) {
       counts[col] = 0;
     }
-    let activeTriagePlannerCount = 0;
     for (const task of tasks) {
       counts[task.column] = (counts[task.column] || 0) + 1;
-      if (task.column === "triage" && task.status === "planning" && !task.paused) {
-        activeTriagePlannerCount += 1;
-      }
     }
-    return { byColumn: counts, activeTriagePlannerCount };
+    return { byColumn: counts, runningAgentCount: countRunningAgentTasks(tasks) };
   } catch {
-    return { byColumn: {}, activeTriagePlannerCount: 0 };
+    return { byColumn: {}, runningAgentCount: 0 };
   }
 }
 async function getProjectHealth(central, projectId) {
   return central.getProjectHealth(projectId);
 }
 function getLiveInFlightAgentCount(taskCounts) {
-  return (taskCounts.byColumn["in-progress"] ?? 0) + taskCounts.activeTriagePlannerCount;
+  return taskCounts.runningAgentCount;
 }
 function buildDisplayHealth(taskCounts, health) {
   return {