dahrk-node 0.1.21 → 0.1.22

package/dist/main.js

@@ -74,6 +74,13 @@ import {
   query
 } from "@anthropic-ai/claude-agent-sdk";
 
+// ../../packages/executor-worktree/src/response-rule.ts
+function decideResponse(bufferedText, endedOnTool, status) {
+  const text = bufferedText.trim();
+  if (status !== "ok" || !text || endedOnTool) return {};
+  return { responseText: text, event: { type: "response", text } };
+}
+
 // ../../packages/executor-worktree/src/claude-mappers.ts
 function mapClaudeMessage(msg) {
   switch (msg.type) {
@@ -168,27 +175,21 @@ function consumeClaudeMessage(msg, state, suppressStageExit) {
   }
   if (msg.type === "result") {
     const status = r.resultStatus === "fail" ? "fail" : "ok";
-    let responseText;
-    if (status === "ok" && state.bufferedText && !state.turnEndedOnTool) {
-      responseText = state.bufferedText;
-      events.push({ type: "response", text: state.bufferedText });
-    }
+    const decision = decideResponse(state.bufferedText ?? "", state.turnEndedOnTool, status);
+    if (decision.event) events.push(decision.event);
     for (const e of r.events) {
       if (suppressStageExit && e.type === "state") continue;
       events.push(e);
     }
     state.bufferedText = null;
     state.turnEndedOnTool = false;
-    return { events, isResult: true, status, responseText };
+    return { events, isResult: true, status, responseText: decision.responseText };
   }
   events.push(...r.events);
   return { events, isResult: false };
 }
 
-// ../../packages/executor-worktree/src/runner-shared.ts
-import { readFileSync } from "fs";
-import { join } from "path";
-import { attachedDocBasename } from "@dahrk/contracts";
+// ../../packages/executor-worktree/src/runtime-session.ts
 var SUMMARISE_PROMPT = "This stage is ending. In ONE concise sentence for a human reviewer reading the Linear ticket, state concretely what you DID or FOUND in this stage and the result (for example which functions or files changed, whether the tests pass, or what a review flagged). Be specific and lead with the outcome. Do not mention internal scratch files or a next-stage entry point. Reply with only that sentence.";
 function makeEmit(runtime, onTrace, now = () => (/* @__PURE__ */ new Date()).toISOString()) {
   return (event, rawRef) => {
@@ -197,6 +198,11 @@ function makeEmit(runtime, onTrace, now = () => (/* @__PURE__ */ new Date()).toI
     onTrace(full);
   };
 }
+
+// ../../packages/executor-worktree/src/prompt-assembly.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+import { attachedDocBasename } from "@dahrk/contracts";
 function stripFrontmatter(text) {
   const lines = text.split("\n");
   if (lines[0]?.trim() !== "---") return text;
@@ -319,6 +325,8 @@ var OPENING_KICKOFF = "Begin now. Using the ticket context and your instructions
 function interactiveSeedText(ctx, instructionInSystemPrompt) {
   return instructionInSystemPrompt ? OPENING_KICKOFF : resolveStagePrompt(ctx);
 }
+
+// ../../packages/executor-worktree/src/mailbox.ts
 var ManagedMailbox = class {
   q = [];
   waiters = [];
@@ -344,36 +352,19 @@ var ManagedMailbox = class {
     };
   }
 };
-function interactiveIdleWindows(ctx) {
-  const idleMs = ctx.config.idleMs ?? Number(process.env.DAHRK_INTERACTIVE_IDLE_MS ?? process.env.SKAKEL_INTERACTIVE_IDLE_MS ?? 12e4);
-  const firstReplyMs = ctx.config.firstReplyMs ?? Number(process.env.DAHRK_INTERACTIVE_FIRST_REPLY_MS ?? process.env.SKAKEL_INTERACTIVE_FIRST_REPLY_MS ?? 6e5);
-  return { firstReplyMs: Math.max(firstReplyMs, idleMs), idleMs };
-}
-function raceNextTurn(pending, idleMs, signal) {
-  return new Promise((resolve3) => {
-    let settled = false;
-    let timer;
-    function finish(r) {
-      if (settled) return;
-      settled = true;
-      if (timer) clearTimeout(timer);
-      signal.removeEventListener("abort", onAbort);
-      resolve3(r);
-    }
-    function onAbort() {
-      finish({ kind: "cancelled" });
-    }
-    if (signal.aborted) {
-      finish({ kind: "cancelled" });
-      return;
-    }
-    signal.addEventListener("abort", onAbort);
-    timer = setTimeout(() => finish({ kind: "idle-timeout" }), idleMs);
-    pending.then(
-      (res) => finish(res.done ? { kind: "turns-exhausted" } : { kind: "turn", value: res.value }),
-      () => finish({ kind: "turns-exhausted" })
-    );
-  });
+
+// ../../packages/executor-worktree/src/elicit-router.ts
+function elicitOutcomeReply(outcome) {
+  switch (outcome.kind) {
+    case "reply":
+      return `The user selected: ${outcome.text}`;
+    case "busy":
+      return "Only one question can be asked at a time; wait for the current one to be answered, then ask again.";
+    case "noreply":
+      return "No response from the user; proceed with your best judgement.";
+    case "cancel":
+      return "The question was cancelled.";
+  }
 }
 function createElicitTurnRouter(turns, opts) {
   const conversation = new ManagedMailbox();
@@ -417,6 +408,147 @@ function createElicitTurnRouter(turns, opts) {
   return { conversation, ask };
 }
 
+// ../../packages/executor-worktree/src/turn-loop.ts
+function interactiveIdleWindows(ctx) {
+  const idleMs = ctx.config.idleMs ?? Number(process.env.DAHRK_INTERACTIVE_IDLE_MS ?? process.env.SKAKEL_INTERACTIVE_IDLE_MS ?? 12e4);
+  const firstReplyMs = ctx.config.firstReplyMs ?? Number(process.env.DAHRK_INTERACTIVE_FIRST_REPLY_MS ?? process.env.SKAKEL_INTERACTIVE_FIRST_REPLY_MS ?? 6e5);
+  return { firstReplyMs: Math.max(firstReplyMs, idleMs), idleMs };
+}
+function raceNextTurn(pending, idleMs, signal) {
+  return new Promise((resolve3) => {
+    let settled = false;
+    let timer;
+    function finish(r) {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      signal.removeEventListener("abort", onAbort);
+      resolve3(r);
+    }
+    function onAbort() {
+      finish({ kind: "cancelled" });
+    }
+    if (signal.aborted) {
+      finish({ kind: "cancelled" });
+      return;
+    }
+    signal.addEventListener("abort", onAbort);
+    timer = setTimeout(() => finish({ kind: "idle-timeout" }), idleMs);
+    pending.then(
+      (res) => finish(res.done ? { kind: "turns-exhausted" } : { kind: "turn", value: res.value }),
+      () => finish({ kind: "turns-exhausted" })
+    );
+  });
+}
+var COALESCE_MS = Number(process.env.DAHRK_COALESCE_MS ?? process.env.SKAKEL_COALESCE_MS ?? 40);
+async function runInteractiveLoop(ctx, turns, emit, makeSession, opts) {
+  const { signal, cancelled, cancel, instructionInSystemPrompt } = opts;
+  const exit = ctx.config.exit ?? "either";
+  const wantsTool = exit === "tool" || exit === "either";
+  const { firstReplyMs, idleMs } = interactiveIdleWindows(ctx);
+  const router = createElicitTurnRouter(turns, { signal, firstReplyMs, idleMs });
+  const humanIter = router.conversation[Symbol.asyncIterator]();
+  let awaitingFirstReply = true;
+  const ask = async (question) => {
+    const outcome = await router.ask(awaitingFirstReply, () => {
+      emit({ type: "elicitation", prompt: question.prompt, signal: "select", options: question.options });
+      ctx.emitElicit?.(question);
+    });
+    return elicitOutcomeReply(outcome);
+  };
+  const session = makeSession({ emit, ask });
+  let toolSummary;
+  let artifact;
+  let exited = "gate";
+  let pending = humanIter.next();
+  try {
+    const seed = await session.sendTurn(interactiveSeedText(ctx, instructionInSystemPrompt));
+    if (seed.stageComplete && wantsTool) {
+      exited = "tool";
+      toolSummary = seed.summary;
+      artifact = seed.artifact;
+    }
+    for (; ; ) {
+      if (exited === "tool") break;
+      const race = await raceNextTurn(pending, awaitingFirstReply ? firstReplyMs : idleMs, signal);
+      awaitingFirstReply = false;
+      if (race.kind === "cancelled") {
+        exited = "cancelled";
+        break;
+      }
+      if (race.kind === "idle-timeout") {
+        exited = "timeout";
+        break;
+      }
+      if (race.kind === "turns-exhausted") {
+        exited = "gate";
+        break;
+      }
+      const texts = [race.value.text];
+      pending = humanIter.next();
+      for (; ; ) {
+        const more = await raceNextTurn(pending, COALESCE_MS, signal);
+        if (more.kind === "turn") {
+          texts.push(more.value.text);
+          pending = humanIter.next();
+          continue;
+        }
+        if (more.kind === "cancelled") exited = "cancelled";
+        break;
+      }
+      if (exited === "cancelled") break;
+      const tr = await session.sendTurn(texts.join("\n"));
+      if (tr.stageComplete && wantsTool) {
+        exited = "tool";
+        toolSummary = tr.summary;
+        artifact = tr.artifact;
+        break;
+      }
+    }
+  } catch (e) {
+    if (!cancelled()) emit({ type: "error", kind: "runtime_error", message: e.message });
+    exited = cancelled() ? "cancelled" : "gate";
+  }
+  let status = "ok";
+  let summary = "";
+  if (exited === "tool") {
+    summary = toolSummary ?? "(stage marked complete)";
+  } else if (exited === "gate") {
+    summary = await session.summariseTurn();
+  } else if (exited === "timeout") {
+    status = "timeout";
+    summary = "(stage timed out awaiting input)";
+    await cancel();
+  } else {
+    status = "fail";
+    summary = "(stage cancelled)";
+  }
+  const costUsd = session.cost();
+  const sessionId = session.sessionId;
+  const outArtifact = status === "ok" ? artifact : void 0;
+  return {
+    status,
+    summary,
+    ...sessionId ? { sessionId } : {},
+    ...costUsd !== void 0 ? { costUsd } : {},
+    ...outArtifact ? { artifact: outArtifact } : {}
+  };
+}
+async function runBatchLoop(session, ctx, hooks, opts) {
+  let status = "ok";
+  try {
+    const tr = await session.sendTurn(resolveStagePrompt(ctx));
+    if (tr.status) status = tr.status;
+  } catch (e) {
+    if (!opts.cancelled()) hooks.emit({ type: "error", kind: "runtime_error", message: e.message });
+    status = "fail";
+  }
+  if (opts.cancelled()) status = "fail";
+  const costUsd = session.cost();
+  const sessionId = session.sessionId;
+  return { status, ...sessionId ? { sessionId } : {}, ...costUsd !== void 0 ? { costUsd } : {} };
+}
+
 // ../../packages/executor-worktree/src/stage-complete-tool.ts
 import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
 import { z } from "zod";
@@ -424,6 +556,10 @@ var STAGE_COMPLETE_TOOL_NAME = "mcp__dahrk__dahrk_stage_complete";
 function createStageCompleteTool() {
   let captured = null;
   let capturedDoc = null;
+  const capture = (args) => {
+    captured = args.summary;
+    if (args.document !== void 0) capturedDoc = args.document;
+  };
   const completeTool = tool(
     "dahrk_stage_complete",
     "End the current stage and hand off a one-sentence summary of what was accomplished. When the stage's deliverable is a document (e.g. a specification or report) to be published, pass its full markdown body as `document`; this is the only way an interactive stage can emit a document, since it cannot write files.",
@@ -432,8 +568,7 @@ function createStageCompleteTool() {
       document: z.string().optional().describe("The full markdown body of the stage's deliverable document, if any.")
     },
     async (args) => {
-      captured = args.summary;
-      if (args.document !== void 0) capturedDoc = args.document;
+      capture(args);
       return { content: [{ type: "text", text: "Stage marked complete." }] };
     }
   );
@@ -442,7 +577,8 @@ function createStageCompleteTool() {
     allowedToolName: STAGE_COMPLETE_TOOL_NAME,
     fired: () => captured !== null,
     summary: () => captured,
-    document: () => capturedDoc
+    document: () => capturedDoc,
+    capture
   };
 }
 
@@ -496,7 +632,6 @@ function createAskUserQuestionTool(deps) {
 }
 
 // ../../packages/executor-worktree/src/claude-adapter.ts
-var COALESCE_MS = Number(process.env.DAHRK_COALESCE_MS ?? process.env.SKAKEL_COALESCE_MS ?? 40);
 var MAX_TURNS = Number(process.env.DAHRK_MAX_TURNS ?? process.env.SKAKEL_MAX_TURNS ?? 64);
 var HANDED_BACK_ARTIFACT_PATH = ".dahrk/scratch/output/document.md";
 var CLAUDE_CODE_SYSTEM_PROMPT = { type: "preset", preset: "claude_code" };
@@ -505,6 +640,7 @@ var userMsg = (text) => ({
   parent_tool_use_id: null,
   message: { role: "user", content: text }
 });
+var defaultAsk = async () => elicitOutcomeReply({ kind: "noreply" });
 var sessionIdOf = (msg) => "session_id" in msg && typeof msg.session_id === "string" ? msg.session_id : void 0;
 var policyCanUseTool = async (ctx, toolName, input) => {
   const verdict2 = ctx.authorizeToolUse?.(toolName, input);
@@ -544,7 +680,25 @@ function runtimeEnvOptions(ctx) {
   if (!ctx.runtimeEnv) return {};
   return { env: { ...process.env, ...ctx.runtimeEnv } };
 }
-function createClaudeRunner() {
+var defaultCreateClaudeSession = ({ prompt, options }) => {
+  const mailbox = prompt === void 0 ? new ManagedMailbox() : void 0;
+  const q = query({ prompt: mailbox ?? prompt, options });
+  const it = q[Symbol.asyncIterator]();
+  return {
+    [Symbol.asyncIterator]: () => it,
+    push: (m) => mailbox?.push(m),
+    end: () => mailbox?.end(),
+    close: () => {
+      try {
+        q.close();
+      } catch {
+      }
+    },
+    interrupt: () => q.interrupt()
+  };
+};
+function createClaudeRunner(deps = {}) {
+  const createSession = deps.createSession ?? defaultCreateClaudeSession;
   const abortController = new AbortController();
   let cancelled = false;
   let active;
@@ -609,11 +763,86 @@ function createClaudeRunner() {
     }
     active = void 0;
   };
+  const makeClaudeRuntimeSession = (ctx, hooks, mode) => {
+    const state = newBufferState();
+    const it = mode.interactive ? mode.session[Symbol.asyncIterator]() : void 0;
+    const consumeInteractiveTurn = async () => {
+      for (; ; ) {
+        const { value: msg, done } = await it.next();
+        if (done) return {};
+        const res = handleMessage(msg, hooks.emit, ctx, state, true);
+        if (res.isResult) return { status: res.status, responseText: res.responseText };
+      }
+    };
+    return {
+      get sessionId() {
+        return sessionId;
+      },
+      async sendTurn(text) {
+        if (!mode.interactive) {
+          const session = createSession({ prompt: text, options: mode.options });
+          active = session;
+          let status2;
+          try {
+            for await (const msg of session) {
+              const res = handleMessage(msg, hooks.emit, ctx, state, false);
+              if (res.isResult && res.status) status2 = res.status;
+            }
+          } finally {
+            closeActive();
+          }
+          return { stageComplete: false, ...status2 !== void 0 ? { status: status2 } : {} };
+        }
+        mode.session.push(userMsg(text));
+        const { status, responseText } = await consumeInteractiveTurn();
+        const stageComplete = mode.stageTool.fired();
+        const doc = stageComplete ? mode.stageTool.document() : null;
+        return {
+          stageComplete,
+          ...stageComplete ? { summary: mode.stageTool.summary() ?? void 0 } : {},
+          ...responseText !== void 0 ? { responseText } : {},
+          ...status !== void 0 ? { status } : {},
+          ...doc !== null ? { artifact: { path: ctx.config.emitArtifact ?? HANDED_BACK_ARTIFACT_PATH, content: doc } } : {}
+        };
+      },
+      async summariseTurn() {
+        if (!mode.interactive) return "(no summary produced)";
+        mode.summarising.value = true;
+        try {
+          mode.session.push(userMsg(SUMMARISE_PROMPT));
+          const { responseText } = await consumeInteractiveTurn();
+          return (responseText ?? "").trim() || "(no summary produced)";
+        } catch {
+          return "(no summary produced)";
+        } finally {
+          mode.summarising.value = false;
+        }
+      },
+      cost() {
+        return costUsd;
+      },
+      dispose() {
+        if (!mode.interactive) return;
+        const iter = it;
+        mode.session.end();
+        void (async () => {
+          try {
+            for (; ; ) {
+              const { done } = await iter.next();
+              if (done) break;
+            }
+          } catch {
+          } finally {
+            closeActive();
+          }
+        })();
+      }
+    };
+  };
   return {
     runtime: "claude-code",
     async runBatch(ctx, onTrace) {
-      const emit = makeEmit("claude-code", onTrace);
-      const prompt = resolveStagePrompt(ctx);
+      const hooks = { emit: makeEmit("claude-code", onTrace), ask: defaultAsk };
       const mcpServers = buildBrokeredMcpServers(ctx);
       const options = {
         ...baseOptions(ctx),
@@ -624,171 +853,50 @@ function createClaudeRunner() {
         // Headless: allow tools to run without an interactive permission prompt (M6 wires policy).
         canUseTool: async (toolName, input) => policyCanUseTool(ctx, toolName, input)
       };
-      const state = newBufferState();
-      let status = "ok";
-      try {
-        const q = query({ prompt, options });
-        active = q;
-        for await (const msg of q) {
-          const res = handleMessage(msg, emit, ctx, state, false);
-          if (res.isResult && res.status) status = res.status;
-        }
-      } catch (e) {
-        if (!cancelled) emit({ type: "error", kind: "runtime_error", message: e.message });
-        status = "fail";
-      } finally {
-        closeActive();
-      }
-      if (cancelled) status = "fail";
-      return { status, ...sessionId ? { sessionId } : {}, ...costUsd !== void 0 ? { costUsd } : {} };
+      const rt = makeClaudeRuntimeSession(ctx, hooks, { interactive: false, options });
+      return runBatchLoop(rt, ctx, hooks, { cancelled: () => cancelled });
     },
     async runInteractive(ctx, turns, onTrace) {
       const emit = makeEmit("claude-code", onTrace);
       const stageTool = createStageCompleteTool();
-      const { firstReplyMs, idleMs } = interactiveIdleWindows(ctx);
-      let awaitingFirstReply = true;
-      const router = createElicitTurnRouter(turns, { signal: abortController.signal, firstReplyMs, idleMs });
-      const askTool = createAskUserQuestionTool({
-        ask: async (question) => {
-          const outcome = await router.ask(awaitingFirstReply, () => {
-            emit({ type: "elicitation", prompt: question.prompt, signal: "select", options: question.options });
-            ctx.emitElicit?.(question);
-          });
-          switch (outcome.kind) {
-            case "reply":
-              return `The user selected: ${outcome.text}`;
-            case "busy":
-              return "Only one question can be asked at a time; wait for the current one to be answered, then ask again.";
-            case "noreply":
-              return "No response from the user; proceed with your best judgement.";
-            case "cancel":
-              return "The question was cancelled.";
-          }
-        }
-      });
-      const brokered = buildBrokeredMcpServers(ctx);
-      let summarising = false;
-      const options = {
-        ...baseOptions(ctx),
-        // Keep the cwd-anchoring preset; fold the stage instruction in via `append` so the
-        // interactive persona still gets it without losing the working-directory context.
-        systemPrompt: hasSystemPrompt(ctx) ? { type: "preset", preset: "claude_code", append: resolveStagePrompt(ctx) } : CLAUDE_CODE_SYSTEM_PROMPT,
-        // Inject the stage-complete exit tool and the AskUserQuestion shadow alongside any brokered
-        // MCP servers (parity with batch).
-        mcpServers: { dahrk: stageTool.server, ask: askTool.server, ...brokered ?? {} },
-        // Redirect the built-in AskUserQuestion to the shadow tool so a structured question surfaces
-        // as a Linear elicitation. The redirect is name-only and single-hop; the tool still runs, so
-        // this is mapping, not gating (DHK-344 / DHK-223).
-        toolAliases: { [ASK_USER_QUESTION_ALIAS]: askTool.allowedToolName },
-        // Auto-approve the injected tools; `allowedTools` is an auto-approve list, not a whitelist, so
-        // it does not restrict the other tools canUseTool allows.
-        allowedTools: [stageTool.allowedToolName, askTool.allowedToolName],
-        canUseTool: async (toolName, input) => interactiveCanUseTool(summarising, stageTool.allowedToolName, ctx, toolName, input),
-        maxTurns: MAX_TURNS,
-        includePartialMessages: false
-      };
-      const exit = ctx.config.exit ?? "either";
-      const wantsTool = exit === "tool" || exit === "either";
-      const mailbox = new ManagedMailbox();
-      const q = query({ prompt: mailbox, options });
-      active = q;
-      const it = q[Symbol.asyncIterator]();
-      const humanIter = router.conversation[Symbol.asyncIterator]();
-      const state = newBufferState();
-      const consumeTurn = async () => {
-        for (; ; ) {
-          const { value: msg, done } = await it.next();
-          if (done) return void 0;
-          const res = handleMessage(msg, emit, ctx, state, true);
-          if (res.isResult) return res.responseText;
-        }
-      };
-      let exited = null;
-      let pending = humanIter.next();
-      try {
-        mailbox.push(userMsg(interactiveSeedText(ctx, hasSystemPrompt(ctx))));
-        await consumeTurn();
-        if (stageTool.fired() && wantsTool) exited = "tool";
-        while (exited === null) {
-          const race = await raceNextTurn(pending, awaitingFirstReply ? firstReplyMs : idleMs, abortController.signal);
-          awaitingFirstReply = false;
-          if (race.kind === "cancelled") {
-            exited = "cancelled";
-            break;
-          }
-          if (race.kind === "idle-timeout") {
-            exited = "timeout";
-            break;
-          }
-          if (race.kind === "turns-exhausted") {
-            exited = "gate";
-            break;
-          }
-          const texts = [race.value.text];
-          pending = humanIter.next();
-          for (; ; ) {
-            const more = await raceNextTurn(pending, COALESCE_MS, abortController.signal);
-            if (more.kind === "turn") {
-              texts.push(more.value.text);
-              pending = humanIter.next();
-              continue;
-            }
-            if (more.kind === "cancelled") exited = "cancelled";
-            break;
-          }
-          if (exited === "cancelled") break;
-          mailbox.push(userMsg(texts.join("\n")));
-          await consumeTurn();
-          if (stageTool.fired() && wantsTool) {
-            exited = "tool";
-            break;
-          }
-        }
-      } catch (e) {
-        if (!cancelled && !exited) emit({ type: "error", kind: "runtime_error", message: e.message });
-        exited = exited ?? (cancelled ? "cancelled" : "gate");
-      }
-      let status = "ok";
-      let summary = "";
-      if (exited === "tool") {
-        summary = stageTool.summary() ?? "(stage marked complete)";
-      } else if (exited === "gate") {
-        summarising = true;
-        try {
-          mailbox.push(userMsg(SUMMARISE_PROMPT));
-          const reply = await consumeTurn();
-          summary = (reply ?? "").trim() || "(no summary produced)";
-        } catch {
-          summary = "(no summary produced)";
-        } finally {
-          summarising = false;
-        }
-      } else if (exited === "timeout") {
-        status = "timeout";
-        summary = "(stage timed out awaiting input)";
-        await this.cancel();
-      } else {
-        status = "fail";
-        summary = "(stage cancelled)";
-      }
-      mailbox.end();
-      try {
-        for (; ; ) {
-          const { done } = await it.next();
-          if (done) break;
-        }
-      } catch {
-      }
-      closeActive();
-      const handedBackDoc = status === "ok" ? stageTool.document() : null;
-      const artifact = handedBackDoc !== null ? { path: ctx.config.emitArtifact ?? HANDED_BACK_ARTIFACT_PATH, content: handedBackDoc } : void 0;
-      return {
-        status,
-        summary,
-        ...sessionId ? { sessionId } : {},
-        ...costUsd !== void 0 ? { costUsd } : {},
-        ...artifact ? { artifact } : {}
+      const summarising = { value: false };
+      let rt;
+      const makeSession = (hooks) => {
+        const askTool = createAskUserQuestionTool({ ask: (question) => hooks.ask(question) });
+        const brokered = buildBrokeredMcpServers(ctx);
+        const options = {
+          ...baseOptions(ctx),
+          // Keep the cwd-anchoring preset; fold the stage instruction in via `append` so the
+          // interactive persona still gets it without losing the working-directory context.
+          systemPrompt: hasSystemPrompt(ctx) ? { type: "preset", preset: "claude_code", append: resolveStagePrompt(ctx) } : CLAUDE_CODE_SYSTEM_PROMPT,
+          // Inject the stage-complete exit tool and the AskUserQuestion shadow alongside any brokered
+          // MCP servers (parity with batch).
+          mcpServers: { dahrk: stageTool.server, ask: askTool.server, ...brokered ?? {} },
+          // Redirect the built-in AskUserQuestion to the shadow tool so a structured question surfaces
+          // as a Linear elicitation. The redirect is name-only and single-hop; the tool still runs, so
+          // this is mapping, not gating (DHK-344 / DHK-223).
+          toolAliases: { [ASK_USER_QUESTION_ALIAS]: askTool.allowedToolName },
+          // Auto-approve the injected tools; `allowedTools` is an auto-approve list, not a whitelist, so
+          // it does not restrict the other tools canUseTool allows.
+          allowedTools: [stageTool.allowedToolName, askTool.allowedToolName],
+          canUseTool: async (toolName, input) => interactiveCanUseTool(summarising.value, stageTool.allowedToolName, ctx, toolName, input),
+          maxTurns: MAX_TURNS,
+          includePartialMessages: false
+        };
+        const session = createSession({ options, stageTool });
+        active = session;
+        rt = makeClaudeRuntimeSession(ctx, hooks, { interactive: true, session, stageTool, summarising });
+        return rt;
       };
+      const result = await runInteractiveLoop(ctx, turns, emit, makeSession, {
+        signal: abortController.signal,
+        cancelled: () => cancelled,
+        cancel: () => this.cancel(),
+        // Claude carries the stage instruction in its system prompt, so the seed can be a short kickoff.
+        instructionInSystemPrompt: hasSystemPrompt(ctx)
+      });
+      rt?.dispose();
+      return result;
     },
     async summarise(ctx) {
       if (!sessionId) return "(no summary: session not established)";
@@ -803,9 +911,9 @@ function createClaudeRunner() {
       };
       try {
         let out2 = "";
-        const q = query({ prompt: SUMMARISE_PROMPT, options });
-        active = q;
-        for await (const msg of q) {
+        const session = createSession({ prompt: SUMMARISE_PROMPT, options });
+        active = session;
+        for await (const msg of session) {
           const found = sessionIdOf(msg);
           if (found) sessionId = found;
           if (msg.type === "result" && msg.subtype === "success") out2 += msg.result;
@@ -833,6 +941,16 @@ function createClaudeRunner() {
 import { join as join4 } from "path";
 
 // ../../packages/executor-worktree/src/pi-mappers.ts
+function parsePiEvent(msg) {
+  if (typeof msg !== "object" || msg === null) return null;
+  const type = msg.type;
+  if (typeof type !== "string") return null;
+  if (type === "message_update") {
+    const ame = msg.assistantMessageEvent;
+    if (typeof ame !== "object" || ame === null) return null;
+  }
+  return msg;
+}
 function mapUsage2(u) {
   return {
     input: u?.input ?? 0,
@@ -929,12 +1047,8 @@ function consumePiEvent(ev, state, suppressStageExit) {
   if (ev.type === "turn_end" || ev.type === "agent_end") {
     const r = mapPiEvent(ev);
     const status = settleStatus(settleMessage(ev));
-    let responseText;
-    const text = state.bufferedText.trim();
-    if (status === "ok" && text && !state.turnEndedOnTool) {
-      responseText = text;
-      events.push({ type: "response", text });
-    }
+    const decision = decideResponse(state.bufferedText, state.turnEndedOnTool, status);
+    if (decision.event) events.push(decision.event);
     if (state.pendingThought) {
       events.push({ type: "thought", subtype: "reasoning_text", text: state.pendingThought });
     }
@@ -945,7 +1059,7 @@ function consumePiEvent(ev, state, suppressStageExit) {
     state.bufferedText = "";
     state.pendingThought = "";
     state.turnEndedOnTool = false;
-    return { events, isResult: true, status, responseText };
+    return { events, isResult: true, status, responseText: decision.responseText };
   }
   return { events, isResult: false };
 }
@@ -1007,7 +1121,6 @@ function writeStageCustomProviders(dir, hint2) {
 }
 
 // ../../packages/executor-worktree/src/pi-adapter.ts
-var COALESCE_MS2 = Number(process.env.DAHRK_COALESCE_MS ?? process.env.SKAKEL_COALESCE_MS ?? 40);
 var PI_STAGE_COMPLETE_TOOL = "dahrk_stage_complete";
 var PI_ASK_USER_QUESTION_TOOL = "ask_user_question";
 function piToolCallDecision(ctx, toolName, input) {
@@ -1061,20 +1174,82 @@ function createBrokeredMcpExtension(servers) {
     }
   };
 }
+var defaultAsk2 = async () => elicitOutcomeReply({ kind: "noreply" });
+function makePiRuntimeSession(s, ctx, hooks, interactive) {
+  return {
+    get sessionId() {
+      return s.sessionId;
+    },
+    async sendTurn(text) {
+      const state = newPiBufferState();
+      let stageComplete = false;
+      let summary;
+      let stageCompleteCallId;
+      let responseText;
+      let status;
+      const unsub = s.subscribe((ev) => {
+        const rawRef = ctx.writeRaw?.(ev);
+        if (ev.type === "tool_execution_start" && ev.toolName === PI_STAGE_COMPLETE_TOOL) {
+          stageComplete = true;
+          stageCompleteCallId = ev.toolCallId;
+          const args = ev.args;
+          if (args?.summary) summary = args.summary;
+          return;
+        }
+        if (ev.type === "tool_execution_end" && ev.toolCallId === stageCompleteCallId) return;
+        const r = consumePiEvent(ev, state, interactive);
+        for (const e of r.events) hooks.emit(e, rawRef);
+        if (r.responseText) responseText = r.responseText;
+        if (r.isResult && r.status) status = r.status;
+      });
+      try {
+        await s.prompt(text);
+      } finally {
+        unsub();
+      }
+      return {
+        stageComplete,
+        ...summary !== void 0 ? { summary } : {},
+        ...responseText !== void 0 ? { responseText } : {},
+        ...status !== void 0 ? { status } : {}
+      };
+    },
+    async summariseTurn() {
+      if (s.agent) s.agent.state.tools = [];
+      const state = newPiBufferState();
+      let out2;
+      const unsub = s.subscribe((ev) => {
+        const r = consumePiEvent(ev, state, true);
+        if (r.responseText) out2 = r.responseText;
+      });
+      try {
+        await s.prompt(SUMMARISE_PROMPT);
+        return (out2 ?? "").trim() || "(no summary produced)";
+      } catch (e) {
+        return `(summary unavailable: ${e.message})`;
+      } finally {
+        unsub();
+      }
+    },
+    cost() {
+      const cost = s.getSessionStats?.()?.cost;
+      return typeof cost === "number" ? cost : void 0;
+    },
+    dispose() {
+      s.dispose();
+    }
+  };
+}
 function createPiRunner(deps = {}) {
   const createSession = deps.createSession ?? defaultCreatePiSession;
   const abortController = new AbortController();
   const signal = abortController.signal;
   let cancelled = false;
   let session;
-  let sessionId;
   const openSession = async (ctx) => {
     if (!session) session = await createSession(ctx);
     return session;
   };
-  const captureSessionId = (s) => {
-    if (s.sessionId) sessionId = s.sessionId;
-  };
   let sessionDisposed = false;
   const disposeSession = () => {
     if (sessionDisposed || !session) return;
@@ -1084,178 +1259,41 @@ function createPiRunner(deps = {}) {
     } catch {
     }
   };
-  const readSessionCost = (s) => {
-    const cost = s.getSessionStats?.()?.cost;
-    return typeof cost === "number" ? cost : void 0;
-  };
   return {
     runtime: "pi",
     async runBatch(ctx, onTrace) {
-      const emit = makeEmit("pi", onTrace);
+      const hooks = { emit: makeEmit("pi", onTrace), ask: defaultAsk2 };
       const s = await openSession(ctx);
       registerToolCallGate(s, ctx);
-      const state = newPiBufferState();
-      let status = "ok";
-      const unsub = s.subscribe((ev) => {
-        const rawRef = ctx.writeRaw?.(ev);
-        const r = consumePiEvent(ev, state, false);
-        for (const e of r.events) emit(e, rawRef);
-        if (r.isResult && r.status) status = r.status;
-      });
-      try {
-        await s.prompt(resolveStagePrompt(ctx));
-      } catch (e) {
-        if (!cancelled) emit({ type: "error", kind: "runtime_error", message: e.message });
-        status = "fail";
-      } finally {
-        unsub();
-      }
-      captureSessionId(s);
-      if (cancelled) status = "fail";
-      const costUsd = readSessionCost(s);
-      if (status !== "ok") disposeSession();
-      return { status, ...sessionId ? { sessionId } : {}, ...costUsd !== void 0 ? { costUsd } : {} };
+      const rt = makePiRuntimeSession(s, ctx, hooks, false);
+      const result = await runBatchLoop(rt, ctx, hooks, { cancelled: () => cancelled });
+      if (result.status !== "ok") disposeSession();
+      return result;
     },
     async runInteractive(ctx, turns, onTrace) {
       const emit = makeEmit("pi", onTrace);
       const s = await openSession(ctx);
       registerToolCallGate(s, ctx);
-      const state = newPiBufferState();
-      const exit = ctx.config.exit ?? "either";
-      const wantsTool = exit === "tool" || exit === "either";
-      let toolFired = false;
-      let toolSummary = null;
-      let stageCompleteCallId;
-      let lastResponseText;
-      const unsub = s.subscribe((ev) => {
-        const rawRef = ctx.writeRaw?.(ev);
-        if (ev.type === "tool_execution_start" && ev.toolName === PI_STAGE_COMPLETE_TOOL) {
-          toolFired = true;
-          stageCompleteCallId = ev.toolCallId;
-          const args = ev.args;
-          if (args?.summary) toolSummary = args.summary;
-          return;
-        }
-        if (ev.type === "tool_execution_end" && ev.toolCallId === stageCompleteCallId) return;
-        const r = consumePiEvent(ev, state, true);
-        for (const e of r.events) emit(e, rawRef);
-        if (r.responseText) lastResponseText = r.responseText;
-      });
-      const { firstReplyMs, idleMs } = interactiveIdleWindows(ctx);
-      const router = createElicitTurnRouter(turns, { signal, firstReplyMs, idleMs });
-      const humanIter = router.conversation[Symbol.asyncIterator]();
-      let awaitingFirstReply = true;
-      const elicitCtx = ctx;
-      const ask = async (question) => {
-        const outcome = await router.ask(awaitingFirstReply, () => {
-          emit({ type: "elicitation", prompt: question.prompt, signal: "select", options: question.options });
-          elicitCtx.emitElicit?.(question);
-        });
-        switch (outcome.kind) {
-          case "reply":
-            return `The user selected: ${outcome.text}`;
-          case "busy":
-            return "Only one question can be asked at a time; wait for the current one to be answered, then ask again.";
-          case "noreply":
-            return "No response from the user; proceed with your best judgement.";
-          case "cancel":
-            return "The question was cancelled.";
-        }
+      const makeSession = (hooks) => {
+        s.setAskUserQuestionHandler?.((questions) => askQuestionsSequentially(questions, (q) => hooks.ask(q)));
+        return makePiRuntimeSession(s, ctx, hooks, true);
       };
-      s.setAskUserQuestionHandler?.((questions) => askQuestionsSequentially(questions, ask));
-      let exited = "gate";
-      let pending = humanIter.next();
-      try {
-        await s.prompt(interactiveSeedText(ctx, false));
-        if (toolFired && wantsTool) exited = "tool";
-        for (; ; ) {
-          if (exited === "tool") break;
-          const race = await raceNextTurn(pending, awaitingFirstReply ? firstReplyMs : idleMs, signal);
-          awaitingFirstReply = false;
-          if (race.kind === "cancelled") {
-            exited = "cancelled";
-            break;
-          }
-          if (race.kind === "idle-timeout") {
-            exited = "timeout";
-            break;
-          }
-          if (race.kind === "turns-exhausted") {
-            exited = "gate";
-            break;
-          }
-          const texts = [race.value.text];
-          pending = humanIter.next();
-          for (; ; ) {
-            const more = await raceNextTurn(pending, COALESCE_MS2, signal);
-            if (more.kind === "turn") {
-              texts.push(more.value.text);
-              pending = humanIter.next();
-              continue;
-            }
-            if (more.kind === "cancelled") exited = "cancelled";
-            break;
-          }
-          if (exited === "cancelled") break;
-          await s.prompt(texts.join("\n"));
-          if (toolFired && wantsTool) {
-            exited = "tool";
-            break;
-          }
-        }
-      } catch (e) {
-        if (!cancelled) emit({ type: "error", kind: "runtime_error", message: e.message });
-        exited = cancelled ? "cancelled" : "gate";
-      }
-      let status = "ok";
-      let summary = "";
-      if (exited === "tool") {
-        summary = toolSummary ?? "(stage marked complete)";
-      } else if (exited === "gate") {
-        lastResponseText = void 0;
-        try {
-          await s.prompt(SUMMARISE_PROMPT);
-          summary = (lastResponseText ?? "").trim() || "(no summary produced)";
-        } catch {
-          summary = "(no summary produced)";
-        }
-      } else if (exited === "timeout") {
-        status = "timeout";
-        summary = "(stage timed out awaiting input)";
-        await this.cancel();
-      } else {
-        status = "fail";
-        summary = "(stage cancelled)";
-      }
-      unsub();
-      captureSessionId(s);
-      const costUsd = readSessionCost(s);
+      const result = await runInteractiveLoop(ctx, turns, emit, makeSession, {
+        signal,
+        cancelled: () => cancelled,
+        cancel: () => this.cancel(),
+        instructionInSystemPrompt: false
+      });
       disposeSession();
-      return {
-        status,
-        summary,
-        ...sessionId ? { sessionId } : {},
-        ...costUsd !== void 0 ? { costUsd } : {}
-      };
+      return result;
     },
     async summarise(ctx) {
       if (!session) return "(no summary: session not established)";
-      const s = session;
-      if (s.agent) s.agent.state.tools = [];
-      const state = newPiBufferState();
-      let out2;
-      const unsub = s.subscribe((ev) => {
-        const r = consumePiEvent(ev, state, true);
-        if (r.responseText) out2 = r.responseText;
-      });
+      const rt = makePiRuntimeSession(session, ctx, { emit: () => {
+      }, ask: defaultAsk2 }, true);
       try {
-        await s.prompt(SUMMARISE_PROMPT);
-        captureSessionId(s);
-        return (out2 ?? "").trim() || "(no summary produced)";
-      } catch (e) {
-        return `(summary unavailable: ${e.message})`;
+        return await rt.summariseTurn();
       } finally {
-        unsub();
         disposeSession();
       }
     },
@@ -1338,7 +1376,7 @@ async function defaultCreatePiSession(ctx) {
     },
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     execute: async (_toolCallId, params) => {
-      const text = askHandler ? await askHandler(params.questions) : "No response from the user; proceed with your best judgement.";
+      const text = askHandler ? await askHandler(params.questions) : elicitOutcomeReply({ kind: "noreply" });
       return { content: [{ type: "text", text }], details: {} };
     }
   });
@@ -1557,7 +1595,8 @@ var PiRpcSession = class {
       }
       return;
     }
-    const ev = msg;
+    const ev = parsePiEvent(msg);
+    if (!ev) return;
     for (const l of [...this.#listeners]) l(ev);
     if (ev.type === "agent_end" && this.#pendingAgentEnd) {
       const d = this.#pendingAgentEnd;
@@ -1620,10 +1659,67 @@ import { execFileSync } from "child_process";
 import { existsSync, mkdirSync, mkdtempSync as mkdtempSync2, readFileSync as readFileSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir2, tmpdir as tmpdir3 } from "os";
 import { basename, dirname, isAbsolute, join as join5 } from "path";
+
+// ../../packages/executor-worktree/src/footprint.ts
+function resolveRenamePath(raw) {
+  const brace = /\{(.*?) => (.*?)\}/;
+  if (brace.test(raw)) {
+    return raw.replace(brace, (_m, _old, next) => next).replace(/\/{2,}/g, "/");
+  }
+  const arrow2 = raw.indexOf(" => ");
+  if (arrow2 !== -1) return raw.slice(arrow2 + " => ".length);
+  return raw;
+}
+function parseNumstat(raw) {
+  const entries = [];
+  for (const line of raw.split("\n")) {
+    if (line.trim() === "") continue;
+    const firstTab = line.indexOf("	");
+    const secondTab = line.indexOf("	", firstTab + 1);
+    if (firstTab === -1 || secondTab === -1) continue;
+    const addedRaw = line.slice(0, firstTab);
+    const removedRaw = line.slice(firstTab + 1, secondTab);
+    const pathRaw = line.slice(secondTab + 1);
+    const binary = addedRaw === "-" && removedRaw === "-";
+    entries.push({
+      path: resolveRenamePath(pathRaw),
+      added: binary ? 0 : Number.parseInt(addedRaw, 10) || 0,
+      removed: binary ? 0 : Number.parseInt(removedRaw, 10) || 0,
+      binary
+    });
+  }
+  return entries;
+}
+function topLevel(path) {
+  const slash = path.indexOf("/");
+  return slash === -1 ? path : path.slice(0, slash);
+}
+function deriveFootprint(entries, opts) {
+  let added = 0;
+  let removed = 0;
+  const scopeSet = /* @__PURE__ */ new Set();
+  const allPaths = [];
+  for (const e of entries) {
+    added += e.added;
+    removed += e.removed;
+    scopeSet.add(topLevel(e.path));
+    allPaths.push(e.path);
+  }
+  const changedPathsTruncated = allPaths.length > opts.cap;
+  return {
+    numstat: { files: entries.length, added, removed },
+    scope: [...scopeSet].sort(),
+    changedPaths: changedPathsTruncated ? allPaths.slice(0, opts.cap) : allPaths,
+    changedPathsTruncated
+  };
+}
+
+// ../../packages/executor-worktree/src/git-service.ts
 var noopLogger = { info: () => {
 }, warn: () => {
 } };
 var SCRATCH_DIR = ".dahrk/scratch";
+var CHANGED_PATHS_CAP = 100;
 var DEFAULT_MERGE_RESOLVE_RULES = [
   { path: "pnpm-lock.yaml", strategy: "theirs" },
   { path: "package-lock.json", strategy: "theirs" },
@@ -1956,6 +2052,7 @@ function createGitService(opts = {}) {
       const { remote, authEnv, cleanup } = resolveRemoteAuth(ref.gitUrl, opts2.credentialToken);
       let pushed = false;
       let integration;
+      let footprint;
       try {
         let fetched = false;
         if (opts2.base) {
@@ -1975,6 +2072,12 @@ function createGitService(opts = {}) {
           if (!delta.some((p) => !isScratchPath(p))) {
             return { headSha, pushed: false, nothingToCommit: true, commitsAhead, integration: "noop" };
           }
+          const numstatEntries = parseNumstat(git(worktreePath, ["diff", "--numstat", "FETCH_HEAD...HEAD"])).filter(
+            (e) => !isScratchPath(e.path)
+          );
+          if (numstatEntries.length > 0) {
+            footprint = deriveFootprint(numstatEntries, { cap: CHANGED_PATHS_CAP });
+          }
           try {
             git(worktreePath, [
               "-c",
@@ -2009,7 +2112,7 @@ function createGitService(opts = {}) {
                 headSha = git(worktreePath, ["rev-parse", "HEAD"]).trim();
               } else {
                 git(worktreePath, ["merge", "--abort"]);
-                return { headSha, pushed: false, nothingToCommit: !dirty, commitsAhead, integration: "conflict", conflictFiles };
+                return { headSha, pushed: false, nothingToCommit: !dirty, commitsAhead, integration: "conflict", conflictFiles, ...footprint ? { footprint } : {} };
               }
             } else {
               const msg = mergeErr.message;
@@ -2025,7 +2128,7 @@ function createGitService(opts = {}) {
       } finally {
         cleanup();
       }
-      return { headSha, pushed, nothingToCommit: !dirty, commitsAhead, ...integration ? { integration } : {} };
+      return { headSha, pushed, nothingToCommit: !dirty, commitsAhead, ...integration ? { integration } : {}, ...footprint ? { footprint } : {} };
     },
     async backupPush(ref, opts2) {
       const { worktreePath } = ref;
@@ -2120,12 +2223,16 @@ import { existsSync as existsSync2, readdirSync, realpathSync, rmSync as rmSync3
 import { join as join6 } from "path";
 var MINUTE = 6e4;
 var HOUR = 60 * MINUTE;
+var DAY = 24 * HOUR;
 var DEFAULTS = {
   // Deliberately non-optional defaults. "No policy configured" used to mean "never collect anything",
   // which is precisely how the disk reached 65 GB. Absent config must mean sane collection, not none.
   maxRuns: 20,
   maxIdleMs: 6 * HOUR,
-  activityGraceMs: 30 * MINUTE
+  activityGraceMs: 30 * MINUTE,
+  // 14 days: long enough that an operator who missed the park log can still recover unpushed work, but
+  // bounded so parked tips cannot pile up for ever. Cited verbatim in docs/logging.md - keep in step.
+  salvageTtlMs: 14 * DAY
 };
 var noop = { info: () => {
 }, warn: () => {
@@ -2166,6 +2273,38 @@ function registeredWorktrees(mirror) {
   }
   return out2.split("\n").filter((l) => l.startsWith("worktree ")).map((l) => canonical(l.slice(9).trim())).filter((p) => p && p !== canonical(mirror));
 }
+function salvageParkedMs(mirror, ref) {
+  try {
+    return statSync(join6(mirror, ref)).mtimeMs;
+  } catch {
+  }
+  try {
+    const ts = gitOut(mirror, ["log", "-g", "--format=%ct", "-1", ref]).trim();
+    if (ts) return Number(ts) * 1e3;
+  } catch {
+  }
+  return void 0;
+}
+function sweepSalvageRefs(mirror, ttlMs, dryRun, now, log) {
+  let refs;
+  try {
+    refs = gitOut(mirror, ["for-each-ref", "--format=%(refname)", "refs/dahrk/salvage/"]).split("\n").map((s) => s.trim()).filter(Boolean);
+  } catch {
+    return 0;
+  }
+  let parked = 0;
+  for (const ref of refs) {
+    const at = salvageParkedMs(mirror, ref);
+    const expired = at !== void 0 && now - at > ttlMs;
+    if (expired && !dryRun) {
+      if (!gitOk(mirror, ["update-ref", "-d", ref])) log.warn(`reaper: could not expire salvage ref ${ref}`);
+      continue;
+    }
+    if (expired) log.info(`reaper (dry-run): would expire salvage ref ${ref}`);
+    parked++;
+  }
+  return parked;
+}
 function createWorktreeReaper(opts) {
   const log = opts.logger ?? noop;
   const mirrors = () => {
@@ -2184,8 +2323,9 @@ function createWorktreeReaper(opts) {
       const maxRuns = policy.maxRuns ?? DEFAULTS.maxRuns;
       const maxIdleMs = policy.maxIdleMs ?? DEFAULTS.maxIdleMs;
       const graceMs = policy.activityGraceMs ?? DEFAULTS.activityGraceMs;
+      const salvageTtlMs = policy.salvageTtlMs ?? DEFAULTS.salvageTtlMs;
       const dryRun = policy.dryRun ?? false;
-      const report = { scanned: 0, reaped: [], skipped: 0, errors: [] };
+      const report = { scanned: 0, reaped: [], skipped: 0, salvagedRefs: 0, errors: [] };
       const now = Date.now();
       const registered = /* @__PURE__ */ new Map();
       for (const m of mirrors()) {
@@ -2247,6 +2387,14 @@ function createWorktreeReaper(opts) {
       if (report.reaped.length) {
         log.info(`reaper: reaped ${report.reaped.length} worktree(s), skipped ${report.skipped}`);
       }
+      for (const m of registered.keys()) {
+        report.salvagedRefs += sweepSalvageRefs(m, salvageTtlMs, dryRun, now, log);
+      }
+      if (report.salvagedRefs) {
+        log.info(
+          `reaper: ${report.salvagedRefs} salvage ref(s) parked, expire ${Math.round(salvageTtlMs / DAY)}d after parking`
+        );
+      }
       return report;
     }
   };
@@ -3520,6 +3668,77 @@ async function startMcpGateway(opts) {
   };
 }
 
+// ../../packages/edge/src/push-outcome.ts
+function resolveDeliverOutcome(r, job, pr) {
+  const { jobId, branch, base } = job;
+  if (r.integration === "noop") {
+    return {
+      jobId,
+      status: "ok",
+      branch,
+      headSha: r.headSha,
+      pushed: false,
+      nothingToCommit: true,
+      commitsAhead: r.commitsAhead,
+      summary: `no changes to deliver on ${branch} - work already present on ${base}`
+    };
+  }
+  if (r.integration === "conflict") {
+    return {
+      jobId,
+      status: "ok",
+      branch,
+      headSha: r.headSha,
+      pushed: false,
+      nothingToCommit: r.nothingToCommit,
+      commitsAhead: r.commitsAhead,
+      integration: "conflict",
+      ...r.conflictFiles ? { conflictFiles: r.conflictFiles } : {},
+      ...r.footprint ?? {},
+      summary: `base advanced; merge conflict on ${branch} (manual merge needed)`
+    };
+  }
+  if (r.integration === "diverged") {
+    return {
+      jobId,
+      status: "fail",
+      branch,
+      headSha: r.headSha,
+      pushed: false,
+      nothingToCommit: r.nothingToCommit,
+      commitsAhead: r.commitsAhead,
+      summary: `branch history diverged from ${base}; cannot auto-integrate on ${branch} (the branch likely needs rebuilding from ${base})`
+    };
+  }
+  return {
+    jobId,
+    status: "ok",
+    branch,
+    headSha: r.headSha,
+    pushed: r.pushed,
+    nothingToCommit: r.nothingToCommit,
+    commitsAhead: r.commitsAhead,
+    ...r.integration ? { integration: r.integration } : {},
+    ...pr?.prUrl ? { prUrl: pr.prUrl } : {},
+    ...pr?.prNumber !== void 0 ? { prNumber: pr.prNumber } : {},
+    ...pr?.prError ? { prError: pr.prError } : {},
+    ...r.footprint ?? {},
+    summary: r.nothingToCommit ? `no changes to commit; ${r.pushed ? "branch pushed" : "nothing pushed"}` : `committed ${r.headSha.slice(0, 7)} and pushed ${branch}`
+  };
+}
+function resolveBackupOutcome(r, job) {
+  return {
+    jobId: job.jobId,
+    status: "ok",
+    branch: job.branch,
+    headSha: r.headSha,
+    pushed: r.pushed,
+    nothingToCommit: r.nothingToCommit,
+    wipRef: r.wipRef,
+    summary: `backup: preserved ${r.headSha.slice(0, 7)} on ${r.wipRef} (no base merge, no PR)`
+  };
+}
+
 // ../../packages/edge/src/stage-runner.ts
 var nowIso2 = () => (/* @__PURE__ */ new Date()).toISOString();
 var PREVIEW = 500;
@@ -4135,17 +4354,7 @@ function createStageRunner(deps) {
               branch: job.branch,
               ...job.workspaceRef.credentialToken ? { credentialToken: job.workspaceRef.credentialToken } : {}
             });
-            const result = {
-              jobId,
-              status: "ok",
-              branch: job.branch,
-              headSha: r.headSha,
-              pushed: r.pushed,
-              nothingToCommit: r.nothingToCommit,
-              wipRef: r.wipRef,
-              summary: `backup: preserved ${r.headSha.slice(0, 7)} on ${r.wipRef} (no base merge, no PR)`
-            };
-            return result;
+            return resolveBackupOutcome(r, { jobId, branch: job.branch });
           } catch (e) {
             return { jobId, status: "fail", branch: job.branch, summary: `backup push failed: ${e.message}` };
           }
@@ -4170,64 +4379,13 @@ function createStageRunner(deps) {
             base: job.base,
             ...job.workspaceRef.credentialToken ? { credentialToken: job.workspaceRef.credentialToken } : {}
           });
-          if (r.integration === "noop") {
-            return {
-              jobId,
-              status: "ok",
-              branch: job.branch,
-              headSha: r.headSha,
-              pushed: false,
-              nothingToCommit: true,
-              commitsAhead: r.commitsAhead,
-              summary: `no changes to deliver on ${job.branch} - work already present on ${job.base}`
-            };
-          }
-          if (r.integration === "conflict") {
-            return {
-              jobId,
-              status: "ok",
-              branch: job.branch,
-              headSha: r.headSha,
-              pushed: false,
-              nothingToCommit: r.nothingToCommit,
-              commitsAhead: r.commitsAhead,
-              integration: "conflict",
-              ...r.conflictFiles ? { conflictFiles: r.conflictFiles } : {},
-              summary: `base advanced; merge conflict on ${job.branch} (manual merge needed)`
-            };
-          }
-          if (r.integration === "diverged") {
-            return {
-              jobId,
-              status: "fail",
-              branch: job.branch,
-              headSha: r.headSha,
-              pushed: false,
-              nothingToCommit: r.nothingToCommit,
-              commitsAhead: r.commitsAhead,
-              summary: `branch history diverged from ${job.base}; cannot auto-integrate on ${job.branch} (the branch likely needs rebuilding from ${job.base})`
-            };
-          }
           const pr = job.openPr && r.pushed ? await deps.gitService.openPrAmbient(ref, {
             branch: job.branch,
             base: job.base,
             title: job.openPr.title,
             body: job.openPr.body
           }) : void 0;
-          return {
-            jobId,
-            status: "ok",
-            branch: job.branch,
-            headSha: r.headSha,
-            pushed: r.pushed,
-            nothingToCommit: r.nothingToCommit,
-            commitsAhead: r.commitsAhead,
-            ...r.integration ? { integration: r.integration } : {},
-            ...pr?.prUrl ? { prUrl: pr.prUrl } : {},
-            ...pr?.prNumber !== void 0 ? { prNumber: pr.prNumber } : {},
-            ...pr?.prError ? { prError: pr.prError } : {},
-            summary: r.nothingToCommit ? `no changes to commit; ${r.pushed ? "branch pushed" : "nothing pushed"}` : `committed ${r.headSha.slice(0, 7)} and pushed ${job.branch}`
-          };
+          return resolveDeliverOutcome(r, { jobId, branch: job.branch, base: job.base }, pr);
         } catch (e) {
           return { jobId, status: "fail", summary: `push failed: ${e.message}` };
         }
@@ -4414,10 +4572,10 @@ async function startEdgeNode(opts) {
   await reconcileInterruptedJobs();
   void stageRunner.reapWorktrees().then((r) => {
     counters.worktreeCount = Math.max(r.scanned - r.reaped.length, 0);
-    if (r.reaped.length) {
+    if (r.reaped.length || r.salvagedRefs) {
       log.info(
-        { reaped: r.reaped, scanned: r.scanned, skipped: r.skipped },
-        `EDGE_REAPED:${r.reaped.length} worktrees (scanned ${r.scanned}, skipped ${r.skipped})`
+        { reaped: r.reaped, scanned: r.scanned, skipped: r.skipped, salvagedRefs: r.salvagedRefs },
+        `EDGE_REAPED:${r.reaped.length} worktrees (scanned ${r.scanned}, skipped ${r.skipped}, salvaged ${r.salvagedRefs})`
       );
     }
     for (const e of r.errors) log.warn({ reapError: e }, `EDGE_REAP_ERROR:${e}`);
@@ -5781,7 +5939,8 @@ function driftOf(stored, repo) {
   const drift = {};
   if (typeof stored.defaultBranch === "string" && stored.defaultBranch !== repo.defaultBranch) drift.branch = stored.defaultBranch;
   if (typeof stored.name === "string" && stored.name !== repo.name) drift.name = stored.name;
-  return drift.branch || drift.name ? drift : void 0;
+  if (typeof stored.gitUrl === "string" && stored.gitUrl !== repo.gitUrl) drift.gitUrl = stored.gitUrl;
+  return drift.branch || drift.name || drift.gitUrl ? drift : void 0;
 }
 async function registerRepo(deps, args) {
   const url = `${args.base}/config/api/repositories`;
@@ -7229,7 +7388,7 @@ async function runStatus(inputs, deps) {
 }
 
 // src/main.ts
-var CLIENT_VERSION = "0.1.21";
+var CLIENT_VERSION = "0.1.22";
 var DEFAULT_HUB_URL = "wss://api.dahrk.ai";
 var list = (v) => (v ?? "").split(",").map((s) => s.trim()).filter(Boolean);
 var RUNTIMES2 = ["claude-code", "codex", "pi"];
@@ -7622,6 +7781,7 @@ async function runRepoAdd(flags) {
         const bits = [];
         if (result.drift.branch) bits.push(`branch ${result.drift.branch} (this repo is on ${repo.defaultBranch})`);
         if (result.drift.name) bits.push(`name ${result.drift.name}`);
+        if (result.drift.gitUrl) bits.push(`URL ${result.drift.gitUrl} (this repo registers as ${repo.gitUrl})`);
         out(hint(`The hub's stored record differs - ${bits.join(", ")} - and was left unchanged.`));
       }
       return 0;