dahrk-node 0.1.19 → 0.1.21

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
@@ -232,7 +233,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;
@@ -497,7 +498,7 @@ 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",
@@ -828,237 +829,11 @@ function createClaudeRunner() {
   };
 }
 
-// ../../packages/executor-worktree/src/codex-adapter.ts
-import { Codex } from "@openai/codex-sdk";
-
-// ../../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 };
-  }
-}
-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-adapter.ts
+import { join as join4 } from "path";
 
 // ../../packages/executor-worktree/src/pi-mappers.ts
-function mapUsage3(u) {
+function mapUsage2(u) {
   return {
     input: u?.input ?? 0,
     output: u?.output ?? 0,
@@ -1099,7 +874,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.
@@ -1175,9 +950,117 @@ function consumePiEvent(ev, state, suppressStageExit) {
   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 COALESCE_MS2 = Number(process.env.DAHRK_COALESCE_MS ?? process.env.SKAKEL_COALESCE_MS ?? 40);
 var PI_STAGE_COMPLETE_TOOL = "dahrk_stage_complete";
+var PI_ASK_USER_QUESTION_TOOL = "ask_user_question";
+function piToolCallDecision(ctx, toolName, input) {
+  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 {
+    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 {
+        }
+      }
+    }
+  };
+}
 function createPiRunner(deps = {}) {
   const createSession = deps.createSession ?? defaultCreatePiSession;
   const abortController = new AbortController();
@@ -1192,6 +1075,15 @@ function createPiRunner(deps = {}) {
   const captureSessionId = (s) => {
     if (s.sessionId) sessionId = s.sessionId;
   };
+  let sessionDisposed = false;
+  const disposeSession = () => {
+    if (sessionDisposed || !session) return;
+    sessionDisposed = true;
+    try {
+      session.dispose();
+    } catch {
+    }
+  };
   const readSessionCost = (s) => {
     const cost = s.getSessionStats?.()?.cost;
     return typeof cost === "number" ? cost : void 0;
@@ -1201,6 +1093,7 @@ function createPiRunner(deps = {}) {
     async runBatch(ctx, onTrace) {
       const emit = makeEmit("pi", onTrace);
       const s = await openSession(ctx);
+      registerToolCallGate(s, ctx);
       const state = newPiBufferState();
       let status = "ok";
       const unsub = s.subscribe((ev) => {
@@ -1220,11 +1113,13 @@ function createPiRunner(deps = {}) {
       captureSessionId(s);
       if (cancelled) status = "fail";
       const costUsd = readSessionCost(s);
+      if (status !== "ok") disposeSession();
       return { status, ...sessionId ? { sessionId } : {}, ...costUsd !== void 0 ? { costUsd } : {} };
     },
     async runInteractive(ctx, turns, onTrace) {
       const emit = makeEmit("pi", onTrace);
       const s = await openSession(ctx);
+      registerToolCallGate(s, ctx);
       const state = newPiBufferState();
       const exit = ctx.config.exit ?? "either";
       const wantsTool = exit === "tool" || exit === "either";
@@ -1246,9 +1141,28 @@ function createPiRunner(deps = {}) {
         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);
+      const router = createElicitTurnRouter(turns, { signal, firstReplyMs, idleMs });
+      const humanIter = router.conversation[Symbol.asyncIterator]();
       let awaitingFirstReply = true;
+      const elicitCtx = ctx;
+      const ask = async (question) => {
+        const outcome = await router.ask(awaitingFirstReply, () => {
+          emit({ type: "elicitation", prompt: question.prompt, signal: "select", options: question.options });
+          elicitCtx.emitElicit?.(question);
+        });
+        switch (outcome.kind) {
+          case "reply":
+            return `The user selected: ${outcome.text}`;
+          case "busy":
+            return "Only one question can be asked at a time; wait for the current one to be answered, then ask again.";
+          case "noreply":
+            return "No response from the user; proceed with your best judgement.";
+          case "cancel":
+            return "The question was cancelled.";
+        }
+      };
+      s.setAskUserQuestionHandler?.((questions) => askQuestionsSequentially(questions, ask));
       let exited = "gate";
       let pending = humanIter.next();
       try {
@@ -1273,7 +1187,7 @@ function createPiRunner(deps = {}) {
           const texts = [race.value.text];
           pending = humanIter.next();
           for (; ; ) {
-            const more = await raceNextTurn(pending, COALESCE_MS3, signal);
+            const more = await raceNextTurn(pending, COALESCE_MS2, signal);
             if (more.kind === "turn") {
               texts.push(more.value.text);
               pending = humanIter.next();
@@ -1316,6 +1230,7 @@ function createPiRunner(deps = {}) {
       unsub();
       captureSessionId(s);
       const costUsd = readSessionCost(s);
+      disposeSession();
       return {
         status,
         summary,
@@ -1341,6 +1256,7 @@ function createPiRunner(deps = {}) {
         return `(summary unavailable: ${e.message})`;
       } finally {
         unsub();
+        disposeSession();
       }
     },
     async cancel() {
@@ -1351,23 +1267,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 +1306,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) : "No response from the user; proceed with your best judgement.";
+      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 +1401,236 @@ 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 = msg;
+    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";
 var noopLogger = { info: () => {
 }, warn: () => {
 } };
-var SCRATCH_DIR = ".skakel/scratch";
+var SCRATCH_DIR = ".dahrk/scratch";
+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 +1640,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 +1679,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,18 +1713,66 @@ 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" };
   const withTokenUser = (gitUrl) => /^https:\/\/[^@/]+@/.test(gitUrl) ? gitUrl : gitUrl.replace(/^https:\/\//, "https://x-access-token@");
-  const mirrorPathFor = (repoId) => join3(mirrorsDir, sanitizeBranchName(repoId));
+  const resolveRemoteAuth = (gitUrl, credentialToken) => {
+    const auth = credentialToken ? setupAuth(credentialToken) : void 0;
+    return {
+      remote: credentialToken ? withTokenUser(gitUrl) : gitUrl,
+      authEnv: auth?.env,
+      cleanup: () => auth?.cleanup()
+    };
+  };
+  const mirrorPathFor = (repoId) => join5(mirrorsDir, sanitizeBranchName(repoId));
   const listWorktrees = (mirror) => {
     let out2;
     try {
@@ -1535,7 +1797,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/*";
@@ -1622,18 +1884,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;
@@ -1669,7 +1932,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) {
@@ -1689,15 +1953,14 @@ function createGitService(opts = {}) {
         } catch {
         }
       }
-      const auth = opts2.credentialToken ? setupAuth(opts2.credentialToken) : void 0;
-      const remote = opts2.credentialToken ? withTokenUser(ref.gitUrl) : ref.gitUrl;
+      const { remote, authEnv, cleanup } = resolveRemoteAuth(ref.gitUrl, opts2.credentialToken);
       let pushed = false;
       let integration;
       try {
         let fetched = false;
         if (opts2.base) {
           try {
-            git(worktreePath, ["fetch", remote, opts2.base], netEnv(auth?.env));
+            git(worktreePath, ["fetch", remote, opts2.base], netEnv(authEnv));
             fetched = true;
           } catch (e) {
             log.warn(`base fetch failed for ${opts2.base}; skipping push-time integration: ${e.message}`);
@@ -1718,30 +1981,49 @@ function createGitService(opts = {}) {
               `user.name=${authorName}`,
               "-c",
               `user.email=${authorEmail}`,
+              "-c",
+              "rerere.enabled=true",
+              "-c",
+              "rerere.autoupdate=true",
               "merge",
               "--no-edit",
               "FETCH_HEAD"
-            ], auth?.env);
+            ], authEnv);
             integration = "clean";
             headSha = git(worktreePath, ["rev-parse", "HEAD"]).trim();
           } 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 };
+              }
+            } 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(auth?.env));
+        git(worktreePath, ["push", remote, `HEAD:refs/heads/${branch}`], netEnv(authEnv));
         pushed = true;
       } finally {
-        auth?.cleanup();
+        cleanup();
       }
       return { headSha, pushed, nothingToCommit: !dirty, commitsAhead, ...integration ? { integration } : {} };
     },
@@ -1752,12 +2034,11 @@ function createGitService(opts = {}) {
       }
       const wipRef = sanitizeBranchName(opts2.branch);
       const { headSha, dirty } = commitPending(worktreePath, opts2.message);
-      const auth = opts2.credentialToken ? setupAuth(opts2.credentialToken) : void 0;
-      const remote = opts2.credentialToken ? withTokenUser(ref.gitUrl) : ref.gitUrl;
+      const { remote, authEnv, cleanup } = resolveRemoteAuth(ref.gitUrl, opts2.credentialToken);
       try {
-        git(worktreePath, ["push", "--force", remote, `HEAD:refs/heads/${wipRef}`], netEnv(auth?.env));
+        git(worktreePath, ["push", "--force", remote, `HEAD:refs/heads/${wipRef}`], netEnv(authEnv));
       } finally {
-        auth?.cleanup();
+        cleanup();
       }
       return { headSha, pushed: true, nothingToCommit: !dirty, wipRef };
     },
@@ -1772,15 +2053,14 @@ function createGitService(opts = {}) {
       if (!dirty) return { dirty: false, headSha, pushed: false };
       git(worktreePath, ["branch", "--force", wipRef, tailSha]);
       let pushed = false;
-      const auth = opts2.credentialToken ? setupAuth(opts2.credentialToken) : void 0;
-      const remote = opts2.credentialToken ? withTokenUser(ref.gitUrl) : ref.gitUrl;
+      const { remote, authEnv, cleanup } = resolveRemoteAuth(ref.gitUrl, opts2.credentialToken);
       try {
-        git(worktreePath, ["push", "--force", remote, `${tailSha}:refs/heads/${wipRef}`], netEnv(auth?.env));
+        git(worktreePath, ["push", "--force", remote, `${tailSha}:refs/heads/${wipRef}`], netEnv(authEnv));
         pushed = true;
       } catch (e) {
         log.warn(`could not push the preserved tail to ${wipRef}: ${e.message}`);
       } finally {
-        auth?.cleanup();
+        cleanup();
       }
       git(worktreePath, ["reset", "--hard", headSha]);
       git(worktreePath, ["clean", "-fd", "--exclude", SCRATCH_DIR]);
@@ -1800,10 +2080,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",
@@ -1825,7 +2105,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) {
@@ -1836,8 +2116,8 @@ 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 DEFAULTS = {
@@ -1867,7 +2147,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 {
@@ -1890,7 +2170,7 @@ 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 [];
     }
@@ -1914,7 +2194,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 [];
         }
@@ -1957,7 +2237,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) {
@@ -1974,20 +2254,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;
@@ -1995,8 +2275,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)) {
@@ -2026,13 +2306,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;
@@ -2042,13 +2322,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("/"));
     }
@@ -2058,8 +2338,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);
@@ -2071,16 +2351,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;
@@ -2088,27 +2368,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
@@ -2167,8 +2441,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() {
@@ -2197,7 +2471,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);
@@ -2232,7 +2506,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
@@ -2335,8 +2609,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
@@ -2460,7 +2734,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}`);
@@ -2526,7 +2800,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})
@@ -2584,9 +2858,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
@@ -2595,8 +2869,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);
@@ -2612,7 +2886,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;
       }
@@ -2662,7 +2936,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).
@@ -2681,26 +2955,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"
@@ -3285,7 +3559,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"));
@@ -3294,23 +3568,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 {
   }
@@ -3329,12 +3603,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;
 }
@@ -3362,14 +3636,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 {
@@ -3389,7 +3663,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 {
     }
@@ -3410,6 +3684,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" });
@@ -3432,7 +3709,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");
         }
@@ -3512,9 +3789,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);
@@ -3530,7 +3807,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 {
             }
           }
@@ -3558,8 +3835,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,
@@ -3573,7 +3850,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,
@@ -3670,6 +3947,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;
@@ -3688,7 +3966,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);
@@ -3699,7 +3981,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);
@@ -3722,7 +4007,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);
@@ -3764,6 +4049,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();
@@ -3774,8 +4073,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`;
@@ -3794,6 +4094,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);
@@ -4035,6 +4338,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 = {
@@ -4215,6 +4529,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") {
@@ -4346,6 +4661,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()));
@@ -4449,7 +4765,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;
@@ -4596,6 +4911,7 @@ var COMMANDS = /* @__PURE__ */ new Set([
   "logs",
   "diagnose",
   "run",
+  "repo",
   "service",
   "doctor",
   "status",
@@ -4619,6 +4935,7 @@ function parseCli(argv) {
     flagArgs = rest;
   }
   if (command === "run") return parseRun(flagArgs);
+  if (command === "repo") return parseRepo(flagArgs);
   if (command === "service") return parseService(flagArgs);
   if (command === "update") return parseUpdate(flagArgs);
   if (command === "logs") return parseLogs(flagArgs);
@@ -4633,6 +4950,8 @@ function parseCli(argv) {
         "hub-url": { type: "string" },
         ephemeral: { type: "boolean", default: false },
         foreground: { type: "boolean", default: false },
+        // `start`: enrol but do not install the service (the operator supervises the node themselves).
+        "no-service": { type: "boolean", default: false },
         // `stop` / `restart`: take the node down even though it has work in flight.
         force: { type: "boolean", default: false },
         // `status`: machine-readable output.
@@ -4654,7 +4973,8 @@ function parseCli(argv) {
     ephemeral,
     // An ephemeral node mints a throwaway id and persists nothing, so there is nothing coherent to hand to
     // a supervisor that restarts it on boot. It is a foreground node by definition.
-    foreground: (values.foreground ?? false) || ephemeral
+    foreground: (values.foreground ?? false) || ephemeral,
+    ...values["no-service"] ? { noService: true } : {}
   };
   if (command === "stop") return { kind: "stop", force };
   if (command === "restart") return { kind: "restart", flags, force };
@@ -4786,6 +5106,43 @@ function parseService(flagArgs) {
   };
   return { kind: "service", flags };
 }
+var REPO_ACTIONS = /* @__PURE__ */ new Set(["add"]);
+var isRepoAction = (s) => REPO_ACTIONS.has(s);
+function parseRepo(flagArgs) {
+  let values;
+  let positionals;
+  try {
+    ({ values, positionals } = parseArgs({
+      args: flagArgs,
+      options: {
+        name: { type: "string" },
+        "hub-url": { type: "string" },
+        token: { type: "string" },
+        help: { type: "boolean", default: false }
+      },
+      allowPositionals: true
+    }));
+  } catch (e) {
+    return { kind: "error", message: e.message };
+  }
+  if (values.help) return { kind: "help", command: "repo" };
+  if (positionals.length === 0) {
+    return { kind: "error", message: "repo: missing action (`dahrk repo add`)" };
+  }
+  if (positionals.length > 1) {
+    return { kind: "error", message: `repo: unexpected argument "${positionals[1]}" (one action at a time)` };
+  }
+  const action = positionals[0];
+  if (!isRepoAction(action)) {
+    return { kind: "error", message: `repo: unknown action "${action}" (expected add)` };
+  }
+  const flags = {
+    ...values.name ? { name: values.name } : {},
+    ...values["hub-url"] ? { hubUrl: values["hub-url"] } : {},
+    ...values.token ? { token: values.token } : {}
+  };
+  return { kind: "repo", flags };
+}
 function parseUpdate(flagArgs) {
   let values;
   try {
@@ -4830,6 +5187,8 @@ function usage(bin, command) {
       "                     setting DAHRK_FOREGROUND=1, which is easier to set in a Dockerfile or pm2 config.",
       "  --ephemeral        Do not persist (or read) node id and token; mint a throwaway id (CI / one-shot).",
       "                     Implies --foreground: a node with no persistent identity has nothing to daemonise.",
+      "  --no-service       Enrol (cache the token) but do not install the always-on service, for a node you",
+      "                     supervise yourself. Run it later with `dahrk start --foreground` (or your own supervisor).",
       "",
       "Only one node may run at a time on a host - they would share this machine's node id and race each",
       "other for Jobs - so a second `start` refuses rather than dialling the hub twice."
@@ -4930,6 +5289,30 @@ function usage(bin, command) {
       "  --token <token>    Enrolment token to verify against the hub (or set DAHRK_ENROL_TOKEN)."
     ].join("\n");
   }
+  if (command === "repo") {
+    return [
+      `Usage: ${bin} repo add [options]`,
+      "",
+      "Register the current git repository with the hub, so it can run workflows. Run it from inside the",
+      "repo - `cd your-repo && dahrk repo add` - and the node reads the `origin` remote and the current",
+      "branch itself: no form, no pasted git URL, because the node already sits next to the code.",
+      "",
+      "The git URL is registered in the form the host can authenticate. An HTTPS origin is kept as-is; an",
+      "SSH origin is kept when this host has an SSH key, and otherwise normalised to HTTPS with a warning.",
+      "Re-running on an already-registered repo is a no-op, not an error or a duplicate.",
+      "",
+      "This uses the node's existing enrolment - run `dahrk start --token <token>` first if it is not yet",
+      "enrolled. It dials the hub itself, so the daemon need not be running.",
+      "",
+      "Actions:",
+      "  add          Register the repository in the current directory.",
+      "",
+      "Options:",
+      "  --name <name>      Display name for the repo (default: the slug from the origin URL).",
+      "  --hub-url <url>    Hub URL to register with (or set DAHRK_HUB_URL).",
+      "  --token <token>    Enrolment token to authenticate with (default: the cached one)."
+    ].join("\n");
+  }
   if (command === "service") {
     return [
       `Usage: ${bin} service install|uninstall [options]`,
@@ -5006,6 +5389,7 @@ function usage(bin, command) {
     "  diagnose  Write a support bundle you can read, and send on if you choose. Uploads nothing.",
     "  status    Is it up, is it enrolled, what is it working on? (local, dials nothing)",
     "  run       Run a workflow locally (engine-backed), e.g. `run preflight`.",
+    "  repo      Register the current repository with the hub (`repo add`).",
     "  doctor    Preflight checks: Node, runtimes, hub reachability, token validity.",
     "  service   Install/uninstall the always-on service by hand (`start` does this for you).",
     "  update    Update the client to the latest release (or print how for your channel).",
@@ -5018,8 +5402,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";
@@ -5134,7 +5518,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})`);
       }
@@ -5195,14 +5579,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
@@ -5335,8 +5719,93 @@ async function runDoctor(inputs, deps = {}) {
   return checks.some((c) => c.status === "fail") ? 1 : 0;
 }
 
+// src/repo-add.ts
+import { createHash as createHash4 } from "crypto";
+var stripRepoSuffix = (s) => s.replace(/\.git$/i, "").replace(/\/+$/, "");
+function splitOwnerRepo(path) {
+  const parts = stripRepoSuffix(path).split("/").filter(Boolean);
+  if (parts.length < 2) return void 0;
+  const repo = parts[parts.length - 1];
+  const owner = parts.slice(0, -1).join("/");
+  return { owner, repo };
+}
+function parseGitRemote(url) {
+  const trimmed = url.trim();
+  if (!trimmed) return void 0;
+  const urlMatch = /^(?:ssh|https?):\/\/(?:[^@/]+@)?([^/:]+)(?::\d+)?\/(.+)$/i.exec(trimmed);
+  if (urlMatch) {
+    const parts = splitOwnerRepo(urlMatch[2]);
+    return parts ? { host: urlMatch[1], ...parts } : void 0;
+  }
+  const scpMatch = /^(?:[^@\s]+@)?([^/:\s]+):(.+)$/.exec(trimmed);
+  if (scpMatch) {
+    const parts = splitOwnerRepo(scpMatch[2]);
+    return parts ? { host: scpMatch[1], ...parts } : void 0;
+  }
+  return void 0;
+}
+var httpsFormOf = (r) => `https://${r.host}/${r.owner}/${r.repo}.git`;
+var isHttpsRemote = (url) => /^https?:\/\//i.test(url.trim());
+function chooseGitUrl(input) {
+  const originUrl = input.originUrl.trim();
+  if (isHttpsRemote(originUrl)) return { gitUrl: originUrl, converted: false };
+  if (input.sshKeyPresent) return { gitUrl: originUrl, converted: false };
+  const parsed = parseGitRemote(originUrl);
+  if (!parsed) return { gitUrl: originUrl, converted: false };
+  return { gitUrl: httpsFormOf(parsed), converted: true };
+}
+var deriveRepoName = (remote) => remote.repo;
+function deriveRepoId(gitUrl) {
+  const parsed = parseGitRemote(gitUrl);
+  const canonical2 = parsed ? `${parsed.host}/${parsed.owner}/${parsed.repo}`.toLowerCase() : gitUrl.trim().toLowerCase();
+  const hash = createHash4("sha256").update(canonical2).digest("hex").slice(0, 12);
+  const slug = (parsed ? parsed.repo : "repo").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "repo";
+  return `${slug}-${hash}`;
+}
+function hubHttpBase(url) {
+  const trimmed = url.trim().replace(/\/+$/, "");
+  if (/^wss:\/\//i.test(trimmed)) return trimmed.replace(/^wss:\/\//i, "https://");
+  if (/^ws:\/\//i.test(trimmed)) return trimmed.replace(/^ws:\/\//i, "http://");
+  return trimmed;
+}
+async function readJson(res) {
+  try {
+    const body = await res.json();
+    return body && typeof body === "object" ? body : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function driftOf(stored, repo) {
+  if (!stored) return void 0;
+  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;
+}
+async function registerRepo(deps, args) {
+  const url = `${args.base}/config/api/repositories`;
+  let res;
+  try {
+    res = await deps.fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${args.token}` },
+      body: JSON.stringify(args.repo)
+    });
+  } catch (e) {
+    return { kind: "error", message: `could not reach the hub at ${args.base}: ${e.message}` };
+  }
+  const stored = await readJson(res);
+  if (res.status === 200 || res.status === 409) {
+    const drift = driftOf(stored, args.repo);
+    return { kind: "already", ...drift ? { drift } : {} };
+  }
+  if (res.ok) return { kind: "registered" };
+  return { kind: "error", message: `the hub rejected the repo (HTTP ${res.status})` };
+}
+
 // 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;
@@ -5376,9 +5845,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
 });
 
@@ -5486,13 +5955,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 {
@@ -5549,7 +6018,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 = [
@@ -5688,7 +6157,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 {
   }
@@ -5708,12 +6177,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;
   }
@@ -5744,7 +6213,18 @@ function probeRepo(repoPath) {
     baseBranch = git(["rev-parse", "--abbrev-ref", "HEAD"]) || void 0;
   } catch {
   }
-  return { path: repoPath, isGitRepo: true, headResolves, ...baseBranch ? { baseBranch } : {} };
+  let remoteUrl;
+  try {
+    remoteUrl = git(["remote", "get-url", "origin"]) || void 0;
+  } catch {
+  }
+  return {
+    path: repoPath,
+    isGitRepo: true,
+    headResolves,
+    ...baseBranch ? { baseBranch } : {},
+    ...remoteUrl ? { remoteUrl } : {}
+  };
 }
 function gatherHostFacts(repoPath) {
   const root = worktreeRoot(process.env);
@@ -5764,14 +6244,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"];
@@ -5779,29 +6259,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 });
@@ -5831,7 +6311,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) {
@@ -5912,9 +6392,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>
 `;
@@ -5937,8 +6417,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
@@ -5949,7 +6429,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,
@@ -5966,7 +6446,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",
@@ -5996,7 +6476,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"];
@@ -6298,7 +6778,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) => {
@@ -6308,7 +6788,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.
@@ -6749,7 +7229,7 @@ async function runStatus(inputs, deps) {
 }
 
 // src/main.ts
-var CLIENT_VERSION = "0.1.19";
+var CLIENT_VERSION = "0.1.21";
 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"];
@@ -6761,7 +7241,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();
@@ -6836,6 +7316,12 @@ async function start(flags) {
   if (wantsForeground(env, flags)) return startForeground(env, flags);
   const enrolled = await enrolToDisk(env);
   if (enrolled !== 0) return enrolled;
+  if (flags.noService) {
+    out("");
+    out(verdict("ok", "Enrolled. Not installing a service (--no-service)."));
+    out(hint("Run the node with `dahrk start --foreground` (or your own supervisor), or `dahrk start` to install the service."));
+    return 0;
+  }
   await offerUpdate(env);
   const outcome = await runNodeStart(serviceInputs(env));
   if (outcome.kind === "error") return outcome.code;
@@ -7081,6 +7567,69 @@ async function runWorkflow(flags) {
     clientVersion: CLIENT_VERSION
   });
 }
+async function runRepoAdd(flags) {
+  const env = applyEnvAliases(process.env);
+  if (flags.hubUrl) env.DAHRK_HUB_URL = flags.hubUrl;
+  if (flags.token) env.DAHRK_ENROL_TOKEN = flags.token;
+  const cwd = process.cwd();
+  const probe2 = probeRepo(cwd);
+  if (!probe2.isGitRepo) {
+    out("");
+    out(verdict("fail", `${cwd} is not a git repository.`));
+    out(hint("Run `dahrk repo add` from inside the repository you want to register."));
+    return 1;
+  }
+  if (!probe2.remoteUrl) {
+    out("");
+    out(verdict("fail", "This repository has no `origin` remote, so there is nothing to register."));
+    out(hint("Add one with `git remote add origin <url>`, then run `dahrk repo add` again."));
+    return 1;
+  }
+  const token = resolveEnrolToken(env);
+  if (!token) {
+    out("");
+    out(verdict("fail", "This node is not enrolled, so it cannot register a repository."));
+    out(hint("Enrol it first with `dahrk start --token <token>`."));
+    return 1;
+  }
+  const { gitUrl, converted } = chooseGitUrl({ originUrl: probe2.remoteUrl, sshKeyPresent: sshKeyPresent() });
+  if (converted) {
+    out("");
+    out(verdict("warn", `No SSH key found on this host, so the SSH remote was registered as HTTPS: ${gitUrl}`));
+    out(hint("Add an SSH key (or set up brokered credentials) if this repo must be cloned over SSH - see DHK-252."));
+  }
+  const parsed = parseGitRemote(gitUrl);
+  const name = flags.name ?? (parsed ? deriveRepoName(parsed) : "repo");
+  const repo = {
+    id: deriveRepoId(gitUrl),
+    name,
+    gitUrl,
+    // HEAD's branch is the run's base. An empty repo (no commits) has none yet; default to `main`.
+    defaultBranch: probe2.baseBranch ?? "main"
+  };
+  const base = hubHttpBase(env.DAHRK_HUB_URL ?? DEFAULT_HUB_URL);
+  const result = await registerRepo({ fetch }, { base, token, repo });
+  out("");
+  switch (result.kind) {
+    case "registered":
+      out(verdict("ok", `Registered ${name} with the hub.`));
+      out(kv("URL", gitUrl));
+      out(kv("Branch", repo.defaultBranch));
+      return 0;
+    case "already":
+      out(verdict("ok", `${name} is already registered - nothing to do.`));
+      if (result.drift) {
+        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}`);
+        out(hint(`The hub's stored record differs - ${bits.join(", ")} - and was left unchanged.`));
+      }
+      return 0;
+    case "error":
+      out(verdict("fail", `Could not register the repository: ${result.message}`));
+      return 1;
+  }
+}
 async function main() {
   const invoked = basename2(process.argv[1] ?? "");
   const bin = !invoked || invoked.startsWith("main.") ? "dahrk" : invoked;
@@ -7127,6 +7676,9 @@ async function main() {
     case "run":
       process.exitCode = await runWorkflow(parsed.flags);
       break;
+    case "repo":
+      process.exitCode = await runRepoAdd(parsed.flags);
+      break;
     case "service": {
       if (parsed.flags.action === "uninstall") {
         process.exitCode = await runServiceUninstall();