@gethmy/agent 1.30.0 → 1.31.0

package/dist/cli.js

@@ -834,7 +834,7 @@ function isDaemonAuthoredComment(comment, identity) {
   return true;
 }
 // ../harmony-shared/dist/agentStaleness.js
-var AGENT_HEARTBEAT_LIVENESS_MS, AGENT_MILESTONE_LIVENESS_MS, AGENT_SWEEP_DAEMON_MS, AGENT_SWEEP_INTERACTIVE_MS, AGENT_SWEEP_PAUSED_MS, SWEPT_SESSION_WRITE_GRACE_MS, ACTIVE_STATUSES;
+var AGENT_HEARTBEAT_LIVENESS_MS, AGENT_MILESTONE_LIVENESS_MS, AGENT_SWEEP_DAEMON_MS, AGENT_SWEEP_INTERACTIVE_MS, AGENT_SWEEP_PAUSED_MS, SWEPT_SESSION_WRITE_GRACE_MS, ACTIVE_STATUSES, NOTICE_DRIVER = "notice";
 var init_agentStaleness = __esm(() => {
   AGENT_HEARTBEAT_LIVENESS_MS = 5 * 60 * 1000;
   AGENT_MILESTONE_LIVENESS_MS = 30 * 60 * 1000;
@@ -893,6 +893,37 @@ function recordsPushedWorkOn(description, branchName) {
   }
   return false;
 }
+function recordedBranchForCard(description, shortId, branchPrefixes) {
+  if (!description || !Number.isFinite(shortId))
+    return null;
+  const anchors = [
+    ...new Set(branchPrefixes.filter((p) => p.length > 0)),
+    ""
+  ];
+  let recorded = null;
+  for (const match of description.matchAll(DAEMON_BRANCH_LINE_PATTERN)) {
+    const ref = match[1];
+    if (!ref || !SAFE_GIT_REF_PATTERN.test(ref))
+      continue;
+    if (anchors.some((p) => ref.startsWith(`${p}${shortId}-`)))
+      recorded = ref;
+  }
+  return recorded;
+}
+function rewriteDaemonBranchLines(description, fromRef, toRef2) {
+  if (!description || !fromRef || !toRef2)
+    return null;
+  if (!SAFE_GIT_REF_PATTERN.test(toRef2))
+    return null;
+  let matched = false;
+  const rewritten = description.replace(DAEMON_BRANCH_LINE_PATTERN, (line, ref) => {
+    if (ref !== fromRef)
+      return line;
+    matched = true;
+    return line.replace(`\`${ref}\``, `\`${toRef2}\``);
+  });
+  return matched ? rewritten : null;
+}
 var BRANCH_REF_PATTERN, DAEMON_BRANCH_LINE_PATTERN, SAFE_GIT_REF_PATTERN, PR_LINK_PATTERN;
 var init_branchRef = __esm(() => {
   BRANCH_REF_PATTERN = /Branch:\s*`([^`]+)`/g;
@@ -1641,6 +1672,18 @@ function entryActionAllowlist(entryAction) {
 function stageDisallowedTools() {
   return STAGE_DAEMON_OWNED_TOOLS.length > 0 ? STAGE_DAEMON_OWNED_TOOLS.join(",") : null;
 }
+function toolsCanCommit(allowedTools) {
+  return allowedTools.split(",").map((t) => t.trim().replace(/\(.*$/, "")).some((t) => COMMIT_CAPABLE_TOOLS.includes(t));
+}
+function stageRunExpectsCommit(stage, allowedTools) {
+  if (!toolsCanCommit(allowedTools))
+    return false;
+  const artifact = stage.artifact_type;
+  if (artifact !== null && artifact !== undefined && NON_DIFF_ARTIFACTS.includes(artifact)) {
+    return false;
+  }
+  return true;
+}
 function customGateMetric(gate) {
   if (gate === null || typeof gate !== "object" || Array.isArray(gate)) {
     return null;
@@ -1677,7 +1720,7 @@ function referencedGateMetrics(def) {
   }
   return out;
 }
-var DEFAULT_LOOP_MAX_ITERATIONS = 5, DEFAULT_LOOP_CONCURRENCY = 1, DEFAULT_ON_ITEM_FAIL = "continue", PLAYBOOK_STAGE_ROLES, SKILL_TOOL_ALLOWLIST, HARMONY_TOOL_RE, STAGE_DAEMON_OWNED_TOOLS;
+var DEFAULT_LOOP_MAX_ITERATIONS = 5, DEFAULT_LOOP_CONCURRENCY = 1, DEFAULT_ON_ITEM_FAIL = "continue", PLAYBOOK_STAGE_ROLES, SKILL_TOOL_ALLOWLIST, HARMONY_TOOL_RE, STAGE_DAEMON_OWNED_TOOLS, COMMIT_CAPABLE_TOOLS, NON_DIFF_ARTIFACTS;
 var init_playbookStage = __esm(() => {
   PLAYBOOK_STAGE_ROLES = [
     "author",
@@ -1698,11 +1741,20 @@ var init_playbookStage = __esm(() => {
     "mcp__harmony__harmony_start_agent_session",
     "mcp__harmony__harmony_move_card"
   ];
+  COMMIT_CAPABLE_TOOLS = ["Bash", "Write", "Edit"];
+  NON_DIFF_ARTIFACTS = ["plan", "review", "document", "decision"];
 });
 
 // ../harmony-shared/dist/projectTemplates.js
 var init_projectTemplates = () => {};
 
+// ../harmony-shared/dist/realtimeChannel.js
+var inFlightDetach;
+var init_realtimeChannel = __esm(() => {
+  init_logger();
+  inFlightDetach = new WeakMap;
+});
+
 // ../harmony-shared/dist/reviewMethodology.js
 var REVIEW_SYSTEM_PROMPT = `You are a senior code reviewer. Follow this two-pass methodology strictly.
 Report findings; do NOT fix them. This is a read-only review.
@@ -2023,6 +2075,7 @@ var init_dist = __esm(() => {
   init_playbookCatalog();
   init_playbookStage();
   init_projectTemplates();
+  init_realtimeChannel();
   init_reviewTools();
   init_stageHandoff();
   init_types();
@@ -2331,12 +2384,12 @@ var init_plan_phase = __esm(() => {
 
 // src/types.ts
 function agentIdentifier(workerId) {
-  return `harmony-daemon-${workerId}`;
+  return `${DAEMON_IDENTIFIER_BASE}-${workerId}`;
 }
 function endStatusForCancel(reason) {
   return reason === "human_stop" ? "cancelled" : "paused";
 }
-var DEFAULT_AGENT_CONFIG, IN_PROGRESS_COLUMN = "In Progress", NEED_REVIEW_LABEL = "Need Review", NEED_REVIEW_LABEL_COLOR = "#f59e0b", AGENT_NAME = "Harmony Agent";
+var DEFAULT_AGENT_CONFIG, IN_PROGRESS_COLUMN = "In Progress", NEED_REVIEW_LABEL = "Need Review", NEED_REVIEW_LABEL_COLOR = "#f59e0b", AGENT_NAME = "Harmony Agent", DAEMON_IDENTIFIER_BASE = "harmony-daemon", NOTICE_IDENTIFIER;
 var init_types2 = __esm(() => {
   init_board_review();
   init_contract_phase();
@@ -2468,6 +2521,7 @@ var init_types2 = __esm(() => {
       maxCardsPerSweep: 10
     }
   };
+  NOTICE_IDENTIFIER = `${DAEMON_IDENTIFIER_BASE}-notice`;
 });
 
 // src/config.ts
@@ -5103,6 +5157,7 @@ import {
   captureDiffStat,
   createPullRequest,
   detectGitProvider as detectGitProvider3,
+  extractPrUrl as extractPrUrl2,
   getBranchWebUrl,
   log as log16,
   pushBranch,
@@ -5141,7 +5196,7 @@ function buildTokenPayload(stats) {
     numTurns: stats.cost.numTurns
   };
 }
-async function runCompletion(client, card, branchName, worktreePath, config, workerId, sessionIdentifier, agentId, sessionStats, workspaceId, agentSessionId, stateStore, onMovedToCompletion, onBeforeWorktreeCleanup, runBaselineSha, effectiveMaxTurns) {
+async function runCompletion(client, card, branchName, worktreePath, config, workerId, sessionIdentifier, agentId, sessionStats, workspaceId, agentSessionId, stateStore, onMovedToCompletion, onBeforeWorktreeCleanup, runBaselineSha, effectiveMaxTurns, expectsCommits) {
   let verificationResult = {
     passed: true,
     buildErrors: [],
@@ -5161,6 +5216,20 @@ async function runCompletion(client, card, branchName, worktreePath, config, wor
       log16.warn(TAG15, `No commits on branch ${branchName} — ${failureSummary}; parking for a decision`);
       return "park";
     }
+    if (expectsCommits === false) {
+      log16.info(TAG15, `No commits on branch ${branchName} — this stage's deliverable is not a diff; its gate decides the run`);
+      if (onBeforeWorktreeCleanup) {
+        try {
+          await onBeforeWorktreeCleanup(worktreePath);
+        } catch (err) {
+          log16.warn(TAG15, `onBeforeWorktreeCleanup hook failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+        }
+      } else {
+        await endRunSession({ client, tag: TAG15 }, card, { status: "completed" }, buildTokenPayload(sessionStats), "throw");
+      }
+      await teardownWorktree(client, card.id, worktreePath, branchName);
+      return true;
+    }
     log16.warn(TAG15, `No commits on branch ${branchName} — ${failureSummary}; counting as a failed attempt`);
     const noCommitHandback = await guardedHandback(client, card.id, {
       agentId,
@@ -5187,6 +5256,9 @@ async function runCompletion(client, card, branchName, worktreePath, config, wor
     log16.error(TAG15, `pre-verify push failed for ${branchName}: ${err instanceof Error ? err.message : err}`);
   }
   const recoveryUrl = lastPushedSha ? getBranchWebUrl(branchName, worktreePath) : null;
+  if (lastPushedSha) {
+    await recordBranchProvenance(client, card, branchName);
+  }
   if (config.verification.enabled) {
     await client.updateAgentProgress(card.id, {
       agentIdentifier: sessionIdentifier,
@@ -5283,17 +5355,16 @@ async function runCompletion(client, card, branchName, worktreePath, config, wor
   if (config.completion.postSummary) {
     await postSummary(client, card, branchName, worktreePath, prUrl, config.worktree.baseBranch, sessionStats);
   }
-  let endDisposition = { status: "completed" };
   if (onBeforeWorktreeCleanup) {
     try {
-      const disposition = await onBeforeWorktreeCleanup(worktreePath);
-      if (disposition)
-        endDisposition = disposition;
+      await onBeforeWorktreeCleanup(worktreePath);
     } catch (err) {
       log16.warn(TAG15, `onBeforeWorktreeCleanup hook failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
     }
   }
-  await endRunSession({ client, tag: TAG15 }, card, endDisposition, buildTokenPayload(sessionStats), "throw");
+  if (!onBeforeWorktreeCleanup) {
+    await endRunSession({ client, tag: TAG15 }, card, { status: "completed" }, buildTokenPayload(sessionStats), "throw");
+  }
   if (workspaceId) {
     const diffStat = captureDiffStat(worktreePath, config.worktree.baseBranch);
     const changedFiles = diffStat && diffStat.files.length > 0 ? diffStat.files : sessionStats?.filesEditedPaths ?? [];
@@ -5397,18 +5468,47 @@ function checkHasCommits(worktreePath, baseBranch, baselineSha, gitImpl = (args,
     return false;
   }
 }
+function stripDaemonBlocks(description) {
+  const indices = [SUMMARY_MARKER, BRANCH_PROVENANCE_MARKER].map((marker) => description.indexOf(marker)).filter((index) => index >= 0);
+  if (indices.length === 0)
+    return description;
+  return description.slice(0, Math.min(...indices)).trimEnd();
+}
+async function recordBranchProvenance(client, card, branchName) {
+  try {
+    let description = card.description || "";
+    try {
+      const { card: latest } = await client.getCard(card.id);
+      description = latest.description ?? description;
+    } catch {}
+    if (recordsPushedWorkOn(description, branchName))
+      return;
+    const block = `
+
+${BRANCH_PROVENANCE_MARKER} (pushed — a later run continues it)
+Branch: \`${branchName}\``;
+    await client.updateCard(card.id, { description: description + block });
+    log16.info(TAG15, `Recorded branch provenance on #${card.short_id}`);
+  } catch (err) {
+    log16.warn(TAG15, `Failed to record branch provenance on #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+  }
+}
 async function postSummary(client, card, branchName, worktreePath, prUrl, baseBranch, sessionStats) {
   let commitLog = "";
   try {
     commitLog = execFileSync5("git", ["log", "--oneline", `origin/${baseBranch}..HEAD`], { cwd: worktreePath, encoding: "utf-8" }).trim();
   } catch {}
-  const SUMMARY_MARKER = `---
-**Agent completed**`;
+  let existingDesc = card.description || "";
+  try {
+    const { card: latest } = await client.getCard(card.id);
+    existingDesc = latest.description ?? existingDesc;
+  } catch {}
+  const carriedPrUrl = prUrl ?? extractPrUrl2(existingDesc);
   const parts = [`
 
 ${SUMMARY_MARKER}`];
-  if (prUrl) {
-    parts.push(`PR: ${prUrl}`);
+  if (carriedPrUrl) {
+    parts.push(`PR: ${carriedPrUrl}`);
   }
   parts.push(`Branch: \`${branchName}\``);
   if (sessionStats) {
@@ -5439,8 +5539,7 @@ ${commitLog}
 \`\`\``);
   }
   try {
-    const existingDesc = card.description || "";
-    const baseDesc = existingDesc.includes(SUMMARY_MARKER) ? existingDesc.slice(0, existingDesc.indexOf(SUMMARY_MARKER)).trimEnd() : existingDesc;
+    const baseDesc = stripDaemonBlocks(existingDesc);
     await client.updateCard(card.id, {
       description: baseDesc + parts.join(`
 `)
@@ -5450,8 +5549,11 @@ ${commitLog}
     log16.error(TAG15, `Failed to post summary: ${err instanceof Error ? err.message : err}`);
   }
 }
-var TAG15 = "completion";
+var TAG15 = "completion", SUMMARY_MARKER = `---
+**Agent completed**`, BRANCH_PROVENANCE_MARKER = `---
+**Agent branch**`;
 var init_completion = __esm(() => {
+  init_dist();
   init_board_helpers();
   init_episode_writer();
   init_handback();
@@ -5838,6 +5940,9 @@ var init_progress_tracker = __esm(() => {
 
 // src/prompt.ts
 import { log as log18 } from "@gethmy/harness";
+import {
+  buildMemoryQuery
+} from "@gethmy/mcp/src/api-client.js";
 function buildSteeringPrompt(messages) {
   if (messages.length === 1)
     return messages[0];
@@ -5870,11 +5975,11 @@ function renderPreviousAttemptsSection(failures) {
   ].join(`
 `);
 }
-async function buildPrompt(enriched, branchName, worktreePath, client, workspaceId, projectId) {
+async function buildPrompt(enriched, branchName, worktreePath, client, workspaceId, projectId, onRecallOutcome) {
   const { card } = enriched;
   const [pastEpisodesSection, referenceSection] = await Promise.all([
-    renderPastEpisodesSection(client, card.title, card.description ?? "", workspaceId, projectId),
-    renderReferenceSection(client, card.title, card.description ?? "", workspaceId, projectId)
+    renderPastEpisodesSection(client, card.title, card.description ?? "", workspaceId, projectId, onRecallOutcome),
+    renderReferenceSection(client, card.title, card.description ?? "", workspaceId, projectId, onRecallOutcome)
   ]);
   try {
     const result = await client.generateCardPrompt({
@@ -5915,12 +6020,11 @@ ${section}` : "";
     return "";
   }
 }
-async function renderPastEpisodesSection(client, title, description, workspaceId, projectId) {
+async function renderPastEpisodesSection(client, title, description, workspaceId, projectId, onOutcome) {
   if (!projectId)
     return "";
   try {
-    const query = `${title}
-${description}`.trim();
+    const query = buildMemoryQuery(title, description);
     const { entities } = await client.harmonyRecall({
       workspaceId,
       projectId,
@@ -5932,6 +6036,7 @@ ${description}`.trim();
       includeEpisodes: true,
       consumer: "agent-prompt"
     });
+    onOutcome?.({ flavour: "past_episodes", count: entities.length });
     if (entities.length === 0)
       return "";
     const bullets = entities.map((entity) => {
@@ -5960,17 +6065,18 @@ ${description}`.trim();
 ## Similar past tasks
 ${bullets}`;
   } catch (err) {
+    const error = err instanceof Error ? err.message : String(err);
     log18.warn(TAG17, "past-episodes recall failed", {
       event: "episode_recall_failed",
-      error: err instanceof Error ? err.message : String(err)
+      error
     });
+    onOutcome?.({ flavour: "past_episodes", count: 0, failure: error });
     return "";
   }
 }
-async function renderReferenceSection(client, title, description, workspaceId, projectId) {
+async function renderReferenceSection(client, title, description, workspaceId, projectId, onOutcome) {
   try {
-    const query = `${title}
-${description}`.trim();
+    const query = buildMemoryQuery(title, description);
     const { entities } = await client.harmonyRecall({
       workspaceId,
       projectId,
@@ -5979,6 +6085,7 @@ ${description}`.trim();
       topK: 5,
       consumer: "agent-prompt"
     });
+    onOutcome?.({ flavour: "reference", count: entities.length });
     if (entities.length === 0)
       return "";
     const bullets = entities.map((entity) => {
@@ -5993,10 +6100,12 @@ ${description}`.trim();
 ## How we work here
 ${bullets}`;
   } catch (err) {
+    const error = err instanceof Error ? err.message : String(err);
     log18.warn(TAG17, "reference recall failed", {
       event: "reference_recall_failed",
-      error: err instanceof Error ? err.message : String(err)
+      error
     });
+    onOutcome?.({ flavour: "reference", count: 0, failure: error });
     return "";
   }
 }
@@ -6056,7 +6165,7 @@ import {
   cleanupWorktree as cleanupWorktree3,
   createPullRequest as createPullRequest2,
   detectGitProvider as detectGitProvider4,
-  extractPrUrl as extractPrUrl2,
+  extractPrUrl as extractPrUrl3,
   getBranchWebUrl as getBranchWebUrl2,
   getHeadSha,
   log as log19,
@@ -6354,19 +6463,31 @@ ${runLogTail}
       }
     }
     await addLabelByName(client, card, config.review.approvedLabel, config.review.approvedLabelColor);
-    if (prUrl) {
+    const renamedFrom = branchName && approvedBranch && approvedBranch !== branchName ? branchName : null;
+    const renamedTo = renamedFrom ? approvedBranch : null;
+    if (prUrl || renamedFrom) {
       try {
         const { card: latest } = await client.getCard(card.id);
-        const desc = latest.description || "";
-        if (!extractPrUrl2(desc)) {
+        let desc = latest.description || "";
+        let changed = false;
+        if (renamedFrom && renamedTo) {
+          const rewritten = rewriteDaemonBranchLines(desc, renamedFrom, renamedTo);
+          if (rewritten !== null) {
+            desc = rewritten;
+            changed = true;
+          }
+        }
+        if (prUrl && !extractPrUrl3(desc)) {
           const separator = desc ? `
 ` : "";
-          await client.updateCard(card.id, {
-            description: `${desc}${separator}PR: ${prUrl}`
-          });
+          desc = `${desc}${separator}PR: ${prUrl}`;
+          changed = true;
+        }
+        if (changed) {
+          await client.updateCard(card.id, { description: desc });
         }
       } catch (err) {
-        log19.warn(TAG18, `Failed to persist PR URL to #${card.short_id} description: ${err instanceof Error ? err.message : err}`);
+        log19.warn(TAG18, `Failed to persist PR URL / branch rename to #${card.short_id} description: ${err instanceof Error ? err.message : err}`);
       }
     }
     if (branchName) {
@@ -6543,6 +6664,7 @@ ${runLogTail}
 var TAG18 = "review-completion", MAX_FINDINGS = 10, MAX_SUBTASK_TITLE = 120, COMMENT_BODY_BUDGET = 9500, REVIEW_MARKER = `---
 **Review:`, RUN_LOG_TAIL_BYTES = 2048;
 var init_review_completion = __esm(() => {
+  init_dist();
   init_board_helpers();
   init_completion();
   init_episode_writer();
@@ -9086,6 +9208,9 @@ var init_motor_driver = () => {};
 
 // src/stage-advance.ts
 import { gateConfigErrorReason, log as log29 } from "@gethmy/harness";
+function endDispositionFor(outcome) {
+  return "endDisposition" in outcome && outcome.endDisposition ? outcome.endDisposition : { status: "completed" };
+}
 function handoffText(stage) {
   if (stage.handoff && typeof stage.handoff === "object") {
     const summary = stage.handoff.summary ?? stage.handoff.description;
@@ -9094,16 +9219,6 @@ function handoffText(stage) {
   }
   return stage.name;
 }
-function stageEndDisposition(evaluation, _stage, stageIndex, def) {
-  if (!evaluation?.passed)
-    return { status: "completed" };
-  const next = nextStageAfter(def, stageIndex);
-  if (next.kind === "next" && next.stage.owner === "human") {
-    const reason = `Stage "${next.stage.name}" is yours: ${handoffText(next.stage)}`;
-    return { status: "blocked", blockers: [reason] };
-  }
-  return { status: "completed" };
-}
 function gateKindOf(stage) {
   return stage.gate && typeof stage.gate === "object" ? String(stage.gate.kind ?? "gate") : "gate";
 }
@@ -9161,9 +9276,9 @@ async function holdGateMisconfigured(card, stage, detail, deps) {
       currentTask: reason
     });
   } catch {}
-  await holdForHuman(deps.client, card, reason, deps.runId, deps.stateStore);
+  const endDisposition = await holdForHuman(deps.client, card, reason, deps.runId, deps.stateStore);
   log29.info(TAG27, `#${card.short_id} GateMisconfigured: ${reason}`);
-  return { kind: "held_misconfigured", reason };
+  return { kind: "held_misconfigured", reason, endDisposition };
 }
 function firstErrorMessage(evaluation) {
   const e = evaluation?.findings.find((f) => f.level === "error");
@@ -9232,13 +9347,9 @@ async function advanceConvergeLoop(card, stage, stageIndex, def, evaluation, loo
         currentTask: reason
       });
     } catch {}
-    await holdForHuman(deps.client, card, reason, deps.runId, deps.stateStore, {
-      keepAttempts: true,
-      endStatus: "blocked",
-      blockers: [reason]
-    });
+    const endDisposition = await holdForHuman(deps.client, card, reason, deps.runId, deps.stateStore, { keepAttempts: true, endStatus: "blocked", blockers: [reason] });
     log29.info(TAG27, `#${card.short_id} LoopExhausted: ${reason}`);
-    return { kind: "held_gate_unmet", reason };
+    return { kind: "held_gate_unmet", reason, endDisposition };
   }
   const guard = await guardStageReclaim(card, `converge-loop iteration of "${stage.name}"`, deps);
   if (!guard.proceed) {
@@ -9311,14 +9422,14 @@ async function advanceStageOnGate(card, stage, stageIndex, def, evaluation, deps
   }
   if (next.kind === "out_of_range") {
     const reason = `Stage advancement aborted: stage index ${stageIndex} is out of range for the pinned playbook version — holding for a human.`;
-    await holdForHuman(deps.client, card, reason, deps.runId, deps.stateStore);
-    return { kind: "held_misconfigured", reason };
+    const endDisposition = await holdForHuman(deps.client, card, reason, deps.runId, deps.stateStore);
+    return { kind: "held_misconfigured", reason, endDisposition };
   }
   const toColumn = await resolveStageColumnName(deps.client, card, next.stage);
   if (!toColumn) {
     const reason = `Stage "${stage.name}" passed but the next stage "${next.stage.name}" has no resolvable board column — holding for a human (never moving to an undefined column).`;
-    await holdForHuman(deps.client, card, reason, deps.runId, deps.stateStore);
-    return { kind: "held_misconfigured", reason };
+    const endDisposition = await holdForHuman(deps.client, card, reason, deps.runId, deps.stateStore);
+    return { kind: "held_misconfigured", reason, endDisposition };
   }
   await persistStagePointer(deps.client, card, {
     currentStage: next.stage.id,
@@ -9341,11 +9452,13 @@ async function advanceStageOnGate(card, stage, stageIndex, def, evaluation, deps
   log29.info(TAG27, `#${card.short_id} advanced "${stage.name}" → "${next.stage.name}" (column "${toColumn}")`);
   if (next.stage.owner === "human") {
     const reason = `Stage "${next.stage.name}" is yours: ${handoffText(next.stage)}`;
-    await holdForHuman(deps.client, card, reason, deps.runId, deps.stateStore, {
-      keepAttempts: true,
-      endStatus: "blocked",
-      blockers: [reason]
-    });
+    const endDisposition = await holdForHuman(deps.client, card, reason, deps.runId, deps.stateStore, { keepAttempts: true, endStatus: "blocked", blockers: [reason] });
+    return {
+      kind: "advanced",
+      toStageId: next.stage.id,
+      toColumn,
+      endDisposition
+    };
   }
   return { kind: "advanced", toStageId: next.stage.id, toColumn };
 }
@@ -9362,13 +9475,9 @@ async function handleGateUnmet(card, stage, summary, deps) {
         currentTask: reason
       });
     } catch {}
-    await holdForHuman(deps.client, card, reason, deps.runId, deps.stateStore, {
-      keepAttempts: true,
-      endStatus: "blocked",
-      blockers: [reason]
-    });
+    const endDisposition = await holdForHuman(deps.client, card, reason, deps.runId, deps.stateStore, { keepAttempts: true, endStatus: "blocked", blockers: [reason] });
     log29.info(TAG27, `#${card.short_id} GateUnmetExhausted: ${reason}`);
-    return { kind: "held_gate_unmet", reason };
+    return { kind: "held_gate_unmet", reason, endDisposition };
   }
   const guard = await guardStageReclaim(card, `gate-unmet re-run of "${stage.name}"`, deps);
   if (!guard.proceed) {
@@ -9430,21 +9539,16 @@ async function holdForHuman(client, card, reason, runId, stateStore, opts = {})
     await client.addComment(card.id, reason, { commentType: "blocker" });
   } catch {}
   try {
-    const result = await runTransition(client, card, {
-      removeLabels: [AGENT_LABEL],
-      endSession: {
-        status: opts.endStatus ?? "paused",
-        blockers: opts.blockers,
-        failureReason: "other",
-        failureSummary: reason.slice(0, 300)
-      }
-    }, { store: stateStore, runId });
-    if (opts.endStatus === "blocked" && result.endSession?.ended === false) {
-      log29.warn(TAG27, `#${card.short_id} hold intended to end the session BLOCKED, but it was already ended (${result.endSession.reason ?? "unknown reason"}) — no agent_blocked push fired from this write.`);
-    }
+    await runTransition(client, card, { removeLabels: [AGENT_LABEL] }, { store: stateStore, runId });
   } catch (err) {
     log29.warn(TAG27, `hold transition failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
   }
+  return {
+    status: opts.endStatus ?? "paused",
+    blockers: opts.blockers,
+    failureReason: "other",
+    failureSummary: reason.slice(0, 300)
+  };
 }
 var TAG27 = "stage-advance", AGENT_LABEL = "agent";
 var init_stage_advance = __esm(() => {
@@ -9464,12 +9568,14 @@ import {
   collectGateEvidence as collectGateEvidence2,
   createWorktree,
   describeApiError as describeApiError2,
+  fetchExistingBranch,
   log as log30,
   makeBranchName,
   normalizeGateSpec,
   pushBranch as pushBranch3,
   readWorktreeHead,
   reapGroup as reapGroup2,
+  resolveContinuationTarget,
   SdkAgentRunner as SdkAgentRunner2,
   signalGroup as signalGroup2,
   sizeRun,
@@ -9755,12 +9861,18 @@ class Worker {
       log30.info(this.tag, resuming ? `Resuming #${card.short_id} "${card.title}" with ${this.grantedTurns ?? "the default"} more turns` : `Preparing #${card.short_id} "${card.title}"`);
       const attemptCount = await this.stateStore.incrementAttempt(card.id);
       const isRework = attemptCount > 1;
-      const recordedBranch = extractBranchRef(card.description);
-      const continuesPushedWork = isRework || recordsPushedWorkOn(card.description, this.branchName);
-      if (continuesPushedWork && !isRework) {
-        log30.info(this.tag, `Card records completed work on ${this.branchName} — continuing that branch instead of rebuilding from ${this.config.worktree.baseBranch}`);
-      } else if (recordedBranch && recordedBranch !== this.branchName) {
-        log30.warn(this.tag, `Card records branch ${recordedBranch} but this run targets ${this.branchName} — starting fresh; the recorded branch is left untouched`);
+      const recordedBranch = recordedBranchForCard(card.description, card.short_id, [
+        this.config.worktree.failedBranchPrefix,
+        this.config.worktree.approvedBranchPrefix
+      ]);
+      const continuesPushedWork = isRework || recordedBranch !== null;
+      if (!resuming && recordedBranch) {
+        if (recordedBranch !== this.branchName) {
+          log30.info(this.tag, `Card records pushed work on ${recordedBranch} — continuing that branch instead of ${this.branchName}`);
+          this.branchName = recordedBranch;
+        } else if (!isRework) {
+          log30.info(this.tag, `Card records pushed work on ${this.branchName} — continuing that branch instead of rebuilding from ${this.config.worktree.baseBranch}`);
+        }
       }
       this.startHeartbeat();
       this.sizingOutcome = await this.sizeThisRun(card);
@@ -9850,8 +9962,20 @@ class Worker {
         return;
       }
       if (!resuming) {
+        const continueRequested = stageCtx.kind === "run" || stageCtx.kind === "motor" || continuesPushedWork;
+        const repoRoot = execFileSync7("git", ["rev-parse", "--show-toplevel"], {
+          encoding: "utf-8"
+        }).trim();
+        const target = resolveContinuationTarget(this.branchName, continueRequested, this.config.worktree.failedBranchPrefix, this.config.worktree.approvedBranchPrefix, (ref) => fetchExistingBranch(repoRoot, ref));
+        if (target.branchName !== this.branchName) {
+          log30.info(this.tag, `Branch ${this.branchName} is gone from origin but its approved rename ${target.branchName} exists — continuing that branch`);
+          this.branchName = target.branchName;
+        } else if (target.reason === "exists_on_origin") {
+          log30.info(this.tag, `Branch ${this.branchName} exists on origin with no card record — continuing it rather than resetting it`);
+        }
         this.worktreePath = createWorktree(this.config.worktree.basePath, this.config.worktree.baseBranch, this.branchName, {
-          continueExisting: stageCtx.kind === "run" || stageCtx.kind === "motor" || continuesPushedWork
+          continueExisting: target.continueExisting,
+          branchExistsOnOrigin: target.existsOnOrigin
         });
         this.runBaselineSha = readWorktreeHead(this.worktreePath);
       }
@@ -9941,9 +10065,8 @@ class Worker {
       const stageRun = stageCtx.kind === "run" ? stageCtx : null;
       const onBeforeWorktreeCleanup = stageRun ? async (worktreePath) => {
         stageGateEvaluation = await this.collectStageGateEvidence(card, stageRun.stage, worktreePath, subtasks);
-        return stageEndDisposition(stageGateEvaluation, stageRun.stage, stageRun.index, stageRun.def);
       } : undefined;
-      const completed = await runCompletion(this.client, card, this.branchName, this.worktreePath, this.config, this.id, this.sessionIdentifier, this.identity.agentId, this.lastSessionStats, this.workspaceId, this.sessionId, this.stateStore, this.onCardCompleted, onBeforeWorktreeCleanup, this.runBaselineSha, this.effectiveMaxTurns);
+      const completed = await runCompletion(this.client, card, this.branchName, this.worktreePath, this.config, this.id, this.sessionIdentifier, this.identity.agentId, this.lastSessionStats, this.workspaceId, this.sessionId, this.stateStore, this.onCardCompleted, onBeforeWorktreeCleanup, this.runBaselineSha, this.effectiveMaxTurns, stageRun ? stageRunExpectsCommit(stageRun.stage, stageRun.allowedTools) : true);
       if (completed === "park") {
         await this.parkForDecision(card, "max_turns");
         return;
@@ -9951,24 +10074,29 @@ class Worker {
       this.worktreePath = null;
       this.verificationFailed = !completed;
       if (completed && stageRun) {
-        const outcome = await this.advanceFromGateEvaluation(card, stageRun.stage, stageRun.index, stageRun.def, stageGateEvaluation);
-        switch (outcome.kind) {
-          case "requeued_gate_unmet":
-          case "held_gate_unmet":
-          case "held_misconfigured":
-            this.held = true;
-            break;
-          case "reclaim_refused":
-            this.held = true;
-            log30.info(this.tag, `#${card.short_id} stage reclaim refused (${outcome.reason})${outcome.released ? " — released the daemon's claim" : ""}`);
-            break;
-          case "advanced":
-          case "completed_terminal":
-          case "no_advance":
-            break;
-          default: {
-            const _exhaustive = outcome;
+        let outcome = { kind: "no_advance" };
+        try {
+          outcome = await this.advanceFromGateEvaluation(card, stageRun.stage, stageRun.index, stageRun.def, stageGateEvaluation);
+          switch (outcome.kind) {
+            case "requeued_gate_unmet":
+            case "held_gate_unmet":
+            case "held_misconfigured":
+              this.held = true;
+              break;
+            case "reclaim_refused":
+              this.held = true;
+              log30.info(this.tag, `#${card.short_id} stage reclaim refused (${outcome.reason})${outcome.released ? " — released the daemon's claim" : ""}`);
+              break;
+            case "advanced":
+            case "completed_terminal":
+            case "no_advance":
+              break;
+            default: {
+              const _exhaustive = outcome;
+            }
           }
+        } finally {
+          await this.endStageRunSession(card, outcome);
         }
       }
     } catch (err) {
@@ -10627,28 +10755,33 @@ class Worker {
     this.completionStarted = true;
     await this.recordPhase("completing");
     const evaluation = verdict ? evaluationFromVerdict(verdict, result.structured) : null;
-    await this.finishMotorStageRun(card, ctx, stageEndDisposition(evaluation, ctx.stage, ctx.index, ctx.def));
-    const outcome = await this.advanceFromGateEvaluation(card, ctx.stage, ctx.index, ctx.def, evaluation);
-    switch (outcome.kind) {
-      case "requeued_gate_unmet":
-      case "held_gate_unmet":
-      case "held_misconfigured":
-        this.held = true;
-        break;
-      case "reclaim_refused":
-        this.held = true;
-        log30.info(this.tag, `#${card.short_id} stage reclaim refused (${outcome.reason})${outcome.released ? " — released the daemon's claim" : ""}`);
-        break;
-      case "advanced":
-      case "completed_terminal":
-      case "no_advance":
-        break;
-      default: {
-        const _exhaustive = outcome;
+    await this.finishMotorStageRun(card, ctx);
+    let outcome = { kind: "no_advance" };
+    try {
+      outcome = await this.advanceFromGateEvaluation(card, ctx.stage, ctx.index, ctx.def, evaluation);
+      switch (outcome.kind) {
+        case "requeued_gate_unmet":
+        case "held_gate_unmet":
+        case "held_misconfigured":
+          this.held = true;
+          break;
+        case "reclaim_refused":
+          this.held = true;
+          log30.info(this.tag, `#${card.short_id} stage reclaim refused (${outcome.reason})${outcome.released ? " — released the daemon's claim" : ""}`);
+          break;
+        case "advanced":
+        case "completed_terminal":
+        case "no_advance":
+          break;
+        default: {
+          const _exhaustive = outcome;
+        }
       }
+    } finally {
+      await this.endStageRunSession(card, outcome);
     }
   }
-  async finishMotorStageRun(card, ctx, disposition = { status: "completed" }) {
+  async finishMotorStageRun(card, ctx) {
     const worktreePath = this.worktreePath;
     if (worktreePath) {
       commitUncommittedChanges(worktreePath, card);
@@ -10666,7 +10799,6 @@ class Worker {
     } else {
       log30.warn(this.tag, `completion.moveToColumn is empty — #${card.short_id} stays in its current column after the motor stage run`);
     }
-    await endRunSession({ client: this.client, tag: this.tag }, card, disposition, {}, "log");
     await this.closeoutMotorWorktree(card);
   }
   async closeoutMotorWorktree(card) {
@@ -10681,7 +10813,9 @@ class Worker {
     this.worktreePath = null;
   }
   async buildFreshRunPrompt(enriched, card, stageCtx, continuesPushedWork, resuming) {
-    const basePrompt = await buildPrompt(enriched, this.branchName, this.worktreePath, this.client, this.workspaceId, this.projectId);
+    const recallOutcomes = [];
+    const basePrompt = await buildPrompt(enriched, this.branchName, this.worktreePath, this.client, this.workspaceId, this.projectId, (outcome) => recallOutcomes.push(outcome));
+    this.recordPromptAssembled(recallOutcomes);
     let prompt = basePrompt;
     if (stageCtx.kind === "run") {
       const loop = getStageLoop(stageCtx.stage);
@@ -10820,6 +10954,9 @@ ${prompt}`;
       return { kind: "no_advance" };
     }
   }
+  async endStageRunSession(card, outcome) {
+    await endRunSession({ client: this.client, tag: this.tag }, card, endDispositionFor(outcome), buildTokenPayload(this.lastSessionStats), "log");
+  }
   selectImplementModel(card) {
     const attempts = this.stateStore.getCard(card.id)?.attempts ?? 1;
     const choice = chooseImplementModel(this.config.claude, card, attempts, this.sizing ?? undefined);
@@ -10859,6 +10996,19 @@ ${prompt}`;
     }
     return outcome;
   }
+  recordPromptAssembled(outcomes) {
+    const countOf = (flavour) => outcomes.find((o) => o.flavour === flavour)?.count ?? 0;
+    const failures = outcomes.flatMap((o) => o.failure ? [{ flavour: o.flavour, message: o.failure.slice(0, 300) }] : []);
+    this.cliRunner?.record({
+      kind: "prompt_assembled",
+      source: "system",
+      payload: {
+        episodeCount: countOf("past_episodes"),
+        referenceCount: countOf("reference"),
+        ...failures.length > 0 ? { recallFailures: failures } : {}
+      }
+    });
+  }
   recordRunSized() {
     if (!this.modelChoice)
       return;
@@ -11680,10 +11830,11 @@ class Pool {
       return;
     try {
       await this.client.updateAgentProgress(cardId, {
-        agentIdentifier: agentIdentifier(0),
+        agentIdentifier: NOTICE_IDENTIFIER,
         agentName: AGENT_NAME,
         status: "waiting",
-        currentTask
+        currentTask,
+        driver: NOTICE_DRIVER
       });
       this.lastWaitingEmit.set(cardId, currentTask);
     } catch (err) {
@@ -12219,6 +12370,7 @@ Reassign the card — that clears the turn count and starts it fresh — or rais
 }
 var TAG29 = "pool";
 var init_pool = __esm(() => {
+  init_dist();
   init_board_helpers();
   init_budget_pause();
   init_handback();
@@ -14520,6 +14672,7 @@ async function main() {
   };
   process.on("SIGINT", () => shutdown("SIGINT"));
   process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGHUP", () => shutdown("SIGHUP"));
   process.on("uncaughtException", (err) => {
     log42.error(TAG40, `Uncaught exception: ${err.message}`);
     exitCode = 1;