dahrk-node 0.1.20 → 0.1.22

package/dist/main.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
+import "./chunk-FYS2JH42.js";
 
 // src/main.ts
 import { execFileSync as execFileSync9 } from "child_process";
 import { existsSync as existsSync14, readFileSync as readFileSync11, realpathSync as realpathSync5 } from "fs";
 import { randomUUID as randomUUID3 } from "crypto";
 import { homedir as homedir7, platform as osPlatform4 } from "os";
-import { basename as basename2, join as join17 } from "path";
+import { basename as basename2, join as join19 } from "path";
 import { pathToFileURL } from "url";
 
 // ../../packages/edge/src/ws-client.ts
@@ -73,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) {
@@ -167,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) => {
@@ -196,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;
@@ -232,7 +239,7 @@ function documentsBlock(ctx) {
   let budget = MAX_INLINE_DOCS_TOTAL_CHARS;
   const parts = [];
   for (const doc of docs) {
-    const path = `.skakel/scratch/docs/${attachedDocBasename(doc)}.md`;
+    const path = `.dahrk/scratch/docs/${attachedDocBasename(doc)}.md`;
     const cap = Math.max(0, Math.min(MAX_INLINE_DOC_CHARS, budget));
     const body = doc.content.trim();
     const truncated = body.length > cap;
@@ -318,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 = [];
@@ -343,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();
@@ -416,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";
@@ -423,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.",
@@ -431,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." }] };
     }
   );
@@ -441,7 +577,8 @@ function createStageCompleteTool() {
     allowedToolName: STAGE_COMPLETE_TOOL_NAME,
     fired: () => captured !== null,
     summary: () => captured,
-    document: () => capturedDoc
+    document: () => capturedDoc,
+    capture
   };
 }
 
@@ -495,15 +632,15 @@ 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 = ".skakel/scratch/output/document.md";
+var HANDED_BACK_ARTIFACT_PATH = ".dahrk/scratch/output/document.md";
 var CLAUDE_CODE_SYSTEM_PROMPT = { type: "preset", preset: "claude_code" };
 var userMsg = (text) => ({
   type: "user",
   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);
@@ -543,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;
@@ -608,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),
@@ -623,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)";
@@ -802,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;
@@ -828,237 +937,21 @@ function createClaudeRunner() {
   };
 }
 
-// ../../packages/executor-worktree/src/codex-adapter.ts
-import { Codex } from "@openai/codex-sdk";
+// ../../packages/executor-worktree/src/pi-adapter.ts
+import { join as join4 } from "path";
 
-// ../../packages/executor-worktree/src/codex-mappers.ts
-function mapItem(item) {
-  switch (item.type) {
-    case "reasoning":
-      return [{ type: "thought", subtype: "reasoning_text", text: item.text }];
-    case "agent_message":
-      return [{ type: "response", text: item.text }];
-    case "command_execution":
-      return [
-        { type: "action", tool: "command", toolUseId: item.id, input: { command: item.command } },
-        { type: "observation", toolUseId: item.id, output: item.aggregated_output, isError: item.status === "failed" }
-      ];
-    case "mcp_tool_call":
-      return [
-        { type: "action", tool: `${item.server}/${item.tool}`, toolUseId: item.id, input: item.arguments },
-        { type: "observation", toolUseId: item.id, output: item.result?.content ?? item.error, isError: Boolean(item.error) }
-      ];
-    case "web_search":
-      return [{ type: "action", tool: "web_search", toolUseId: item.id, input: { query: item.query } }];
-    case "file_change":
-      return [{ type: "action", tool: "apply_patch", toolUseId: item.id, input: item.changes }];
-    case "todo_list":
-      return [{ type: "thought", text: JSON.stringify(item.items) }];
-    case "error":
-      return [{ type: "error", kind: "item_error", message: item.message }];
-    default:
-      return [];
-  }
-}
-function mapCodexEvent(ev) {
-  switch (ev.type) {
-    case "item.completed":
-      return { events: mapItem(ev.item), recognised: true };
-    case "turn.completed":
-      return {
-        events: [
-          { type: "state", event: "stage-exit", status: "ok", usage: mapUsage2(ev.usage) }
-        ],
-        recognised: true
-      };
-    case "turn.failed":
-      return {
-        events: [
-          { type: "error", kind: "turn_failed", message: JSON.stringify(ev.error ?? {}) },
-          { type: "state", event: "stage-exit", status: "fail" }
-        ],
-        recognised: true
-      };
-    case "error":
-      return { events: [{ type: "error", kind: "thread_error", message: ev.message }], recognised: true };
-    // Lifecycle / interim updates: recognised, captured in raw sidecar, not normalised.
-    case "thread.started":
-    case "turn.started":
-    case "item.started":
-    case "item.updated":
-      return { events: [], recognised: true };
-    default:
-      return { events: [], recognised: false };
+// ../../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_tokens ?? 0,
-    output: u?.output_tokens ?? 0,
-    cacheRead: u?.cached_input_tokens ?? 0,
-    cacheCreate: 0
-  };
-}
-
-// ../../packages/executor-worktree/src/codex-adapter.ts
-var COALESCE_MS2 = Number(process.env.DAHRK_COALESCE_MS ?? process.env.SKAKEL_COALESCE_MS ?? 40);
-var CODEX_COST_UNAVAILABLE_NOTE = "codex-adapter: cost reporting unavailable for the Codex runtime (the SDK reports tokens, not price); costUsd left unset, not $0\n";
-function warnCostUnavailable(write = (s) => void process.stderr.write(s)) {
-  write(CODEX_COST_UNAVAILABLE_NOTE);
-}
-function runtimeEnvOptions2(ctx) {
-  if (!ctx.runtimeEnv) return {};
-  const env = {};
-  for (const [k, v] of Object.entries(process.env)) if (v !== void 0) env[k] = v;
-  return { env: { ...env, ...ctx.runtimeEnv } };
-}
-function createCodexRunner() {
-  const abortController = new AbortController();
-  const signal = abortController.signal;
-  let cancelled = false;
-  let thread;
-  let sessionId;
-  const threadOptions = (ctx) => ({
-    workingDirectory: ctx.workspace.worktreePath,
-    sandboxMode: "workspace-write",
-    skipGitRepoCheck: true,
-    ...ctx.config.model ? { model: ctx.config.model } : {}
-  });
-  const openThread = (ctx) => {
-    const codex = new Codex(runtimeEnvOptions2(ctx));
-    const t = ctx.sessionId ? codex.resumeThread(ctx.sessionId, threadOptions(ctx)) : codex.startThread(threadOptions(ctx));
-    thread = t;
-    return t;
-  };
-  const pumpTurn = async (events, emit, ctx, suppressStageExit) => {
-    let failed = false;
-    for await (const ev of events) {
-      const rawRef = ctx.writeRaw?.(ev);
-      const { events: mapped } = mapCodexEvent(ev);
-      for (const e of mapped) {
-        if (suppressStageExit && e.type === "state") continue;
-        emit(e, rawRef);
-      }
-      if (ev.type === "thread.started") sessionId = ev.thread_id;
-      if (ev.type === "turn.failed") failed = true;
-    }
-    return failed;
-  };
-  const captureThreadId = (t) => {
-    if (t.id) sessionId = t.id;
-  };
-  return {
-    runtime: "codex",
-    async runBatch(ctx, onTrace) {
-      if (ctx.config.mcpServers && ctx.config.mcpServers.length > 0) {
-        process.stderr.write("codex-adapter: MCP servers not supported on Codex; ignoring\n");
-      }
-      const emit = makeEmit("codex", onTrace);
-      const t = openThread(ctx);
-      let status = "ok";
-      try {
-        const { events } = await t.runStreamed(resolveStagePrompt(ctx), { signal });
-        if (await pumpTurn(events, emit, ctx, false)) status = "fail";
-      } catch (e) {
-        if (!cancelled) emit({ type: "error", kind: "runtime_error", message: e.message });
-        status = "fail";
-      }
-      captureThreadId(t);
-      if (cancelled) status = "fail";
-      warnCostUnavailable();
-      return { status, ...sessionId ? { sessionId } : {} };
-    },
-    async runInteractive(ctx, turns, onTrace) {
-      const emit = makeEmit("codex", onTrace);
-      const t = openThread(ctx);
-      const exit = ctx.config.exit ?? "either";
-      if (exit === "tool" || exit === "either") {
-        process.stderr.write("codex-adapter: interactive tool-exit not supported in M4; using gate exit\n");
-      }
-      const humanIter = turns[Symbol.asyncIterator]();
-      const { firstReplyMs, idleMs } = interactiveIdleWindows(ctx);
-      let awaitingFirstReply = true;
-      let exited = "gate";
-      let pending = humanIter.next();
-      try {
-        const seed = await t.runStreamed(interactiveSeedText(ctx, false), { signal });
-        await pumpTurn(seed.events, emit, ctx, true);
-        for (; ; ) {
-          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;
-          const { events } = await t.runStreamed(texts.join("\n"), { signal });
-          await pumpTurn(events, emit, ctx, true);
-        }
-      } catch (e) {
-        if (!cancelled) emit({ type: "error", kind: "runtime_error", message: e.message });
-        exited = cancelled ? "cancelled" : "gate";
-      }
-      let status = "ok";
-      let summary = "";
-      if (exited === "gate") {
-        try {
-          const turn = await t.run(SUMMARISE_PROMPT, { signal });
-          summary = (turn.finalResponse ?? "").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)";
-      }
-      captureThreadId(t);
-      warnCostUnavailable();
-      return { status, summary, ...sessionId ? { sessionId } : {} };
-    },
-    async summarise(ctx) {
-      if (!thread) return "(no summary: thread not established)";
-      try {
-        const turn = await thread.run(SUMMARISE_PROMPT, { signal });
-        captureThreadId(thread);
-        return (turn.finalResponse ?? "").trim() || "(no summary produced)";
-      } catch (e) {
-        return `(summary unavailable: ${e.message})`;
-      }
-    },
-    async cancel() {
-      if (cancelled) return;
-      cancelled = true;
-      abortController.abort();
-    }
-  };
-}
-
-// ../../packages/executor-worktree/src/pi-mappers.ts
-function mapUsage3(u) {
   return {
     input: u?.input ?? 0,
     output: u?.output ?? 0,
@@ -1099,7 +992,7 @@ function mapPiEvent(ev) {
         const kind = ev.type === "agent_end" ? "agent_error" : "turn_error";
         events.push({ type: "error", kind, message: m?.errorMessage ?? m?.stopReason ?? "failed" });
       }
-      events.push({ type: "state", event: "stage-exit", status, usage: mapUsage3(m?.usage) });
+      events.push({ type: "state", event: "stage-exit", status, usage: mapUsage2(m?.usage) });
       return { events, recognised: true };
     }
     // Streamed deltas: owned by the buffered state machine, no discrete event here.
@@ -1154,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 });
     }
@@ -1170,162 +1059,162 @@ 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 };
 }
 
