@runfusion/fusion 0.9.0 → 0.9.1

package/dist/bin.js

@@ -1344,7 +1344,7 @@ function getAvailableTemplates(config) {
 function getTemplatesForRole(role, config) {
   return getAvailableTemplates(config).filter((t) => t.role === role);
 }
-var EXECUTOR_PROMPT_TEXT, TRIAGE_PROMPT_TEXT, REVIEWER_PROMPT_TEXT, MERGER_BASE_PROMPT_TEXT, SENIOR_ENGINEER_PROMPT_TEXT, STRICT_REVIEWER_PROMPT_TEXT, CONCISE_TRIAGE_PROMPT_TEXT, BUILTIN_AGENT_PROMPTS;
+var EXECUTOR_PROMPT_TEXT, TRIAGE_PROMPT_TEXT, REVIEWER_PROMPT_TEXT, MERGER_BASE_PROMPT_TEXT, SENIOR_ENGINEER_PROMPT_TEXT, STRICT_REVIEWER_PROMPT_TEXT, CONCISE_TRIAGE_PROMPT_TEXT, EXECUTOR_HEARTBEAT_GUIDANCE, TRIAGE_HEARTBEAT_GUIDANCE, REVIEWER_HEARTBEAT_GUIDANCE, MERGER_HEARTBEAT_GUIDANCE, SENIOR_ENGINEER_HEARTBEAT_GUIDANCE, STRICT_REVIEWER_HEARTBEAT_GUIDANCE, CONCISE_TRIAGE_HEARTBEAT_GUIDANCE, BUILTIN_AGENT_PROMPTS;
 var init_agent_prompts = __esm({
   "../core/src/agent-prompts.ts"() {
     "use strict";
@@ -2166,13 +2166,64 @@ Write a PROMPT.md specification to the given path. Be brief and precise \u2014 a
 5. **No placeholders:** Real content only.
 6. **Read first:** Examine codebase before writing spec.
 7. **Be concise:** Short descriptions, minimal prose. Focus on what matters.`;
+    EXECUTOR_HEARTBEAT_GUIDANCE = `## Heartbeat Run Behavior
+
+Treat each heartbeat as a short autonomous execution cycle.
+
+- If a task is assigned: inspect the latest task state, continue the next concrete implementation step, run the smallest useful verification, and either advance the task or log the blocker precisely.
+- If no task is assigned: execute your standing instructions. Review unread messages, scan for blocked or failing engineering work, create narrowly scoped follow-up tasks, and capture durable implementation notes other agents will need later.
+- Do not idle simply because no task is linked. Use heartbeat time to reduce engineering risk, unblock work, and keep execution moving in small, concrete increments.`;
+    TRIAGE_HEARTBEAT_GUIDANCE = `## Heartbeat Run Behavior
+
+Use heartbeat runs to keep the planning pipeline healthy.
+
+- If a task is assigned: turn the rough request into a complete, execution-ready PROMPT.md with clear scope, steps, dependencies, and verification criteria.
+- If no task is assigned: execute your planning instructions. Patrol for vague requests, blocked tasks that need better specification, review follow-ups that should become new tasks, and dependency gaps that are slowing executors down.
+- Favor ambiguity reduction over busywork. Every heartbeat should leave the queue more actionable than you found it.`;
+    REVIEWER_HEARTBEAT_GUIDANCE = `## Heartbeat Run Behavior
+
+Use heartbeat runs to keep review quality high and queues moving.
+
+- If a task is assigned: perform the review with findings first, focusing on correctness, regressions, missing tests, and operational risk.
+- If no task is assigned: execute your review instructions. Look for work waiting on review, failed validations, suspicious recent changes, and places where a second pass would prevent a bad merge.
+- Prefer surfacing concrete findings, follow-up tasks, or merge blockers over rewriting implementation yourself.`;
+    MERGER_HEARTBEAT_GUIDANCE = `## Heartbeat Run Behavior
+
+Use heartbeat runs to keep merge-ready work from stalling.
+
+- If a task is assigned: verify merge preconditions, resolve the next safe merge step, and surface conflicts or missing gates immediately.
+- If no task is assigned: execute your merge instructions. Inspect the in-review and merge-ready queue, look for unresolved conflicts, missing approvals, broken post-review state, and tasks that are ready for the final merge push.
+- Optimize for safe flow, not raw throughput. Clear blockers, communicate risks, and only move merge work forward when the repository stays trustworthy.`;
+    SENIOR_ENGINEER_HEARTBEAT_GUIDANCE = `## Heartbeat Run Behavior
+
+Treat each heartbeat as an autonomous senior-engineering pass.
+
+- If a task is assigned: push the implementation forward decisively, making sound architectural choices, validating risky changes early, and documenting trade-offs that downstream agents should inherit.
+- If no task is assigned: execute your standing instructions. Hunt for architectural drift, flaky quality gates, latent integration risk, and follow-up work that needs a strong technical owner.
+- Spend heartbeat time where leverage is highest: unblock teams, reduce complexity, and turn vague engineering risk into concrete next actions.`;
+    STRICT_REVIEWER_HEARTBEAT_GUIDANCE = `## Heartbeat Run Behavior
+
+Use heartbeat runs to enforce a high review bar.
+
+- If a task is assigned: review for worst-case failure modes first, especially security, backward compatibility, edge cases, and missing regression coverage.
+- If no task is assigned: execute your review instructions. Look for merges that feel under-reviewed, risky diffs that deserve another pass, and follow-up work needed before code should land.
+- Bias toward precise findings and explicit risk articulation. A quiet heartbeat should mean the code is genuinely clean, not that you stopped looking.`;
+    CONCISE_TRIAGE_HEARTBEAT_GUIDANCE = `## Heartbeat Run Behavior
+
+Keep heartbeat output lean and useful.
+
+- If a task is assigned: produce the minimum complete PROMPT.md needed for an executor to act safely.
+- If no task is assigned: execute your planning instructions, scan for underspecified or blocked work, and turn it into short, actionable task specs or follow-up tickets.
+- Prefer crisp decisions, clear file scope, and concrete verification steps over narrative detail.`;
     BUILTIN_AGENT_PROMPTS = [
       {
         id: "default-executor",
         name: "Default Executor",
         description: "Standard task execution agent with full tooling and review support.",
         role: "executor",
-        prompt: EXECUTOR_PROMPT_TEXT,
+        prompt: `${EXECUTOR_PROMPT_TEXT}
+
+${EXECUTOR_HEARTBEAT_GUIDANCE}`,
         builtIn: true
       },
       {
@@ -2180,7 +2231,9 @@ Write a PROMPT.md specification to the given path. Be brief and precise \u2014 a
         name: "Default Triage",
         description: "Standard task specification agent producing detailed PROMPT.md files.",
         role: "triage",
-        prompt: TRIAGE_PROMPT_TEXT,
+        prompt: `${TRIAGE_PROMPT_TEXT}
+
+${TRIAGE_HEARTBEAT_GUIDANCE}`,
         builtIn: true
       },
       {
@@ -2188,7 +2241,9 @@ Write a PROMPT.md specification to the given path. Be brief and precise \u2014 a
         name: "Default Reviewer",
         description: "Standard independent code and plan reviewer with balanced criteria.",
         role: "reviewer",
-        prompt: REVIEWER_PROMPT_TEXT,
+        prompt: `${REVIEWER_PROMPT_TEXT}
+
+${REVIEWER_HEARTBEAT_GUIDANCE}`,
         builtIn: true
       },
       {
@@ -2196,7 +2251,9 @@ Write a PROMPT.md specification to the given path. Be brief and precise \u2014 a
         name: "Default Merger",
         description: "Standard merge agent for squash merges with conflict resolution.",
         role: "merger",
-        prompt: MERGER_BASE_PROMPT_TEXT,
+        prompt: `${MERGER_BASE_PROMPT_TEXT}
+
+${MERGER_HEARTBEAT_GUIDANCE}`,
         builtIn: true
       },
       {
@@ -2204,7 +2261,9 @@ Write a PROMPT.md specification to the given path. Be brief and precise \u2014 a
         name: "Senior Engineer",
         description: "Autonomous executor with architectural awareness, performance focus, and minimal hand-holding. Makes independent decisions on routine matters.",
         role: "executor",
-        prompt: SENIOR_ENGINEER_PROMPT_TEXT,
+        prompt: `${SENIOR_ENGINEER_PROMPT_TEXT}
+
+${SENIOR_ENGINEER_HEARTBEAT_GUIDANCE}`,
         builtIn: true
       },
       {
@@ -2212,7 +2271,9 @@ Write a PROMPT.md specification to the given path. Be brief and precise \u2014 a
         name: "Strict Reviewer",
         description: "Rigorous reviewer with stricter criteria for security, edge cases, backward compatibility, and type safety. Issues REVISE more readily.",
         role: "reviewer",
-        prompt: STRICT_REVIEWER_PROMPT_TEXT,
+        prompt: `${STRICT_REVIEWER_PROMPT_TEXT}
+
+${STRICT_REVIEWER_HEARTBEAT_GUIDANCE}`,
         builtIn: true
       },
       {
@@ -2220,7 +2281,9 @@ Write a PROMPT.md specification to the given path. Be brief and precise \u2014 a
         name: "Concise Triage",
         description: "Shorter, more focused specification format with minimal prose. Produces compact PROMPT.md files with essential information only.",
         role: "triage",
-        prompt: CONCISE_TRIAGE_PROMPT_TEXT,
+        prompt: `${CONCISE_TRIAGE_PROMPT_TEXT}
+
+${CONCISE_TRIAGE_HEARTBEAT_GUIDANCE}`,
         builtIn: true
       }
     ];
@@ -31994,6 +32057,9 @@ ${newTask.description}
             task.nextRecoveryAt = void 0;
           }
           await this.atomicWriteTaskJson(dir2, task);
+          if (toColumn === "done") {
+            this.clearLinkedAgentTaskIds(id, task.updatedAt);
+          }
           if (this.isWatching) this.taskCache.set(id, { ...task });
           this.emit("task:moved", { task, from: fromColumn, to: toColumn });
           return task;
@@ -32701,11 +32767,34 @@ ${task.description}
             }
             rewrittenDependents.push(updatedDependent);
           }
+          this.clearLinkedAgentTaskIds(taskId);
           this.db.prepare("DELETE FROM tasks WHERE id = ?").run(taskId);
           this.db.bumpLastModified();
         });
         return rewrittenDependents;
       }
+      /**
+       * Clear `agent.taskId` links that point at a task which has transitioned out
+       * of active work. This keeps heartbeat scheduling aligned with live task
+       * storage and prevents stale task-scoped heartbeat runs.
+       */
+      clearLinkedAgentTaskIds(taskId, updatedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+        const linkedAgents = this.db.prepare("SELECT id FROM agents WHERE taskId = ?").all(taskId);
+        if (linkedAgents.length === 0) {
+          return;
+        }
+        this.db.prepare(`
+      UPDATE agents
+      SET
+        taskId = NULL,
+        updatedAt = ?,
+        data = CASE
+          WHEN json_valid(data) THEN json_set(json_remove(data, '$.taskId'), '$.updatedAt', ?)
+          ELSE data
+        END
+      WHERE taskId = ?
+    `).run(updatedAt, updatedAt, taskId);
+      }
       /**
        * Clean up the git branch associated with a task.
        *
@@ -32987,6 +33076,7 @@ ${task.description}
           });
           if (!cleanup) {
             await this.atomicWriteTaskJson(dir2, task);
+            this.clearLinkedAgentTaskIds(id, task.updatedAt);
             if (this.isWatching) this.taskCache.set(id, { ...task });
             this.emit("task:moved", { task, from: "done", to: "archived" });
             return task;
@@ -33000,6 +33090,7 @@ ${task.description}
           }
           const entry = await this.taskToArchiveEntry(task, task.columnMovedAt);
           this.archiveDb.upsert(entry);
+          this.clearLinkedAgentTaskIds(id, task.updatedAt);
           this.db.prepare("DELETE FROM tasks WHERE id = ?").run(id);
           this.db.bumpLastModified();
           const { rm: rm6 } = await import("node:fs/promises");
@@ -36913,10 +37004,105 @@ async function summarizeCommitBody(diffStat, rootDir, provider, modelId, opts) {
     }
   }
 }
+async function summarizeCommitSubject(diffStat, rootDir, provider, modelId, opts) {
+  const trimmedStat = (diffStat ?? "").trim();
+  const trimmedCommitLog = (opts?.commitLog ?? "").trim();
+  if (trimmedStat.length === 0 && trimmedCommitLog.length === 0) {
+    return null;
+  }
+  const truncatedStat = trimmedStat.length > MAX_COMMIT_BODY_INPUT_LENGTH ? trimmedStat.slice(0, MAX_COMMIT_BODY_INPUT_LENGTH) + "\n\u2026(truncated)" : trimmedStat;
+  const truncatedCommitLog = trimmedCommitLog.length > MAX_COMMIT_BODY_INPUT_LENGTH ? trimmedCommitLog.slice(0, MAX_COMMIT_BODY_INPUT_LENGTH) + "\n\u2026(truncated)" : trimmedCommitLog;
+  const userPromptParts = [];
+  if (opts?.branch) userPromptParts.push(`Branch: ${opts.branch}`);
+  if (opts?.taskId) userPromptParts.push(`Task: ${opts.taskId}`);
+  if (userPromptParts.length > 0) userPromptParts.push("");
+  if (truncatedCommitLog.length > 0) {
+    userPromptParts.push("Step commits being merged in (most recent first):");
+    userPromptParts.push(truncatedCommitLog);
+    userPromptParts.push("");
+  }
+  if (truncatedStat.length > 0) {
+    userPromptParts.push("Files changed (`git diff --stat`):");
+    userPromptParts.push(truncatedStat);
+    userPromptParts.push("");
+  }
+  userPromptParts.push("Write the commit subject now.");
+  const userPrompt = userPromptParts.join("\n");
+  const timeoutMs = opts?.timeoutMs ?? DEFAULT_COMMIT_SUBJECT_TIMEOUT_MS;
+  const aborter = new AbortController();
+  const timer = setTimeout(() => aborter.abort(), timeoutMs);
+  if (opts?.signal) {
+    if (opts.signal.aborted) aborter.abort();
+    else opts.signal.addEventListener("abort", () => aborter.abort(), { once: true });
+  }
+  let session;
+  try {
+    const createFnAgent12 = await getFnAgent();
+    if (!createFnAgent12) {
+      if (DEBUG) console.log("[ai-summarize] AI engine not available for commit subject");
+      return null;
+    }
+    const agentOptions = {
+      cwd: rootDir,
+      systemPrompt: COMMIT_SUBJECT_SYSTEM_PROMPT,
+      tools: "readonly"
+    };
+    if (provider && modelId) {
+      agentOptions.defaultProvider = provider;
+      agentOptions.defaultModelId = modelId;
+    }
+    const agentResult = await createFnAgent12(agentOptions);
+    if (!agentResult?.session) return null;
+    session = agentResult.session;
+    await session.prompt(userPrompt);
+    if (aborter.signal.aborted) return null;
+    if (session.state?.error) {
+      if (DEBUG) console.log(`[ai-summarize] Commit-subject session error: ${session.state.error}`);
+      return null;
+    }
+    const messages = session.state?.messages ?? [];
+    const assistant = messages.filter((m) => m.role === "assistant").pop();
+    if (!assistant?.content) return null;
+    let raw = "";
+    if (typeof assistant.content === "string") {
+      raw = assistant.content;
+    } else if (Array.isArray(assistant.content)) {
+      raw = assistant.content.filter(
+        (c) => c.type === "text" && typeof c.text === "string"
+      ).map((c) => c.text).join("");
+    }
+    return sanitizeCommitSubject(raw);
+  } catch (err) {
+    if (DEBUG) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.log(`[ai-summarize] Commit-subject generation failed: ${message}`);
+    }
+    return null;
+  } finally {
+    clearTimeout(timer);
+    try {
+      session?.dispose?.();
+    } catch {
+    }
+  }
+}
+function sanitizeCommitSubject(raw) {
+  if (!raw) return null;
+  const firstLine = raw.split(/\r?\n/).map((l) => l.trim()).find((l) => l.length > 0);
+  if (!firstLine) return null;
+  let subject = firstLine.replace(/^[-*]\s+/, "").replace(/^["'`]+|["'`]+$/g, "").trim();
+  subject = subject.replace(/^[a-z]+(?:\([^)]+\))?:\s*/i, "").trim();
+  subject = subject.replace(/\.+$/, "").trim();
+  if (!subject) return null;
+  if (subject.length > MAX_COMMIT_SUBJECT_LENGTH) {
+    subject = subject.slice(0, MAX_COMMIT_SUBJECT_LENGTH).trim();
+  }
+  return subject || null;
+}
 function __resetSummarizeState() {
   rateLimits.clear();
 }
-var SUMMARIZE_SYSTEM_PROMPT, MAX_DESCRIPTION_LENGTH, MIN_DESCRIPTION_LENGTH, MAX_TITLE_LENGTH, MAX_REQUESTS_PER_HOUR, RATE_LIMIT_WINDOW_MS, CLEANUP_INTERVAL_MS, rateLimits, cleanupInterval, ValidationError, RateLimitError, AiServiceError, DEBUG, COMMIT_BODY_SYSTEM_PROMPT, MAX_COMMIT_BODY_INPUT_LENGTH, MAX_COMMIT_BODY_LENGTH, DEFAULT_COMMIT_BODY_TIMEOUT_MS;
+var SUMMARIZE_SYSTEM_PROMPT, MAX_DESCRIPTION_LENGTH, MIN_DESCRIPTION_LENGTH, MAX_TITLE_LENGTH, MAX_REQUESTS_PER_HOUR, RATE_LIMIT_WINDOW_MS, CLEANUP_INTERVAL_MS, rateLimits, cleanupInterval, ValidationError, RateLimitError, AiServiceError, DEBUG, COMMIT_BODY_SYSTEM_PROMPT, MAX_COMMIT_BODY_INPUT_LENGTH, MAX_COMMIT_BODY_LENGTH, DEFAULT_COMMIT_BODY_TIMEOUT_MS, COMMIT_SUBJECT_SYSTEM_PROMPT, MAX_COMMIT_SUBJECT_LENGTH, DEFAULT_COMMIT_SUBJECT_TIMEOUT_MS;
 var init_ai_summarize = __esm({
   "../core/src/ai-summarize.ts"() {
     "use strict";
@@ -36976,6 +37162,20 @@ Your job is to summarize what landed \u2014 using the branch's step commit subje
     MAX_COMMIT_BODY_INPUT_LENGTH = 4e3;
     MAX_COMMIT_BODY_LENGTH = 2e3;
     DEFAULT_COMMIT_BODY_TIMEOUT_MS = 3e4;
+    COMMIT_SUBJECT_SYSTEM_PROMPT = `You write commit message subjects for merge commits.
+
+Your job is to summarize what landed \u2014 using the branch's step commit subjects (when provided) and the \`git diff --stat\` \u2014 into a single subject line that conveys the change's essence at a glance.
+
+## Guidelines
+- Output ONLY the subject text \u2014 no quotes, no markdown, no body, no trailing period
+- Do NOT include any \`feat:\`, \`fix:\`, scope, or task-id prefix \u2014 the caller adds that
+- Imperative mood ("add X", "fix Y", "refactor Z") and lower-case first word
+- Hard cap: 60 characters; aim for 40\u201355
+- Be specific: name the most consequential module/feature/behavior that changed
+- If the branch has one clear theme, describe it; if it's mixed, lead with the largest change
+- Do not invent details that aren't in the input`;
+    MAX_COMMIT_SUBJECT_LENGTH = 60;
+    DEFAULT_COMMIT_SUBJECT_TIMEOUT_MS = 15e3;
   }
 });
 
@@ -49156,6 +49356,7 @@ __export(src_exports, {
   COLUMN_DESCRIPTIONS: () => COLUMN_DESCRIPTIONS,
   COLUMN_LABELS: () => COLUMN_LABELS,
   COMMIT_BODY_SYSTEM_PROMPT: () => COMMIT_BODY_SYSTEM_PROMPT,
+  COMMIT_SUBJECT_SYSTEM_PROMPT: () => COMMIT_SUBJECT_SYSTEM_PROMPT,
   COMPACT_MEMORY_SYSTEM_PROMPT: () => COMPACT_MEMORY_SYSTEM_PROMPT,
   CentralCore: () => CentralCore,
   CentralDatabase: () => CentralDatabase,
@@ -49166,6 +49367,7 @@ __export(src_exports, {
   DEFAULT_AGENT_HEARTBEAT_INTERVAL_MS: () => DEFAULT_AGENT_HEARTBEAT_INTERVAL_MS,
   DEFAULT_AUTO_SUMMARIZE_SCHEDULE: () => DEFAULT_AUTO_SUMMARIZE_SCHEDULE,
   DEFAULT_COMMIT_BODY_TIMEOUT_MS: () => DEFAULT_COMMIT_BODY_TIMEOUT_MS,
+  DEFAULT_COMMIT_SUBJECT_TIMEOUT_MS: () => DEFAULT_COMMIT_SUBJECT_TIMEOUT_MS,
   DEFAULT_EXECUTION_MODE: () => DEFAULT_EXECUTION_MODE,
   DEFAULT_GLOBAL_SETTINGS: () => DEFAULT_GLOBAL_SETTINGS,
   DEFAULT_INSIGHT_SCHEDULE: () => DEFAULT_INSIGHT_SCHEDULE,
@@ -49189,6 +49391,7 @@ __export(src_exports, {
   InsightStore: () => InsightStore,
   MAX_COMMIT_BODY_INPUT_LENGTH: () => MAX_COMMIT_BODY_INPUT_LENGTH,
   MAX_COMMIT_BODY_LENGTH: () => MAX_COMMIT_BODY_LENGTH,
+  MAX_COMMIT_SUBJECT_LENGTH: () => MAX_COMMIT_SUBJECT_LENGTH,
   MAX_DESCRIPTION_LENGTH: () => MAX_DESCRIPTION_LENGTH,
   MAX_REQUESTS_PER_HOUR: () => MAX_REQUESTS_PER_HOUR,
   MAX_ROUTINE_RUN_HISTORY: () => MAX_ROUTINE_RUN_HISTORY,
@@ -49425,6 +49628,7 @@ __export(src_exports, {
   runGhAsync: () => runGhAsync,
   runGhJson: () => runGhJson,
   runGhJsonAsync: () => runGhJsonAsync,
+  sanitizeCommitSubject: () => sanitizeCommitSubject,
   scheduleQmdInstallAndRefresh: () => scheduleQmdInstallAndRefresh,
   scheduleQmdProjectMemoryRefresh: () => scheduleQmdProjectMemoryRefresh,
   searchProjectMemory: () => searchProjectMemory,
@@ -49434,6 +49638,7 @@ __export(src_exports, {
   slugify: () => slugify,
   sortTasksByPriorityThenAgeAndId: () => sortTasksByPriorityThenAgeAndId,
   summarizeCommitBody: () => summarizeCommitBody,
+  summarizeCommitSubject: () => summarizeCommitSubject,
   summarizeTitle: () => summarizeTitle,
   syncAutoSummarizeAutomation: () => syncAutoSummarizeAutomation,
   syncBackupAutomation: () => syncBackupAutomation,
@@ -56503,21 +56708,37 @@ function resetMergeWithWarn(rootDir, taskId, label) {
 async function buildDeterministicMergeMessage(params) {
   const { taskId, branch, commitLog, diffStat, includeTaskId, rootDir, settings, signal } = params;
   const prefix = includeTaskId ? `feat(${taskId})` : "feat";
-  const subject = `${prefix}: merge ${branch}`;
+  const fallbackSubject = `${prefix}: merge ${branch}`;
   const trimmedCommitLog = commitLog?.trim() ?? "";
   const trimmedDiffStat = diffStat?.trim() ?? "";
   const commitsSection = trimmedCommitLog.length > 0 ? trimmedCommitLog : `- merge ${branch}`;
   let aiSummary = null;
+  let aiSubject = null;
   if (rootDir && settings && (trimmedCommitLog.length > 0 || trimmedDiffStat.length > 0)) {
     const useTitleSummarizer = !!settings.titleSummarizerProvider && !!settings.titleSummarizerModelId;
     const provider = useTitleSummarizer ? settings.titleSummarizerProvider : settings.defaultProviderOverride && settings.defaultModelIdOverride ? settings.defaultProviderOverride : settings.defaultProvider;
     const modelId = useTitleSummarizer ? settings.titleSummarizerModelId : settings.defaultProviderOverride && settings.defaultModelIdOverride ? settings.defaultModelIdOverride : settings.defaultModelId;
-    aiSummary = await summarizeCommitBody(trimmedDiffStat, rootDir, provider, modelId, {
-      branch,
-      taskId,
-      commitLog: trimmedCommitLog,
-      signal
-    }).catch(() => null);
+    const [bodyResult, subjectResult] = await Promise.all([
+      summarizeCommitBody(trimmedDiffStat, rootDir, provider, modelId, {
+        branch,
+        taskId,
+        commitLog: trimmedCommitLog,
+        signal
+      }).catch(() => null),
+      summarizeCommitSubject(trimmedDiffStat, rootDir, provider, modelId, {
+        branch,
+        taskId,
+        commitLog: trimmedCommitLog,
+        signal
+      }).catch(() => null)
+    ]);
+    aiSummary = bodyResult;
+    aiSubject = subjectResult;
+  }
+  let subject = fallbackSubject;
+  if (aiSubject && aiSubject.length > 0) {
+    const candidate = `${prefix}: ${aiSubject}`;
+    subject = candidate.length > 72 ? candidate.slice(0, 72).trimEnd() : candidate;
   }
   const sections = [];
   if (aiSummary && aiSummary.trim().length > 0) {
@@ -56578,11 +56799,18 @@ async function commitOrAmendMergeWithFixes(rootDir, taskId, branch, commitLog, i
       );
       return false;
     }
+    const actualContext = await computeActualMergeCommitContext({
+      rootDir,
+      integrationTargetSha: preAttemptHeadSha,
+      branch
+    });
+    const messageCommitLog = actualContext.commitLog || commitLog;
+    const messageDiffStat = actualContext.diffStat || diffStat;
     const { subjectArg, bodyArg } = await buildDeterministicMergeMessage({
       taskId,
       branch,
-      commitLog,
-      diffStat,
+      commitLog: messageCommitLog,
+      diffStat: messageDiffStat,
       includeTaskId,
       rootDir,
       settings,
@@ -57034,6 +57262,52 @@ async function collectPatchIds(rootDir, target, windowSize) {
   }
   return ids;
 }
+async function computeActualMergeCommitContext(params) {
+  const { rootDir, integrationTargetSha, branch } = params;
+  const targetArg = quoteArg(integrationTargetSha);
+  let diffStat = "";
+  try {
+    const { stdout: stagedStat } = await execAsync2(
+      `git diff --cached ${targetArg} --stat`,
+      { cwd: rootDir, encoding: "utf-8" }
+    );
+    diffStat = stagedStat.trim();
+    if (diffStat.length === 0) {
+      const { stdout: headStat } = await execAsync2(
+        `git diff ${targetArg} HEAD --stat`,
+        { cwd: rootDir, encoding: "utf-8" }
+      );
+      diffStat = headStat.trim();
+    }
+  } catch {
+  }
+  let commitLog = "";
+  try {
+    const targetPatchIds = await collectPatchIds(rootDir, integrationTargetSha, 200);
+    const { stdout: branchShas } = await execAsync2(
+      `git log ${targetArg}..${quoteArg(branch)} --format=%H`,
+      { cwd: rootDir, encoding: "utf-8" }
+    );
+    const shas = branchShas.trim().split("\n").filter(Boolean);
+    const lines = [];
+    for (const sha of shas) {
+      const pid = await commitPatchId(rootDir, sha);
+      if (pid && targetPatchIds.has(pid)) continue;
+      try {
+        const { stdout: subj } = await execAsync2(
+          `git log -1 ${quoteArg(sha)} --format=%s`,
+          { cwd: rootDir, encoding: "utf-8" }
+        );
+        const s = subj.trim();
+        if (s) lines.push(`- ${s}`);
+      } catch {
+      }
+    }
+    commitLog = lines.join("\n");
+  } catch {
+  }
+  return { commitLog, diffStat };
+}
 async function listBranchCommits(rootDir, target, branch) {
   try {
     const { stdout } = await execAsync2(
@@ -58647,11 +58921,25 @@ async function executeMergeAttempt(params, aiTracker) {
     }
     try {
       const authorArg = getCommitAuthorArg(params.settings);
+      let integrationTargetSha;
+      try {
+        const { stdout } = await execAsync2("git rev-parse HEAD~1", {
+          cwd: rootDir,
+          encoding: "utf-8"
+        });
+        integrationTargetSha = stdout.trim() || void 0;
+      } catch {
+      }
+      const actualContext = integrationTargetSha ? await computeActualMergeCommitContext({
+        rootDir,
+        integrationTargetSha,
+        branch
+      }) : { commitLog: "", diffStat: "" };
       const { subjectArg, bodyArg } = await buildDeterministicMergeMessage({
         taskId,
         branch,
-        commitLog,
-        diffStat,
+        commitLog: actualContext.commitLog || commitLog,
+        diffStat: actualContext.diffStat || diffStat,
         includeTaskId,
         rootDir,
         settings: params.settings,
@@ -65483,30 +65771,27 @@ var init_effective_node = __esm({
 });
 
 // ../engine/src/node-routing-policy.ts
-function applyUnavailableNodePolicy(nodeStatus, policy, isLocal) {
-  if (isLocal) {
-    return { allowed: true, fallbackToLocal: false, reason: "local-execution" };
+function applyUnavailableNodePolicy(params) {
+  const { effectiveNode, nodeHealth, policy } = params;
+  if (effectiveNode.source === "local") {
+    return { allowed: true, fallbackToLocal: false };
   }
-  if (nodeStatus === void 0) {
-    return { allowed: true, fallbackToLocal: false, reason: "unknown-health" };
+  if (nodeHealth === "online" || nodeHealth === void 0) {
+    return { allowed: true, fallbackToLocal: false };
   }
-  if (nodeStatus === "online") {
-    return { allowed: true, fallbackToLocal: false, reason: "healthy" };
-  }
-  if (!UNHEALTHY_STATUSES.has(nodeStatus)) {
-    return { allowed: true, fallbackToLocal: false, reason: "healthy" };
+  if (!effectiveNode.nodeId || !UNHEALTHY_STATUSES.has(nodeHealth)) {
+    return { allowed: true, fallbackToLocal: false };
   }
   if (policy === "fallback-local") {
     return {
       allowed: true,
       fallbackToLocal: true,
-      reason: `fallback-local:${nodeStatus}`
+      reason: `Node ${effectiveNode.nodeId} is ${nodeHealth}; falling back to local per policy`
     };
   }
   return {
     allowed: false,
-    fallbackToLocal: false,
-    reason: `blocked:${nodeStatus}`
+    reason: `Node ${effectiveNode.nodeId} is ${nodeHealth}; policy is block`
   };
 }
 var UNHEALTHY_STATUSES;
@@ -65681,7 +65966,7 @@ var init_scheduler = __esm({
       /** Tracks mission-linked tasks observed with status=failed before moveTask clears status/error. */
       failedTaskIds = /* @__PURE__ */ new Set();
       /** Tracks tasks blocked by unavailable-node policy to deduplicate block log entries. */
-      blockedNodeTaskIds = /* @__PURE__ */ new Set();
+      wasNodeBlocked = /* @__PURE__ */ new Set();
       /**
        * Validate that a task's filesystem state is intact.
        * Checks that the task directory exists and PROMPT.md is present and non-empty.
@@ -65743,7 +66028,7 @@ var init_scheduler = __esm({
           this.options.missionAutopilot.stop();
         }
         this.failedTaskIds.clear();
-        this.blockedNodeTaskIds.clear();
+        this.wasNodeBlocked.clear();
         schedulerLog.log("Stopped");
       }
       /**
@@ -66005,35 +66290,24 @@ var init_scheduler = __esm({
             }
             let effectiveNode = resolveEffectiveNode(freshTask, settings);
             schedulerLog.log(`Task ${task.id} routed to node=${effectiveNode.nodeId ?? "local"} (source=${effectiveNode.source})`);
-            if (effectiveNode.nodeId !== void 0 && this.options.nodeHealthMonitor) {
-              const nodeStatus = this.options.nodeHealthMonitor.getNodeHealth(effectiveNode.nodeId);
-              const policyResult = applyUnavailableNodePolicy(
-                nodeStatus,
-                settings.unavailableNodePolicy,
-                false
-              );
-              if (!policyResult.allowed) {
-                if (!this.blockedNodeTaskIds.has(task.id)) {
-                  this.blockedNodeTaskIds.add(task.id);
-                  schedulerLog.log(
-                    `Task ${task.id} dispatch blocked \u2014 node ${effectiveNode.nodeId} is ${nodeStatus ?? "unknown"} (policy: block)`
-                  );
-                  await this.store.logEntry(
-                    task.id,
-                    `Routing blocked: node ${effectiveNode.nodeId} is ${nodeStatus ?? "unknown"}, policy=block`
-                  );
+            if (effectiveNode.nodeId && this.options.nodeHealthMonitor) {
+              const nodeHealth = this.options.nodeHealthMonitor.getNodeHealth(effectiveNode.nodeId);
+              const decision = applyUnavailableNodePolicy({
+                effectiveNode,
+                nodeHealth,
+                policy: settings.unavailableNodePolicy
+              });
+              if (!decision.allowed) {
+                if (!this.wasNodeBlocked.has(task.id)) {
+                  this.wasNodeBlocked.add(task.id);
+                  schedulerLog.warn(`Task ${task.id} blocked: ${decision.reason}`);
+                  await this.store.logEntry(task.id, decision.reason);
                 }
                 continue;
               }
-              this.blockedNodeTaskIds.delete(task.id);
-              if (policyResult.fallbackToLocal) {
-                schedulerLog.log(
-                  `Task ${task.id} falling back to local \u2014 node ${effectiveNode.nodeId} is ${nodeStatus ?? "unknown"} (policy: fallback-local)`
-                );
-                await this.store.logEntry(
-                  task.id,
-                  `Routing fallback to local: node ${effectiveNode.nodeId} is ${nodeStatus ?? "unknown"}, policy=fallback-local`
-                );
+              if (decision.fallbackToLocal) {
+                schedulerLog.log(`Task ${task.id} falling back to local: ${decision.reason}`);
+                await this.store.logEntry(task.id, decision.reason);
                 effectiveNode = { nodeId: void 0, source: "local" };
               }
             }
@@ -66047,6 +66321,7 @@ var init_scheduler = __esm({
               effectiveNodeSource: effectiveNode.source
             });
             await this.store.moveTask(task.id, "in-progress");
+            this.wasNodeBlocked.delete(task.id);
             await this.store.logEntry(task.id, `Node routing resolved: ${effectiveNode.nodeId ?? "local"} (source: ${effectiveNode.source})`);
             this.options.onSchedule?.(task);
             started++;
@@ -71130,6 +71405,7 @@ When sending messages:
             }
             const agentHasIdentity = hasAgentIdentity(agent);
             const isAgentEphemeral = isEphemeralAgent(agent);
+            const canRunNoTaskHeartbeat = agentHasIdentity && !isAgentEphemeral;
             let taskId = explicitTaskId ?? agent.taskId;
             let inboxSelection = null;
             if (!taskId) {
@@ -71166,7 +71442,7 @@ When sending messages:
               engineRunContext.taskId = taskId;
             }
             if (!taskId) {
-              if (!agentHasIdentity || isAgentEphemeral) {
+              if (!canRunNoTaskHeartbeat) {
                 heartbeatLog.log(`Agent ${agentId} has no task assignment \u2014 graceful exit`);
                 await this.completeRun(agentId, run.id, {
                   status: "completed",
@@ -71176,7 +71452,7 @@ When sending messages:
               }
               heartbeatLog.log(`Agent ${agentId} has no task but has identity \u2014 running no-task heartbeat`);
             }
-            const isNoTaskRun = !taskId;
+            let isNoTaskRun = !taskId;
             if (!isNoTaskRun) {
               const validStates = ["active", "running", "idle"];
               if (!validStates.includes(agent.state)) {
@@ -71202,53 +71478,99 @@ When sending messages:
                 });
                 return await this.store.getRunDetail(agentId, run.id);
               }
-              if (taskDetail.checkedOutBy && taskDetail.checkedOutBy !== agentId) {
-                heartbeatLog.warn(
-                  `Agent ${agentId} does not hold checkout for ${resolvedTaskId2} (held by ${taskDetail.checkedOutBy}) \u2014 graceful exit`
-                );
-                await this.completeRun(agentId, run.id, {
-                  status: "completed",
-                  resultJson: {
-                    reason: "checkout_conflict",
-                    taskId: resolvedTaskId2,
-                    checkedOutBy: taskDetail.checkedOutBy
+              if (taskDetail.column === "done" || taskDetail.column === "archived") {
+                if (agent.taskId === resolvedTaskId2) {
+                  heartbeatLog.log(
+                    `Agent ${agentId} linked task ${resolvedTaskId2} is ${taskDetail.column} \u2014 clearing assignment and running heartbeat without task context`
+                  );
+                  try {
+                    await this.store.assignTask(agentId, void 0, runContext);
+                  } catch (clearErr) {
+                    heartbeatLog.warn(
+                      `Failed to clear terminal task assignment ${resolvedTaskId2} for ${agentId}: ${clearErr instanceof Error ? clearErr.message : String(clearErr)}`
+                    );
                   }
-                });
-                return await this.store.getRunDetail(agentId, run.id);
+                  taskId = void 0;
+                  taskDetail = void 0;
+                  isNoTaskRun = true;
+                  if (!canRunNoTaskHeartbeat) {
+                    await this.completeRun(agentId, run.id, {
+                      status: "completed",
+                      resultJson: { reason: "no_assignment" }
+                    });
+                    return await this.store.getRunDetail(agentId, run.id);
+                  }
+                } else {
+                  heartbeatLog.log(
+                    `Heartbeat for ${agentId} targeted terminal task ${resolvedTaskId2} (${taskDetail.column}) \u2014 graceful exit`
+                  );
+                  await this.completeRun(agentId, run.id, {
+                    status: "completed",
+                    resultJson: { reason: "terminal_task", taskId: resolvedTaskId2, column: taskDetail.column }
+                  });
+                  return await this.store.getRunDetail(agentId, run.id);
+                }
               }
-              const blockedBy = typeof taskDetail.blockedBy === "string" ? taskDetail.blockedBy.trim() : "";
-              const isBlockedTask = taskDetail.status === "queued" && blockedBy.length > 0;
-              if (isBlockedTask) {
-                const commentCount = (taskDetail.comments?.length ?? 0) + (taskDetail.steeringComments?.length ?? 0);
-                const lastCommentId = taskDetail.comments?.at(-1)?.id;
-                const lastSteeringCommentId = taskDetail.steeringComments?.at(-1)?.id;
-                const contextHash = Buffer.from(
-                  JSON.stringify({ commentCount, lastCommentId, lastSteeringCommentId, blockedBy })
-                ).toString("base64").slice(0, 16);
-                const currentBlockedState = {
-                  taskId: resolvedTaskId2,
-                  blockedBy,
-                  recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
-                  contextHash
-                };
-                const previousBlockedState = await this.store.getLastBlockedState(agentId);
-                if (previousBlockedState && isBlockedStateDuplicate(currentBlockedState, previousBlockedState)) {
+              if (isNoTaskRun) {
+                heartbeatLog.log(`Agent ${agentId} terminal task assignment resolved into no-task heartbeat`);
+              } else {
+                const liveTaskDetail = taskDetail;
+                if (!liveTaskDetail) {
+                  heartbeatLog.warn(`Task ${resolvedTaskId2} lost detail after terminal-assignment handling \u2014 graceful exit`);
                   await this.completeRun(agentId, run.id, {
                     status: "completed",
-                    resultJson: { reason: "blocked_duplicate", taskId: resolvedTaskId2, blockedBy }
+                    resultJson: { reason: "task_not_found", taskId: resolvedTaskId2 }
+                  });
+                  return await this.store.getRunDetail(agentId, run.id);
+                }
+                if (liveTaskDetail.checkedOutBy && liveTaskDetail.checkedOutBy !== agentId) {
+                  heartbeatLog.warn(
+                    `Agent ${agentId} does not hold checkout for ${resolvedTaskId2} (held by ${liveTaskDetail.checkedOutBy}) \u2014 graceful exit`
+                  );
+                  await this.completeRun(agentId, run.id, {
+                    status: "completed",
+                    resultJson: {
+                      reason: "checkout_conflict",
+                      taskId: resolvedTaskId2,
+                      checkedOutBy: liveTaskDetail.checkedOutBy
+                    }
+                  });
+                  return await this.store.getRunDetail(agentId, run.id);
+                }
+                const blockedBy = typeof liveTaskDetail.blockedBy === "string" ? liveTaskDetail.blockedBy.trim() : "";
+                const isBlockedTask = liveTaskDetail.status === "queued" && blockedBy.length > 0;
+                if (isBlockedTask) {
+                  const commentCount = (liveTaskDetail.comments?.length ?? 0) + (liveTaskDetail.steeringComments?.length ?? 0);
+                  const lastCommentId = liveTaskDetail.comments?.at(-1)?.id;
+                  const lastSteeringCommentId = liveTaskDetail.steeringComments?.at(-1)?.id;
+                  const contextHash = Buffer.from(
+                    JSON.stringify({ commentCount, lastCommentId, lastSteeringCommentId, blockedBy })
+                  ).toString("base64").slice(0, 16);
+                  const currentBlockedState = {
+                    taskId: resolvedTaskId2,
+                    blockedBy,
+                    recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                    contextHash
+                  };
+                  const previousBlockedState = await this.store.getLastBlockedState(agentId);
+                  if (previousBlockedState && isBlockedStateDuplicate(currentBlockedState, previousBlockedState)) {
+                    await this.completeRun(agentId, run.id, {
+                      status: "completed",
+                      resultJson: { reason: "blocked_duplicate", taskId: resolvedTaskId2, blockedBy }
+                    });
+                    return await this.store.getRunDetail(agentId, run.id);
+                  }
+                  const blockedMessage = `Task is blocked by ${blockedBy}; waiting for dependency/context changes before retrying.`;
+                  await taskStore.addComment(resolvedTaskId2, blockedMessage, "agent", void 0, runContext);
+                  await audit.database({ type: "task:comment:add", target: resolvedTaskId2, metadata: { blockedBy } });
+                  await this.store.setLastBlockedState(agentId, currentBlockedState);
+                  heartbeatLog.log(`Task ${resolvedTaskId2} is blocked by ${blockedBy} \u2014 recorded blocked state`);
+                  await this.completeRun(agentId, run.id, {
+                    status: "completed",
+                    resultJson: { reason: "blocked", taskId: resolvedTaskId2, blockedBy }
                   });
                   return await this.store.getRunDetail(agentId, run.id);
                 }
-                const blockedMessage = `Task is blocked by ${blockedBy}; waiting for dependency/context changes before retrying.`;
-                await taskStore.addComment(resolvedTaskId2, blockedMessage, "agent", void 0, runContext);
-                await audit.database({ type: "task:comment:add", target: resolvedTaskId2, metadata: { blockedBy } });
-                await this.store.setLastBlockedState(agentId, currentBlockedState);
-                heartbeatLog.log(`Task ${resolvedTaskId2} is blocked by ${blockedBy} \u2014 recorded blocked state`);
-                await this.completeRun(agentId, run.id, {
-                  status: "completed",
-                  resultJson: { reason: "blocked", taskId: resolvedTaskId2, blockedBy }
-                });
-                return await this.store.getRunDetail(agentId, run.id);
               }
             }
             if (!isNoTaskRun) {
@@ -79360,6 +79682,7 @@ __export(src_exports2, {
   WebhookNotificationProvider: () => WebhookNotificationProvider,
   WorktreePool: () => WorktreePool,
   aiMergeTask: () => aiMergeTask,
+  applyUnavailableNodePolicy: () => applyUnavailableNodePolicy,
   buildAgentChatPrompt: () => buildAgentChatPrompt,
   buildNtfyClickUrl: () => buildNtfyClickUrl,
   buildRuntimeResolutionContext: () => buildRuntimeResolutionContext,
@@ -79443,6 +79766,7 @@ var init_src2 = __esm({
     init_project_engine();
     init_project_engine_manager();
     init_node_health_monitor();
+    init_node_routing_policy();
     init_peer_exchange_service();
     init_remote_access();
     init_remote_node_client();
@@ -92902,6 +93226,13 @@ function registerSettingsMemoryRoutes(ctx, deps) {
       if (clientSettings.archiveAgentLogMode !== void 0 && !["none", "compact", "full"].includes(clientSettings.archiveAgentLogMode)) {
         throw badRequest("archiveAgentLogMode must be one of: none, compact, full");
       }
+      if (clientSettings.unavailableNodePolicy !== void 0) {
+        const validatedUnavailableNodePolicy = validateUnavailableNodePolicy(clientSettings.unavailableNodePolicy);
+        if (validatedUnavailableNodePolicy === void 0) {
+          throw badRequest("unavailableNodePolicy must be one of: block, fallback-local");
+        }
+        clientSettings.unavailableNodePolicy = validatedUnavailableNodePolicy;
+      }
       if (clientSettings.memoryBackendType !== void 0) {
         if (clientSettings.memoryBackendType !== null && typeof clientSettings.memoryBackendType !== "string") {
           throw badRequest("memoryBackendType must be a string or null");