@runfusion/fusion 0.50.0 → 0.51.0

package/dist/extension.js

@@ -564,6 +564,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);
@@ -572,7 +586,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;
@@ -688,6 +702,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",
@@ -1244,6 +1259,8 @@ var init_settings_schema = __esm({
       testCommand: void 0,
       buildCommand: void 0,
       recycleWorktrees: false,
+      showWorktreeGrouping: false,
+      openTasksInRightSidebar: false,
       executorAllowSiblingBranchRename: false,
       worktreeNaming: "random",
       worktrunk: {
@@ -1411,6 +1428,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,
@@ -4611,19 +4630,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.
-
-## Your Role
-You are a fast-path spec writer. Keep output lean but executable, with enough precision that an executor can run immediately.
+    FAST_TRIAGE_PROMPT_TEXT = `You are a task specification agent for "fn". This task is running in **fast mode**.
 
-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}
@@ -4632,205 +4653,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: {Outcome-oriented implementation step}
+- [ ] {Specific verifiable outcome.}
+- [ ] {Specific verifiable outcome.}
 
-### Step 1: {Implementation step name}
+### 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.
 
-- [ ] {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)
-
-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
-
-## 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.
+## 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.
 
-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
@@ -10723,6 +10608,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" },
@@ -10742,14 +10639,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;
   }
@@ -10769,7 +10668,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";
@@ -10786,7 +10685,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",
@@ -11300,6 +11198,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;
@@ -11312,10 +11225,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"]);
   }
 });
 
@@ -47778,6 +47692,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.
@@ -54600,20 +54543,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,
@@ -54622,7 +54555,7 @@ ${TASK_UPSERT_SQL_ASSIGNMENTS}
             const newTask = {
               id: newId,
               lineageId: generateTaskLineageId(),
-              title: normalizedTitle.title ?? "Refinement",
+              title: refinementTitle,
               description: `${feedback.trim()}
 
 Refines: ${id}`,
@@ -60870,6 +60803,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();
@@ -60897,7 +60833,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:
@@ -64154,6 +64092,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,
@@ -64161,7 +64144,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 });
@@ -64221,7 +64204,6 @@ function finalizeWindowSummary(summary) {
 var init_agent_token_usage = __esm({
   "../core/src/agent-token-usage.ts"() {
     "use strict";
-    init_types();
   }
 });
 
@@ -66135,16 +66117,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) {
@@ -88160,6 +88132,7 @@ __export(src_exports, {
   aggregatePluginActivations: () => aggregatePluginActivations,
   aggregateProductivityAnalytics: () => aggregateProductivityAnalytics,
   aggregateSignalsAnalytics: () => aggregateSignalsAnalytics,
+  aggregateTaskTokenTotalsByAgentLink: () => aggregateTaskTokenTotalsByAgentLink,
   aggregateTeamAnalytics: () => aggregateTeamAnalytics,
   aggregateTokenAnalytics: () => aggregateTokenAnalytics,
   aggregateToolAnalytics: () => aggregateToolAnalytics,
@@ -88250,6 +88223,7 @@ __export(src_exports, {
   countDualAcceptDisagreements: () => countDualAcceptDisagreements,
   countInterventions: () => countInterventions,
   countRecentIdenticalStallEntries: () => countRecentIdenticalStallEntries,
+  countRunningAgentTasks: () => countRunningAgentTasks,
   countUsageEventsBy: () => countUsageEventsBy,
   createActivityLogSnapshot: () => createActivityLogSnapshot,
   createAgentRunSnapshot: () => createAgentRunSnapshot,
@@ -88452,6 +88426,7 @@ __export(src_exports, {
   isResearchExperimentalEnabled: () => isResearchExperimentalEnabled,
   isRetryableMeshWriteFailure: () => isRetryableMeshWriteFailure,
   isRunRecord: () => isRunRecord,
+  isRunningAgentTask: () => isRunningAgentTask,
   isSandboxExperimentalEnabled: () => isSandboxExperimentalEnabled,
   isSecretAccessPolicy: () => isSecretAccessPolicy,
   isSecretScope: () => isSecretScope,
@@ -88713,6 +88688,7 @@ __export(src_exports, {
   syncMemoryBackupRoutine: () => syncMemoryBackupRoutine,
   syncMemoryDreamsAutomation: () => syncMemoryDreamsAutomation,
   syncScheduledEvalBatchAutomation: () => syncScheduledEvalBatchAutomation,
+  taskHasManualOpenPullRequest: () => taskHasManualOpenPullRequest,
   taskMatchesReplicatedCreate: () => taskMatchesReplicatedCreate,
   toJson: () => toJson,
   toJsonNullable: () => toJsonNullable,
@@ -88873,7 +88849,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();
@@ -88893,6 +88868,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();
@@ -89629,6 +89605,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",
@@ -89670,6 +89651,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",
@@ -90557,7 +90543,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 {
@@ -90584,10 +90570,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;
@@ -90738,13 +90725,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.
@@ -90793,6 +90788,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;
+      }
+    };
   }
 });
 
@@ -161599,7 +161683,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";
@@ -161631,6 +161715,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)
@@ -161941,6 +162027,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.
@@ -162299,9 +162485,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;
@@ -162336,12 +162529,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) {
@@ -162590,12 +162778,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(
@@ -175847,9 +176030,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({
@@ -177197,9 +177378,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({
@@ -178544,28 +178723,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 index of indexes) {
+          if (steps[index].status !== "pending") {
+            await this.store.updateStep(taskId, index, "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.
@@ -181129,39 +181328,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
@@ -181224,9 +181429,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 {
@@ -186515,6 +186718,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.
 
@@ -186553,11 +186757,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 = "";
@@ -186587,7 +186802,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,
@@ -186597,11 +186812,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),
@@ -187703,6 +187949,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:**
@@ -187739,8 +187987,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.
@@ -187832,6 +188080,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.
@@ -193360,12 +193609,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) {
@@ -198355,6 +198613,7 @@ var init_in_process_runtime = __esm({
       executor;
       worktreePool;
       globalSemaphore;
+      projectSemaphore;
       stuckTaskDetector;
       /**
        * Per-project CLI Agent Executor runtime bundle (PTY manager + telemetry hub +
@@ -198502,6 +198761,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 {
@@ -198561,7 +198821,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,
@@ -198658,7 +198918,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,
@@ -198856,7 +199116,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,
@@ -199155,6 +199415,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");
@@ -203690,7 +203956,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;
@@ -210701,6 +210967,7 @@ var init_sse2 = __esm({
 var init_project_store_resolver = __esm({
   "../dashboard/src/project-store-resolver.ts"() {
     "use strict";
+    init_src();
   }
 });
 
@@ -215816,6 +216083,15 @@ async function generatePrMetadata(input) {
     const templateExists = await raceWithAbort(access9(templatePath).then(() => true).catch(() => false), combinedSignal);
     const template = templateExists ? await raceWithAbort(readFile26(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({
@@ -215828,26 +216104,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);
@@ -215880,7 +216157,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";
@@ -215888,6 +216165,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");
   }
 });
 
@@ -227842,8 +228130,8 @@ Path: .fusion/tasks/${params.id}/attachments/${attachment.filename}`
   pi2.registerTool({
     name: "fn_task_pause",
     label: "fn: Pause Task",
-    description: "Pause a task \u2014 stops all automated agent and scheduler interaction for this task.",
-    promptSnippet: "Pause a Fusion task (stops automation)",
+    description: "Pause a task for explicit user-requested manual control \u2014 stops all automated agent and scheduler interaction. Agents should not pause tasks to handle failures or blockers; use retry, create/delegate follow-up work, or let the task surface as failed instead.",
+    promptSnippet: "Pause a Fusion task only for explicit user-requested manual control; do not use for failure/blocker handling",
     parameters: Type9.Object({
       id: Type9.String({ description: "Task ID (e.g. FN-001)" })
     }),