+// ../../packages/executor-worktree/src/pi-auth.ts
+import { mkdtempSync, rmSync, writeFileSync } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join3 } from "path";
+function readAuthHint(ctx) {
+  return ctx.runtimeAuth;
+}
+function applyApiKeyAuth(hint2, runtimeEnv, authStorage) {
+  const env = runtimeEnv ?? {};
+  for (const p of hint2?.providers ?? []) {
+    if (p.kind !== "api_key") continue;
+    const value = env[p.envVar];
+    if (value) authStorage.setRuntimeApiKey(p.provider, value);
+  }
+}
+function buildAuthJson(hint2) {
+  const entries = [];
+  for (const p of hint2?.providers ?? []) {
+    if (p.kind !== "oauth") continue;
+    entries.push([p.provider, { type: "oauth", ...p.extra, access: p.access, refresh: p.refresh, expires: p.expires }]);
+  }
+  return entries.length ? Object.fromEntries(entries) : void 0;
+}
+function buildCustomProviders(hint2) {
+  const providers = {};
+  for (const p of hint2?.providers ?? []) {
+    if (p.kind !== "api_key" || !p.baseUrl) continue;
+    providers[p.provider] = {
+      baseUrl: p.baseUrl,
+      ...p.headers ? { headers: p.headers } : {},
+      ...p.models ? { models: p.models } : {}
+    };
+  }
+  return Object.keys(providers).length ? { providers } : void 0;
+}
+function createStageConfigDir() {
+  return mkdtempSync(join3(tmpdir2(), "dahrk-pi-"));
+}
+function cleanupStageConfigDir(dir) {
+  rmSync(dir, { recursive: true, force: true });
+}
+function writeStageAuthFile(dir, hint2) {
+  const authJson = buildAuthJson(hint2);
+  if (!authJson) return void 0;
+  const path = join3(dir, "auth.json");
+  writeFileSync(path, JSON.stringify(authJson, null, 2));
+  return path;
+}
+function writeStageCustomProviders(dir, hint2) {
+  const models = buildCustomProviders(hint2);
+  if (!models) return void 0;
+  const path = join3(dir, "models.json");
+  writeFileSync(path, JSON.stringify(models, null, 2));
+  return path;
+}
+
 // ../../packages/executor-worktree/src/pi-adapter.ts
-var COALESCE_MS3 = Number(process.env.DAHRK_COALESCE_MS ?? process.env.SKAKEL_COALESCE_MS ?? 40);
 var PI_STAGE_COMPLETE_TOOL = "dahrk_stage_complete";
-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;
-  };
-  const readSessionCost = (s) => {
-    const cost = s.getSessionStats?.()?.cost;
-    return typeof cost === "number" ? cost : void 0;
-  };
+var PI_ASK_USER_QUESTION_TOOL = "ask_user_question";
+function piToolCallDecision(ctx, toolName, input) {
+  const verdict2 = ctx.authorizeToolUse?.(toolName, input);
+  if (verdict2?.verdict === "deny") {
+    return { block: true, reason: verdict2.reason ?? `tool "${toolName}" denied by policy ${verdict2.policy}` };
+  }
+  return void 0;
+}
+function registerToolCallGate(s, ctx) {
+  const policyCtx = ctx;
+  s.setToolCallGate?.((toolName, input) => piToolCallDecision(policyCtx, toolName, input));
+}
+function buildBrokeredPiMcpServers(ctx) {
+  const servers = ctx.config.mcpServers;
+  if (!servers || servers.length === 0 || !ctx.mcpProxyBaseUrl) return void 0;
+  const entries = {};
+  for (const s of servers) entries[s.id] = { type: s.type, url: `${ctx.mcpProxyBaseUrl}/${s.id}` };
+  return entries;
+}
+function createBrokeredMcpExtension(servers) {
   return {
-    runtime: "pi",
-    async runBatch(ctx, onTrace) {
-      const emit = makeEmit("pi", onTrace);
-      const s = await openSession(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();
+    name: "dahrk-brokered-mcp",
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    factory: async (pi) => {
+      const { Client } = await import("./client-MZ5GEQAD.js");
+      const { StreamableHTTPClientTransport } = await import("./streamableHttp-S27HYW5J.js");
+      for (const [id, server] of Object.entries(servers)) {
+        try {
+          const client = new Client({ name: `dahrk-${id}`, version: "0.1.0" });
+          await client.connect(new StreamableHTTPClientTransport(new URL(server.url)));
+          const { tools } = await client.listTools();
+          for (const tool3 of tools) {
+            pi.registerTool({
+              name: tool3.name,
+              label: tool3.name,
+              description: tool3.description ?? "",
+              // The MCP inputSchema is a JSON-schema object; Pi validates against it at runtime (its
+              // custom tools use the same plain-object shape - see the injected tools above).
+              parameters: tool3.inputSchema,
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              execute: async (_toolCallId, params) => {
+                const result = await client.callTool({ name: tool3.name, arguments: params ?? {} });
+                return { content: result.content, details: {} };
+              }
+            });
+          }
+        } catch {
+        }
       }
-      captureSessionId(s);
-      if (cancelled) status = "fail";
-      const costUsd = readSessionCost(s);
-      return { status, ...sessionId ? { sessionId } : {}, ...costUsd !== void 0 ? { costUsd } : {} };
+    }
+  };
+}
+var defaultAsk2 = async () => elicitOutcomeReply({ kind: "noreply" });
+function makePiRuntimeSession(s, ctx, hooks, interactive) {
+  return {
+    get sessionId() {
+      return s.sessionId;
     },
-    async runInteractive(ctx, turns, onTrace) {
-      const emit = makeEmit("pi", onTrace);
-      const s = await openSession(ctx);
+    async sendTurn(text) {
       const state = newPiBufferState();
-      const exit = ctx.config.exit ?? "either";
-      const wantsTool = exit === "tool" || exit === "either";
-      let toolFired = false;
-      let toolSummary = null;
+      let stageComplete = false;
+      let summary;
       let stageCompleteCallId;
-      let lastResponseText;
+      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) {
-          toolFired = true;
+          stageComplete = 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 humanIter = turns[Symbol.asyncIterator]();
-      const { firstReplyMs, idleMs } = interactiveIdleWindows(ctx);
-      let awaitingFirstReply = true;
-      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_MS3, 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)";
+          if (args?.summary) summary = args.summary;
+          return;
         }
-      } else if (exited === "timeout") {
-        status = "timeout";
-        summary = "(stage timed out awaiting input)";
-        await this.cancel();
-      } else {
-        status = "fail";
-        summary = "(stage cancelled)";
+        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();
       }
-      unsub();
-      captureSessionId(s);
-      const costUsd = readSessionCost(s);
       return {
-        status,
-        summary,
-        ...sessionId ? { sessionId } : {},
-        ...costUsd !== void 0 ? { costUsd } : {}
+        stageComplete,
+        ...summary !== void 0 ? { summary } : {},
+        ...responseText !== void 0 ? { responseText } : {},
+        ...status !== void 0 ? { status } : {}
       };
     },
-    async summarise(ctx) {
-      if (!session) return "(no summary: session not established)";
-      const s = session;
+    async summariseTurn() {
       if (s.agent) s.agent.state.tools = [];
       const state = newPiBufferState();
       let out2;
@@ -1335,7 +1224,6 @@ function createPiRunner(deps = {}) {
       });
       try {
         await s.prompt(SUMMARISE_PROMPT);
-        captureSessionId(s);
         return (out2 ?? "").trim() || "(no summary produced)";
       } catch (e) {
         return `(summary unavailable: ${e.message})`;
@@ -1343,6 +1231,72 @@ function createPiRunner(deps = {}) {
         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;
+  const openSession = async (ctx) => {
+    if (!session) session = await createSession(ctx);
+    return session;
+  };
+  let sessionDisposed = false;
+  const disposeSession = () => {
+    if (sessionDisposed || !session) return;
+    sessionDisposed = true;
+    try {
+      session.dispose();
+    } catch {
+    }
+  };
+  return {
+    runtime: "pi",
+    async runBatch(ctx, onTrace) {
+      const hooks = { emit: makeEmit("pi", onTrace), ask: defaultAsk2 };
+      const s = await openSession(ctx);
+      registerToolCallGate(s, ctx);
+      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 makeSession = (hooks) => {
+        s.setAskUserQuestionHandler?.((questions) => askQuestionsSequentially(questions, (q) => hooks.ask(q)));
+        return makePiRuntimeSession(s, ctx, hooks, true);
+      };
+      const result = await runInteractiveLoop(ctx, turns, emit, makeSession, {
+        signal,
+        cancelled: () => cancelled,
+        cancel: () => this.cancel(),
+        instructionInSystemPrompt: false
+      });
+      disposeSession();
+      return result;
+    },
+    async summarise(ctx) {
+      if (!session) return "(no summary: session not established)";
+      const rt = makePiRuntimeSession(session, ctx, { emit: () => {
+      }, ask: defaultAsk2 }, true);
+      try {
+        return await rt.summariseTurn();
+      } finally {
+        disposeSession();
+      }
+    },
     async cancel() {
       if (cancelled) return;
       cancelled = true;
@@ -1351,23 +1305,31 @@ function createPiRunner(deps = {}) {
         await session?.abort();
       } catch {
       }
-      try {
-        session?.dispose();
-      } catch {
-      }
+      disposeSession();
     }
   };
 }
 async function defaultCreatePiSession(ctx) {
   const spec = "@earendil-works/pi-coding-agent";
   const mod = await import(spec);
-  const { AuthStorage, ModelRegistry, SessionManager, createAgentSession, defineTool, resolveCliModel } = mod;
-  const authStorage = AuthStorage.create();
-  for (const [key, value] of Object.entries(ctx.runtimeEnv ?? {})) {
-    const provider = PROVIDER_BY_ENV[key];
-    if (provider) authStorage.setRuntimeApiKey(provider, value);
-  }
-  const modelRegistry = ModelRegistry.create(authStorage);
+  const {
+    AuthStorage,
+    DefaultResourceLoader,
+    ModelRegistry,
+    SessionManager,
+    SettingsManager,
+    createAgentSession,
+    defineTool,
+    getAgentDir,
+    resolveCliModel
+  } = mod;
+  const hint2 = readAuthHint(ctx);
+  const configDir = createStageConfigDir();
+  writeStageAuthFile(configDir, hint2);
+  writeStageCustomProviders(configDir, hint2);
+  const authStorage = AuthStorage.create(join4(configDir, "auth.json"));
+  applyApiKeyAuth(hint2, ctx.runtimeEnv, authStorage);
+  const modelRegistry = ModelRegistry.create(authStorage, join4(configDir, "models.json"));
   let model;
   if (ctx.config.model) {
     const resolved = resolveCliModel({ cliModel: ctx.config.model, modelRegistry });
@@ -1382,22 +1344,89 @@ async function defaultCreatePiSession(ctx) {
     parameters: { type: "object", properties: { summary: { type: "string" } }, required: ["summary"] },
     execute: async () => ({ content: [{ type: "text", text: "Stage marked complete." }], details: {} })
   });
+  let askHandler;
+  const askUserQuestion = defineTool({
+    name: PI_ASK_USER_QUESTION_TOOL,
+    label: "Ask the user a question",
+    description: "Ask the human a structured multiple-choice question and wait for their selection. Use this when you need the human to choose between options before you can continue.",
+    parameters: {
+      type: "object",
+      properties: {
+        questions: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              question: { type: "string" },
+              options: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: { label: { type: "string" }, description: { type: "string" } },
+                  required: ["label"]
+                }
+              },
+              multiSelect: { type: "boolean" }
+            },
+            required: ["question", "options"]
+          }
+        }
+      },
+      required: ["questions"]
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    execute: async (_toolCallId, params) => {
+      const text = askHandler ? await askHandler(params.questions) : elicitOutcomeReply({ kind: "noreply" });
+      return { content: [{ type: "text", text }], details: {} };
+    }
+  });
+  let toolCallGate;
+  const toolGateExtension = {
+    name: "dahrk-tool-gate",
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    factory: (pi) => {
+      pi.on("tool_call", (event) => toolCallGate?.(event.toolName, event.input));
+    }
+  };
+  const cwd = ctx.workspace.worktreePath;
+  const agentDir = getAgentDir();
+  const settingsManager = SettingsManager.create(cwd, agentDir);
+  const brokeredMcp = buildBrokeredPiMcpServers(ctx);
+  const extensionFactories = brokeredMcp ? [toolGateExtension, createBrokeredMcpExtension(brokeredMcp)] : [toolGateExtension];
+  const resourceLoader = new DefaultResourceLoader({
+    cwd,
+    agentDir,
+    settingsManager,
+    extensionFactories
+  });
+  await resourceLoader.reload();
   const { session } = await createAgentSession({
     sessionManager: SessionManager.inMemory(ctx.workspace.worktreePath),
     authStorage,
     modelRegistry,
-    cwd: ctx.workspace.worktreePath,
-    customTools: [stageComplete],
+    settingsManager,
+    resourceLoader,
+    cwd,
+    customTools: [stageComplete, askUserQuestion],
     ...model ? { model } : {}
   });
-  return session;
+  const piSession = session;
+  const innerDispose = piSession.dispose.bind(piSession);
+  piSession.dispose = () => {
+    try {
+      innerDispose();
+    } finally {
+      cleanupStageConfigDir(configDir);
+    }
+  };
+  piSession.setAskUserQuestionHandler = (handler) => {
+    askHandler = handler;
+  };
+  piSession.setToolCallGate = (gate) => {
+    toolCallGate = gate;
+  };
+  return piSession;
 }
-var PROVIDER_BY_ENV = {
-  ANTHROPIC_API_KEY: "anthropic",
-  OPENAI_API_KEY: "openai",
-  GEMINI_API_KEY: "google",
-  GOOGLE_API_KEY: "google"
-};
 function modelFamily(id) {
   const last = id.split(".").pop() ?? id;
   return last.replace(/-v\d+:\d+$/, "").toLowerCase();
@@ -1410,15 +1439,294 @@ function pickAuthedModel(resolved, available) {
   return available.find((m) => modelFamily(m.id) === family) ?? resolved;
 }
 
+// ../../packages/executor-worktree/src/pi-container.ts
+import { spawn as nodeSpawn } from "child_process";
+
+// ../../packages/executor-worktree/src/pi-rpc-client.ts
+import { StringDecoder } from "string_decoder";
+function createLineDecoder() {
+  const decoder = new StringDecoder("utf8");
+  let buffer = "";
+  const drain = () => {
+    const lines = [];
+    for (; ; ) {
+      const nl = buffer.indexOf("\n");
+      if (nl === -1) break;
+      let line = buffer.slice(0, nl);
+      buffer = buffer.slice(nl + 1);
+      if (line.endsWith("\r")) line = line.slice(0, -1);
+      lines.push(line);
+    }
+    return lines;
+  };
+  return {
+    push(chunk) {
+      buffer += typeof chunk === "string" ? chunk : decoder.write(chunk);
+      return drain();
+    },
+    end() {
+      buffer += decoder.end();
+      const lines = drain();
+      if (buffer.length > 0) {
+        const last = buffer.endsWith("\r") ? buffer.slice(0, -1) : buffer;
+        buffer = "";
+        lines.push(last);
+      }
+      return lines;
+    }
+  };
+}
+function deferred() {
+  let resolve3;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve3 = res;
+    reject = rej;
+  });
+  return { promise, resolve: resolve3, reject };
+}
+var isResponse = (msg) => typeof msg === "object" && msg !== null && msg.type === "response";
+var PiRpcSession = class {
+  #sessionId;
+  #listeners = [];
+  /** Command responses awaited by id (correlated via the optional `id` field). */
+  #pendingResponses = /* @__PURE__ */ new Map();
+  /** The in-flight `prompt()` resolver, settled on the next `agent_end`. */
+  #pendingAgentEnd;
+  #reqCounter = 0;
+  #disposed = false;
+  #child;
+  #kill;
+  constructor(child, options = {}) {
+    this.#child = child;
+    this.#kill = options.kill;
+    const decoder = createLineDecoder();
+    const onData = (chunk) => {
+      for (const line of decoder.push(chunk)) if (line.length > 0) this.#onLine(line);
+    };
+    child.stdout?.on("data", onData);
+    child.stdout?.on("end", () => {
+      for (const line of decoder.end()) if (line.length > 0) this.#onLine(line);
+    });
+  }
+  get sessionId() {
+    return this.#sessionId;
+  }
+  subscribe(listener) {
+    this.#listeners.push(listener);
+    return () => {
+      this.#listeners = this.#listeners.filter((l) => l !== listener);
+    };
+  }
+  async prompt(text) {
+    if (this.#disposed) throw new Error("pi rpc session disposed");
+    const agentEnd = deferred();
+    this.#pendingAgentEnd = agentEnd;
+    const ack = await this.#send("prompt", { message: text });
+    if (ack.success === false) {
+      this.#pendingAgentEnd = void 0;
+      throw new Error(ack.error ?? "prompt rejected");
+    }
+    await agentEnd.promise;
+  }
+  async abort() {
+    if (this.#disposed) return;
+    await this.#send("abort", {});
+  }
+  /** Best-effort refresh of the resume token from `get_state`; swallows a failed lookup. */
+  async getState() {
+    if (this.#disposed) return;
+    try {
+      const res = await this.#send("get_state", {});
+      const id = res.data?.sessionId;
+      if (typeof id === "string" && id) this.#sessionId = id;
+    } catch {
+    }
+  }
+  dispose() {
+    if (this.#disposed) return;
+    this.#disposed = true;
+    try {
+      this.#child.stdin?.end();
+    } catch {
+    }
+    const err = new Error("pi rpc session disposed");
+    for (const d of this.#pendingResponses.values()) d.reject(err);
+    this.#pendingResponses.clear();
+    if (this.#pendingAgentEnd) {
+      this.#pendingAgentEnd.reject(err);
+      this.#pendingAgentEnd = void 0;
+    }
+    if (this.#kill) {
+      const kill = this.#kill;
+      this.#kill = void 0;
+      void kill();
+    }
+  }
+  /** Write a command as one LF-terminated JSON line and await its correlated response. */
+  #send(type, fields) {
+    const id = `req-${++this.#reqCounter}`;
+    const d = deferred();
+    this.#pendingResponses.set(id, d);
+    try {
+      this.#child.stdin?.write(`${JSON.stringify({ id, type, ...fields })}
+`);
+    } catch (e) {
+      this.#pendingResponses.delete(id);
+      d.reject(e);
+    }
+    return d.promise;
+  }
+  #onLine(line) {
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (isResponse(msg)) {
+      const id = msg.id;
+      if (typeof id === "string") {
+        const pending = this.#pendingResponses.get(id);
+        if (pending) {
+          this.#pendingResponses.delete(id);
+          pending.resolve(msg);
+        }
+      }
+      return;
+    }
+    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;
+      this.#pendingAgentEnd = void 0;
+      d.resolve();
+    }
+  }
+};
+
+// ../../packages/executor-worktree/src/pi-container.ts
+var DEFAULT_IMAGE = process.env.DAHRK_PI_IMAGE ?? process.env.SKAKEL_PI_IMAGE ?? "dahrk/pi:latest";
+var _seq = 0;
+function createContainerPiSession(opts = {}) {
+  const {
+    image = DEFAULT_IMAGE,
+    scratchDir: optsScratchDir,
+    spawn: spawnFn = nodeSpawn,
+    onStderr = (line) => void process.stderr.write(`pi-container: ${line}
+`)
+  } = opts;
+  return async (ctx) => {
+    const containerName = `dahrk-pi-${Date.now()}-${++_seq}`;
+    const resolvedScratchDir = optsScratchDir ?? ctx.workspace.scratchPath;
+    const mountArgs = resolvedScratchDir ? ["-v", `${resolvedScratchDir}:/dahrk/scratch`] : [];
+    const envArgs = [];
+    for (const [k, v] of Object.entries(ctx.runtimeEnv ?? {})) {
+      envArgs.push("-e", `${k}=${v}`);
+    }
+    const child = spawnFn(
+      "docker",
+      ["run", "-i", "--rm", "--name", containerName, ...mountArgs, ...envArgs, image, "pi", "--mode", "rpc"],
+      { stdio: ["pipe", "pipe", "pipe"] }
+    );
+    child.stderr?.setEncoding("utf8");
+    let stderrBuf = "";
+    child.stderr?.on("data", (chunk) => {
+      stderrBuf += chunk;
+      const lines = stderrBuf.split("\n");
+      stderrBuf = lines.pop() ?? "";
+      for (const line of lines) if (line.trim()) onStderr(line);
+    });
+    child.stderr?.on("end", () => {
+      if (stderrBuf.trim()) onStderr(stderrBuf);
+      stderrBuf = "";
+    });
+    const killContainer = () => new Promise((resolve3) => {
+      const killer = spawnFn("docker", ["kill", containerName], { stdio: "ignore" });
+      killer.on("exit", () => resolve3());
+      killer.on("error", () => resolve3());
+    });
+    return new PiRpcSession(child, { kill: killContainer });
+  };
+}
+function createIsolatedPiRunner(opts = {}) {
+  return createPiRunner({ createSession: createContainerPiSession(opts) });
+}
+
 // ../../packages/executor-worktree/src/git-service.ts
 import { execFileSync } from "child_process";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync as readFileSync2, rmSync, writeFileSync } from "fs";
-import { homedir as homedir2, tmpdir as tmpdir2 } from "os";
-import { basename, dirname, isAbsolute, join as join3 } from "path";
+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 = ".skakel/scratch";
+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" },
+  { path: "yarn.lock", strategy: "theirs" },
+  { path: "CHANGELOG.md", strategy: "union" },
+  { path: "CHANGELOG.internal.md", strategy: "union" }
+];
 function parseOwnerRepo(gitUrl) {
   const m = /[:/]([^/:]+)\/([^/]+?)(?:\.git)?$/.exec(gitUrl.trim());
   return m ? `${m[1]}/${m[2]}` : void 0;
@@ -1428,10 +1736,10 @@ function sanitizeBranchName(name) {
   return name.replace(/[`~^:?*[\]\\@{}\s]/g, "-").replace(/\.{2,}/g, ".").replace(/\/{2,}/g, "/").replace(/\.lock(\/|$)/g, "$1").replace(/^[.\-/]+/, "").replace(/[.\-/]+$/, "").replace(/-{2,}/g, "-");
 }
 function resolveWorktreesDir(override) {
-  return override ?? process.env.DAHRK_WORKTREES_DIR ?? process.env.SKAKEL_WORKTREES_DIR ?? join3(homedir2(), ".dahrk", "worktrees");
+  return override ?? process.env.DAHRK_WORKTREES_DIR ?? process.env.SKAKEL_WORKTREES_DIR ?? join5(homedir2(), ".dahrk", "worktrees");
 }
 function resolveMirrorsDir(override) {
-  return override ?? process.env.DAHRK_MIRRORS_DIR ?? process.env.SKAKEL_MIRRORS_DIR ?? join3(homedir2(), ".dahrk", "mirrors");
+  return override ?? process.env.DAHRK_MIRRORS_DIR ?? process.env.SKAKEL_MIRRORS_DIR ?? join5(homedir2(), ".dahrk", "mirrors");
 }
 function createGitService(opts = {}) {
   const worktreesDir = resolveWorktreesDir(opts.worktreesDir);
@@ -1467,15 +1775,17 @@ function createGitService(opts = {}) {
     return (stderr?.trim() || err?.message || String(e)).split("\n")[0] ?? String(e);
   };
   const excludeScratchLocally = (worktreePath) => {
-    const entry = `${SCRATCH_DIR}/`;
+    const entries = [`${SCRATCH_DIR}/`];
     try {
       const rel = git(worktreePath, ["rev-parse", "--git-path", "info/exclude"]).trim();
-      const excludePath = isAbsolute(rel) ? rel : join3(worktreePath, rel);
+      const excludePath = isAbsolute(rel) ? rel : join5(worktreePath, rel);
       const existing = existsSync(excludePath) ? readFileSync2(excludePath, "utf-8") : "";
-      if (existing.split("\n").some((l) => l.trim() === entry)) return;
+      const lines = existing.split("\n").map((l) => l.trim());
+      const toAdd = entries.filter((e) => !lines.includes(e));
+      if (toAdd.length === 0) return;
       mkdirSync(dirname(excludePath), { recursive: true });
       const sep4 = existing && !existing.endsWith("\n") ? "\n" : "";
-      writeFileSync(excludePath, `${existing}${sep4}${entry}
+      writeFileSync2(excludePath, `${existing}${sep4}${toAdd.join("\n")}
 `);
     } catch (e) {
       log.warn(`could not set worktree scratch exclude at ${worktreePath}: ${e.message}`);
@@ -1499,13 +1809,53 @@ function createGitService(opts = {}) {
     }
     return { headSha: git(worktreePath, ["rev-parse", "HEAD"]).trim(), dirty };
   };
+  const unmergedPaths = (worktreePath) => git(worktreePath, ["diff", "--name-only", "--diff-filter=U"]).split("\n").map((l) => l.trim()).filter(Boolean);
+  const unionMerge = (worktreePath, p) => {
+    const stage = (n) => {
+      try {
+        return git(worktreePath, ["show", `:${n}:${p}`]);
+      } catch {
+        return "";
+      }
+    };
+    const dir = mkdtempSync2(join5(tmpdir3(), "dahrk-union-"));
+    try {
+      const ours = join5(dir, "ours");
+      const base = join5(dir, "base");
+      const theirs = join5(dir, "theirs");
+      writeFileSync2(ours, stage(2));
+      writeFileSync2(base, stage(1));
+      writeFileSync2(theirs, stage(3));
+      const merged = git(worktreePath, ["merge-file", "-p", "--union", ours, base, theirs]);
+      writeFileSync2(join5(worktreePath, p), merged);
+    } finally {
+      rmSync2(dir, { recursive: true, force: true });
+    }
+  };
+  const preResolveConflicts = (worktreePath, rules) => {
+    gitOk2(worktreePath, ["rerere"]);
+    for (const p of unmergedPaths(worktreePath)) {
+      const rule = rules.find((r) => r.path === p || basename(p) === r.path);
+      if (!rule) continue;
+      try {
+        if (rule.strategy === "union") {
+          unionMerge(worktreePath, p);
+        } else {
+          git(worktreePath, ["checkout", `--${rule.strategy}`, "--", p]);
+        }
+        git(worktreePath, ["add", "--", p]);
+      } catch (e) {
+        log.warn(`pre-resolve of ${p} (${rule.strategy}) failed: ${e.message}`);
+      }
+    }
+  };
   const setupAuth = (token) => {
-    const dir = mkdtempSync(join3(tmpdir2(), "dahrk-cred-"));
-    const script = join3(dir, "askpass.sh");
-    writeFileSync(script, '#!/bin/sh\nprintf "%s" "$DAHRK_GIT_TOKEN"\n', { mode: 448 });
+    const dir = mkdtempSync2(join5(tmpdir3(), "dahrk-cred-"));
+    const script = join5(dir, "askpass.sh");
+    writeFileSync2(script, '#!/bin/sh\nprintf "%s" "$DAHRK_GIT_TOKEN"\n', { mode: 448 });
     return {
       env: { ...process.env, GIT_ASKPASS: script, DAHRK_GIT_TOKEN: token, GIT_TERMINAL_PROMPT: "0" },
-      cleanup: () => rmSync(dir, { recursive: true, force: true })
+      cleanup: () => rmSync2(dir, { recursive: true, force: true })
     };
   };
   const netEnv = (authEnv) => authEnv ?? { ...process.env, GIT_TERMINAL_PROMPT: "0" };
@@ -1518,7 +1868,7 @@ function createGitService(opts = {}) {
       cleanup: () => auth?.cleanup()
     };
   };
-  const mirrorPathFor = (repoId) => join3(mirrorsDir, sanitizeBranchName(repoId));
+  const mirrorPathFor = (repoId) => join5(mirrorsDir, sanitizeBranchName(repoId));
   const listWorktrees = (mirror) => {
     let out2;
     try {
@@ -1543,7 +1893,7 @@ function createGitService(opts = {}) {
     } catch (e) {
       log.warn(`git worktree remove failed for ${worktreePath}: ${e.message}`);
     }
-    rmSync(worktreePath, { recursive: true, force: true });
+    rmSync2(worktreePath, { recursive: true, force: true });
     gitOk2(mirror, ["worktree", "prune"]);
   };
   const TRACKING_REFSPEC = "+refs/heads/*:refs/remotes/origin/*";
@@ -1630,18 +1980,19 @@ function createGitService(opts = {}) {
     baseBranch: spec.baseBranch,
     branch: sanitizeBranchName(spec.branch ?? `dahrk/${spec.runId}`),
     worktreePath,
-    scratchPath: join3(worktreePath, ".skakel", "scratch")
+    scratchPath: join5(worktreePath, SCRATCH_DIR)
   });
   return {
     worktreesDir,
     async createWorktree(spec) {
       const { repoId, gitUrl, baseBranch, runId } = spec;
       const branchName = sanitizeBranchName(spec.branch ?? `dahrk/${runId}`);
-      const worktreePath = join3(worktreesDir, runId);
+      const worktreePath = join5(worktreesDir, runId);
       mkdirSync(worktreesDir, { recursive: true });
       if (existsSync(worktreePath) && gitOk2(worktreePath, ["rev-parse", "--git-dir"])) {
         log.info(`reusing existing worktree at ${worktreePath}`);
-        mkdirSync(join3(worktreePath, ".skakel", "scratch"), { recursive: true });
+        mkdirSync(join5(worktreePath, SCRATCH_DIR), { recursive: true });
+        excludeScratchLocally(worktreePath);
         return refFor(spec, worktreePath);
       }
       const auth = spec.credentialToken ? setupAuth(spec.credentialToken) : void 0;
@@ -1677,7 +2028,8 @@ function createGitService(opts = {}) {
       if (!gitOk2(worktreePath, ["rev-parse", "--verify", "-q", "HEAD"])) {
         throw new Error(`base '${baseBranch}' did not materialise into ${worktreePath} (unborn HEAD)`);
       }
-      mkdirSync(join3(worktreePath, ".skakel", "scratch"), { recursive: true });
+      mkdirSync(join5(worktreePath, SCRATCH_DIR), { recursive: true });
+      excludeScratchLocally(worktreePath);
       return refFor(spec, worktreePath);
     },
     async commitAndPush(ref, opts2) {
@@ -1700,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) {
@@ -1719,12 +2072,22 @@ 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",
               `user.name=${authorName}`,
               "-c",
               `user.email=${authorEmail}`,
+              "-c",
+              "rerere.enabled=true",
+              "-c",
+              "rerere.autoupdate=true",
               "merge",
               "--no-edit",
               "FETCH_HEAD"
@@ -1734,15 +2097,30 @@ function createGitService(opts = {}) {
           } catch (mergeErr) {
             const inMerge = gitOk2(worktreePath, ["rev-parse", "--verify", "-q", "MERGE_HEAD"]);
             if (inMerge) {
-              const conflictFiles = git(worktreePath, ["diff", "--name-only", "--diff-filter=U"]).split("\n").map((l) => l.trim()).filter(Boolean);
-              git(worktreePath, ["merge", "--abort"]);
-              return { headSha, pushed: false, nothingToCommit: !dirty, commitsAhead, integration: "conflict", conflictFiles };
-            }
-            const msg = mergeErr.message;
-            if (/unrelated histories|refusing to merge/i.test(msg)) {
-              return { headSha, pushed: false, nothingToCommit: !dirty, commitsAhead, integration: "diverged" };
+              preResolveConflicts(worktreePath, opts2.mergeResolve ?? DEFAULT_MERGE_RESOLVE_RULES);
+              const conflictFiles = unmergedPaths(worktreePath);
+              if (conflictFiles.length === 0) {
+                git(worktreePath, [
+                  "-c",
+                  `user.name=${authorName}`,
+                  "-c",
+                  `user.email=${authorEmail}`,
+                  "commit",
+                  "--no-edit"
+                ]);
+                integration = "clean";
+                headSha = git(worktreePath, ["rev-parse", "HEAD"]).trim();
+              } else {
+                git(worktreePath, ["merge", "--abort"]);
+                return { headSha, pushed: false, nothingToCommit: !dirty, commitsAhead, integration: "conflict", conflictFiles, ...footprint ? { footprint } : {} };
+              }
+            } else {
+              const msg = mergeErr.message;
+              if (/unrelated histories|refusing to merge/i.test(msg)) {
+                return { headSha, pushed: false, nothingToCommit: !dirty, commitsAhead, integration: "diverged" };
+              }
+              throw mergeErr;
             }
-            throw mergeErr;
           }
         }
         git(worktreePath, ["push", remote, `HEAD:refs/heads/${branch}`], netEnv(authEnv));
@@ -1750,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;
@@ -1805,10 +2183,10 @@ function createGitService(opts = {}) {
           return void 0;
         }
       };
-      const tmp = mkdtempSync(join3(tmpdir2(), "dahrk-pr-"));
-      const bodyFile = join3(tmp, "body.md");
+      const tmp = mkdtempSync2(join5(tmpdir3(), "dahrk-pr-"));
+      const bodyFile = join5(tmp, "body.md");
       try {
-        writeFileSync(bodyFile, opts2.body ?? "");
+        writeFileSync2(bodyFile, opts2.body ?? "");
         try {
           gh(worktreePath, [
             "pr",
@@ -1830,7 +2208,7 @@ function createGitService(opts = {}) {
         }
         return readBack() ?? { prError: "gh pr create reported success but no PR was found" };
       } finally {
-        rmSync(tmp, { recursive: true, force: true });
+        rmSync2(tmp, { recursive: true, force: true });
       }
     },
     async teardownWorktree(ref) {
@@ -1841,16 +2219,20 @@ function createGitService(opts = {}) {
 
 // ../../packages/executor-worktree/src/worktree-reaper.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync2, readdirSync, realpathSync, rmSync as rmSync2, statSync } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync2, readdirSync, realpathSync, rmSync as rmSync3, statSync } from "fs";
+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: () => {
@@ -1872,7 +2254,7 @@ var canonical = (p) => {
   }
 };
 function lastUsedMs(worktreePath) {
-  const candidates = [join4(worktreePath, ".skakel", "scratch", "state.json"), worktreePath];
+  const candidates = [join6(worktreePath, ".dahrk", "scratch", "state.json"), worktreePath];
   let newest = 0;
   for (const p of candidates) {
     try {
@@ -1891,11 +2273,43 @@ 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 = () => {
     try {
-      return readdirSync(opts.mirrorsDir).map((d) => join4(opts.mirrorsDir, d)).filter((m) => gitOk(m, ["rev-parse", "--git-dir"]));
+      return readdirSync(opts.mirrorsDir).map((d) => join6(opts.mirrorsDir, d)).filter((m) => gitOk(m, ["rev-parse", "--git-dir"]));
     } catch {
       return [];
     }
@@ -1909,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()) {
@@ -1919,7 +2334,7 @@ function createWorktreeReaper(opts) {
       }
       const onDisk = (() => {
         try {
-          return readdirSync(opts.worktreesDir).map((d) => canonical(join4(opts.worktreesDir, d)));
+          return readdirSync(opts.worktreesDir).map((d) => canonical(join6(opts.worktreesDir, d)));
         } catch {
           return [];
         }
@@ -1962,7 +2377,7 @@ function createWorktreeReaper(opts) {
           if (d.mirror) {
             gitOk(d.mirror, ["worktree", "remove", "--force", d.path]);
           }
-          rmSync2(d.path, { recursive: true, force: true });
+          rmSync3(d.path, { recursive: true, force: true });
           if (d.mirror) gitOk(d.mirror, ["worktree", "prune"]);
           report.reaped.push({ runId: d.runId, path: d.path, reason: d.reason });
         } catch (e) {
@@ -1972,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;
     }
   };
@@ -1979,20 +2402,20 @@ function createWorktreeReaper(opts) {
 
 // ../../packages/executor-worktree/src/trace-writer.ts
 import { createHash } from "crypto";
-import { appendFileSync, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join5 } from "path";
+import { appendFileSync, mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join7 } from "path";
 var DEFAULT_SPILL_BYTES = 8192;
 function createTraceWriter(scratchPath, meta, opts = {}) {
   const spillBytes = opts.spillBytes ?? DEFAULT_SPILL_BYTES;
-  const dir = join5(scratchPath, "traces", meta.stageId, `attempt-${meta.attempt}`);
-  mkdirSync2(join5(dir, "blobs"), { recursive: true });
-  mkdirSync2(join5(dir, "raw"), { recursive: true });
-  const tracePath = join5(dir, "trace.jsonl");
-  const metaPath = join5(dir, "meta.json");
+  const dir = join7(scratchPath, "traces", meta.stageId, `attempt-${meta.attempt}`);
+  mkdirSync2(join7(dir, "blobs"), { recursive: true });
+  mkdirSync2(join7(dir, "raw"), { recursive: true });
+  const tracePath = join7(dir, "trace.jsonl");
+  const metaPath = join7(dir, "meta.json");
   let current = { ...meta };
   let nextSeq = 0;
   let rawCount = 0;
-  writeFileSync2(metaPath, JSON.stringify(current, null, 2));
+  writeFileSync3(metaPath, JSON.stringify(current, null, 2));
   const tooBig = (value) => {
     const s = typeof value === "string" ? value : JSON.stringify(value ?? "");
     return s.length > spillBytes;
@@ -2000,8 +2423,8 @@ function createTraceWriter(scratchPath, meta, opts = {}) {
   const spillValue = (value) => {
     const data = typeof value === "string" ? value : JSON.stringify(value);
     const sha = createHash("sha256").update(data).digest("hex");
-    writeFileSync2(join5(dir, "blobs", sha), data);
-    return join5("blobs", sha);
+    writeFileSync3(join7(dir, "blobs", sha), data);
+    return join7("blobs", sha);
   };
   const spill = (event) => {
     if (event.type === "thought" && event.text !== void 0 && tooBig(event.text)) {
@@ -2031,13 +2454,13 @@ function createTraceWriter(scratchPath, meta, opts = {}) {
       return written;
     },
     writeRaw(record) {
-      const rel = join5("raw", `${rawCount++}.json`);
-      writeFileSync2(join5(dir, rel), JSON.stringify(record, null, 2));
+      const rel = join7("raw", `${rawCount++}.json`);
+      writeFileSync3(join7(dir, rel), JSON.stringify(record, null, 2));
       return rel;
     },
     finalise(patch = {}) {
       current = { ...current, ...patch };
-      writeFileSync2(metaPath, JSON.stringify(current, null, 2));
+      writeFileSync3(metaPath, JSON.stringify(current, null, 2));
     },
     count() {
       return nextSeq;
@@ -2047,13 +2470,13 @@ function createTraceWriter(scratchPath, meta, opts = {}) {
 
 // ../../packages/executor-worktree/src/pack-cache.ts
 import { createHash as createHash2 } from "crypto";
-import { cpSync, existsSync as existsSync3, mkdirSync as mkdirSync3, mkdtempSync as mkdtempSync2, readdirSync as readdirSync2, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname2, join as join6, relative, sep } from "path";
+import { cpSync, existsSync as existsSync3, mkdirSync as mkdirSync3, mkdtempSync as mkdtempSync3, readdirSync as readdirSync2, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname2, join as join8, relative, sep } from "path";
 function readManifestFiles(dir) {
   const out2 = [];
   const walk = (cur) => {
     for (const entry of readdirSync2(cur, { withFileTypes: true })) {
-      const abs = join6(cur, entry.name);
+      const abs = join8(cur, entry.name);
       if (entry.isDirectory()) walk(abs);
       else out2.push(relative(dir, abs).split(sep).join("/"));
     }
@@ -2063,8 +2486,8 @@ function readManifestFiles(dir) {
 }
 
 // ../../packages/executor-worktree/src/overlay.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname3, join as join7 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname3, join as join9 } from "path";
 function sameBytes(dest, bytes) {
   try {
     return readFileSync3(dest).equals(bytes);
@@ -2076,16 +2499,16 @@ async function overlayComponents(opts) {
   const { worktreePath, runtime, components, cache } = opts;
   const result = { written: [], skippedRepoLocal: [], warnings: [] };
   for (const ref of components) {
-    if (runtime === "codex") {
+    if (runtime !== "claude-code") {
       result.warnings.push(
-        `codex runtime: ${ref.kind} \`${ref.name}@${ref.version}\` not materialised; inline into the prompt or use Claude`
+        `${runtime} runtime: ${ref.kind} \`${ref.name}@${ref.version}\` not materialised; inline into the prompt or use Claude`
       );
       continue;
     }
     const { dir } = await cache.materialise(ref);
     for (const relPath of readManifestFiles(dir)) {
-      const src = join7(dir, relPath);
-      const dest = join7(worktreePath, relPath);
+      const src = join9(dir, relPath);
+      const dest = join9(worktreePath, relPath);
       const bytes = readFileSync3(src);
       if (existsSync4(dest)) {
         if (sameBytes(dest, bytes)) continue;
@@ -2093,27 +2516,21 @@ async function overlayComponents(opts) {
         continue;
       }
       mkdirSync4(dirname3(dest), { recursive: true });
-      writeFileSync4(dest, bytes);
+      writeFileSync5(dest, bytes);
       result.written.push(relPath);
     }
   }
   return result;
 }
 
-// ../../packages/executor-worktree/src/pi-container.ts
-import { spawn as nodeSpawn } from "child_process";
-
-// ../../packages/executor-worktree/src/pi-rpc-client.ts
-import { StringDecoder } from "string_decoder";
-
-// ../../packages/executor-worktree/src/pi-container.ts
-var DEFAULT_IMAGE = process.env.DAHRK_PI_IMAGE ?? process.env.SKAKEL_PI_IMAGE ?? "dahrk/pi:latest";
-
 // ../../packages/executor-worktree/src/index.ts
 function makeRunner(runtime) {
   if ((process.env.DAHRK_RUNNER ?? process.env.SKAKEL_RUNNER ?? "real") === "mock") return createMockRunner(runtime);
-  if (runtime === "pi") return createPiRunner();
-  return runtime === "codex" ? createCodexRunner() : createClaudeRunner();
+  if (runtime === "pi") return piContainerIsolationRequired() ? createIsolatedPiRunner() : createPiRunner();
+  return createClaudeRunner();
+}
+function piContainerIsolationRequired() {
+  return (process.env.DAHRK_PI_ISOLATION ?? process.env.SKAKEL_PI_ISOLATION) === "container";
 }
 
 // ../../packages/edge/src/health.ts
@@ -2172,8 +2589,8 @@ function collectHealth(inputs) {
 }
 
 // ../../packages/edge/src/job-ledger.ts
-import { chmodSync, existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync4, renameSync, unlinkSync, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname4, join as join8 } from "path";
+import { chmodSync, existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync4, renameSync, unlinkSync, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname4, join as join10 } from "path";
 var FILE_MODE = 384;
 var DIR_MODE = 448;
 function nullJobLedger() {
@@ -2202,7 +2619,7 @@ function fileJobLedger(file, warn = console.warn) {
     const tmp = `${file}.${process.pid}.tmp`;
     try {
       mkdirSync5(dirname4(file), { recursive: true, mode: DIR_MODE });
-      writeFileSync5(tmp, `${JSON.stringify(entries, null, 2)}
+      writeFileSync6(tmp, `${JSON.stringify(entries, null, 2)}
 `, { mode: FILE_MODE });
       chmodSync(tmp, FILE_MODE);
       renameSync(tmp, file);
@@ -2237,7 +2654,7 @@ function announceableJobs(entries) {
   return out2;
 }
 function jobLedgerFile(stateDir2) {
-  return join8(stateDir2, "jobs.json");
+  return join10(stateDir2, "jobs.json");
 }
 
 // ../../packages/edge/src/log-shipper.ts
@@ -2340,8 +2757,8 @@ function ceilingFromEnv(env) {
 }
 
 // ../../packages/edge/src/logger.ts
-import { closeSync, existsSync as existsSync6, mkdirSync as mkdirSync6, openSync, renameSync as renameSync2, rmSync as rmSync4, statSync as statSync2, writeSync } from "fs";
-import { join as join9 } from "path";
+import { closeSync, existsSync as existsSync6, mkdirSync as mkdirSync6, openSync, renameSync as renameSync2, rmSync as rmSync5, statSync as statSync2, writeSync } from "fs";
+import { join as join11 } from "path";
 import pino from "pino";
 
 // ../../packages/edge/src/redact.ts
@@ -2465,7 +2882,7 @@ var RotatingFile = class {
       closeSync(this.fd);
       this.fd = void 0;
       const oldest = `${this.path}.${this.maxFiles}`;
-      if (existsSync6(oldest)) rmSync4(oldest, { force: true });
+      if (existsSync6(oldest)) rmSync5(oldest, { force: true });
       for (let i = this.maxFiles - 1; i >= 1; i--) {
         const from = `${this.path}.${i}`;
         if (existsSync6(from)) renameSync2(from, `${this.path}.${i + 1}`);
@@ -2531,7 +2948,7 @@ function createNodeLogger(opts = {}) {
   if (opts.dir && fileLevel !== "silent") {
     try {
       mkdirSync6(opts.dir, { recursive: true, mode: 448 });
-      const file = new RotatingFile(join9(opts.dir, "node.jsonl"), opts.maxBytes ?? 10 * 1024 * 1024, opts.maxFiles ?? 5);
+      const file = new RotatingFile(join11(opts.dir, "node.jsonl"), opts.maxBytes ?? 10 * 1024 * 1024, opts.maxFiles ?? 5);
       streams.push({ level: fileLevel, stream: file });
     } catch (e) {
       process.stderr.write(`dahrk: file logging disabled (${e.message})
@@ -2589,9 +3006,9 @@ function denyToolRule(tool3) {
 // ../../packages/edge/src/stage-runner.ts
 import { execFileSync as execFileSync5 } from "child_process";
 import { createHash as createHash3 } from "crypto";
-import { mkdirSync as mkdirSync7, readdirSync as readdirSync3, readFileSync as readFileSync5, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "fs";
-import { tmpdir as tmpdir4 } from "os";
-import { isAbsolute as isAbsolute3, join as join11, relative as relative3, resolve as resolve2, sep as sep3 } from "path";
+import { mkdirSync as mkdirSync7, readdirSync as readdirSync3, readFileSync as readFileSync5, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "fs";
+import { tmpdir as tmpdir5 } from "os";
+import { isAbsolute as isAbsolute3, join as join13, relative as relative3, resolve as resolve2, sep as sep3 } from "path";
 import { attachedDocBasename as attachedDocBasename2 } from "@dahrk/contracts";
 
 // ../../packages/edge/src/builtins.ts
@@ -2600,8 +3017,8 @@ import { execFileSync as execFileSync4 } from "child_process";
 // ../../packages/edge/src/fs-roots.ts
 import { execFileSync as execFileSync3 } from "child_process";
 import { existsSync as existsSync7, realpathSync as realpathSync2 } from "fs";
-import { homedir as homedir3, tmpdir as tmpdir3 } from "os";
-import { dirname as dirname5, isAbsolute as isAbsolute2, join as join10, relative as relative2, resolve, sep as sep2 } from "path";
+import { homedir as homedir3, tmpdir as tmpdir4 } from "os";
+import { dirname as dirname5, isAbsolute as isAbsolute2, join as join12, relative as relative2, resolve, sep as sep2 } from "path";
 function isUnder(root, target) {
   const rel = relative2(resolve(root), resolve(target));
   return rel === "" || !rel.startsWith(`..${sep2}`) && rel !== ".." && !isAbsolute2(rel);
@@ -2617,7 +3034,7 @@ function realish(p) {
   while (head !== dirname5(head)) {
     if (existsSync7(head)) {
       try {
-        return join10(realpathSync2.native(head), ...tail.reverse());
+        return join12(realpathSync2.native(head), ...tail.reverse());
       } catch {
         return p;
       }
@@ -2667,7 +3084,7 @@ function computeFsRoots(opts) {
     // Every git command in the worktree reads and writes here.
     ...[gitCommonDir(opts.worktreePath)].filter((p) => Boolean(p)).map(realish),
     // Scratch space: `mkdtemp`, git's temp files, and an agent tidying a throwaway dir it created.
-    ...[tmpdir3(), "/tmp", "/private/tmp", "/var/folders", "/private/var/folders"].map(realish),
+    ...[tmpdir4(), "/tmp", "/private/tmp", "/var/folders", "/private/var/folders"].map(realish),
     // The safe I/O sinks. `2>/dev/null` is on a third of the shell commands real stages run; treating
     // it as a write outside the worktree would deny most of a normal build. The raw devices are NOT
     // here, so `> /dev/sda` still fails confinement (as well as shell_guard's device-write regex).
@@ -2686,26 +3103,26 @@ function computeFsRoots(opts) {
     "/System",
     "/proc",
     "/sys",
-    join10(home, ".gitconfig"),
-    join10(home, ".config"),
-    join10(home, ".npmrc"),
-    join10(home, ".cache"),
-    join10(home, "Library", "Caches"),
-    join10(home, "Library", "pnpm"),
-    join10(home, ".local", "share"),
-    join10(home, ".nvm"),
-    join10(home, ".volta"),
-    join10(home, ".asdf"),
-    join10(home, ".cargo"),
-    join10(home, ".rustup"),
+    join12(home, ".gitconfig"),
+    join12(home, ".config"),
+    join12(home, ".npmrc"),
+    join12(home, ".cache"),
+    join12(home, "Library", "Caches"),
+    join12(home, "Library", "pnpm"),
+    join12(home, ".local", "share"),
+    join12(home, ".nvm"),
+    join12(home, ".volta"),
+    join12(home, ".asdf"),
+    join12(home, ".cargo"),
+    join12(home, ".rustup"),
     ...splitRoots(process.env.DAHRK_FS_EXTRA_READ_ROOTS).map((p) => realish(resolve(p)))
   ].map(realish);
   const deny = [
-    join10(home, ".ssh"),
-    join10(home, ".aws"),
-    join10(home, ".gnupg"),
-    join10(home, ".config", "gcloud"),
-    join10(home, "Library", "Keychains"),
+    join12(home, ".ssh"),
+    join12(home, ".aws"),
+    join12(home, ".gnupg"),
+    join12(home, ".config", "gcloud"),
+    join12(home, "Library", "Keychains"),
     "/Volumes",
     "/etc/shadow",
     "/etc/sudoers"
@@ -3251,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;
@@ -3290,7 +3778,7 @@ var attemptOf = (jobId) => {
 };
 var digest = (value) => `sha256:${createHash3("sha256").update(JSON.stringify(value)).digest("hex").slice(0, 16)}`;
 function writeScratchState(ref, job, attempt, status) {
-  const statePath = join11(ref.scratchPath, "state.json");
+  const statePath = join13(ref.scratchPath, "state.json");
   let state;
   try {
     state = JSON.parse(readFileSync5(statePath, "utf8"));
@@ -3299,23 +3787,23 @@ function writeScratchState(ref, job, attempt, status) {
   }
   state.stages[job.stageId] = { currentAttempt: attempt, status };
   mkdirSync7(ref.scratchPath, { recursive: true });
-  writeFileSync6(statePath, JSON.stringify(state, null, 2));
+  writeFileSync7(statePath, JSON.stringify(state, null, 2));
 }
 function writeIssueContext(ref, issueContext) {
   if (issueContext === void 0) return;
   try {
     mkdirSync7(ref.scratchPath, { recursive: true });
-    writeFileSync6(join11(ref.scratchPath, "issue.md"), issueContext);
+    writeFileSync7(join13(ref.scratchPath, "issue.md"), issueContext);
   } catch {
   }
 }
 function writeAttachedDocuments(ref, docs) {
   if (!docs || docs.length === 0) return;
   try {
-    const dir = join11(ref.scratchPath, "docs");
+    const dir = join13(ref.scratchPath, "docs");
     mkdirSync7(dir, { recursive: true });
     for (const doc of docs) {
-      writeFileSync6(join11(dir, `${attachedDocBasename2(doc)}.md`), doc.content);
+      writeFileSync7(join13(dir, `${attachedDocBasename2(doc)}.md`), doc.content);
     }
   } catch {
   }
@@ -3334,12 +3822,12 @@ function writeGuidance(ref, guidance) {
   if (!guidance || guidance.length === 0) return;
   try {
     mkdirSync7(ref.scratchPath, { recursive: true });
-    writeFileSync6(join11(ref.scratchPath, "guidance.md"), renderGuidanceMarkdown(guidance));
+    writeFileSync7(join13(ref.scratchPath, "guidance.md"), renderGuidanceMarkdown(guidance));
   } catch {
   }
 }
 var ARTIFACT_CAP_BYTES = 64 * 1024;
-var SCRATCH_OUTPUT_DIR = ".skakel/scratch/output";
+var SCRATCH_OUTPUT_DIR = ".dahrk/scratch/output";
 function capContent(raw) {
   return raw.length > ARTIFACT_CAP_BYTES ? raw.slice(0, ARTIFACT_CAP_BYTES) : raw;
 }
@@ -3367,14 +3855,14 @@ function readEmittedArtifact(ref, relPath) {
   }
 }
 function scanScratchOutput(ref, preferRel) {
+  const preferBase = preferRel?.split("/").pop();
   try {
-    const names = readdirSync3(join11(ref.worktreePath, SCRATCH_OUTPUT_DIR)).filter(
+    const names = readdirSync3(join13(ref.worktreePath, SCRATCH_OUTPUT_DIR)).filter(
       (n) => n.toLowerCase().endsWith(".md")
     );
     if (names.length === 0) return void 0;
-    const preferBase = preferRel?.split("/").pop();
     const pick = preferBase && names.includes(preferBase) ? preferBase : names[0];
-    const raw = readFileSync5(join11(ref.worktreePath, SCRATCH_OUTPUT_DIR, pick), "utf8");
+    const raw = readFileSync5(join13(ref.worktreePath, SCRATCH_OUTPUT_DIR, pick), "utf8");
     if (raw.trim().length === 0) return void 0;
     return { path: `${SCRATCH_OUTPUT_DIR}/${pick}`, content: capContent(raw) };
   } catch {
@@ -3394,7 +3882,7 @@ function scanChangedMarkdown(ref) {
   );
   for (const rel of rels) {
     try {
-      const raw = readFileSync5(join11(ref.worktreePath, rel), "utf8");
+      const raw = readFileSync5(join13(ref.worktreePath, rel), "utf8");
       if (raw.trim().length > 0) return { path: rel, content: capContent(raw) };
     } catch {
     }
@@ -3415,6 +3903,9 @@ function resolveStageArtifact(ref, emitArtifact, handedBack) {
   if (changed) return { artifact: changed, source: "changed-file" };
   return void 0;
 }
+function runtimeUsesMcpGateway(runtime) {
+  return runtime === "claude-code" || runtime === "pi";
+}
 function createStageRunner(deps) {
   const worktrees = /* @__PURE__ */ new Map();
   const log = deps.logger ?? createNodeLogger({ level: "silent" });
@@ -3437,7 +3928,7 @@ function createStageRunner(deps) {
     if (ref) {
       if (scratchOnly.has(runId)) {
         try {
-          rmSync5(ref.worktreePath, { recursive: true, force: true });
+          rmSync6(ref.worktreePath, { recursive: true, force: true });
         } catch (e) {
           log.warn({ err: e, runId, path: ref.worktreePath }, "teardown: could not remove scratch dir");
         }
@@ -3517,9 +4008,9 @@ function createStageRunner(deps) {
               ...job.workspaceRef.credentialToken ? { credentialToken: job.workspaceRef.credentialToken } : {}
             });
           } else {
-            const base = deps.scratchRoot ?? join11(tmpdir4(), "dahrk", "scratch");
-            const worktreePath = join11(base, runId);
-            const scratchPath = join11(worktreePath, ".skakel", "scratch");
+            const base = deps.scratchRoot ?? join13(tmpdir5(), "dahrk", "scratch");
+            const worktreePath = join13(base, runId);
+            const scratchPath = join13(worktreePath, ".dahrk", "scratch");
             mkdirSync7(scratchPath, { recursive: true });
             ref = { repoId: "", gitUrl: "", repo: "", baseBranch: "", worktreePath, scratchPath };
             scratchOnly.add(runId);
@@ -3535,7 +4026,7 @@ function createStageRunner(deps) {
           const slash = job.agentConfig.emitArtifact.lastIndexOf("/");
           if (artifactDir && slash > 0) {
             try {
-              mkdirSync7(join11(ref.worktreePath, job.agentConfig.emitArtifact.slice(0, slash)), { recursive: true });
+              mkdirSync7(join13(ref.worktreePath, job.agentConfig.emitArtifact.slice(0, slash)), { recursive: true });
             } catch {
             }
           }
@@ -3563,8 +4054,8 @@ function createStageRunner(deps) {
           if (!sink) return;
           const base = { tenantId: job.tenantId, runId, stageId, attempt };
           try {
-            for (const name of readdirSync3(join11(writer.dir, "blobs"))) {
-              const bytes = readFileSync5(join11(writer.dir, "blobs", name));
+            for (const name of readdirSync3(join13(writer.dir, "blobs"))) {
+              const bytes = readFileSync5(join13(writer.dir, "blobs", name));
               const { url } = await sink.requestBlobUrl({
                 ...base,
                 sha256: name,
@@ -3578,7 +4069,7 @@ function createStageRunner(deps) {
           }
           let archiveKey;
           try {
-            const bytes = readFileSync5(join11(writer.dir, "trace.jsonl"));
+            const bytes = readFileSync5(join13(writer.dir, "trace.jsonl"));
             const sha = createHash3("sha256").update(bytes).digest("hex");
             const { key, url } = await sink.requestBlobUrl({
               ...base,
@@ -3675,6 +4166,7 @@ function createStageRunner(deps) {
           return finish("fail", `${stageId}: denied at stage entry (${entry.policy})`, job.sessionId);
         }
         let denied = false;
+        const surfacedDenyReasons = /* @__PURE__ */ new Set();
         let escapedUnblocked = false;
         const authorisedActions = [];
         const runtime = agentConfig.runtime;
@@ -3693,7 +4185,11 @@ function createStageRunner(deps) {
             streamEvent(writer.append({ seq: 0, ts: nowIso2(), type: "observation", runtime, toolUseId, isError: true, output: { error: reason } }));
           }
           streamEvent(writer.append({ seq: 0, ts: nowIso2(), type: "state", runtime, event: "policy-deny", detail: reason }));
-          deps.sendProgress({ jobId, kind: "error", ts: nowIso2(), text: reason });
+          const surfaceKey = `${verdict2.policy}\0${reason}`;
+          if (!surfacedDenyReasons.has(surfaceKey)) {
+            surfacedDenyReasons.add(surfaceKey);
+            deps.sendProgress({ jobId, kind: "error", ts: nowIso2(), text: reason });
+          }
         };
         const authorizeToolUse = (tool3, input) => {
           const verdict2 = evaluatePolicies({ kind: "action", stageId, tool: tool3, input }, rules);
@@ -3704,7 +4200,10 @@ function createStageRunner(deps) {
           }
           return verdict2;
         };
+        let bumpStall = () => {
+        };
         const onTrace = (event) => {
+          bumpStall();
           if (event.type === "action") {
             const key = actionKey(event.tool, event.input);
             const authorised = authorisedActions.indexOf(key);
@@ -3727,7 +4226,7 @@ function createStageRunner(deps) {
           if (event.type !== "state") deps.sendProgress({ jobId, kind: event.type, ts: event.ts, ...previewOf(event) });
         };
         const mcpServers = agentConfig.mcpServers;
-        if (mcpServers && mcpServers.length > 0 && runtime === "claude-code") {
+        if (mcpServers && mcpServers.length > 0 && runtimeUsesMcpGateway(runtime)) {
           gateway = await startMcpGateway({ servers: mcpServers, creds: job.brokeredCreds ?? {} });
         }
         const runner = deps.makeRunner(runtime);
@@ -3769,6 +4268,20 @@ function createStageRunner(deps) {
           timedOut = true;
           void runner.cancel();
         }, killMs) : void 0;
+        let stalled = false;
+        let stallTimer;
+        const stallSource = agentConfig.stallMs ?? Number(process.env.DAHRK_BATCH_STALL_MS ?? process.env.SKAKEL_BATCH_STALL_MS ?? 3e5);
+        const stallMs = interactive ? 0 : Math.max(0, Math.floor(stallSource));
+        if (stallMs > 0) {
+          bumpStall = () => {
+            if (stallTimer) clearTimeout(stallTimer);
+            stallTimer = setTimeout(() => {
+              stalled = true;
+              void runner.cancel();
+            }, stallMs);
+          };
+          bumpStall();
+        }
         try {
           if (interactive) {
             const mailbox = new ManagedMailbox();
@@ -3779,8 +4292,9 @@ function createStageRunner(deps) {
           }
         } finally {
           if (killTimer) clearTimeout(killTimer);
+          if (stallTimer) clearTimeout(stallTimer);
         }
-        let status = timedOut ? "timeout" : result.status;
+        let status = timedOut || stalled ? "timeout" : result.status;
         if (status === "ok" && escapedUnblocked) {
           status = "fail";
           const msg = `stage reached outside the run's worktree and the ${runtime} runtime could not block it before it ran`;
@@ -3799,6 +4313,9 @@ function createStageRunner(deps) {
           }
         }
         let summary = result.summary ?? `${stageId}: ${status}`;
+        if (stalled && !timedOut) {
+          summary = `${stageId}: stalled (no output for ${Math.round(stallMs / 1e3)}s)`;
+        }
         if (!interactive && status === "ok") {
           try {
             summary = await runner.summarise(ctx);
@@ -3837,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}` };
           }
@@ -3872,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}` };
         }
@@ -4040,6 +4496,17 @@ async function startEdgeNode(opts) {
       if (oldest !== void 0) lastResults.delete(oldest);
     }
   };
+  const ackedCancels = /* @__PURE__ */ new Map();
+  const ackCancel = (jobId) => {
+    const frame = { type: "cancel-ack", jobId };
+    ackedCancels.delete(jobId);
+    ackedCancels.set(jobId, frame);
+    if (ackedCancels.size > MAX_RESEND) {
+      const oldest = ackedCancels.keys().next().value;
+      if (oldest !== void 0) ackedCancels.delete(oldest);
+    }
+    send(frame);
+  };
   const pendingBlob = /* @__PURE__ */ new Map();
   let blobReqCounter = 0;
   const trace = {
@@ -4105,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}`);
@@ -4220,6 +4687,7 @@ async function startEdgeNode(opts) {
     if (msg.type === "cancel") {
       log.info({ jobId: msg.jobId }, `JOB_CANCEL:${msg.jobId}`);
       stageRunner.cancel(msg.jobId);
+      ackCancel(msg.jobId);
       return;
     }
     if (msg.type === "turn") {
@@ -4351,6 +4819,7 @@ async function startEdgeNode(opts) {
       log.info({ hubUrl: opts.hubUrl, nodeId, connectCount }, "EDGE_CONNECTED");
       sendHello();
       for (const frame of lastResults.values()) send(frame);
+      for (const frame of ackedCancels.values()) send(frame);
       startHeartbeat(sock, opts.heartbeatMs ?? 5e3);
     });
     sock.on("message", (raw) => void onMessage(raw.toString()));
@@ -4454,7 +4923,6 @@ async function startEdgeNode(opts) {
 import { execFile } from "child_process";
 var PROBES = [
   { runtime: "claude-code", cmd: "claude" },
-  { runtime: "codex", cmd: "codex" },
   { runtime: "pi", cmd: "pi" }
 ];
 var DEFAULT_TIMEOUT_MS = 5e3;
@@ -5092,8 +5560,8 @@ function usage(bin, command) {
 }
 
 // src/diagnose.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync8, readdirSync as readdirSync4, readFileSync as readFileSync6, statSync as statSync3, writeFileSync as writeFileSync7 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync8, readdirSync as readdirSync4, readFileSync as readFileSync6, statSync as statSync3, writeFileSync as writeFileSync8 } from "fs";
+import { join as join14 } from "path";
 
 // src/ui.ts
 import { styleText } from "util";
@@ -5208,7 +5676,7 @@ async function buildBundle(deps) {
   if (deps.exists(deps.crashDir)) {
     for (const name of deps.listDir(deps.crashDir).filter((f) => f.endsWith(".json")).sort()) {
       try {
-        crashes.push(JSON.parse(deps.readFile(join12(deps.crashDir, name))));
+        crashes.push(JSON.parse(deps.readFile(join14(deps.crashDir, name))));
       } catch (e) {
         warnings.push(`could not read crash record ${name} (${e.message})`);
       }
@@ -5269,14 +5737,14 @@ var defaultDiagnoseDeps = (paths, clientVersion, doctor) => ({
   listDir: (p) => readdirSync4(p),
   exists: (p) => existsSync8(p),
   writeFile: (p, content) => {
-    const dir = join12(p, "..");
+    const dir = join14(p, "..");
     if (!existsSync8(dir)) mkdirSync8(dir, { recursive: true });
-    writeFileSync7(p, content, { mode: 384 });
+    writeFileSync8(p, content, { mode: 384 });
   },
   out
 });
 function defaultBundlePath(cwd, now) {
-  return join12(cwd, `dahrk-diagnose-${now.toISOString().replace(/[:.]/g, "-")}.json`);
+  return join14(cwd, `dahrk-diagnose-${now.toISOString().replace(/[:.]/g, "-")}.json`);
 }
 
 // src/doctor.ts
@@ -5471,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`;
@@ -5495,7 +5964,7 @@ async function registerRepo(deps, args) {
 }
 
 // src/lock.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync9, readFileSync as readFileSync7, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync9, readFileSync as readFileSync7, rmSync as rmSync7, writeFileSync as writeFileSync9 } from "fs";
 import { dirname as dirname6 } from "path";
 function parseLock(content) {
   if (!content) return void 0;
@@ -5535,9 +6004,9 @@ var defaultLockDeps = (file) => ({
   },
   writeFile: (path, content) => {
     if (!existsSync9(dirname6(path))) mkdirSync9(dirname6(path), { recursive: true, mode: 448 });
-    writeFileSync8(path, content);
+    writeFileSync9(path, content);
   },
-  removeFile: (path) => rmSync6(path, { force: true }),
+  removeFile: (path) => rmSync7(path, { force: true }),
   isAlive
 });
 
@@ -5645,13 +6114,13 @@ var defaultLogsDeps = (files, jsonlFile) => ({
 });
 
 // src/process-safety.ts
-import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync9 } from "fs";
-import { join as join13 } from "path";
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
+import { join as join15 } from "path";
 function writeCrashRecord(dir, record) {
   try {
     mkdirSync10(dir, { recursive: true, mode: 448 });
-    const file = join13(dir, `${record.at.replace(/[:.]/g, "-")}.json`);
-    writeFileSync9(file, `${JSON.stringify(record, null, 2)}
+    const file = join15(dir, `${record.at.replace(/[:.]/g, "-")}.json`);
+    writeFileSync10(file, `${JSON.stringify(record, null, 2)}
 `, { mode: 384 });
     return file;
   } catch {
@@ -5708,7 +6177,7 @@ import { execFileSync as execFileSync6 } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
 import { accessSync, constants as fsConstants, existsSync as existsSync11, readdirSync as readdirSync5, statfsSync as statfsSync2 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join14 } from "path";
+import { join as join16 } from "path";
 var REPORT_BASE_URL = "https://app.dahrk.ai/r";
 var LOW_DISK_BYTES = 512 * 1024 * 1024;
 var PREFLIGHT_STAGES = [
@@ -5847,7 +6316,7 @@ function commandPresent(cmd) {
 }
 function sshKeyPresent() {
   try {
-    const dir = join14(homedir4(), ".ssh");
+    const dir = join16(homedir4(), ".ssh");
     if (existsSync11(dir) && readdirSync5(dir).some((f) => f.endsWith(".pub"))) return true;
   } catch {
   }
@@ -5867,12 +6336,12 @@ function writable(dir) {
   }
 }
 function worktreeRoot(env) {
-  return env.DAHRK_WORKTREES_DIR ?? join14(env.DAHRK_STATE_DIR ?? join14(homedir4(), ".dahrk"), "worktrees");
+  return env.DAHRK_WORKTREES_DIR ?? join16(env.DAHRK_STATE_DIR ?? join16(homedir4(), ".dahrk"), "worktrees");
 }
 function nearestExisting(dir) {
   let cur = dir;
   while (!existsSync11(cur)) {
-    const parent = join14(cur, "..");
+    const parent = join16(cur, "..");
     if (parent === cur) break;
     cur = parent;
   }
@@ -5934,14 +6403,14 @@ function gatherHostFacts(repoPath) {
 
 // src/service.ts
 import { execFileSync as execFileSync7 } from "child_process";
-import { chmodSync as chmodSync3, existsSync as existsSync13, mkdirSync as mkdirSync12, readFileSync as readFileSync10, realpathSync as realpathSync3, rmSync as rmSync7, writeFileSync as writeFileSync11 } from "fs";
+import { chmodSync as chmodSync3, existsSync as existsSync13, mkdirSync as mkdirSync12, readFileSync as readFileSync10, realpathSync as realpathSync3, rmSync as rmSync8, writeFileSync as writeFileSync12 } from "fs";
 import { homedir as homedir6, platform as osPlatform3, userInfo } from "os";
-import { join as join16 } from "path";
+import { join as join18 } from "path";
 
 // src/state.ts
-import { chmodSync as chmodSync2, existsSync as existsSync12, mkdirSync as mkdirSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync10 } from "fs";
+import { chmodSync as chmodSync2, existsSync as existsSync12, mkdirSync as mkdirSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync11 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join15 } from "path";
+import { join as join17 } from "path";
 var RUNTIMES = ["claude-code", "codex", "pi"];
 var isRuntime = (v) => RUNTIMES.includes(v);
 var STRING_FIELDS = ["nodeId", "enrolToken", "name", "tenantId", "updateCheckedAt", "updateLatest"];
@@ -5949,29 +6418,29 @@ var isDesired = (v) => v === "running" || v === "stopped";
 var FILE_MODE2 = 384;
 var DIR_MODE2 = 448;
 function stateDir(env) {
-  return env.DAHRK_STATE_DIR ?? join15(homedir5(), ".dahrk");
+  return env.DAHRK_STATE_DIR ?? join17(homedir5(), ".dahrk");
 }
 function legacyStateDir(env) {
-  return env.DAHRK_STATE_DIR ? void 0 : join15(homedir5(), ".skakel");
+  return env.DAHRK_STATE_DIR ? void 0 : join17(homedir5(), ".skakel");
 }
 function stateFile(env) {
-  return join15(stateDir(env), "node.json");
+  return join17(stateDir(env), "node.json");
 }
 function logDir(env) {
-  return join15(stateDir(env), "logs");
+  return join17(stateDir(env), "logs");
 }
 function logFiles(env) {
   const dir = logDir(env);
-  return { out: join15(dir, "node.out.log"), err: join15(dir, "node.err.log") };
+  return { out: join17(dir, "node.out.log"), err: join17(dir, "node.err.log") };
 }
 function jsonlLogFile(env) {
-  return join15(logDir(env), "node.jsonl");
+  return join17(logDir(env), "node.jsonl");
 }
 function crashDir(env) {
-  return join15(logDir(env), "crashes");
+  return join17(logDir(env), "crashes");
 }
 function lockFile(env) {
-  return join15(stateDir(env), "node.pid");
+  return join17(stateDir(env), "node.pid");
 }
 function setDesired(env, desired) {
   writeState(env, { desired });
@@ -6001,7 +6470,7 @@ function writeState(env, patch) {
   try {
     mkdirSync11(dir, { recursive: true, mode: DIR_MODE2 });
     const next = { ...readState(file), ...patch };
-    writeFileSync10(file, `${JSON.stringify(next, null, 2)}
+    writeFileSync11(file, `${JSON.stringify(next, null, 2)}
 `, { mode: FILE_MODE2 });
     chmodSync2(file, FILE_MODE2);
   } catch (e) {
@@ -6082,9 +6551,9 @@ ${envEntries}
   <key>ThrottleInterval</key>
   <integer>10</integer>
   <key>StandardOutPath</key>
-  <string>${xmlEscape(join16(inputs.logDir, "node.out.log"))}</string>
+  <string>${xmlEscape(join18(inputs.logDir, "node.out.log"))}</string>
   <key>StandardErrorPath</key>
-  <string>${xmlEscape(join16(inputs.logDir, "node.err.log"))}</string>
+  <string>${xmlEscape(join18(inputs.logDir, "node.err.log"))}</string>
 </dict>
 </plist>
 `;
@@ -6107,8 +6576,8 @@ Type=simple
 ExecStart=${exec}
 ${envLines}
 WorkingDirectory=${inputs.homeDir}
-StandardOutput=append:${join16(inputs.logDir, "node.out.log")}
-StandardError=append:${join16(inputs.logDir, "node.err.log")}
+StandardOutput=append:${join18(inputs.logDir, "node.out.log")}
+StandardError=append:${join18(inputs.logDir, "node.err.log")}
 Restart=on-failure
 RestartSec=3
 RestartPreventExitStatus=78
@@ -6119,7 +6588,7 @@ WantedBy=default.target
 }
 function buildPlan(inputs) {
   if (inputs.manager === "launchd") {
-    const filePath2 = join16(inputs.homeDir, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+    const filePath2 = join18(inputs.homeDir, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
     return {
       manager: "launchd",
       label: LAUNCHD_LABEL,
@@ -6136,7 +6605,7 @@ function buildPlan(inputs) {
       logHint: "dahrk logs -f"
     };
   }
-  const filePath = join16(inputs.homeDir, ".config", "systemd", "user", SYSTEMD_UNIT);
+  const filePath = join18(inputs.homeDir, ".config", "systemd", "user", SYSTEMD_UNIT);
   const user = userInfo().username;
   return {
     manager: "systemd",
@@ -6166,7 +6635,7 @@ function unitIsCurrent(plan, onDisk) {
   return onDisk === plan.content;
 }
 function unitPath(manager, homeDir) {
-  return manager === "launchd" ? join16(homeDir, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`) : join16(homeDir, ".config", "systemd", "user", SYSTEMD_UNIT);
+  return manager === "launchd" ? join18(homeDir, "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`) : join18(homeDir, ".config", "systemd", "user", SYSTEMD_UNIT);
 }
 function statusCommand(manager) {
   return manager === "launchd" ? ["launchctl", "list", LAUNCHD_LABEL] : ["systemctl", "--user", "show", SYSTEMD_UNIT, "-p", "ActiveState", "-p", "MainPID"];
@@ -6468,7 +6937,7 @@ var defaultDeps3 = () => ({
   // no reason for it to be world-readable. `writeFileSync`'s `mode` applies only when it CREATES the file,
   // so chmod explicitly too - re-installing over a unit an older client left at 0644 must tighten it.
   writeFile: (path, content) => {
-    writeFileSync11(path, content, { mode: UNIT_FILE_MODE });
+    writeFileSync12(path, content, { mode: UNIT_FILE_MODE });
     chmodSync3(path, UNIT_FILE_MODE);
   },
   readFile: (path) => {
@@ -6478,7 +6947,7 @@ var defaultDeps3 = () => ({
       return void 0;
     }
   },
-  removeFile: (path) => rmSync7(path, { force: true }),
+  removeFile: (path) => rmSync8(path, { force: true }),
   fileExists: (path) => existsSync13(path),
   // Captured, never inherited. A supervisor's stderr is ours to relay when it matters, not to leak
   // unconditionally: `runCommands` decides who needs to read it.
@@ -6919,7 +7388,7 @@ async function runStatus(inputs, deps) {
 }
 
 // src/main.ts
-var CLIENT_VERSION = "0.1.20";
+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"];
@@ -6931,7 +7400,7 @@ function resolveNodeId(env, opts = {}) {
   if (existing) return existing;
   const legacy = legacyStateDir(env);
   if (legacy) {
-    const legacyId = readState(join17(legacy, "node.json")).nodeId;
+    const legacyId = readState(join19(legacy, "node.json")).nodeId;
     if (legacyId) return legacyId;
   }
   const nodeId = randomUUID3();
@@ -7312,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;