dsh-loop-engine 0.1.5-rc1 → 0.1.5-rc2

package/lib/index.js

@@ -46,22 +46,25 @@ var __callDispose = (stack, error, hasError) => {
 
 // src/index.ts
 import { mkdirSync, readFileSync as readFileSync3, renameSync, writeFileSync } from "node:fs";
-import { mkdir as mkdir2, readFile as readFile6, rename as rename2, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir2, readFile as readFile5, rename as rename2, writeFile as writeFile2 } from "node:fs/promises";
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { dirname as dirname6, join as join11 } from "node:path";
+import { dirname as dirname5, join as join12 } from "node:path";
 import z6 from "@deepseek-ai/schemastery";
 import { resolveDshHome } from "@deepseek-ai/dsh-home-paths";
 
 // src/engine-claude/loop.ts
-import { Service } from "@deepseek-ai/cordis";
 import z from "@deepseek-ai/schemastery";
-import { emitAgentEvent } from "@deepseek-ai/dsh-agent";
 import { MAX_TIMER_DELAY_MS } from "@deepseek-ai/dsh-timeout";
-import { interruptedTurnClosers, SessionLogOffset, SessionPreparation } from "@deepseek-ai/dsh-session";
 
 // src/engine-claude/agent.ts
 import { agentEvents } from "@deepseek-ai/dsh-agent";
-import { LlmError, createAssistantMessage, createUserMessage, errorChain } from "@deepseek-ai/dsh-llm";
+import {
+  AssistantStreamAccumulator as AssistantStreamAccumulator2,
+  LlmError,
+  createAssistantMessage,
+  createUserMessage,
+  errorChain
+} from "@deepseek-ai/dsh-llm";
 import { createScope } from "@deepseek-ai/dsh-scope";
 import { canonicalHeader } from "@deepseek-ai/dsh-session";
 import { query as officialQuery } from "@anthropic-ai/claude-agent-sdk";
@@ -148,12 +151,16 @@ function toolResultContent(content) {
 }
 function mapUsage(usage) {
   return {
-    inputTokens: usage.input_tokens,
-    outputTokens: usage.output_tokens,
+    inputTokens: usage.input_tokens ?? 0,
+    outputTokens: usage.output_tokens ?? 0,
     ...usage.cache_read_input_tokens == null ? {} : { cacheReadTokens: usage.cache_read_input_tokens },
     ...usage.cache_creation_input_tokens == null ? {} : { cacheWriteTokens: usage.cache_creation_input_tokens }
   };
 }
+function meaningfulUsage(usage) {
+  if (usage === void 0) return void 0;
+  return usage.inputTokens !== 0 || usage.outputTokens !== 0 || (usage.cacheReadTokens ?? 0) !== 0 || (usage.cacheWriteTokens ?? 0) !== 0 ? usage : void 0;
+}
 function mapStreamEvent(event, toolCalls) {
   switch (event.type) {
     case "content_block_start": {
@@ -845,6 +852,17 @@ var ClaudeCodeAgent = class {
   requestHeaderLogged = false;
   /** Agent-lifecycle-local counter naming each streamed attempt. */
   streamAttempts = 0;
+  /**
+   * Tool results logged into the currently open step. A result means the
+   * segment that requested the call is finished, so the next assistant content
+   * opens the next step (see {@link beginSegment}).
+   */
+  stepSettledTools = 0;
+  /**
+   * Whether the current query has rotated into a second step. The query-total
+   * usage record is only meaningful while one step holds the whole query.
+   */
+  rotated = false;
   get status() {
     return this.phase.kind === "idle" || this.phase.kind === "maintenance" ? "idle" : "running";
   }
@@ -1091,7 +1109,7 @@ var ClaudeCodeAgent = class {
           const stepEnd = await this.step();
           if (turnEnds === null) turnEnds = stepEnd;
         } finally {
-          this.session.append("step/end", { turn, step });
+          this.session.append("step/end", { turn, step: phase.step });
         }
         signal.throwIfAborted();
         if (turnEnds && this.inbox.nextStep.length === 0) {
@@ -1124,6 +1142,24 @@ var ClaudeCodeAgent = class {
     phase.step = 0;
     return true;
   }
+  /**
+   * Rotate to the next step when the segment that ran a tool has finished, so
+   * each assistant segment lands in its own step.
+   *
+   * Called as new assistant content begins. A step holding a settled tool
+   * result means the previous segment is complete, and the content about to be
+   * written belongs to the next one. Rotating here (rather than when a call is
+   * announced) keeps calls announced together — one model turn — in one step.
+   * @param phase - the running phase carrying the open step's position.
+   */
+  beginSegment(phase) {
+    if (this.stepSettledTools === 0) return;
+    this.session.append("step/end", { turn: phase.turn, step: phase.step });
+    phase.step += 1;
+    this.session.append("step/start", { turn: phase.turn, step: phase.step });
+    this.stepSettledTools = 0;
+    this.rotated = true;
+  }
   /** Model label recorded in the request header for one lifecycle. */
   modelLabel() {
     return this.config.model ?? NATIVE_MODEL_LABEL;
@@ -1144,8 +1180,11 @@ var ClaudeCodeAgent = class {
   /** Run one Claude Code query for the current step and map its transcript into the session log. */
   async step() {
     if (this.phase.kind !== "running") throw new Error(`agent "${this.id}": step outside running phase`);
-    const { turn, step, abort: { signal } } = this.phase;
+    const phase = this.phase;
+    const { abort: { signal } } = phase;
     signal.throwIfAborted();
+    this.stepSettledTools = 0;
+    this.rotated = false;
     const cwd = this.session.header.cwd;
     if (cwd === void 0 || cwd.length === 0) {
       throw new Error(`agent "${this.id}": no working directory \u2014 start the session with cwd metadata`);
@@ -1186,8 +1225,8 @@ var ClaudeCodeAgent = class {
           live = new DriverAssistantStream(
             this.id,
             ++this.streamAttempts,
-            turn,
-            step,
+            phase.turn,
+            phase.step,
             (frame2) => this.dispatch.emit("agent/assistant-stream", { frame: frame2 })
           );
           live.start();
@@ -1197,11 +1236,17 @@ var ClaudeCodeAgent = class {
       const toolCalls = /* @__PURE__ */ new Map();
       const reasoningByIndex = /* @__PURE__ */ new Map();
       let pendingUsage;
+      let requestUsage;
       signal.throwIfAborted();
       for await (const message of query) {
         signal.throwIfAborted();
         switch (message.type) {
           case "stream_event": {
+            const event = message.event;
+            if (event.type === "message_start") requestUsage = void 0;
+            else if (event.type === "message_delta" && event.usage !== void 0) {
+              requestUsage = meaningfulUsage(mapUsage(event.usage));
+            }
             for (const chunk of mapStreamEvent(message.event, toolCalls)) {
               currentStream().push(chunk);
               if (chunk.type === "reasoning-delta") {
@@ -1219,7 +1264,7 @@ var ClaudeCodeAgent = class {
               reasoning.forEach((block, index) => {
                 reasoningByIndex.set(index, block.text);
               });
-              pendingUsage = mapped.usage;
+              pendingUsage = meaningfulUsage(mapped.usage) ?? requestUsage;
               break;
             }
             let content = mapped.content;
@@ -1228,13 +1273,14 @@ var ClaudeCodeAgent = class {
               content = [...synthesized, ...content];
             }
             if (content.length > 0) {
+              this.beginSegment(phase);
               reasoningByIndex.clear();
-              const usage = mapped.usage ?? pendingUsage;
+              const usage = meaningfulUsage(mapped.usage) ?? requestUsage ?? pendingUsage;
               pendingUsage = void 0;
               const attempt = live;
               const data = {
-                turn,
-                step,
+                turn: phase.turn,
+                step: phase.step,
                 message: createAssistantMessage({
                   content,
                   source: { provider: PROVIDER, model: mapped.model }
@@ -1252,8 +1298,8 @@ var ClaudeCodeAgent = class {
             }
             for (const call of mapped.toolCalls) {
               this.session.append("tool/call", {
-                turn,
-                step,
+                turn: phase.turn,
+                step: phase.step,
                 callId: call.callId,
                 name: call.name,
                 arguments: call.arguments
@@ -1263,7 +1309,8 @@ var ClaudeCodeAgent = class {
           }
           case "user": {
             for (const result of mapToolResults(message.message)) {
-              this.session.append("tool/result", { turn, step, message: result }, { surfaceOp: "append" });
+              this.session.append("tool/result", { turn: phase.turn, step: phase.step, message: result }, { surfaceOp: "append" });
+              this.stepSettledTools += 1;
             }
             break;
           }
@@ -1271,10 +1318,11 @@ var ClaudeCodeAgent = class {
             if (reasoningByIndex.size > 0) {
               const trailing = [...reasoningByIndex.entries()].sort((a, b) => a[0] - b[0]).map(([, text]) => ({ type: "reasoning", text }));
               reasoningByIndex.clear();
+              this.beginSegment(phase);
               const attempt = live;
               const data = {
-                turn,
-                step,
+                turn: phase.turn,
+                step: phase.step,
                 message: createAssistantMessage({
                   content: trailing,
                   source: { provider: PROVIDER, model: NATIVE_MODEL_LABEL }
@@ -1290,6 +1338,16 @@ var ClaudeCodeAgent = class {
               }
               pendingUsage = void 0;
             }
+            const stepUsage = meaningfulUsage(mapUsage(message.usage));
+            if (stepUsage !== void 0 && !this.rotated) {
+              const accumulator = new AssistantStreamAccumulator2();
+              accumulator.push({ time: Date.now(), chunk: { type: "usage", usage: stepUsage } });
+              this.session.append("assistant/attempt", {
+                turn: phase.turn,
+                step: phase.step,
+                stream: [...accumulator.snapshot()]
+              });
+            }
             if (message.subtype === "success") {
               finished = true;
             } else {
@@ -1318,6 +1376,11 @@ var ClaudeCodeAgent = class {
   }
 };
 
+// src/driver-core/hosted-loop-factory.ts
+import { Service } from "@deepseek-ai/cordis";
+import { emitAgentEvent } from "@deepseek-ai/dsh-agent";
+import { interruptedTurnClosers, SessionLogOffset, SessionPreparation } from "@deepseek-ai/dsh-session";
+
 // src/driver-core/ownership.ts
 var INACTIVE_FIBER_VALUES = {
   FAILED: 3,
@@ -1406,54 +1469,23 @@ async function raceAbortCall(operation, signal, id, releaseAbandoned) {
   }
 }
 
-// src/engine-claude/loop.ts
-var CLAUDE_CODE_PERMISSION_MODES = [
-  "dontAsk",
-  "acceptEdits",
-  "auto",
-  "plan",
-  "bypassPermissions"
-];
-var Config = z.object({
-  permissionMode: z.union([...CLAUDE_CODE_PERMISSION_MODES]),
-  env: z.dict(z.string()).default({}),
-  model: z.string(),
-  disposeGraceMs: z.number().default(DEFAULT_DISPOSE_GRACE_MS),
-  maxTurns: z.number().step(1).min(1)
-});
-function resolveConfig(config) {
-  const disposeGraceMs = config.disposeGraceMs ?? DEFAULT_DISPOSE_GRACE_MS;
-  if (!Number.isFinite(disposeGraceMs) || disposeGraceMs <= 0) {
-    throw new Error("agent-loop-claude-code: disposeGraceMs must be a positive finite number");
-  }
-  if (disposeGraceMs > MAX_TIMER_DELAY_MS) {
-    throw new Error(
-      `agent-loop-claude-code: disposeGraceMs must be no greater than ${MAX_TIMER_DELAY_MS}`
-    );
-  }
-  return {
-    permissionMode: config.permissionMode,
-    env: config.env ?? {},
-    model: config.model,
-    disposeGraceMs,
-    maxTurns: config.maxTurns
-  };
-}
-var ClaudeCodeLoop = class extends Service {
-  /** Services the loop resolves through its own fiber; blessed identically to the package-level entry inject. */
-  static inject = ["agents", "sessions", "systemPrompt", "subprocess"];
+// src/driver-core/hosted-loop-factory.ts
+var HostedLoopFactory = class extends Service {
   /** Validated configuration owned by the loop plugin. */
   config;
   ownership;
   /** Plain holder prevents Cordis from re-tracing the factory's dependency context through a caller shadow. */
   runtime;
-  constructor(ctx, config) {
-    super(ctx, "agentLoopClaudeCode");
-    this.config = resolveConfig(config);
+  /** Cordis service name, also the prefix of every effect label. */
+  label;
+  constructor(ctx, label, config) {
+    super(ctx, label);
+    this.label = label;
+    this.config = config;
     this.ownership = new FactoryOwnership(ctx.fiber);
     this.runtime = { ctx };
-    ctx.effect(() => () => this.ownership.dispose(), "agentLoopClaudeCode.transactions()");
-    ctx.effect(() => ctx.agents.setFactory(this), "agentLoopClaudeCode.setFactory()");
+    ctx.effect(() => () => this.ownership.dispose(), `${label}.transactions()`);
+    ctx.effect(() => ctx.agents.setFactory(this), `${label}.setFactory()`);
     ctx.systemPrompt.variable("provider", (context) => context.agent?.options.provider);
     ctx.systemPrompt.variable("model", (context) => context.agent?.options.model);
     ctx.systemPrompt.variable("cwd", (context) => context.agent?.session.header.cwd);
@@ -1518,7 +1550,7 @@ var ClaudeCodeLoop = class extends Service {
         if (disposing !== void 0) return;
         abort.abort(new Error(`agent "${id}" setup aborted: owner disposed during setup`));
         return dispose(true);
-      }, `agentLoopClaudeCode.lifecycle(${id})`);
+      }, `${this.label}.lifecycle(${id})`);
     } catch (error) {
       untrack();
       callerSignal?.removeEventListener("abort", onCallerAbort);
@@ -1530,7 +1562,7 @@ var ClaudeCodeLoop = class extends Service {
       throw abort.signal.reason instanceof Error ? abort.signal.reason : new Error(String(abort.signal.reason));
     };
     try {
-      const agent = machine = new ClaudeCodeAgent(loopCtx, id, options, session, this.config);
+      const agent = machine = this.buildAgent(loopCtx, id, options, session);
       machineReady.resolve();
       assertLive();
       return {
@@ -1685,7 +1717,7 @@ var ClaudeCodeLoop = class extends Service {
       const ownerAbort = new AbortController();
       const unfollowOwner = ownerCtx.effect(() => () => {
         ownerAbort.abort(new Error(`agent "${id}" setup aborted: owner disposed during setup`));
-      }, `agentLoopClaudeCode.resume-load(${id})`);
+      }, `${this.label}.resume-load(${id})`);
       const fused = AbortSignal.any([
         ...options.signal === void 0 ? [] : [options.signal],
         ownerAbort.signal,
@@ -1746,11 +1778,53 @@ var ClaudeCodeLoop = class extends Service {
   }
 };
 
+// src/engine-claude/loop.ts
+var CLAUDE_CODE_PERMISSION_MODES = [
+  "dontAsk",
+  "acceptEdits",
+  "auto",
+  "plan",
+  "bypassPermissions"
+];
+var Config = z.object({
+  permissionMode: z.union([...CLAUDE_CODE_PERMISSION_MODES]),
+  env: z.dict(z.string()).default({}),
+  model: z.string(),
+  disposeGraceMs: z.number().default(DEFAULT_DISPOSE_GRACE_MS),
+  maxTurns: z.number().step(1).min(1)
+});
+function resolveConfig(config) {
+  const disposeGraceMs = config.disposeGraceMs ?? DEFAULT_DISPOSE_GRACE_MS;
+  if (!Number.isFinite(disposeGraceMs) || disposeGraceMs <= 0) {
+    throw new Error("agent-loop-claude-code: disposeGraceMs must be a positive finite number");
+  }
+  if (disposeGraceMs > MAX_TIMER_DELAY_MS) {
+    throw new Error(
+      `agent-loop-claude-code: disposeGraceMs must be no greater than ${MAX_TIMER_DELAY_MS}`
+    );
+  }
+  return {
+    permissionMode: config.permissionMode,
+    env: config.env ?? {},
+    model: config.model,
+    disposeGraceMs,
+    maxTurns: config.maxTurns
+  };
+}
+var ClaudeCodeLoop = class extends HostedLoopFactory {
+  /** Services the loop resolves through its own fiber; blessed identically to the package-level entry inject. */
+  static inject = ["agents", "sessions", "systemPrompt", "subprocess"];
+  constructor(ctx, config) {
+    super(ctx, "agentLoopClaudeCode", resolveConfig(config));
+  }
+  /** Construct the Claude Code driver for one prepared session. */
+  buildAgent(loopCtx, id, options, session) {
+    return new ClaudeCodeAgent(loopCtx, id, options, session, this.config);
+  }
+};
+
 // src/engine-codex/loop.ts
-import { Service as Service2 } from "@deepseek-ai/cordis";
 import z2 from "@deepseek-ai/schemastery";
-import { emitAgentEvent as emitAgentEvent2 } from "@deepseek-ai/dsh-agent";
-import { interruptedTurnClosers as interruptedTurnClosers2, SessionLogOffset as SessionLogOffset2, SessionPreparation as SessionPreparation2 } from "@deepseek-ai/dsh-session";
 
 // src/engine-codex/agent.ts
 import { agentEvents as agentEvents2 } from "@deepseek-ai/dsh-agent";
@@ -1763,6 +1837,42 @@ var DEFAULT_CODEX_PERMISSION = {
   sandboxMode: "read-only",
   approvalPolicy: "never"
 };
+function userInputQuestions(params) {
+  if (typeof params !== "object" || params === null) return [];
+  const raw = params.questions;
+  if (!Array.isArray(raw)) return [];
+  const questions = [];
+  for (const entry of raw) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const question = entry;
+    if (typeof question.id !== "string" || question.id === "") continue;
+    if (typeof question.question !== "string" || question.question === "") continue;
+    const options = Array.isArray(question.options) ? question.options.flatMap((option) => {
+      if (typeof option !== "object" || option === null) return [];
+      const { label, description } = option;
+      if (typeof label !== "string") return [];
+      return [{ label, ...typeof description === "string" ? { description } : {} }];
+    }) : [];
+    questions.push({
+      id: question.id,
+      question: question.question,
+      ...typeof question.header === "string" && question.header !== "" ? { header: question.header } : {},
+      ...options.length > 0 ? { options } : {}
+    });
+  }
+  return questions;
+}
+function userInputResponse(answer) {
+  if (answer === void 0) return { answers: {} };
+  const answers = {};
+  for (const item of answer.answers) {
+    answers[item.id] = { answers: [...item.selected, ...item.custom === void 0 || item.custom === "" ? [] : [item.custom]] };
+  }
+  return { answers };
+}
+function elicitationResponse() {
+  return { action: "decline" };
+}
 function resolveSessionPermission2(events) {
   if (sessionSandboxMode(events) === "danger-full-access") {
     return { sandboxMode: "danger-full-access", approvalPolicy: "never" };
@@ -1772,6 +1882,68 @@ function resolveSessionPermission2(events) {
   }
   return DEFAULT_CODEX_PERMISSION;
 }
+var REASON_INPUT_CAP2 = 200;
+function approvalToolName(method) {
+  switch (method) {
+    case "item/commandExecution/requestApproval":
+      return "command";
+    case "item/fileChange/requestApproval":
+      return "file-change";
+    case "item/permissions/requestApproval":
+      return "permissions";
+    default:
+      return method;
+  }
+}
+function approvalKind(method) {
+  switch (method) {
+    case "item/commandExecution/requestApproval":
+      return "command execution";
+    case "item/fileChange/requestApproval":
+      return "file change";
+    case "item/permissions/requestApproval":
+      return "permission change";
+    default:
+      return method;
+  }
+}
+function approvalDetail(method, params) {
+  if (typeof params !== "object" || params === null) return String(params);
+  const record = params;
+  if (method === "item/commandExecution/requestApproval" && typeof record.command === "string") {
+    return record.command;
+  }
+  if (typeof record.reason === "string") return record.reason;
+  if (method === "item/fileChange/requestApproval" && typeof record.grantRoot === "string") {
+    return record.grantRoot;
+  }
+  return JSON.stringify(params);
+}
+function approvalReason2(method, params) {
+  const detail = approvalDetail(method, params);
+  const bounded = detail.length > REASON_INPUT_CAP2 ? `${detail.slice(0, REASON_INPUT_CAP2 - 3)}...` : detail;
+  return `Codex requests permission for ${approvalKind(method)}: ${bounded}`;
+}
+function approvalDecision(outcome) {
+  return outcome === "allowed-once" ? "accept" : "decline";
+}
+function permissionsGrant(outcome, requested) {
+  return outcome === "allowed-once" ? { permissions: requested, scope: "turn" } : { permissions: {}, scope: "turn" };
+}
+function resolveApprovalRequest(method, params, outcome) {
+  switch (method) {
+    case "item/commandExecution/requestApproval":
+      return { result: { decision: approvalDecision(outcome) } };
+    case "item/fileChange/requestApproval":
+      return { result: { decision: approvalDecision(outcome) } };
+    case "item/permissions/requestApproval": {
+      const requested = typeof params === "object" && params !== null ? params.permissions ?? {} : {};
+      return { result: permissionsGrant(outcome, requested) };
+    }
+    default:
+      return { error: { code: -32601, message: "Method not found" } };
+  }
+}
 
 // src/engine-codex/appserver/client.ts
 import { spawn } from "node:child_process";
@@ -1788,6 +1960,7 @@ var AppServerClient = class _AppServerClient {
   reqId = 1;
   pending = /* @__PURE__ */ new Map();
   notificationHandler;
+  requestHandler;
   stderrHandler;
   disposed = false;
   /** Whether this client was disposed or its server process exited. */
@@ -1827,6 +2000,10 @@ var AppServerClient = class _AppServerClient {
   onNotification(handler) {
     this.notificationHandler = handler;
   }
+  /** Set the handler for server-initiated requests (e.g. approvals). */
+  onRequest(handler) {
+    this.requestHandler = handler;
+  }
   /** Set the stderr handler for server log lines. */
   onStderr(handler) {
     this.stderrHandler = handler;
@@ -1888,7 +2065,12 @@ var AppServerClient = class _AppServerClient {
     } catch {
       return;
     }
+    if (obj.id !== void 0 && obj.method !== void 0) {
+      void this.answerRequest(obj.method, obj.params, obj.id);
+      return;
+    }
     if (obj.id !== void 0) {
+      if (typeof obj.id !== "number") return;
       const pending = this.pending.get(obj.id);
       if (pending) {
         this.pending.delete(obj.id);
@@ -1898,11 +2080,24 @@ var AppServerClient = class _AppServerClient {
           pending.resolve(obj.result);
         }
       }
+      return;
     }
     if (obj.method !== void 0) {
       this.notificationHandler?.(obj.method, obj.params);
     }
   }
+  /** Resolve one inbound server request and write the JSON-RPC reply to stdin. */
+  async answerRequest(method, params, id) {
+    let outcome;
+    try {
+      outcome = this.requestHandler !== void 0 ? await this.requestHandler(method, params, id) : { error: { code: -32601, message: "Method not found" } };
+    } catch (error) {
+      outcome = { error: { code: -32603, message: error instanceof Error ? error.message : "internal error" } };
+    }
+    if (this.disposed) return;
+    const reply = "result" in outcome ? { id, result: outcome.result } : { id, error: outcome.error };
+    this.process.stdin?.write(JSON.stringify(reply) + "\n");
+  }
 };
 
 // src/engine-codex/appserver/thread.ts
@@ -2109,6 +2304,9 @@ function mapMcpToolCall(item) {
 // src/engine-codex/agent.ts
 var PROVIDER2 = "codex";
 var NATIVE_MODEL_LABEL2 = "codex-native";
+function nonEmptyText(parts) {
+  return parts !== void 0 && parts.some((part) => part.length > 0) ? parts.join("\n") : void 0;
+}
 var CodexAgent = class {
   constructor(loopCtx, id, options, session, config) {
     this.loopCtx = loopCtx;
@@ -2154,14 +2352,103 @@ var CodexAgent = class {
   requestHeaderLogged = false;
   /** Agent-lifecycle-local counter naming each streamed attempt. */
   streamAttempts = 0;
+  /**
+   * Tool results logged into the currently open step. A result means the
+   * segment that requested the call is finished, so the next assistant content
+   * opens the next step (see {@link beginSegment}).
+   */
+  stepSettledTools = 0;
+  /**
+   * Rotate to the next step when the segment that ran a tool has finished, so
+   * each assistant segment lands in its own step.
+   *
+   * Called as new assistant content begins. A step holding a settled tool
+   * result means the previous segment is complete, and the content about to be
+   * written belongs to the next one. Rotating here (rather than when a call is
+   * announced) keeps calls announced together — one model turn — in one step.
+   * @param phase - the running phase carrying the open step's position.
+   */
+  beginSegment(phase) {
+    if (this.stepSettledTools === 0) return;
+    this.session.append("step/end", { turn: phase.turn, step: phase.step });
+    phase.step += 1;
+    this.session.append("step/start", { turn: phase.turn, step: phase.step });
+    this.stepSettledTools = 0;
+  }
   /** Lazily created app-server client, reused across steps and released on scope teardown. */
   appServer;
   /** Return the cached app-server client, spawning one on first use or after a dead process. */
   async appServerClient() {
     if (this.appServer !== void 0 && !this.appServer.closed) return this.appServer;
     this.appServer = await AppServerClient.create();
+    this.appServer.onRequest((method, params) => this.answerRequest(method, params));
     return this.appServer;
   }
+  /**
+   * Answer one server-initiated interaction. Approvals go through the dsh
+   * approval seam; a `request_user_input` question goes to the user-questions
+   * seam (both fail closed when their seam is absent), and an MCP elicitation is
+   * declined outright. Anything else is a protocol error.
+   * @param method - the server request method.
+   * @param params - the server request params.
+   * @returns the JSON-RPC outcome to send back.
+   */
+  async answerRequest(method, params) {
+    if (method === "item/tool/requestUserInput") return this.answerUserInput(params);
+    if (method === "mcpServer/elicitation/request") return { result: elicitationResponse() };
+    return this.answerApproval(method, params);
+  }
+  /** Resolve one native Codex approval request through the dsh approval seam. */
+  async answerApproval(method, params) {
+    const outcome = await this.requestApproval(method, params);
+    return resolveApprovalRequest(method, params, outcome);
+  }
+  /**
+   * Put one `request_user_input` question to the human through the dsh
+   * user-questions seam. The seam itself fails closed (`NO_PROVIDER`) when no
+   * answerer is composed, so a refusal degrades to "no answers given" and the
+   * turn continues; asking is never silently skipped, and the degradation is
+   * logged rather than swallowed.
+   * @param params - the request params carrying the questions.
+   * @returns the response payload (or the empty answer when nobody answered).
+   */
+  async answerUserInput(params) {
+    const questions = userInputQuestions(params);
+    const service = this.loopCtx.get("userQuestions");
+    if (questions.length === 0) {
+      return { result: userInputResponse(void 0) };
+    }
+    if (service === void 0) {
+      this.loopCtx.logger.warn("loop-engine: codex asked for user input, but the user-questions service is not composed; answering with no answers");
+      return { result: userInputResponse(void 0) };
+    }
+    const phase = this.phase;
+    const signal = phase.kind === "running" ? phase.abort.signal : void 0;
+    try {
+      const answer = await service.ask({
+        questions,
+        agent: this,
+        ...signal === void 0 ? {} : { signal }
+      });
+      return { result: userInputResponse(answer) };
+    } catch (error) {
+      this.loopCtx.logger.warn(`loop-engine: codex user-input request went unanswered: ${String(error)}`);
+      return { result: userInputResponse(void 0) };
+    }
+  }
+  /** Ask the dsh approval seam; fail closed to a denial when it is absent. */
+  async requestApproval(method, params) {
+    const approval = this.loopCtx.get("approval");
+    if (approval === void 0) return "unavailable";
+    const phase = this.phase;
+    const signal = phase.kind === "running" ? phase.abort.signal : void 0;
+    return approval.request({
+      agent: this,
+      toolName: approvalToolName(method),
+      reason: approvalReason2(method, params),
+      ...signal === void 0 ? {} : { signal }
+    });
+  }
   get status() {
     return this.phase.kind === "idle" || this.phase.kind === "maintenance" ? "idle" : "running";
   }
@@ -2390,7 +2677,7 @@ var CodexAgent = class {
           const stepEnd = await this.step();
           if (turnEnds === null) turnEnds = stepEnd;
         } finally {
-          this.session.append("step/end", { turn, step });
+          this.session.append("step/end", { turn, step: phase.step });
         }
         signal.throwIfAborted();
         if (turnEnds && this.inbox.nextStep.length === 0) {
@@ -2443,8 +2730,10 @@ var CodexAgent = class {
   /** Run one Codex thread for the current step and map its transcript into the session log. */
   async step() {
     if (this.phase.kind !== "running") throw new Error(`agent "${this.id}": step outside running phase`);
-    const { turn, step, abort: { signal } } = this.phase;
+    const phase = this.phase;
+    const { abort: { signal } } = phase;
     signal.throwIfAborted();
+    this.stepSettledTools = 0;
     const cwd = this.session.header.cwd;
     if (cwd === void 0 || cwd.length === 0) {
       throw new Error(`agent "${this.id}": no working directory \u2014 start the session with cwd metadata`);
@@ -2485,6 +2774,7 @@ var CodexAgent = class {
       let finished = false;
       const pendingReasoning = [];
       const pendingReasoningStream = [];
+      const streamedReasoning = /* @__PURE__ */ new Map();
       let held;
       let reasoningBlockStarted = false;
       let textBlockStarted = false;
@@ -2494,20 +2784,29 @@ var CodexAgent = class {
           live = new DriverAssistantStream(
             this.id,
             ++this.streamAttempts,
-            turn,
-            step,
+            phase.turn,
+            phase.step,
             (frame2) => this.dispatch.emit("agent/assistant-stream", { frame: frame2 })
           );
           live.start();
         }
         return live;
       };
+      const foldReasoning = () => {
+        if (pendingReasoning.length === 0) return;
+        const reasoningBlocks = pendingReasoning.map((text) => ({ type: "reasoning", text }));
+        held = held === void 0 ? { content: reasoningBlocks, stream: [...pendingReasoningStream] } : { ...held, content: [...held.content, ...reasoningBlocks], stream: [...held.stream, ...pendingReasoningStream] };
+        pendingReasoning.length = 0;
+        pendingReasoningStream.length = 0;
+        reasoningBlockStarted = false;
+      };
       const flushHeld = (usage) => {
+        foldReasoning();
         if (held === void 0) return;
         const attempt = live;
         const data = {
-          turn,
-          step,
+          turn: phase.turn,
+          step: phase.step,
           message: createAssistantMessage2({
             content: held.content,
             source: { provider: PROVIDER2, model: this.modelLabel() }
@@ -2524,16 +2823,10 @@ var CodexAgent = class {
         }
         held = void 0;
       };
-      const flushReasoning = (usage) => {
-        if (pendingReasoning.length === 0) return;
-        flushHeld();
-        held = {
-          content: pendingReasoning.map((text) => ({ type: "reasoning", text })),
-          stream: [...pendingReasoningStream]
-        };
-        pendingReasoning.length = 0;
-        pendingReasoningStream.length = 0;
-        flushHeld(usage);
+      const foldToolCall = (call) => {
+        foldReasoning();
+        const block = { type: "tool-call", id: call.callId, name: call.name, arguments: call.arguments };
+        held = held === void 0 ? { content: [block], stream: [] } : { ...held, content: [...held.content, block] };
       };
       signal.throwIfAborted();
       for await (const event of events) {
@@ -2544,7 +2837,7 @@ var CodexAgent = class {
           case "item-started": {
             if (event.itemType === "agentMessage") {
               textBlockStarted = false;
-              textBlockIndex = pendingReasoning.length;
+              textBlockIndex = (held?.content.length ?? 0) + pendingReasoning.length;
             }
             break;
           }
@@ -2559,85 +2852,100 @@ var CodexAgent = class {
           case "reasoning-summary-delta":
           case "reasoning-text-delta":
           case "plan-delta": {
-            const index = pendingReasoning.length;
+            this.beginSegment(phase);
+            const index = (held?.content.length ?? 0) + pendingReasoning.length;
             if (!reasoningBlockStarted) {
               reasoningBlockStarted = true;
               currentStream().push({ type: "block-start", index, blockType: "reasoning" });
             }
             currentStream().push({ type: "reasoning-delta", index, text: event.delta });
+            if (event.kind !== "plan-delta") {
+              streamedReasoning.set(event.itemId, (streamedReasoning.get(event.itemId) ?? "") + event.delta);
+            }
             break;
           }
           case "item-completed": {
             const item = event.item;
             if (item.type === "reasoning") {
-              const summary = item.summary;
-              const content = item.content;
-              const text = summary?.join("\n") ?? content?.join("\n") ?? "";
+              const terminal = item;
+              const text = nonEmptyText(terminal.summary) ?? nonEmptyText(terminal.content) ?? streamedReasoning.get(terminal.id) ?? "";
+              streamedReasoning.delete(terminal.id);
               pendingReasoning.push(text);
               pendingReasoningStream.push(...live?.takeStream() ?? []);
               reasoningBlockStarted = false;
+            } else if (item.type === "plan") {
+              live?.takeStream();
+              reasoningBlockStarted = false;
             } else if (item.type === "agentMessage") {
+              this.beginSegment(phase);
               const textStream = live?.takeStream() ?? [];
-              flushHeld();
-              held = {
-                content: [
-                  ...pendingReasoning.map((text) => ({ type: "reasoning", text })),
-                  { type: "text", text: item.text ?? "" }
-                ],
-                stream: [...pendingReasoningStream, ...textStream]
-              };
+              const reasoningBlocks = pendingReasoning.map((text) => ({ type: "reasoning", text }));
+              const textBlock = { type: "text", text: item.text ?? "" };
+              if (held === void 0) {
+                held = { content: [...reasoningBlocks, textBlock], stream: [...pendingReasoningStream, ...textStream] };
+              } else {
+                held = {
+                  ...held,
+                  content: [...held.content, ...reasoningBlocks, textBlock],
+                  stream: [...held.stream, ...pendingReasoningStream, ...textStream]
+                };
+              }
               pendingReasoning.length = 0;
               pendingReasoningStream.length = 0;
               reasoningBlockStarted = false;
               textBlockStarted = false;
             } else if (item.type === "commandExecution") {
-              flushReasoning();
-              flushHeld();
+              this.beginSegment(phase);
               const activity = mapCommandExecution(item);
+              foldToolCall(activity.call);
+              flushHeld();
               this.session.append("tool/call", {
-                turn,
-                step,
+                turn: phase.turn,
+                step: phase.step,
                 callId: activity.call.callId,
                 name: activity.call.name,
                 arguments: activity.call.arguments
               });
-              this.session.append("tool/result", { turn, step, message: activity.result }, { surfaceOp: "append" });
+              this.session.append("tool/result", { turn: phase.turn, step: phase.step, message: activity.result }, { surfaceOp: "append" });
+              this.stepSettledTools += 1;
             } else if (item.type === "fileChange") {
-              flushReasoning();
-              flushHeld();
+              this.beginSegment(phase);
               const activity = mapFileChange(item);
+              foldToolCall(activity.call);
+              flushHeld();
               this.session.append("tool/call", {
-                turn,
-                step,
+                turn: phase.turn,
+                step: phase.step,
                 callId: activity.call.callId,
                 name: activity.call.name,
                 arguments: activity.call.arguments
               });
-              this.session.append("tool/result", { turn, step, message: activity.result }, { surfaceOp: "append" });
+              this.session.append("tool/result", { turn: phase.turn, step: phase.step, message: activity.result }, { surfaceOp: "append" });
+              this.stepSettledTools += 1;
             } else if (item.type === "mcpToolCall") {
-              flushReasoning();
-              flushHeld();
+              this.beginSegment(phase);
               const activity = mapMcpToolCall(item);
+              foldToolCall(activity.call);
+              flushHeld();
               this.session.append("tool/call", {
-                turn,
-                step,
+                turn: phase.turn,
+                step: phase.step,
                 callId: activity.call.callId,
                 name: activity.call.name,
                 arguments: activity.call.arguments
               });
-              this.session.append("tool/result", { turn, step, message: activity.result }, { surfaceOp: "append" });
+              this.session.append("tool/result", { turn: phase.turn, step: phase.step, message: activity.result }, { surfaceOp: "append" });
+              this.stepSettledTools += 1;
             }
             break;
           }
           case "turn-completed": {
             const usage = event.turn.usage ? mapUsage2(event.turn.usage) : void 0;
-            if (pendingReasoning.length > 0) flushReasoning(usage);
-            else flushHeld(usage);
+            flushHeld(usage);
             finished = true;
             break;
           }
           case "error":
-            flushReasoning();
             flushHeld();
             throw new LlmError2(event.error.message, "CODEX_ERROR");
           /* v8 ignore next -- AppServerEvent is a closed union; no unknown kinds */
@@ -2645,7 +2953,6 @@ var CodexAgent = class {
             break;
         }
       }
-      flushReasoning();
       flushHeld();
       if (!finished) {
         throw new LlmError2(
@@ -2688,310 +2995,15 @@ function resolveConfig2(config) {
     model: config.model
   };
 }
-var CodexLoop = class extends Service2 {
+var CodexLoop = class extends HostedLoopFactory {
   /** Services the loop resolves through its own fiber; blessed identically to the package-level entry inject. */
   static inject = ["agents", "sessions", "systemPrompt"];
-  /** Validated configuration owned by the loop plugin. */
-  config;
-  ownership;
-  /** Plain holder prevents Cordis from re-tracing the factory's dependency context through a caller shadow. */
-  runtime;
   constructor(ctx, config) {
-    super(ctx, "agentLoopCodex");
-    this.config = resolveConfig2(config);
-    this.ownership = new FactoryOwnership(ctx.fiber);
-    this.runtime = { ctx };
-    ctx.effect(() => () => this.ownership.dispose(), "agentLoopCodex.transactions()");
-    ctx.effect(() => ctx.agents.setFactory(this), "agentLoopCodex.setFactory()");
-    ctx.systemPrompt.variable("provider", (context) => context.agent?.options.provider);
-    ctx.systemPrompt.variable("model", (context) => context.agent?.options.model);
-    ctx.systemPrompt.variable("cwd", (context) => context.agent?.session.header.cwd);
+    super(ctx, "agentLoopCodex", resolveConfig2(config));
   }
-  /**
-   * Construct the driver, scope, and one memoized reverse teardown for a new
-   * agent. The teardown is registered with the factory and the owner fiber
-   * BEFORE publication, so a mid-setup unload rolls everything back; `signal`
-   * fuses caller cancellation with lifecycle teardown for setup awaits.
-   */
-  /* jscpd:ignore-start -- ownership/transaction machinery mirrors the Claude Code loop factory. */
-  prepare(ownerCtx, id, options, session, callerSignal, handle, parentAgent) {
-    ownerCtx.fiber.assertActive();
-    if (!this.ownership.isActive()) throw new Error("agent loop is not active");
-    if (callerSignal?.aborted) {
-      throw callerSignal.reason instanceof Error ? callerSignal.reason : new Error(`agent "${id}" creation aborted`, { cause: callerSignal.reason });
-    }
-    const loopCtx = this.runtime.ctx;
-    const abort = new AbortController();
-    const onCallerAbort = () => {
-      abort.abort(callerSignal?.reason instanceof Error ? callerSignal.reason : new Error(`agent "${id}" creation aborted`, { cause: callerSignal?.reason }));
-    };
-    const onFactoryTeardown = () => {
-      abort.abort(this.ownership.signal.reason);
-    };
-    callerSignal?.addEventListener("abort", onCallerAbort, { once: true });
-    this.ownership.signal.addEventListener("abort", onFactoryTeardown, { once: true });
-    let machine;
-    let detachSession;
-    let detachAgent;
-    let disposing;
-    const machineReady = Promise.withResolvers();
-    const dispose = (ownerTriggered = false) => disposing ??= (async () => {
-      abort.abort(new Error(`agent "${id}" lifecycle disposed`));
-      callerSignal?.removeEventListener("abort", onCallerAbort);
-      this.ownership.signal.removeEventListener("abort", onFactoryTeardown);
-      try {
-        if (machine === void 0) await machineReady.promise;
-        if (machine !== void 0) {
-          machine.cancel({ kind: "disposed" });
-          await machine.whenIdle();
-          await machine.scope.dispose();
-        }
-      } finally {
-        try {
-          await handle?.close();
-        } finally {
-          try {
-            detachAgent?.();
-            detachSession?.();
-          } finally {
-            untrack();
-            if (!ownerTriggered) await unfollowOwner();
-          }
-        }
-      }
-    })();
-    const untrack = this.ownership.track(dispose);
-    let unfollowOwner;
-    try {
-      unfollowOwner = ownerCtx.effect(() => () => {
-        if (disposing !== void 0) return;
-        abort.abort(new Error(`agent "${id}" setup aborted: owner disposed during setup`));
-        return dispose(true);
-      }, `agentLoopCodex.lifecycle(${id})`);
-    } catch (error) {
-      untrack();
-      callerSignal?.removeEventListener("abort", onCallerAbort);
-      this.ownership.signal.removeEventListener("abort", onFactoryTeardown);
-      throw error;
-    }
-    const assertLive = () => {
-      if (!abort.signal.aborted) return;
-      throw abort.signal.reason instanceof Error ? abort.signal.reason : new Error(String(abort.signal.reason));
-    };
-    try {
-      const agent = machine = new CodexAgent(loopCtx, id, options, session, this.config);
-      machineReady.resolve();
-      assertLive();
-      return {
-        agent,
-        signal: abort.signal,
-        publish: (source) => {
-          assertLive();
-          detachSession = agent.ctx.sessions.enter(session);
-          detachAgent = loopCtx.agents.enter(agent, parentAgent);
-          agent.ctx.sessions.announce(session);
-          assertLive();
-          loopCtx.agents.announce(agent);
-          assertLive();
-          emitAgentEvent2(loopCtx, agent, "agent/session-start", { source });
-          assertLive();
-          return { agent, dispose };
-        },
-        dispose
-      };
-    } catch (error) {
-      machineReady.resolve();
-      void dispose();
-      throw error;
-    }
-  }
-  /** Prepare one Agent around an acquired Session, run setup, and publish it. */
-  async setupAndPublish(ownerCtx, id, preparation, agentOptions, setup, signal, source, stored, parentAgent) {
-    var _stack = [];
-    try {
-      const ownedPreparation = __using(_stack, preparation);
-      const session = ownedPreparation.session;
-      let prepared;
-      try {
-        prepared = this.prepare(ownerCtx, id, agentOptions, session, signal, stored?.handle, parentAgent);
-      } catch (error) {
-        await stored?.handle.close().catch(() => {
-        });
-        throw error;
-      }
-      try {
-        const setupCommit = await raceAbort(setup?.(prepared.agent.ctx, prepared.agent), prepared.signal, id);
-        setupCommit?.commit();
-        await this.appendUnstoredSuffix(stored, session);
-        return prepared.publish(source);
-      } catch (error) {
-        await prepared.dispose().catch(() => {
-        });
-        throw error;
-      }
-    } catch (_) {
-      var _error = _, _hasError = true;
-    } finally {
-      __callDispose(_stack, _error, _hasError);
-    }
-  }
-  /**
-   * Create an agent and session under one caller-supplied identity, owned by
-   * the accessing fiber. When a persistence backend is mounted, the session's
-   * durable identity is stored before publication.
-   * @param ownerCtx - caller context that structurally owns the lifecycle.
-   * @param options - identities, optional live parent, session seed/metadata, loop options, setup, and cancellation.
-   * @returns the published handle.
-   */
-  async createAgent(ownerCtx, options) {
-    const preparation = SessionPreparation2.create(this.runtime.ctx.sessions.prepare(options.sessionId, {
-      ...options.seed === void 0 ? {} : { seed: options.seed },
-      ...options.meta === void 0 ? {} : { meta: options.meta },
-      ...options.inheritedEventCount === void 0 ? {} : { inheritedEventCount: options.inheritedEventCount }
-    }));
-    const published = (async () => {
-      let stored;
-      try {
-        stored = options.signal === void 0 ? await this.createStoredSession(preparation.session) : await raceAbortCall(
-          () => this.createStoredSession(preparation.session, options.signal),
-          options.signal,
-          options.sessionId,
-          (abandoned) => {
-            void abandoned?.handle.close().catch(() => {
-            });
-          }
-        );
-      } catch (error) {
-        preparation[Symbol.dispose]();
-        throw error;
-      }
-      return this.setupAndPublish(
-        ownerCtx,
-        options.sessionId,
-        preparation,
-        options.agentOptions ?? {},
-        options.setup,
-        options.signal,
-        "startup",
-        stored,
-        options.parentAgent
-      );
-    })();
-    this.ownership.trackWrapper(published);
-    return published;
-  }
-  /**
-   * Take a fresh session's write ownership when persistence is mounted.
-   * Nothing is appended here: the constructor seed (which never re-emits
-   * through `session/event`) is stored by {@link appendUnstoredSuffix} at the
-   * publication commit point, so a failed or cancelled setup closes an
-   * unmaterialized handle and leaves no stored residue — the same id can be
-   * created again.
-   * @param session - the unpublished session to store.
-   * @param signal - optional cancellation forwarded to the backend create.
-   * @returns the owned handle and stored cursor, or `undefined` without a backend.
-   */
-  async createStoredSession(session, signal) {
-    const persistence = this.runtime.ctx.get("sessionPersistence");
-    if (persistence === void 0) return void 0;
-    const handle = await persistence.create(session.header, {
-      inheritedEventCount: session.inheritedEventCount,
-      ...signal === void 0 ? {} : { signal }
-    });
-    return { handle, storedCount: 0 };
-  }
-  /**
-   * Durably store the session events appended since the last stored cursor.
-   * Pre-publication appends (constructor seed markers, setup-window events)
-   * never re-emit through `session/event`, so publication must flush them
-   * through the handle before live events start routing into it.
-   * @param stored - the session's owned handle and stored cursor, if any.
-   * @param session - the unpublished session whose suffix is stored.
-   */
-  async appendUnstoredSuffix(stored, session) {
-    if (stored === void 0) return;
-    const suffix = session.snapshotEvents(SessionLogOffset2(stored.storedCount));
-    if (suffix.length > 0) await stored.handle.append(suffix);
-    stored.storedCount += suffix.length;
-  }
-  /**
-   * Resume an owned agent from the configured persistence service.
-   * @param ownerCtx - caller context that owns load, setup, and the live lifecycle.
-   * @param options - persisted identity, optional live parent, loop options, setup, and cancellation.
-   * @returns the published handle.
-   */
-  async resume(ownerCtx, options) {
-    const persistence = this.runtime.ctx.get("sessionPersistence");
-    if (persistence === void 0) {
-      throw new Error("cannot resume: session persistence is not configured (load a dsh-session-persistence backend)");
-    }
-    return this.resumeWith(ownerCtx, persistence, options);
-  }
-  /** Resume through an explicit persistence service. */
-  resumeWith(ownerCtx, persistence, options) {
-    const id = options.resumeSessionId;
-    const published = (async () => {
-      const ownerAbort = new AbortController();
-      const unfollowOwner = ownerCtx.effect(() => () => {
-        ownerAbort.abort(new Error(`agent "${id}" setup aborted: owner disposed during setup`));
-      }, `agentLoopCodex.resume-load(${id})`);
-      const fused = AbortSignal.any([
-        ...options.signal === void 0 ? [] : [options.signal],
-        ownerAbort.signal,
-        this.ownership.signal
-      ]);
-      let handle;
-      let stored;
-      let preparation;
-      try {
-        try {
-          handle = await raceAbortCall(
-            () => persistence.open(id, "write", { signal: fused }),
-            fused,
-            id,
-            (abandoned) => {
-              void abandoned.close();
-            }
-          );
-          const coldRead = await handle.read(0, void 0, { signal: fused });
-          fused.throwIfAborted();
-          const persisted = coldRead.events;
-          const closers = interruptedTurnClosers2(persisted);
-          if (closers.length > 0) await handle.append(closers);
-          preparation = SessionPreparation2.create(this.runtime.ctx.sessions.prepare(id, {
-            seed: [...persisted, ...closers],
-            meta: structuredClone(handle.header),
-            inheritedEventCount: handle.inheritedEventCount,
-            eventState: coldRead.eventState
-          }));
-          stored = { handle, storedCount: persisted.length + closers.length };
-          await this.appendUnstoredSuffix(stored, preparation.session);
-        } finally {
-          await unfollowOwner();
-        }
-        ownerCtx.fiber.assertActive();
-        if (!this.ownership.isActive()) throw new Error("agent loop is not active");
-        const owned = stored;
-        handle = void 0;
-        return await this.setupAndPublish(
-          ownerCtx,
-          id,
-          preparation,
-          options.agentOptions ?? {},
-          options.setup,
-          options.signal,
-          "resume",
-          owned,
-          options.parentAgent
-        );
-      } finally {
-        preparation?.[Symbol.dispose]();
-        await handle?.close().catch(() => {
-        });
-      }
-    })();
-    this.ownership.trackWrapper(published);
-    return published;
+  /** Construct the Codex driver for one prepared session. */
+  buildAgent(loopCtx, id, options, session) {
+    return new CodexAgent(loopCtx, id, options, session, this.config);
   }
 };
 
@@ -2999,23 +3011,20 @@ var CodexLoop = class extends Service2 {
 import { readFileSync } from "node:fs";
 import { dirname as dirname2, join as join2 } from "node:path";
 import { fileURLToPath } from "node:url";
-import { Service as Service3 } from "@deepseek-ai/cordis";
 import z3 from "@deepseek-ai/schemastery";
-import { emitAgentEvent as emitAgentEvent3 } from "@deepseek-ai/dsh-agent";
-import { interruptedTurnClosers as interruptedTurnClosers3, SessionLogOffset as SessionLogOffset3, SessionPreparation as SessionPreparation3 } from "@deepseek-ai/dsh-session";
 
 // src/engine-pi/agent.ts
 import { agentEvents as agentEvents3 } from "@deepseek-ai/dsh-agent";
-import { ToolCallId as ToolCallId4, LlmError as LlmError3, createAssistantMessage as createAssistantMessage3, createUserMessage as createUserMessage3, errorChain as errorChain3 } from "@deepseek-ai/dsh-llm";
+import { ToolCallId as ToolCallId5, LlmError as LlmError3, createAssistantMessage as createAssistantMessage3, createUserMessage as createUserMessage3, errorChain as errorChain3 } from "@deepseek-ai/dsh-llm";
 import { createScope as createScope3 } from "@deepseek-ai/dsh-scope";
 import { canonicalHeader as canonicalHeader3 } from "@deepseek-ai/dsh-session";
 
 // src/engine-pi/permission.ts
 var DEFAULT_PI_PERMISSION = {
   sandboxMode: "read-only",
-  tools: ["read", "grep", "find", "ls"]
+  tools: ["read"]
 };
-var WORKSPACE_WRITE_TOOLS = ["read", "grep", "find", "ls", "write", "edit"];
+var WORKSPACE_WRITE_TOOLS = ["read", "write", "edit"];
 var FULL_ACCESS_TOOLS = [];
 function toolsForSandbox(mode) {
   switch (mode) {
@@ -3226,7 +3235,7 @@ var PiRpcClient = class _PiRpcClient {
 
 // src/engine-pi/rpc/mapping.ts
 import {
-  ToolCallId as ToolCallId3,
+  ToolCallId as ToolCallId4,
   createToolResultMessage as createToolResultMessage3
 } from "@deepseek-ai/dsh-llm";
 function mapUsage3(usage) {
@@ -3257,7 +3266,7 @@ function resultText(content) {
 }
 function mapToolResult(ev) {
   return createToolResultMessage3({
-    callId: ToolCallId3(ev.toolCallId),
+    callId: ToolCallId4(ev.toolCallId),
     content: [{ type: "text", text: resultText(ev.result) || "(no content)" }],
     isError: ev.isError
   });
@@ -3267,10 +3276,6 @@ function mapToolResult(ev) {
 var PROVIDER3 = "pi";
 var NATIVE_MODEL_LABEL3 = "pi-native";
 var TOOLS_FLAG = "--tools";
-function specsEqual(a, b) {
-  if (a === void 0) return false;
-  return a.cwd === b.cwd && a.env === b.env && a.argv.length === b.argv.length && a.argv.every((value, index) => value === b.argv[index]);
-}
 var PiAgent = class {
   constructor(loopCtx, id, options, session, config, spawn4, bin, catalog) {
     this.loopCtx = loopCtx;
@@ -3322,18 +3327,39 @@ var PiAgent = class {
   requestHeaderLogged = false;
   /** Agent-lifecycle-local counter naming each streamed attempt. */
   streamAttempts = 0;
-  /** Lazily created RPC client, reused across steps and released on scope teardown. */
+  /** This step's RPC child; released by the step teardown and the scope teardown. */
   rpc;
-  /** The spawn spec the cached client was built from; a change forces a respawn. */
-  lastSpec;
-  /** Return the cached RPC client, respawning when the spec or process changed. */
-  async rpcClient(cwd) {
-    const spec = this.spawnSpec(cwd);
-    if (this.rpc !== void 0 && !this.rpc.closed && specsEqual(this.lastSpec, spec)) return this.rpc;
-    this.rpc?.dispose();
-    const client = PiRpcClient.create(spec, this.spawn);
+  /**
+   * Tool results logged into the currently open step. A result means the
+   * segment that requested the call is finished, so the next assistant content
+   * opens the next step (see {@link beginSegment}).
+   */
+  stepSettledTools = 0;
+  /**
+   * Rotate to the next step when the segment that ran a tool has finished, so
+   * each assistant segment lands in its own step.
+   *
+   * Called as new assistant content begins. A step holding a settled tool
+   * result means the previous segment is complete, and the content about to be
+   * written belongs to the next one. Rotating at a message boundary keeps calls
+   * announced together — one model turn — in one step.
+   * @param phase - the running phase carrying the open step's position.
+   */
+  beginSegment(phase) {
+    if (this.stepSettledTools === 0) return;
+    this.session.append("step/end", { turn: phase.turn, step: phase.step });
+    phase.step += 1;
+    this.session.append("step/start", { turn: phase.turn, step: phase.step });
+    this.stepSettledTools = 0;
+  }
+  /**
+   * Open this step's RPC child. The Pi RPC process is single-session, so a step
+   * never reuses one: the step teardown disposes it and the next step respawns
+   * a fresh child.
+   */
+  rpcClient(cwd) {
+    const client = PiRpcClient.create(this.spawnSpec(cwd), this.spawn);
     this.rpc = client;
-    this.lastSpec = spec;
     return client;
   }
   get status() {
@@ -3565,7 +3591,7 @@ var PiAgent = class {
           const stepEnd = await this.step();
           if (turnEnds === null) turnEnds = stepEnd;
         } finally {
-          this.session.append("step/end", { turn, step });
+          this.session.append("step/end", { turn, step: phase.step });
         }
         signal.throwIfAborted();
         if (turnEnds && this.inbox.nextStep.length === 0) {
@@ -3688,8 +3714,10 @@ var PiAgent = class {
    */
   async step() {
     if (this.phase.kind !== "running") throw new Error(`agent "${this.id}": step outside running phase`);
-    const { turn, step, abort: { signal } } = this.phase;
+    const phase = this.phase;
+    const { abort: { signal } } = phase;
     signal.throwIfAborted();
+    this.stepSettledTools = 0;
     const cwd = this.session.header.cwd;
     if (cwd === void 0 || cwd.length === 0) {
       throw new Error(`agent "${this.id}": no working directory \u2014 start the session with cwd metadata`);
@@ -3716,15 +3744,15 @@ var PiAgent = class {
           live = new DriverAssistantStream(
             this.id,
             ++this.streamAttempts,
-            turn,
-            step,
+            phase.turn,
+            phase.step,
             (frame2) => this.dispatch.emit("agent/assistant-stream", { frame: frame2 })
           );
           live.start();
         }
         return live;
       };
-      const client = await this.rpcClient(cwd);
+      const client = this.rpcClient(cwd);
       signal.throwIfAborted();
       await client.newSession();
       client.clearEvents();
@@ -3736,14 +3764,17 @@ var PiAgent = class {
       const startedReasoning = /* @__PURE__ */ new Set();
       const thinkingByIndex = /* @__PURE__ */ new Map();
       const emittedToolCalls = /* @__PURE__ */ new Set();
+      let pendingToolCalls = [];
+      let pendingCallLog = [];
+      let callsToLog = [];
       let lastUsage;
       let assistantFlushed = false;
       const flushHeld = (usage) => {
         if (held === void 0) return;
         const attempt = live;
         const data = {
-          turn,
-          step,
+          turn: phase.turn,
+          step: phase.step,
           message: createAssistantMessage3({
             content: held.content,
             source: { provider: PROVIDER3, model: this.modelLabel() }
@@ -3759,6 +3790,16 @@ var PiAgent = class {
           live = void 0;
         }
         held = void 0;
+        for (const call of callsToLog) {
+          this.session.append("tool/call", {
+            turn: phase.turn,
+            step: phase.step,
+            callId: ToolCallId5(call.callId),
+            name: call.name,
+            arguments: call.arguments
+          });
+        }
+        callsToLog = [];
       };
       const ensureTextBlock = (index) => {
         if (startedText.has(index)) return;
@@ -3774,13 +3815,17 @@ var PiAgent = class {
         if (emittedToolCalls.has(callId)) return;
         emittedToolCalls.add(callId);
         const argumentsValue = typeof rawArguments === "string" ? rawArguments : JSON.stringify(rawArguments ?? {});
-        this.session.append("tool/call", {
-          turn,
-          step,
-          callId: ToolCallId4(callId),
-          name: name2,
-          arguments: argumentsValue
-        });
+        pendingToolCalls.push({ type: "tool-call", id: ToolCallId5(callId), name: name2, arguments: argumentsValue });
+        pendingCallLog.push({ callId, name: name2, arguments: argumentsValue });
+      };
+      const ensureToolCallOwner = () => {
+        if (pendingToolCalls.length === 0) return;
+        flushHeld();
+        held = { content: [...pendingToolCalls] };
+        pendingToolCalls = [];
+        callsToLog = pendingCallLog;
+        pendingCallLog = [];
+        flushHeld();
       };
       const contentOf = (message) => {
         let blocks = [];
@@ -3796,6 +3841,12 @@ var PiAgent = class {
           const folded = [...thinkingByIndex.entries()].sort((a, b) => a[0] - b[0]).map(([, text]) => ({ type: "reasoning", text }));
           blocks = [...folded, ...blocks];
         }
+        if (pendingToolCalls.length > 0) {
+          blocks = [...blocks, ...pendingToolCalls];
+          pendingToolCalls = [];
+          callsToLog = pendingCallLog;
+          pendingCallLog = [];
+        }
         return blocks;
       };
       signal.throwIfAborted();
@@ -3813,6 +3864,7 @@ var PiAgent = class {
             break;
           case "message_start":
             if (event.message.role === "assistant") {
+              this.beginSegment(phase);
               startedText.clear();
               startedReasoning.clear();
               thinkingByIndex.clear();
@@ -3864,21 +3916,26 @@ var PiAgent = class {
             break;
           case "tool_execution_end":
             emitToolCall(event.toolCallId, event.toolName, void 0);
+            ensureToolCallOwner();
             this.session.append("tool/result", {
-              turn,
-              step,
+              turn: phase.turn,
+              step: phase.step,
               message: mapToolResult({ toolCallId: event.toolCallId, result: event.result, isError: event.isError })
             }, { surfaceOp: "append" });
+            this.stepSettledTools += 1;
             break;
           case "turn_end": {
             if (!assistantFlushed && event.message !== void 0) {
               if (event.message.usage !== void 0) lastUsage = mapUsage3(event.message.usage);
               held = { content: contentOf(event.message) };
             }
+            flushHeld(lastUsage);
+            assistantFlushed = true;
             for (const toolResult2 of event.toolResults ?? []) {
-              this.appendToolResult(turn, step, toolResult2);
+              ensureToolCallOwner();
+              this.appendToolResult(phase.turn, phase.step, toolResult2);
+              this.stepSettledTools += 1;
             }
-            flushHeld(lastUsage);
             finished = true;
             break;
           }
@@ -4051,14 +4108,9 @@ function fromSubprocess(handle) {
     terminate: () => handle.terminate()
   };
 }
-var PiLoop = class extends Service3 {
+var PiLoop = class extends HostedLoopFactory {
   /** Services the loop resolves through its own fiber; blessed identically to the package-level entry inject. */
   static inject = ["agents", "sessions", "systemPrompt", "subprocess"];
-  /** Validated configuration owned by the loop plugin. */
-  config;
-  ownership;
-  /** Plain holder prevents Cordis from re-tracing the factory's dependency context through a caller shadow. */
-  runtime;
   /** Process-tree spawn capability handed to every agent, sandboxed by the subprocess seam. */
   spawn;
   /** Resolved Pi CLI entrypoint; `argv[0]` of every Pi RPC child. */
@@ -4066,10 +4118,7 @@ var PiLoop = class extends Service3 {
   /** Discovered Pi model catalog, forwarded to each agent so it can validate the session-selected model against what pi can actually serve. */
   catalog;
   constructor(ctx, config) {
-    super(ctx, "agentLoopPi");
-    this.config = resolveConfig3(config);
-    this.ownership = new FactoryOwnership(ctx.fiber);
-    this.runtime = { ctx };
+    super(ctx, "agentLoopPi", resolveConfig3(config));
     this.bin = piCliEntrypoint();
     this.catalog = config.piCatalogHolder ?? { entries: [] };
     this.spawn = (spec) => fromSubprocess(this.runtime.ctx.subprocess.spawn(piSubprocessSpec(spec, PI_DISPOSE_GRACE_MS)));
@@ -4081,318 +4130,28 @@ var PiLoop = class extends Service3 {
         holder.entries = [];
       });
     }
-    ctx.effect(() => () => this.ownership.dispose(), "agentLoopPi.transactions()");
-    ctx.effect(() => ctx.agents.setFactory(this), "agentLoopPi.setFactory()");
-    ctx.systemPrompt.variable("provider", (context) => context.agent?.options.provider);
-    ctx.systemPrompt.variable("model", (context) => context.agent?.options.model);
-    ctx.systemPrompt.variable("cwd", (context) => context.agent?.session.header.cwd);
   }
-  /**
-   * Construct the driver, scope, and one memoized reverse teardown for a new
-   * agent. The teardown is registered with the factory and the owner fiber
-   * BEFORE publication, so a mid-setup unload rolls everything back; `signal`
-   * fuses caller cancellation with lifecycle teardown for setup awaits.
-   */
-  /* jscpd:ignore-start -- ownership/transaction machinery mirrors the Claude Code loop factory. */
-  prepare(ownerCtx, id, options, session, callerSignal, handle, parentAgent) {
-    ownerCtx.fiber.assertActive();
-    if (!this.ownership.isActive()) throw new Error("agent loop is not active");
-    if (callerSignal?.aborted) {
-      throw callerSignal.reason instanceof Error ? callerSignal.reason : new Error(`agent "${id}" creation aborted`, { cause: callerSignal.reason });
-    }
-    const loopCtx = this.runtime.ctx;
-    const abort = new AbortController();
-    const onCallerAbort = () => {
-      abort.abort(callerSignal?.reason instanceof Error ? callerSignal.reason : new Error(`agent "${id}" creation aborted`, { cause: callerSignal?.reason }));
-    };
-    const onFactoryTeardown = () => {
-      abort.abort(this.ownership.signal.reason);
-    };
-    callerSignal?.addEventListener("abort", onCallerAbort, { once: true });
-    this.ownership.signal.addEventListener("abort", onFactoryTeardown, { once: true });
-    let machine;
-    let detachSession;
-    let detachAgent;
-    let disposing;
-    const machineReady = Promise.withResolvers();
-    const dispose = (ownerTriggered = false) => disposing ??= (async () => {
-      abort.abort(new Error(`agent "${id}" lifecycle disposed`));
-      callerSignal?.removeEventListener("abort", onCallerAbort);
-      this.ownership.signal.removeEventListener("abort", onFactoryTeardown);
-      try {
-        if (machine === void 0) await machineReady.promise;
-        if (machine !== void 0) {
-          machine.cancel({ kind: "disposed" });
-          await machine.whenIdle();
-          await machine.scope.dispose();
-        }
-      } finally {
-        try {
-          await handle?.close();
-        } finally {
-          try {
-            detachAgent?.();
-            detachSession?.();
-          } finally {
-            untrack();
-            if (!ownerTriggered) await unfollowOwner();
-          }
-        }
-      }
-    })();
-    const untrack = this.ownership.track(dispose);
-    let unfollowOwner;
-    try {
-      unfollowOwner = ownerCtx.effect(() => () => {
-        if (disposing !== void 0) return;
-        abort.abort(new Error(`agent "${id}" setup aborted: owner disposed during setup`));
-        return dispose(true);
-      }, `agentLoopPi.lifecycle(${id})`);
-    } catch (error) {
-      untrack();
-      callerSignal?.removeEventListener("abort", onCallerAbort);
-      this.ownership.signal.removeEventListener("abort", onFactoryTeardown);
-      throw error;
-    }
-    const assertLive = () => {
-      if (!abort.signal.aborted) return;
-      throw abort.signal.reason instanceof Error ? abort.signal.reason : new Error(String(abort.signal.reason));
-    };
-    try {
-      const agent = machine = new PiAgent(
-        loopCtx,
-        id,
-        options,
-        session,
-        this.config,
-        this.spawn,
-        this.bin,
-        this.catalog
-      );
-      machineReady.resolve();
-      assertLive();
-      return {
-        agent,
-        signal: abort.signal,
-        publish: (source) => {
-          assertLive();
-          detachSession = agent.ctx.sessions.enter(session);
-          detachAgent = loopCtx.agents.enter(agent, parentAgent);
-          agent.ctx.sessions.announce(session);
-          assertLive();
-          loopCtx.agents.announce(agent);
-          assertLive();
-          emitAgentEvent3(loopCtx, agent, "agent/session-start", { source });
-          assertLive();
-          return { agent, dispose };
-        },
-        dispose
-      };
-    } catch (error) {
-      machineReady.resolve();
-      void dispose();
-      throw error;
-    }
-  }
-  /** Prepare one Agent around an acquired Session, run setup, and publish it. */
-  async setupAndPublish(ownerCtx, id, preparation, agentOptions, setup, signal, source, stored, parentAgent) {
-    var _stack = [];
-    try {
-      const ownedPreparation = __using(_stack, preparation);
-      const session = ownedPreparation.session;
-      let prepared;
-      try {
-        prepared = this.prepare(ownerCtx, id, agentOptions, session, signal, stored?.handle, parentAgent);
-      } catch (error) {
-        await stored?.handle.close().catch(() => {
-        });
-        throw error;
-      }
-      try {
-        const setupCommit = await raceAbort(setup?.(prepared.agent.ctx, prepared.agent), prepared.signal, id);
-        setupCommit?.commit();
-        await this.appendUnstoredSuffix(stored, session);
-        return prepared.publish(source);
-      } catch (error) {
-        await prepared.dispose().catch(() => {
-        });
-        throw error;
-      }
-    } catch (_) {
-      var _error = _, _hasError = true;
-    } finally {
-      __callDispose(_stack, _error, _hasError);
-    }
-  }
-  /**
-   * Create an agent and session under one caller-supplied identity, owned by
-   * the accessing fiber. When a persistence backend is mounted, the session's
-   * durable identity is stored before publication.
-   * @param ownerCtx - caller context that structurally owns the lifecycle.
-   * @param options - identities, optional live parent, session seed/metadata, loop options, setup, and cancellation.
-   * @returns the published handle.
-   */
-  async createAgent(ownerCtx, options) {
-    const preparation = SessionPreparation3.create(this.runtime.ctx.sessions.prepare(options.sessionId, {
-      ...options.seed === void 0 ? {} : { seed: options.seed },
-      ...options.meta === void 0 ? {} : { meta: options.meta },
-      ...options.inheritedEventCount === void 0 ? {} : { inheritedEventCount: options.inheritedEventCount }
-    }));
-    const published = (async () => {
-      let stored;
-      try {
-        stored = options.signal === void 0 ? await this.createStoredSession(preparation.session) : await raceAbortCall(
-          () => this.createStoredSession(preparation.session, options.signal),
-          options.signal,
-          options.sessionId,
-          (abandoned) => {
-            void abandoned?.handle.close().catch(() => {
-            });
-          }
-        );
-      } catch (error) {
-        preparation[Symbol.dispose]();
-        throw error;
-      }
-      return this.setupAndPublish(
-        ownerCtx,
-        options.sessionId,
-        preparation,
-        options.agentOptions ?? {},
-        options.setup,
-        options.signal,
-        "startup",
-        stored,
-        options.parentAgent
-      );
-    })();
-    this.ownership.trackWrapper(published);
-    return published;
-  }
-  /**
-   * Take a fresh session's write ownership when persistence is mounted.
-   * Nothing is appended here: the constructor seed (which never re-emits
-   * through `session/event`) is stored by {@link appendUnstoredSuffix} at the
-   * publication commit point, so a failed or cancelled setup closes an
-   * unmaterialized handle and leaves no stored residue — the same id can be
-   * created again.
-   * @param session - the unpublished session to store.
-   * @param signal - optional cancellation forwarded to the backend create.
-   * @returns the owned handle and stored cursor, or `undefined` without a backend.
-   */
-  async createStoredSession(session, signal) {
-    const persistence = this.runtime.ctx.get("sessionPersistence");
-    if (persistence === void 0) return void 0;
-    const handle = await persistence.create(session.header, {
-      inheritedEventCount: session.inheritedEventCount,
-      ...signal === void 0 ? {} : { signal }
-    });
-    return { handle, storedCount: 0 };
-  }
-  /**
-   * Durably store the session events appended since the last stored cursor.
-   * Pre-publication appends (constructor seed markers, setup-window events)
-   * never re-emit through `session/event`, so publication must flush them
-   * through the handle before live events start routing into it.
-   * @param stored - the session's owned handle and stored cursor, if any.
-   * @param session - the unpublished session whose suffix is stored.
-   */
-  async appendUnstoredSuffix(stored, session) {
-    if (stored === void 0) return;
-    const suffix = session.snapshotEvents(SessionLogOffset3(stored.storedCount));
-    if (suffix.length > 0) await stored.handle.append(suffix);
-    stored.storedCount += suffix.length;
-  }
-  /**
-   * Resume an owned agent from the configured persistence service.
-   * @param ownerCtx - caller context that owns load, setup, and the live lifecycle.
-   * @param options - persisted identity, optional live parent, loop options, setup, and cancellation.
-   * @returns the published handle.
-   */
-  async resume(ownerCtx, options) {
-    const persistence = this.runtime.ctx.get("sessionPersistence");
-    if (persistence === void 0) {
-      throw new Error("cannot resume: session persistence is not configured (load a dsh-session-persistence backend)");
-    }
-    return this.resumeWith(ownerCtx, persistence, options);
-  }
-  /** Resume through an explicit persistence service. */
-  resumeWith(ownerCtx, persistence, options) {
-    const id = options.resumeSessionId;
-    const published = (async () => {
-      const ownerAbort = new AbortController();
-      const unfollowOwner = ownerCtx.effect(() => () => {
-        ownerAbort.abort(new Error(`agent "${id}" setup aborted: owner disposed during setup`));
-      }, `agentLoopPi.resume-load(${id})`);
-      const fused = AbortSignal.any([
-        ...options.signal === void 0 ? [] : [options.signal],
-        ownerAbort.signal,
-        this.ownership.signal
-      ]);
-      let handle;
-      let stored;
-      let preparation;
-      try {
-        try {
-          handle = await raceAbortCall(
-            () => persistence.open(id, "write", { signal: fused }),
-            fused,
-            id,
-            (abandoned) => {
-              void abandoned.close();
-            }
-          );
-          const coldRead = await handle.read(0, void 0, { signal: fused });
-          fused.throwIfAborted();
-          const persisted = coldRead.events;
-          const closers = interruptedTurnClosers3(persisted);
-          if (closers.length > 0) await handle.append(closers);
-          preparation = SessionPreparation3.create(this.runtime.ctx.sessions.prepare(id, {
-            seed: [...persisted, ...closers],
-            meta: structuredClone(handle.header),
-            inheritedEventCount: handle.inheritedEventCount,
-            eventState: coldRead.eventState
-          }));
-          stored = { handle, storedCount: persisted.length + closers.length };
-          await this.appendUnstoredSuffix(stored, preparation.session);
-        } finally {
-          await unfollowOwner();
-        }
-        ownerCtx.fiber.assertActive();
-        if (!this.ownership.isActive()) throw new Error("agent loop is not active");
-        const owned = stored;
-        handle = void 0;
-        return await this.setupAndPublish(
-          ownerCtx,
-          id,
-          preparation,
-          options.agentOptions ?? {},
-          options.setup,
-          options.signal,
-          "resume",
-          owned,
-          options.parentAgent
-        );
-      } finally {
-        preparation?.[Symbol.dispose]();
-        await handle?.close().catch(() => {
-        });
-      }
-    })();
-    this.ownership.trackWrapper(published);
-    return published;
+  /** Construct the Pi RPC driver for one prepared session. */
+  buildAgent(loopCtx, id, options, session) {
+    return new PiAgent(
+      loopCtx,
+      id,
+      options,
+      session,
+      this.config,
+      this.spawn,
+      this.bin,
+      this.catalog
+    );
   }
 };
 
 // src/engine-kimi/loop.ts
-import { Service as Service4 } from "@deepseek-ai/cordis";
 import z4 from "@deepseek-ai/schemastery";
-import { emitAgentEvent as emitAgentEvent4 } from "@deepseek-ai/dsh-agent";
-import { interruptedTurnClosers as interruptedTurnClosers4, SessionLogOffset as SessionLogOffset4, SessionPreparation as SessionPreparation4 } from "@deepseek-ai/dsh-session";
 
 // src/engine-kimi/agent.ts
 import { agentEvents as agentEvents4 } from "@deepseek-ai/dsh-agent";
-import { ToolCallId as ToolCallId6, LlmError as LlmError4, createAssistantMessage as createAssistantMessage4, createUserMessage as createUserMessage4, errorChain as errorChain4 } from "@deepseek-ai/dsh-llm";
+import { ToolCallId as ToolCallId7, LlmError as LlmError4, createAssistantMessage as createAssistantMessage4, createUserMessage as createUserMessage4, errorChain as errorChain4 } from "@deepseek-ai/dsh-llm";
 import { createScope as createScope4 } from "@deepseek-ai/dsh-scope";
 import { canonicalHeader as canonicalHeader4 } from "@deepseek-ai/dsh-session";
 
@@ -4450,6 +4209,17 @@ function isPermissionRequestFrame(frame2) {
 }
 
 // src/engine-kimi/acp/client.ts
+function permissionOptionsOf(frame2) {
+  const params = frame2.params;
+  if (params === void 0 || !Array.isArray(params.options)) return [];
+  return params.options.filter((option) => typeof option === "object" && option !== null && typeof option.optionId === "string");
+}
+function permissionResponse(approved, options) {
+  const candidates = options.filter((option) => option.kind === (approved ? "allow_once" : "reject_once"));
+  const match = candidates.length === 1 ? candidates[0] : void 0;
+  if (match === void 0) return { outcome: { outcome: "cancelled" } };
+  return { outcome: { outcome: "selected", optionId: match.optionId } };
+}
 function defaultSpawn2(spec) {
   const child = spawn3(spec.argv[0], spec.argv.slice(1), {
     cwd: spec.cwd,
@@ -4558,9 +4328,13 @@ var AcpClient = class _AcpClient {
   cancel(sessionId) {
     this.request("session/cancel", { sessionId }).catch(() => void 0);
   }
-  /** Answer a pending `session/request_permission`. */
-  respondPermission(id, approved) {
-    this.process.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, result: { approved } })}
+  /**
+   * Answer a pending `session/request_permission`.
+   * @param id - the reverse-RPC request id.
+   * @param response - the ACP outcome to answer with.
+   */
+  respondPermission(id, response) {
+    this.process.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, result: response })}
 `);
   }
   /** Consume every buffered update as an async generator. */
@@ -4642,12 +4416,12 @@ var AcpClient = class _AcpClient {
   }
   async handlePermission(id, frame2) {
     const approved = this.permissionHandler === void 0 ? false : await this.permissionHandler(frame2);
-    this.respondPermission(id, approved);
+    this.respondPermission(id, permissionResponse(approved, permissionOptionsOf(frame2)));
   }
 };
 
 // src/engine-kimi/acp/mapping.ts
-import { ToolCallId as ToolCallId5, createToolResultMessage as createToolResultMessage4 } from "@deepseek-ai/dsh-llm";
+import { ToolCallId as ToolCallId6, createToolResultMessage as createToolResultMessage4 } from "@deepseek-ai/dsh-llm";
 function isTextChunk(update) {
   return update.sessionUpdate === "agent_message_chunk";
 }
@@ -4672,6 +4446,11 @@ function toolCallIdOf(update) {
 function toolCallName(update) {
   return update.title;
 }
+function toolRawInput(update) {
+  const raw = update.rawInput;
+  if (raw === void 0) return void 0;
+  return typeof raw === "string" ? raw : JSON.stringify(raw);
+}
 function isToolSettledStatus(status) {
   return status !== "pending" && status !== "queued" && status !== "running" && status !== "in_progress";
 }
@@ -4679,12 +4458,13 @@ function isToolErrorStatus(status) {
   return status === "failed" || status === "error" || status === "denied";
 }
 function toolContentText(update) {
-  const blocks = update.content ?? [];
+  const blocks = update.content;
+  if (!Array.isArray(blocks)) return void 0;
   return blocks.map((block) => block.type === "content" && block.content.type === "text" ? block.content.text : "").join("");
 }
 function toolResult(callId, text, isError) {
   return createToolResultMessage4({
-    callId: ToolCallId5(callId),
+    callId: ToolCallId6(callId),
     content: [{ type: "text", text: text.length > 0 ? text : "(no content)" }],
     isError
   });
@@ -4965,7 +4745,7 @@ var KimiAgent = class {
           const stepEnd = await this.step();
           if (turnEnds === null) turnEnds = stepEnd;
         } finally {
-          this.session.append("step/end", { turn, step });
+          this.session.append("step/end", { turn, step: phase.step });
         }
         signal.throwIfAborted();
         if (turnEnds && this.inbox.nextStep.length === 0) {
@@ -5028,507 +4808,313 @@ var KimiAgent = class {
     const client = AcpClient.create(spec, this.spawn);
     this.acp = client;
     this.lastSpec = spec;
-    try {
-      await client.initialize();
-    } catch (error) {
-      this.acp = void 0;
-      this.lastSpec = void 0;
-      client.dispose();
-      throw error;
-    }
-    return client;
-  }
-  /** Build the `kimi acp` argv/cwd/env for the persistent child. */
-  spawnSpec(cwd) {
-    return {
-      argv: kimiAcpArgv(this.bin),
-      cwd,
-      env: this.config.env
-    };
-  }
-  /** Run one `kimi acp` step for the current session history and map the streamed updates. */
-  async step() {
-    if (this.phase.kind !== "running") throw new Error(`agent "${this.id}": step outside running phase`);
-    const { turn, step, abort: { signal } } = this.phase;
-    signal.throwIfAborted();
-    this.blocks = [];
-    this.emittedToolCalls = /* @__PURE__ */ new Set();
-    this.toolText = /* @__PURE__ */ new Map();
-    const cwd = this.session.header.cwd;
-    if (cwd === void 0 || cwd.length === 0) {
-      throw new Error(`agent "${this.id}": no working directory \u2014 start the session with cwd metadata`);
-    }
-    const history = this.session.deriveMessages();
-    const prompt = serializeHistory(history);
-    if (prompt.length === 0) {
-      throw new Error(`agent "${this.id}": cannot derive a prompt from an empty session log`);
-    }
-    this.assertRequestHeader();
-    signal.throwIfAborted();
-    const client = await this.acpClient(cwd);
-    signal.throwIfAborted();
-    client.onPermission(() => resolveToolApproval(this.session.snapshotEvents()));
-    const acpSessionId = await client.newSession(cwd);
-    signal.throwIfAborted();
-    let live;
-    try {
-      const currentStream = () => {
-        if (live === void 0) {
-          live = new DriverAssistantStream(
-            this.id,
-            ++this.streamAttempts,
-            turn,
-            step,
-            (frame2) => this.dispatch.emit("agent/assistant-stream", { frame: frame2 })
-          );
-          live.start();
-        }
-        return live;
-      };
-      client.onUpdate((update) => this.applyUpdate(turn, step, update, currentStream));
-      const cancel = () => {
-        client.cancel(acpSessionId);
-      };
-      signal.addEventListener("abort", cancel, { once: true });
-      try {
-        await raceAbort(client.prompt(acpSessionId, prompt), signal, this.id);
-      } finally {
-        signal.removeEventListener("abort", cancel);
-      }
-      this.flushAssistant(turn, step, currentStream);
-      if (this.blocks.length === 0 && this.emittedToolCalls.size === 0) {
-        throw new LlmError4(
-          `agent "${this.id}": kimi query produced no assistant output`,
-          "KIMI_NO_RESULT"
-        );
-      }
-      return { kind: "completed" };
-    } finally {
-      if (live !== void 0 && !live.ended) live.abandon();
-    }
-  }
-  /** Per-step accumulation state for streamed assistant blocks and tool calls. */
-  blocks = [];
-  emittedToolCalls = /* @__PURE__ */ new Set();
-  toolText = /* @__PURE__ */ new Map();
-  blockRef(type) {
-    return this.blocks.find((block) => block.type === type);
-  }
-  ensureBlock(type) {
-    const existing = this.blockRef(type);
-    if (existing !== void 0) return existing;
-    const index = this.blocks.length;
-    const block = { index, type, text: "" };
-    this.blocks.push(block);
-    return block;
-  }
-  /** Apply one streamed update to the current step's blocks and stream. */
-  applyUpdate(turn, step, update, currentStream) {
-    if (isThoughtChunk(update)) {
-      const delta = chunkDelta(update);
-      if (delta === "") return;
-      const block = this.ensureBlock("reasoning");
-      if (block.text === "") currentStream().push({ type: "block-start", index: block.index, blockType: "reasoning" });
-      currentStream().push({ type: "reasoning-delta", index: block.index, text: delta });
-      block.text += delta;
-      return;
-    }
-    if (isTextChunk(update)) {
-      const delta = chunkDelta(update);
-      if (delta === "") return;
-      const block = this.ensureBlock("text");
-      if (block.text === "") currentStream().push({ type: "block-start", index: block.index, blockType: "text" });
-      currentStream().push({ type: "text-delta", index: block.index, text: delta });
-      block.text += delta;
-      return;
-    }
-    if (isToolCall(update)) {
-      const callId = toolCallIdOf(update);
-      if (callId === "" || this.emittedToolCalls.has(callId)) return;
-      this.emittedToolCalls.add(callId);
-      const name2 = toolCallName(update);
-      this.session.append("tool/call", { turn, step, callId: ToolCallId6(callId), name: name2, arguments: "{}" });
-      this.toolText.set(callId, "");
-      return;
-    }
-    if (isToolCallUpdate(update)) {
-      const callId = toolCallIdOf(update);
-      if (callId === "" || !this.toolText.has(callId)) return;
-      const delta = toolContentText(update);
-      const accumulated = `${this.toolText.get(callId)}${delta}`;
-      this.toolText.set(callId, accumulated);
-      const status = update.status;
-      if (isToolSettledStatus(status)) {
-        const message = toolResult(callId, accumulated, isToolErrorStatus(status));
-        this.session.append("tool/result", { turn, step, message }, { surfaceOp: "append" });
-        this.toolText.delete(callId);
-      }
-      return;
-    }
-  }
-  /**
-   * Flush the accumulated assistant blocks into one durable assistant/message
-   * carrying the exact stream the attempt published live.
-   * @param turn - durable turn owning the message.
-   * @param step - durable step owning the message.
-   * @param currentStream - the step's live attempt accessor; a step whose
-   *   blocks streamed always has one open, while a tool-only step has none.
-   */
-  flushAssistant(turn, step, currentStream) {
-    if (this.blocks.length === 0 && this.emittedToolCalls.size === 0) return;
-    const content = [];
-    const attempt = this.blocks.length === 0 ? void 0 : currentStream();
-    for (const block of this.blocks) {
-      const delta = block.text;
-      content.push(block.type === "text" ? { type: "text", text: delta } : { type: "reasoning", text: delta });
-      attempt?.push({ type: "block-end", index: block.index, block: block.type === "text" ? { type: "text", text: delta } : { type: "reasoning", text: delta } });
-    }
-    const data = {
-      turn,
-      step,
-      message: createAssistantMessage4({
-        content,
-        source: { provider: PROVIDER4, model: this.modelLabel() }
-      }),
-      // The attempt's exact timed stream travels with its message.
-      stream: attempt?.stream ?? []
-    };
-    if (attempt === void 0) {
-      this.session.append("assistant/message", data, { surfaceOp: "append" });
-    } else {
-      attempt.settle(() => this.session.append("assistant/message", data, { surfaceOp: "append" }).seq);
-    }
-  }
-};
-
-// src/engine-kimi/loop.ts
-var KIMI_DISPOSE_GRACE_MS = 3e3;
-var Config4 = z4.object({
-  model: z4.string(),
-  env: z4.dict(z4.string()).default({}),
-  bin: z4.string()
-});
-function resolveConfig4(config) {
-  return {
-    model: config.model,
-    env: config.env ?? {},
-    bin: kimiBinResolver(config.bin)
-  };
-}
-var KimiLoop = class extends Service4 {
-  /** Services the loop resolves through its own fiber; blessed identically to the package-level entry inject. */
-  static inject = ["agents", "sessions", "systemPrompt", "subprocess"];
-  /** Validated configuration owned by the loop plugin. */
-  config;
-  ownership;
-  /** Plain holder prevents Cordis from re-tracing the factory's dependency context through a caller shadow. */
-  runtime;
-  /** One-shot spawn capability handed to every agent, sandboxed by the subprocess seam. */
-  spawn;
-  constructor(ctx, config) {
-    super(ctx, "agentLoopKimi");
-    this.config = resolveConfig4(config);
-    this.ownership = new FactoryOwnership(ctx.fiber);
-    this.runtime = { ctx };
-    this.spawn = (spec) => fromSubprocess2(this.runtime.ctx.subprocess.spawn(kimiSubprocessSpec(spec, KIMI_DISPOSE_GRACE_MS)));
-    ctx.effect(() => () => this.ownership.dispose(), "agentLoopKimi.transactions()");
-    ctx.effect(() => ctx.agents.setFactory(this), "agentLoopKimi.setFactory()");
-    ctx.systemPrompt.variable("provider", (context) => context.agent?.options.provider);
-    ctx.systemPrompt.variable("model", (context) => context.agent?.options.model);
-    ctx.systemPrompt.variable("cwd", (context) => context.agent?.session.header.cwd);
-  }
-  /**
-   * Construct the driver, scope, and one memoized reverse teardown for a new
-   * agent. The teardown is registered with the factory and the owner fiber
-   * BEFORE publication, so a mid-setup unload rolls everything back; `signal`
-   * fuses caller cancellation with lifecycle teardown for setup awaits.
-   */
-  /* jscpd:ignore-start -- ownership/transaction machinery mirrors the Claude Code loop factory. */
-  prepare(ownerCtx, id, options, session, callerSignal, handle, parentAgent) {
-    ownerCtx.fiber.assertActive();
-    if (!this.ownership.isActive()) throw new Error("agent loop is not active");
-    if (callerSignal?.aborted) {
-      throw callerSignal.reason instanceof Error ? callerSignal.reason : new Error(`agent "${id}" creation aborted`, { cause: callerSignal.reason });
-    }
-    const loopCtx = this.runtime.ctx;
-    const abort = new AbortController();
-    const onCallerAbort = () => {
-      abort.abort(callerSignal?.reason instanceof Error ? callerSignal.reason : new Error(`agent "${id}" creation aborted`, { cause: callerSignal?.reason }));
-    };
-    const onFactoryTeardown = () => {
-      abort.abort(this.ownership.signal.reason);
-    };
-    callerSignal?.addEventListener("abort", onCallerAbort, { once: true });
-    this.ownership.signal.addEventListener("abort", onFactoryTeardown, { once: true });
-    let machine;
-    let detachSession;
-    let detachAgent;
-    let disposing;
-    const machineReady = Promise.withResolvers();
-    const dispose = (ownerTriggered = false) => disposing ??= (async () => {
-      abort.abort(new Error(`agent "${id}" lifecycle disposed`));
-      callerSignal?.removeEventListener("abort", onCallerAbort);
-      this.ownership.signal.removeEventListener("abort", onFactoryTeardown);
-      try {
-        if (machine === void 0) await machineReady.promise;
-        if (machine !== void 0) {
-          machine.cancel({ kind: "disposed" });
-          await machine.whenIdle();
-          await machine.scope.dispose();
-        }
-      } finally {
-        try {
-          await handle?.close();
-        } finally {
-          try {
-            detachAgent?.();
-            detachSession?.();
-          } finally {
-            untrack();
-            if (!ownerTriggered) await unfollowOwner();
-          }
-        }
-      }
-    })();
-    const untrack = this.ownership.track(dispose);
-    let unfollowOwner;
-    try {
-      unfollowOwner = ownerCtx.effect(() => () => {
-        if (disposing !== void 0) return;
-        abort.abort(new Error(`agent "${id}" setup aborted: owner disposed during setup`));
-        return dispose(true);
-      }, `agentLoopKimi.lifecycle(${id})`);
-    } catch (error) {
-      untrack();
-      callerSignal?.removeEventListener("abort", onCallerAbort);
-      this.ownership.signal.removeEventListener("abort", onFactoryTeardown);
-      throw error;
-    }
-    const assertLive = () => {
-      if (!abort.signal.aborted) return;
-      throw abort.signal.reason instanceof Error ? abort.signal.reason : new Error(String(abort.signal.reason));
-    };
-    try {
-      const agent = machine = new KimiAgent(loopCtx, id, options, session, this.config, this.spawn, this.config.bin);
-      machineReady.resolve();
-      assertLive();
-      return {
-        agent,
-        signal: abort.signal,
-        publish: (source) => {
-          assertLive();
-          detachSession = agent.ctx.sessions.enter(session);
-          detachAgent = loopCtx.agents.enter(agent, parentAgent);
-          agent.ctx.sessions.announce(session);
-          assertLive();
-          loopCtx.agents.announce(agent);
-          assertLive();
-          emitAgentEvent4(loopCtx, agent, "agent/session-start", { source });
-          assertLive();
-          return { agent, dispose };
-        },
-        dispose
-      };
+    try {
+      await client.initialize();
     } catch (error) {
-      machineReady.resolve();
-      void dispose();
+      this.acp = void 0;
+      this.lastSpec = void 0;
+      client.dispose();
       throw error;
     }
+    return client;
   }
-  /** Prepare one Agent around an acquired Session, run setup, and publish it. */
-  async setupAndPublish(ownerCtx, id, preparation, agentOptions, setup, signal, source, stored, parentAgent) {
-    var _stack = [];
+  /** Build the `kimi acp` argv/cwd/env for the persistent child. */
+  spawnSpec(cwd) {
+    return {
+      argv: kimiAcpArgv(this.bin),
+      cwd,
+      env: this.config.env
+    };
+  }
+  /** Run one `kimi acp` step for the current session history and map the streamed updates. */
+  async step() {
+    if (this.phase.kind !== "running") throw new Error(`agent "${this.id}": step outside running phase`);
+    const phase = this.phase;
+    const { abort: { signal } } = phase;
+    signal.throwIfAborted();
+    this.blocks = [];
+    this.pendingCalls = /* @__PURE__ */ new Map();
+    this.segmentCalls = [];
+    this.toolContent = /* @__PURE__ */ new Map();
+    this.producedOutput = false;
+    this.stepSettledTools = 0;
+    const cwd = this.session.header.cwd;
+    if (cwd === void 0 || cwd.length === 0) {
+      throw new Error(`agent "${this.id}": no working directory \u2014 start the session with cwd metadata`);
+    }
+    const history = this.session.deriveMessages();
+    const prompt = serializeHistory(history);
+    if (prompt.length === 0) {
+      throw new Error(`agent "${this.id}": cannot derive a prompt from an empty session log`);
+    }
+    this.assertRequestHeader();
+    signal.throwIfAborted();
+    const client = await this.acpClient(cwd);
+    signal.throwIfAborted();
+    client.onPermission(() => resolveToolApproval(this.session.snapshotEvents()));
+    const acpSessionId = await client.newSession(cwd);
+    signal.throwIfAborted();
     try {
-      const ownedPreparation = __using(_stack, preparation);
-      const session = ownedPreparation.session;
-      let prepared;
+      client.onUpdate((update) => this.applyUpdate(phase, update));
+      const cancel = () => {
+        client.cancel(acpSessionId);
+      };
+      signal.addEventListener("abort", cancel, { once: true });
       try {
-        prepared = this.prepare(ownerCtx, id, agentOptions, session, signal, stored?.handle, parentAgent);
-      } catch (error) {
-        await stored?.handle.close().catch(() => {
-        });
-        throw error;
+        await raceAbort(client.prompt(acpSessionId, prompt), signal, this.id);
+      } finally {
+        signal.removeEventListener("abort", cancel);
       }
-      try {
-        const setupCommit = await raceAbort(setup?.(prepared.agent.ctx, prepared.agent), prepared.signal, id);
-        setupCommit?.commit();
-        await this.appendUnstoredSuffix(stored, session);
-        return prepared.publish(source);
-      } catch (error) {
-        await prepared.dispose().catch(() => {
-        });
-        throw error;
+      for (const [callId, call] of this.pendingCalls) {
+        this.segmentCalls.push({ callId, name: call.name, arguments: "{}" });
       }
-    } catch (_) {
-      var _error = _, _hasError = true;
+      this.pendingCalls.clear();
+      this.flushSegment(phase);
+      if (!this.producedOutput) {
+        throw new LlmError4(
+          `agent "${this.id}": kimi query produced no assistant output`,
+          "KIMI_NO_RESULT"
+        );
+      }
+      return { kind: "completed" };
     } finally {
-      __callDispose(_stack, _error, _hasError);
+      if (this.live !== void 0 && !this.live.ended) this.live.abandon();
+      this.live = void 0;
     }
   }
+  /** Per-step accumulation state for streamed assistant blocks and tool calls. */
+  blocks = [];
   /**
-   * Create an agent and session under one caller-supplied identity, owned by
-   * the accessing fiber. When a persistence backend is mounted, the session's
-   * durable identity is stored before publication.
-   * @param ownerCtx - caller context that structurally owns the lifecycle.
-   * @param options - identities, optional live parent, session seed/metadata, loop options, setup, and cancellation.
-   * @returns the published handle.
+   * Announced calls still waiting for the update that carries their input,
+   * keyed by call id, holding the latest content snapshot seen meanwhile (a
+   * frame can report output before it reports input). `toolContent` holds the
+   * calls already logged, so a call is in exactly one of the two.
    */
-  async createAgent(ownerCtx, options) {
-    const preparation = SessionPreparation4.create(this.runtime.ctx.sessions.prepare(options.sessionId, {
-      ...options.seed === void 0 ? {} : { seed: options.seed },
-      ...options.meta === void 0 ? {} : { meta: options.meta },
-      ...options.inheritedEventCount === void 0 ? {} : { inheritedEventCount: options.inheritedEventCount }
-    }));
-    const published = (async () => {
-      let stored;
-      try {
-        stored = options.signal === void 0 ? await this.createStoredSession(preparation.session) : await raceAbortCall(
-          () => this.createStoredSession(preparation.session, options.signal),
-          options.signal,
-          options.sessionId,
-          (abandoned) => {
-            void abandoned?.handle.close().catch(() => {
-            });
-          }
-        );
-      } catch (error) {
-        preparation[Symbol.dispose]();
-        throw error;
-      }
-      return this.setupAndPublish(
-        ownerCtx,
-        options.sessionId,
-        preparation,
-        options.agentOptions ?? {},
-        options.setup,
-        options.signal,
-        "startup",
-        stored,
-        options.parentAgent
-      );
-    })();
-    this.ownership.trackWrapper(published);
-    return published;
-  }
+  pendingCalls = /* @__PURE__ */ new Map();
+  /** Whether the current step published any assistant message at all. */
+  producedOutput = false;
   /**
-   * Take a fresh session's write ownership when persistence is mounted.
-   * Nothing is appended here: the constructor seed (which never re-emits
-   * through `session/event`) is stored by {@link appendUnstoredSuffix} at the
-   * publication commit point, so a failed or cancelled setup closes an
-   * unmaterialized handle and leaves no stored residue — the same id can be
-   * created again.
-   * @param session - the unpublished session to store.
-   * @param signal - optional cancellation forwarded to the backend create.
-   * @returns the owned handle and stored cursor, or `undefined` without a backend.
+   * Tool results logged into the currently open step. A result means the
+   * segment that requested the call is finished, so the next assistant content
+   * opens the next step (see {@link beginSegment}).
    */
-  async createStoredSession(session, signal) {
-    const persistence = this.runtime.ctx.get("sessionPersistence");
-    if (persistence === void 0) return void 0;
-    const handle = await persistence.create(session.header, {
-      inheritedEventCount: session.inheritedEventCount,
-      ...signal === void 0 ? {} : { signal }
-    });
-    return { handle, storedCount: 0 };
-  }
+  stepSettledTools = 0;
   /**
-   * Durably store the session events appended since the last stored cursor.
-   * Pre-publication appends (constructor seed markers, setup-window events)
-   * never re-emit through `session/event`, so publication must flush them
-   * through the handle before live events start routing into it.
-   * @param stored - the session's owned handle and stored cursor, if any.
-   * @param session - the unpublished session whose suffix is stored.
+   * Tool calls the current segment has already received input for, awaiting the
+   * segment's single assistant message. A model turn that announces several
+   * calls before any result must land them all in ONE message — the chat node
+   * keys by `${turn}:${step}` and replaces blocks on every message, so a second
+   * message would overwrite the first one's reasoning/text (and tool-call head).
+   * The list is flushed once, when the segment closes (its first settled result).
    */
-  async appendUnstoredSuffix(stored, session) {
-    if (stored === void 0) return;
-    const suffix = session.snapshotEvents(SessionLogOffset4(stored.storedCount));
-    if (suffix.length > 0) await stored.handle.append(suffix);
-    stored.storedCount += suffix.length;
+  segmentCalls = [];
+  /** Latest content snapshot per logged tool call (see {@link applyUpdate}). */
+  toolContent = /* @__PURE__ */ new Map();
+  /** The live attempt framing the assistant message being assembled right now. */
+  live;
+  blockRef(type) {
+    return this.blocks.find((block) => block.type === type);
+  }
+  ensureBlock(type) {
+    const existing = this.blockRef(type);
+    if (existing !== void 0) return existing;
+    const index = this.blocks.length;
+    const block = { index, type, text: "" };
+    this.blocks.push(block);
+    return block;
   }
   /**
-   * Resume an owned agent from the configured persistence service.
-   * @param ownerCtx - caller context that owns load, setup, and the live lifecycle.
-   * @param options - persisted identity, optional live parent, loop options, setup, and cancellation.
-   * @returns the published handle.
+   * Rotate to the next step when the segment that ran a tool has finished, so
+   * each assistant segment lands in its own step.
+   *
+   * Called as new assistant content begins. A step holding a settled tool
+   * result means the previous segment is complete, and the content about to be
+   * applied belongs to the next one. Rotating here (rather than when a call is
+   * announced) keeps calls that were announced before any result — one model
+   * turn — in a single step.
    */
-  async resume(ownerCtx, options) {
-    const persistence = this.runtime.ctx.get("sessionPersistence");
-    if (persistence === void 0) {
-      throw new Error("cannot resume: session persistence is not configured (load a dsh-session-persistence backend)");
+  beginSegment(phase) {
+    if (this.stepSettledTools === 0) return;
+    this.session.append("step/end", { turn: phase.turn, step: phase.step });
+    phase.step += 1;
+    this.session.append("step/start", { turn: phase.turn, step: phase.step });
+    this.stepSettledTools = 0;
+  }
+  /** Apply one streamed update to the open step's blocks and stream. */
+  applyUpdate(phase, update) {
+    if (isThoughtChunk(update)) {
+      const delta = chunkDelta(update);
+      if (delta === "") return;
+      this.beginSegment(phase);
+      const block = this.ensureBlock("reasoning");
+      if (block.text === "") this.currentStream(phase).push({ type: "block-start", index: block.index, blockType: "reasoning" });
+      this.currentStream(phase).push({ type: "reasoning-delta", index: block.index, text: delta });
+      block.text += delta;
+      return;
     }
-    return this.resumeWith(ownerCtx, persistence, options);
-  }
-  /** Resume through an explicit persistence service. */
-  resumeWith(ownerCtx, persistence, options) {
-    const id = options.resumeSessionId;
-    const published = (async () => {
-      const ownerAbort = new AbortController();
-      const unfollowOwner = ownerCtx.effect(() => () => {
-        ownerAbort.abort(new Error(`agent "${id}" setup aborted: owner disposed during setup`));
-      }, `agentLoopKimi.resume-load(${id})`);
-      const fused = AbortSignal.any([
-        ...options.signal === void 0 ? [] : [options.signal],
-        ownerAbort.signal,
-        this.ownership.signal
-      ]);
-      let handle;
-      let stored;
-      let preparation;
-      try {
-        try {
-          handle = await raceAbortCall(
-            () => persistence.open(id, "write", { signal: fused }),
-            fused,
-            id,
-            (abandoned) => {
-              void abandoned.close();
-            }
-          );
-          const coldRead = await handle.read(0, void 0, { signal: fused });
-          fused.throwIfAborted();
-          const persisted = coldRead.events;
-          const closers = interruptedTurnClosers4(persisted);
-          if (closers.length > 0) await handle.append(closers);
-          preparation = SessionPreparation4.create(this.runtime.ctx.sessions.prepare(id, {
-            seed: [...persisted, ...closers],
-            meta: structuredClone(handle.header),
-            inheritedEventCount: handle.inheritedEventCount,
-            eventState: coldRead.eventState
-          }));
-          stored = { handle, storedCount: persisted.length + closers.length };
-          await this.appendUnstoredSuffix(stored, preparation.session);
-        } finally {
-          await unfollowOwner();
-        }
-        ownerCtx.fiber.assertActive();
-        if (!this.ownership.isActive()) throw new Error("agent loop is not active");
-        const owned = stored;
-        handle = void 0;
-        return await this.setupAndPublish(
-          ownerCtx,
-          id,
-          preparation,
-          options.agentOptions ?? {},
-          options.setup,
-          options.signal,
-          "resume",
-          owned,
-          options.parentAgent
-        );
-      } finally {
-        preparation?.[Symbol.dispose]();
-        await handle?.close().catch(() => {
-        });
+    if (isTextChunk(update)) {
+      const delta = chunkDelta(update);
+      if (delta === "") return;
+      this.beginSegment(phase);
+      const block = this.ensureBlock("text");
+      if (block.text === "") this.currentStream(phase).push({ type: "block-start", index: block.index, blockType: "text" });
+      this.currentStream(phase).push({ type: "text-delta", index: block.index, text: delta });
+      block.text += delta;
+      return;
+    }
+    if (isToolCall(update)) {
+      const callId = toolCallIdOf(update);
+      if (callId === "" || this.pendingCalls.has(callId) || this.toolContent.has(callId)) return;
+      this.beginSegment(phase);
+      this.pendingCalls.set(callId, { name: toolCallName(update) });
+      return;
+    }
+    if (isToolCallUpdate(update)) {
+      const callId = toolCallIdOf(update);
+      if (callId === "") return;
+      const status = update.status;
+      const settled = isToolSettledStatus(status);
+      const snapshot = toolContentText(update);
+      const pending = this.pendingCalls.get(callId);
+      if (pending !== void 0) {
+        if (snapshot !== void 0) pending.content = snapshot;
+        const args = toolRawInput(update);
+        if (args === void 0 && !settled) return;
+        this.pendingCalls.delete(callId);
+        this.beginSegment(phase);
+        this.segmentCalls.push({ callId, name: pending.name, arguments: args ?? "{}" });
+        this.toolContent.set(callId, pending.content ?? "");
+      } else if (!this.toolContent.has(callId)) {
+        return;
+      } else if (snapshot !== void 0) {
+        this.toolContent.set(callId, snapshot);
       }
-    })();
-    this.ownership.trackWrapper(published);
-    return published;
+      if (settled) {
+        this.flushSegment(phase);
+        const message = toolResult(callId, this.toolContent.get(callId), isToolErrorStatus(status));
+        this.session.append("tool/result", { turn: phase.turn, step: phase.step, message }, { surfaceOp: "append" });
+        this.toolContent.delete(callId);
+        this.stepSettledTools += 1;
+      }
+      return;
+    }
+  }
+  /** The live attempt framing the current segment, opened on its first chunk. */
+  currentStream(phase) {
+    if (this.live === void 0) {
+      this.live = new DriverAssistantStream(
+        this.id,
+        ++this.streamAttempts,
+        phase.turn,
+        phase.step,
+        (frame2) => this.dispatch.emit("agent/assistant-stream", { frame: frame2 })
+      );
+      this.live.start();
+    }
+    return this.live;
+  }
+  /**
+   * Flush the open segment's single assistant message and every `tool/call` it
+   * accumulated, in the load-bearing order assistant/message → tool/call. One
+   * segment produces exactly ONE message even when the model announced several
+   * calls before any result, because the chat view keys an assistant node by
+   * `${turn}:${step}` and replaces its blocks on every message — a second
+   * message in the same step would overwrite the first one's reasoning/text and
+   * leave only the last bare tool-call head visible.
+   * @param phase - the open step the segment belongs to.
+   */
+  flushSegment(phase) {
+    const calls = this.segmentCalls;
+    this.segmentCalls = [];
+    this.flushAssistant(phase, calls);
+    for (const call of calls) {
+      this.session.append("tool/call", { turn: phase.turn, step: phase.step, callId: ToolCallId7(call.callId), name: call.name, arguments: call.arguments });
+    }
+  }
+  /**
+   * Flush the accumulated assistant blocks into one durable assistant/message
+   * carrying the exact stream the attempt published live, optionally closing it
+   * with the tool-call block(s) that ended the segment.
+   *
+   * Every flush settles its own attempt (and so its own live `end` frame): a
+   * step emits one message per assistant segment, and the client pairs a durable
+   * message with the attempt whose `end` cites it, so two messages may not share
+   * one attempt.
+   * @param phase - the open step the message belongs to.
+   * @param toolCalls - the calls that closed this segment, rendered as trailing
+   *   `tool-call` content blocks. A segment with no blocks of its own — a step
+   *   whose only activity was a tool call — still emits this message, so its
+   *   `tool/call` and `tool/result` events have a parent to pair with.
+   */
+  flushAssistant(phase, toolCalls = []) {
+    if (this.blocks.length === 0 && toolCalls.length === 0) return;
+    const content = [];
+    this.producedOutput = true;
+    const attempt = this.blocks.length === 0 ? void 0 : this.currentStream(phase);
+    for (const block of this.blocks) {
+      const delta = block.text;
+      content.push(block.type === "text" ? { type: "text", text: delta } : { type: "reasoning", text: delta });
+      attempt?.push({ type: "block-end", index: block.index, block: block.type === "text" ? { type: "text", text: delta } : { type: "reasoning", text: delta } });
+    }
+    for (const call of toolCalls) {
+      content.push({ type: "tool-call", id: ToolCallId7(call.callId), name: call.name, arguments: call.arguments });
+    }
+    const data = {
+      turn: phase.turn,
+      step: phase.step,
+      message: createAssistantMessage4({
+        content,
+        source: { provider: PROVIDER4, model: this.modelLabel() }
+      }),
+      // The attempt's exact timed stream travels with its message.
+      stream: attempt?.stream ?? []
+    };
+    if (attempt === void 0) {
+      this.session.append("assistant/message", data, { surfaceOp: "append" });
+    } else {
+      attempt.settle(() => this.session.append("assistant/message", data, { surfaceOp: "append" }).seq);
+      this.live = void 0;
+    }
+    this.blocks = [];
+  }
+};
+
+// src/engine-kimi/loop.ts
+var KIMI_DISPOSE_GRACE_MS = 3e3;
+var Config4 = z4.object({
+  model: z4.string(),
+  env: z4.dict(z4.string()).default({}),
+  bin: z4.string()
+});
+function resolveConfig4(config) {
+  return {
+    model: config.model,
+    env: config.env ?? {},
+    bin: kimiBinResolver(config.bin)
+  };
+}
+var KimiLoop = class extends HostedLoopFactory {
+  /** Services the loop resolves through its own fiber; blessed identically to the package-level entry inject. */
+  static inject = ["agents", "sessions", "systemPrompt", "subprocess"];
+  /** One-shot spawn capability handed to every agent, sandboxed by the subprocess seam. */
+  spawn;
+  constructor(ctx, config) {
+    super(ctx, "agentLoopKimi", resolveConfig4(config));
+    this.spawn = (spec) => fromSubprocess2(this.runtime.ctx.subprocess.spawn(kimiSubprocessSpec(spec, KIMI_DISPOSE_GRACE_MS)));
+  }
+  /** Construct the Kimi ACP driver for one prepared session. */
+  buildAgent(loopCtx, id, options, session) {
+    return new KimiAgent(loopCtx, id, options, session, this.config, this.spawn, this.config.bin);
   }
 };
 
 // src/engine-kimi/skills.ts
-import { readdir as readdir2, readFile as readFile3, stat as stat3 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
-import { dirname as dirname3, join as join6, resolve as resolve3 } from "node:path";
+import { join as join7, resolve as resolve3 } from "node:path";
+
+// src/driver-core/agents-md-skill-provider.ts
+import { readdir as readdir2, readFile as readFile3, stat as stat3 } from "node:fs/promises";
+import { dirname as dirname3, join as join6 } from "node:path";
 
 // src/driver-core/context-files.ts
 import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
@@ -5813,37 +5399,39 @@ async function readSources(paths) {
   return parts.length > 0 ? parts.join("\n\n") : void 0;
 }
 
-// src/engine-kimi/skills.ts
-var PROVIDER_NAME2 = "kimi";
-var KIMI_AGENTS_PROJECT_RANK = 140;
-var KIMI_SKILL_PROJECT_RANK = 150;
-var KIMI_SKILL_USER_RANK = 160;
-var KIMI_CONTEXT_POLICY = {
-  primary: ["AGENTS.md"]
-};
-function kimiAgentDir() {
-  const override = process.env.KIMI_CODE_HOME;
-  if (override !== void 0 && override.length > 0) return resolve3(override);
-  return join6(homedir3(), ".kimi-code");
-}
-var KimiSkillProvider = class {
-  constructor(control) {
+// src/driver-core/agents-md-skill-provider.ts
+var AGENTS_MD = "agents-md";
+var AgentsMdSkillProvider = class {
+  constructor(spec, control) {
+    this.spec = spec;
     this.control = control;
+    this.name = spec.name;
   }
+  spec;
   control;
-  name = PROVIDER_NAME2;
+  name;
   async list(options) {
     const candidates = [];
     const cwd = options.cwd;
     if (cwd !== void 0) {
-      const projectDirs = await projectAncestors(cwd);
-      const contextPaths = await collectProjectContextFiles(cwd, KIMI_CONTEXT_POLICY);
-      if (await anySourceNonEmpty(contextPaths)) candidates.push(this.agentsCandidate(contextPaths, KIMI_AGENTS_PROJECT_RANK));
-      for (const dir of projectDirs) {
-        await this.collectSkillsDir(join6(dir, ".kimi-code", "skills"), KIMI_SKILL_PROJECT_RANK, candidates);
+      const contextPaths = await collectProjectContextFiles(cwd, this.spec.contextPolicy);
+      if (await anySourceNonEmpty(contextPaths)) candidates.push(this.agentsCandidate(contextPaths, this.spec.projectRank));
+      if (this.spec.skills !== void 0) {
+        const catalog = this.spec.skills;
+        for (const dir of await projectAncestors(cwd)) {
+          await this.collectSkillsDir(join6(dir, ...catalog.project), catalog.projectRank, candidates);
+        }
       }
     }
-    await this.collectSkillsDir(join6(kimiAgentDir(), "skills"), KIMI_SKILL_USER_RANK, candidates);
+    const userDir = this.spec.userDir();
+    const userContext = this.spec.userContext;
+    if (userContext !== void 0) {
+      const userFile = join6(userDir, userContext.file);
+      if (await fileNonEmpty(userFile)) candidates.push(this.agentsCandidate([userFile], userContext.rank));
+    }
+    if (this.spec.skills !== void 0) {
+      await this.collectSkillsDir(join6(userDir, this.spec.skills.userDir), this.spec.skills.userRank, candidates);
+    }
     if (this.control.signal.aborted) return [];
     return candidates;
   }
@@ -5882,8 +5470,8 @@ var KimiSkillProvider = class {
   agentsCandidate(paths, rank) {
     const first = paths[0];
     return {
-      name: "agents-md",
-      description: "Kimi project instructions (AGENTS.md)",
+      name: AGENTS_MD,
+      description: this.spec.agentsMdDescription,
       invocation: { modelInvocable: true, userInvocable: true },
       source: "custom",
       provider: this.name,
@@ -5893,7 +5481,7 @@ var KimiSkillProvider = class {
       resourceBase: { kind: "file", path: first }
     };
   }
-  /** Collect every skill in one skills directory, both kimi layouts. */
+  /** Collect every skill in one skills directory, both nesting layouts. */
   async collectSkillsDir(skillsDir, rank, candidates) {
     let entries;
     try {
@@ -5944,6 +5532,37 @@ var KimiSkillProvider = class {
   }
 };
 
+// src/engine-kimi/skills.ts
+var KIMI_AGENTS_PROJECT_RANK = 140;
+var KIMI_SKILL_PROJECT_RANK = 150;
+var KIMI_SKILL_USER_RANK = 160;
+var KIMI_CONTEXT_POLICY = {
+  primary: ["AGENTS.md"]
+};
+function kimiAgentDir() {
+  const override = process.env.KIMI_CODE_HOME;
+  if (override !== void 0 && override.length > 0) return resolve3(override);
+  return join7(homedir3(), ".kimi-code");
+}
+var KIMI_SPEC = {
+  name: "kimi",
+  agentsMdDescription: "Kimi project instructions (AGENTS.md)",
+  contextPolicy: KIMI_CONTEXT_POLICY,
+  userDir: kimiAgentDir,
+  projectRank: KIMI_AGENTS_PROJECT_RANK,
+  skills: {
+    project: [".kimi-code", "skills"],
+    projectRank: KIMI_SKILL_PROJECT_RANK,
+    userDir: "skills",
+    userRank: KIMI_SKILL_USER_RANK
+  }
+};
+var KimiSkillProvider = class extends AgentsMdSkillProvider {
+  constructor(control) {
+    super(KIMI_SPEC, control);
+  }
+};
+
 // src/engine-kimi/commands.ts
 import { createUserMessage as createUserMessage5 } from "@deepseek-ai/dsh-llm";
 function forwardKimiCommand(name2) {
@@ -5979,7 +5598,7 @@ var LOOP_ENGINE_SETTINGS_NAMESPACE_LITERAL = "agent-loop-engine";
 // src/settings.ts
 var LOOP_ENGINE_IDS = ["in-process", "claude-code", "codex", "pi", "kimi"];
 var LOOP_ENGINE_SETTINGS_SCHEMA = z5.object({
-  engine: z5.union([z5.const("in-process"), z5.const("claude-code"), z5.const("codex"), z5.const("pi"), z5.const("kimi")]).default("in-process"),
+  engine: z5.union(LOOP_ENGINE_IDS.map((id) => z5.const(id))).default("in-process"),
   showInComposer: z5.boolean().default(true)
 });
 function loopEngineSettingsNamespace() {
@@ -6002,10 +5621,16 @@ function renderManagedBlock(engine) {
     END_MARKER_LINE
   ].join("\n");
 }
+function hasManagedBlock(text) {
+  return text.includes(MANAGED_BLOCK_BEGIN);
+}
 var BEGIN_MARKER_RE = /^# -- dsh-loop-engine managed block: (\S+) --$/m;
-function currentEngineOf(text) {
+function managedBlockEngineOf(text) {
   const engine = BEGIN_MARKER_RE.exec(text)?.[1];
-  return LOOP_ENGINE_IDS.includes(engine ?? "") ? engine : "in-process";
+  return LOOP_ENGINE_IDS.includes(engine ?? "") ? engine : void 0;
+}
+function currentEngineOf(text) {
+  return managedBlockEngineOf(text) ?? "in-process";
 }
 function managedSpan(text) {
   const begin = text.indexOf(MANAGED_BLOCK_BEGIN);
@@ -6063,7 +5688,7 @@ ${block}`;
 // src/preset.ts
 import { mkdir, readFile as readFile4, rename, writeFile } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
-import { dirname as dirname4, join as join7 } from "node:path";
+import { dirname as dirname4, join as join8 } from "node:path";
 var HOSTED_PRESET_ID = "loop-engine";
 var USER_PRESET_DIR = ".agent-presets";
 var COMPOSITION_FILE = "agent.cordis.yml";
@@ -6131,9 +5756,9 @@ async function ensureHostedPreset(dshHome, source) {
   const composition = await source.read(SOURCE_PRESET_ID);
   const stripped = `${MANAGED_HEADER}
 ${stripPresetRows(composition)}`;
-  const dir = join7(dshHome, USER_PRESET_DIR, HOSTED_PRESET_ID);
-  const compositionChanged = await writeIfDifferent(join7(dir, COMPOSITION_FILE), stripped);
-  const metadataChanged = await writeIfDifferent(join7(dir, METADATA_FILE), MANAGED_METADATA);
+  const dir = join8(dshHome, USER_PRESET_DIR, HOSTED_PRESET_ID);
+  const compositionChanged = await writeIfDifferent(join8(dir, COMPOSITION_FILE), stripped);
+  const metadataChanged = await writeIfDifferent(join8(dir, METADATA_FILE), MANAGED_METADATA);
   return compositionChanged || metadataChanged;
 }
 
@@ -6157,13 +5782,20 @@ var HostedEngineRouteAdapter = class extends LlmAdapter {
   }
   label;
   options;
-  /** Advertise the injected Pi models (if any) under this route's provider label. */
+  /**
+   * Advertise the injected Pi models (if any) under this route's provider label.
+   *
+   * The model is what the picker shows at the top level, so `name` is the bare
+   * model; the `provider/model` composite stays the submitted `id`, which is
+   * both what the engine receives as `--model` and how the driver validates a
+   * session-selected model against its catalog.
+   */
   async listModels(_provider) {
     const catalog = this.options.listModels?.() ?? [];
     return catalog.map((entry) => ({
       provider: this.label,
       id: `${entry.provider}/${entry.model}`,
-      name: `${entry.provider}/${entry.model}`
+      name: entry.model
     }));
   }
   stream(_options) {
@@ -6177,7 +5809,7 @@ var HostedEngineRouteAdapter = class extends LlmAdapter {
 // src/commands.ts
 import { readdirSync, readFileSync as readFileSync2 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 import { createUserMessage as createUserMessage6 } from "@deepseek-ai/dsh-llm";
 var COMMAND_NAME = /^[a-z][a-z0-9_-]*$/;
 function forwardClaudeCodeCommand(name2) {
@@ -6214,7 +5846,7 @@ function discoverUserSlashCommands() {
     if (!entry.endsWith(".md")) continue;
     const name2 = entry.slice(0, -".md".length);
     if (!COMMAND_NAME.test(name2) || seen.has(name2)) continue;
-    const path = join8(userCommandsDir(), entry);
+    const path = join9(userCommandsDir(), entry);
     let raw;
     try {
       raw = readFileSync2(path, "utf8");
@@ -6229,7 +5861,7 @@ function discoverUserSlashCommands() {
   return definitions;
 }
 function userCommandsDir() {
-  return join8(homedir4(), ".claude", "commands");
+  return join9(homedir4(), ".claude", "commands");
 }
 function commandDescription(raw) {
   const trimmed = raw.trim();
@@ -6256,67 +5888,27 @@ function commandDescription(raw) {
 
 // src/engine-codex/skills.ts
 import { homedir as homedir5 } from "node:os";
-import { join as join9 } from "node:path";
-var PROVIDER_NAME3 = "codex";
+import { join as join10 } from "node:path";
 var CODEX_PROJECT_RANK = 140;
 var CODEX_USER_RANK = 160;
 var CODEX_CONTEXT_POLICY = { primary: ["AGENTS.md"] };
-var CodexSkillProvider = class {
+var CODEX_SPEC = {
+  name: "codex",
+  agentsMdDescription: "Codex project/user instructions (AGENTS.md)",
+  contextPolicy: CODEX_CONTEXT_POLICY,
+  userDir: () => join10(homedir5(), ".codex"),
+  projectRank: CODEX_PROJECT_RANK,
+  userContext: { file: "AGENTS.md", rank: CODEX_USER_RANK }
+};
+var CodexSkillProvider = class extends AgentsMdSkillProvider {
   constructor(control) {
-    this.control = control;
-  }
-  control;
-  name = PROVIDER_NAME3;
-  async list(options) {
-    const candidates = [];
-    const cwd = options.cwd;
-    if (cwd !== void 0) {
-      const paths = await collectProjectContextFiles(cwd, CODEX_CONTEXT_POLICY);
-      if (await anySourceNonEmpty(paths)) candidates.push(this.agentsCandidate(paths, CODEX_PROJECT_RANK));
-    }
-    const userPath = join9(homedir5(), ".codex", "AGENTS.md");
-    if (await fileNonEmpty(userPath)) candidates.push(this.agentsCandidate([userPath], CODEX_USER_RANK));
-    if (this.control.signal.aborted) return [];
-    return candidates;
-  }
-  async get(candidate, _options) {
-    const locator = candidate.locator;
-    const content = await readSources(locator.paths);
-    if (content === void 0) return void 0;
-    const first = locator.paths[0];
-    return {
-      name: candidate.name,
-      description: candidate.description,
-      invocation: candidate.invocation,
-      source: candidate.source,
-      provider: this.name,
-      content,
-      path: first,
-      resourceBase: { kind: "file", path: first }
-    };
-  }
-  /** One merged `agents-md` candidate for a ranked file set. */
-  agentsCandidate(paths, rank) {
-    const first = paths[0];
-    return {
-      name: "agents-md",
-      description: "Codex project/user instructions (AGENTS.md)",
-      invocation: { modelInvocable: true, userInvocable: true },
-      source: "custom",
-      provider: this.name,
-      rank,
-      locator: { kind: "agents-md", paths },
-      path: first,
-      resourceBase: { kind: "file", path: first }
-    };
+    super(CODEX_SPEC, control);
   }
 };
 
 // src/engine-pi/skills.ts
-import { readdir as readdir3, readFile as readFile5, stat as stat4 } from "node:fs/promises";
 import { homedir as homedir6 } from "node:os";
-import { dirname as dirname5, join as join10, resolve as resolve4 } from "node:path";
-var PROVIDER_NAME4 = "pi";
+import { join as join11, resolve as resolve4 } from "node:path";
 var PI_AGENTS_PROJECT_RANK = 140;
 var PI_SKILL_PROJECT_RANK = 150;
 var PI_AGENTS_USER_RANK = 160;
@@ -6328,126 +5920,25 @@ var PI_CONTEXT_POLICY = {
 function piAgentDir() {
   const override = process.env.PI_CODING_AGENT_DIR;
   if (override !== void 0 && override.length > 0) return resolve4(override);
-  return join10(homedir6(), ".pi", "agent");
-}
-var PiSkillProvider = class {
-  constructor(control) {
-    this.control = control;
-  }
-  control;
-  name = PROVIDER_NAME4;
-  async list(options) {
-    const candidates = [];
-    const cwd = options.cwd;
-    if (cwd !== void 0) {
-      const projectDirs = await projectAncestors(cwd);
-      const contextPaths = await collectProjectContextFiles(cwd, PI_CONTEXT_POLICY);
-      if (await anySourceNonEmpty(contextPaths)) candidates.push(this.agentsCandidate(contextPaths, PI_AGENTS_PROJECT_RANK));
-      for (const dir of projectDirs) {
-        await this.collectSkillsDir(join10(dir, ".pi", "skills"), PI_SKILL_PROJECT_RANK, candidates);
-      }
-    }
-    const userAgentDir = piAgentDir();
-    const userContext = join10(userAgentDir, "AGENTS.md");
-    if (await fileNonEmpty(userContext)) candidates.push(this.agentsCandidate([userContext], PI_AGENTS_USER_RANK));
-    await this.collectSkillsDir(join10(userAgentDir, "skills"), PI_SKILL_USER_RANK, candidates);
-    if (this.control.signal.aborted) return [];
-    return candidates;
-  }
-  async get(candidate, _options) {
-    const locator = candidate.locator;
-    if (locator.kind === "skill-file") {
-      const parsed = await this.tryParse(locator.path);
-      if (parsed === void 0) return void 0;
-      return {
-        name: parsed.name,
-        description: parsed.description,
-        ...parsed.whenToUse === void 0 ? {} : { whenToUse: parsed.whenToUse },
-        invocation: parsed.invocation,
-        source: candidate.source,
-        provider: this.name,
-        content: parsed.content,
-        path: locator.path,
-        resourceBase: { kind: "directory", path: dirname5(locator.path) }
-      };
-    }
-    const content = await readSources(locator.paths);
-    if (content === void 0) return void 0;
-    const first = locator.paths[0];
-    return {
-      name: candidate.name,
-      description: candidate.description,
-      invocation: candidate.invocation,
-      source: candidate.source,
-      provider: this.name,
-      content,
-      path: first,
-      resourceBase: { kind: "file", path: first }
-    };
-  }
-  /** One merged `agents-md` candidate for a ranked file set. */
-  agentsCandidate(paths, rank) {
-    const first = paths[0];
-    return {
-      name: "agents-md",
-      description: "Pi project/user instructions (AGENTS.md / CLAUDE.md)",
-      invocation: { modelInvocable: true, userInvocable: true },
-      source: "custom",
-      provider: this.name,
-      rank,
-      locator: { kind: "agents-md", paths },
-      path: first,
-      resourceBase: { kind: "file", path: first }
-    };
-  }
-  /** Collect every skill in one skills directory, both pi layouts. */
-  async collectSkillsDir(skillsDir, rank, candidates) {
-    let entries;
-    try {
-      entries = await readdir3(skillsDir, { withFileTypes: true, encoding: "utf8" });
-    } catch {
-      return;
-    }
-    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-      const entryPath = join10(skillsDir, entry.name);
-      const info = await stat4(entryPath).catch(() => void 0);
-      if (info === void 0) continue;
-      if (info.isDirectory()) {
-        const path = join10(entryPath, "SKILL.md");
-        const parsed2 = await this.tryParse(path);
-        if (parsed2 === void 0) continue;
-        candidates.push(this.skillCandidate(parsed2, path, rank, entryPath));
-        continue;
-      }
-      if (!entry.name.endsWith(".md")) continue;
-      const parsed = await this.tryParse(entryPath);
-      if (parsed === void 0) continue;
-      candidates.push(this.skillCandidate(parsed, entryPath, rank, skillsDir));
-    }
-  }
-  /** One parsed skill as a ranked candidate. */
-  skillCandidate(skill, path, rank, resourceDir) {
-    return {
-      name: skill.name,
-      description: skill.description,
-      ...skill.whenToUse === void 0 ? {} : { whenToUse: skill.whenToUse },
-      invocation: skill.invocation,
-      source: "custom",
-      provider: this.name,
-      rank,
-      locator: { kind: "skill-file", path },
-      path,
-      resourceBase: { kind: "directory", path: resourceDir }
-    };
+  return join11(homedir6(), ".pi", "agent");
+}
+var PI_SPEC = {
+  name: "pi",
+  agentsMdDescription: "Pi project/user instructions (AGENTS.md / CLAUDE.md)",
+  contextPolicy: PI_CONTEXT_POLICY,
+  userDir: piAgentDir,
+  projectRank: PI_AGENTS_PROJECT_RANK,
+  userContext: { file: "AGENTS.md", rank: PI_AGENTS_USER_RANK },
+  skills: {
+    project: [".pi", "skills"],
+    projectRank: PI_SKILL_PROJECT_RANK,
+    userDir: "skills",
+    userRank: PI_SKILL_USER_RANK
   }
-  /** Parse one SKILL.md file, or `undefined` when it is unreadable or invalid. */
-  async tryParse(path) {
-    try {
-      const raw = await readFile5(path, { encoding: "utf8" });
-      return parseSkillFile(raw);
-    } catch {
-      return void 0;
-    }
+};
+var PiSkillProvider = class extends AgentsMdSkillProvider {
+  constructor(control) {
+    super(PI_SPEC, control);
   }
 };
 
@@ -6473,7 +5964,7 @@ var Config5 = z6.object({
 });
 function resolvePatchPath(config) {
   if (config.patchPath !== void 0 && config.patchPath !== "") return config.patchPath;
-  return join11(
+  return join12(
     resolveDshHome(),
     "profiles",
     config.profile ?? "web",
@@ -6485,20 +5976,20 @@ function isMissing(error) {
 }
 async function readPatchOrUndefined(path) {
   try {
-    return await readFile6(path, "utf8");
+    return await readFile5(path, "utf8");
   } catch (error) {
     if (isMissing(error)) return void 0;
     throw error;
   }
 }
 async function writePatchFile(path, text) {
-  await mkdir2(dirname6(path), { recursive: true });
+  await mkdir2(dirname5(path), { recursive: true });
   const tmp = `${path}.tmp-${randomUUID2()}`;
   await writeFile2(tmp, text, "utf8");
   await rename2(tmp, path);
 }
 function writePatchFileSync(path, text) {
-  mkdirSync(dirname6(path), { recursive: true });
+  mkdirSync(dirname5(path), { recursive: true });
   const tmp = `${path}.tmp-${randomUUID2()}`;
   writeFileSync(tmp, text, "utf8");
   renameSync(tmp, path);
@@ -6553,12 +6044,29 @@ function kimiConfig(config) {
 }
 function apply(ctx, config) {
   const patchPath = resolvePatchPath(config);
-  let fileEngine = currentEngineOf(readPatchFileSync(patchPath));
+  const patchText = readPatchFileSync(patchPath);
+  let fileEngine = currentEngineOf(patchText);
+  if (hasManagedBlock(patchText) && managedBlockEngineOf(patchText) === void 0) {
+    try {
+      writePatchFileSync(patchPath, applyManagedBlock(patchText, "in-process"));
+      fileEngine = "in-process";
+      ctx.logger.error(
+        "loop-engine: the managed block names an engine this build does not recognize; removed it so the base agent loop can own the factory slot. Restart `dsh web` to bring the base loop back."
+      );
+    } catch (error) {
+      ctx.logger.error(`loop-engine: could not repair the unrecognized managed block: ${String(error)}`);
+    }
+  }
   const AGENT_PRESETS_NS = "agent-presets";
   const PRESET_DEFAULT_ATTEMPTS = 30;
   const PRESET_DEFAULT_RETRY_MS = 100;
   let engineFiber;
   let mountedEngine;
+  let mountGeneration = 0;
+  let disposed = false;
+  const retryLater = (run, ms) => setTimeout(() => {
+    if (!disposed) run();
+  }, ms);
   let commandDisposers;
   let skillDisposer;
   const piCatalogHolder = { entries: [] };
@@ -6604,9 +6112,7 @@ function apply(ctx, config) {
     const llm = ctx.get("llm");
     if (llm === void 0) {
       if (attempt < ROUTE_ATTEMPTS) {
-        routeRetry = setTimeout(() => {
-          mountProviderRoute(engine, attempt + 1);
-        }, ROUTE_RETRY_MS);
+        routeRetry = retryLater(() => mountProviderRoute(engine, attempt + 1), ROUTE_RETRY_MS);
       }
       return;
     }
@@ -6615,7 +6121,8 @@ function apply(ctx, config) {
       routeHandle = llm.registerAdapter([label], new HostedEngineRouteAdapter(label, options));
       routeEngine = engine;
     } catch (error) {
-      if (error instanceof Error && error.message.includes("already registered")) {
+      const duplicateAdapter = error?.code === "DUPLICATE_ADAPTER";
+      if (error instanceof Error && (duplicateAdapter || error.message.includes("already registered"))) {
         ctx.logger.warn(`loop-engine: provider route "${label}" is already served by another adapter`);
         return;
       }
@@ -6625,11 +6132,17 @@ function apply(ctx, config) {
   const mutatePresetDefault = (op, attempt = 0) => {
     const settings = ctx.get("settings");
     if (settings === void 0) return;
+    if (settings.describe !== void 0 && !settings.describe().some((entry) => entry.ns === AGENT_PRESETS_NS)) {
+      if (attempt < PRESET_DEFAULT_ATTEMPTS) {
+        presetRetry = retryLater(() => mutatePresetDefault(op, attempt + 1), PRESET_DEFAULT_RETRY_MS);
+      } else {
+        ctx.logger.error(`loop-engine: preset default switch failed: the "${AGENT_PRESETS_NS}" settings namespace never registered`);
+      }
+      return;
+    }
     settings.mutate(AGENT_PRESETS_NS, [op]).then(() => void 0, (error) => {
       if (error instanceof Error && error.message.includes("not registered") && attempt < PRESET_DEFAULT_ATTEMPTS) {
-        presetRetry = setTimeout(() => {
-          mutatePresetDefault(op, attempt + 1);
-        }, PRESET_DEFAULT_RETRY_MS);
+        presetRetry = retryLater(() => mutatePresetDefault(op, attempt + 1), PRESET_DEFAULT_RETRY_MS);
         return;
       }
       ctx.logger.error(`loop-engine: preset default switch failed: ${String(error)}`);
@@ -6645,9 +6158,7 @@ function apply(ctx, config) {
       return;
     }
     if (attempt < PRESET_DEFAULT_ATTEMPTS) {
-      presetRetry = setTimeout(() => {
-        restorePresetDefault(attempt + 1);
-      }, PRESET_DEFAULT_RETRY_MS);
+      presetRetry = retryLater(() => restorePresetDefault(attempt + 1), PRESET_DEFAULT_RETRY_MS);
     }
   };
   const steerPresetDefault = (engine) => {
@@ -6682,21 +6193,30 @@ function apply(ctx, config) {
   };
   const hostFactory = (engine, mount) => {
     if (engineFiber !== void 0) return;
+    const generation = ++mountGeneration;
     const fiber = mount();
     engineFiber = fiber;
     mountedEngine = engine;
     void fiber.then(() => void 0, (error) => {
+      if (generation !== mountGeneration) return;
       cleanupEngineRegistrations();
       engineFiber = void 0;
       mountedEngine = void 0;
-      if (error instanceof Error && error.message.includes("an agent factory is already registered") && mountAttempts < MAX_MOUNT_ATTEMPTS) {
+      const baseLoopHoldsSlot = ctx.get("agentLoop") !== void 0;
+      if (error instanceof Error && (baseLoopHoldsSlot || error.message.includes("an agent factory is already registered")) && mountAttempts < MAX_MOUNT_ATTEMPTS) {
         mountAttempts += 1;
-        mountRetry = setTimeout(() => {
-          mountEngine(engine);
+        mountRetry = retryLater(() => {
+          try {
+            mountEngine(engine);
+          } catch (retryError) {
+            ctx.logger.error(`loop-engine: ${engine} mount retry failed: ${String(retryError)}`);
+          }
         }, MOUNT_RETRY_MS);
         return;
       }
-      ctx.logger.error(`loop-engine: ${engine} factory failed to start: ${String(error)}`);
+      ctx.logger.error(
+        `loop-engine: ${engine} factory failed to start: ${String(error)} \u2014 restart \`dsh web\` to release the factory slot`
+      );
     });
   };
   const mountClaude = () => {
@@ -6764,20 +6284,29 @@ function apply(ctx, config) {
   };
   const unmountEngine = () => {
     const fiber = engineFiber;
+    const engine = mountedEngine;
     mountAttempts = 0;
+    mountGeneration += 1;
     CLEAR_RETRY();
     releaseRoute();
     cleanupEngineRegistrations();
     mountedEngine = void 0;
     if (fiber === void 0) return;
     engineFiber = void 0;
-    void fiber.then((resolved) => {
-      void resolved.dispose();
-    }, () => void 0);
+    void fiber.then(
+      (resolved) => {
+        resolved.dispose().catch((error) => {
+          ctx.logger.error(`loop-engine: ${String(engine)} factory dispose failed: ${String(error)}`);
+        });
+      },
+      /* v8 ignore next -- a fiber that failed already cleared engineFiber in hostFactory's rejection handler, so this rejection arm is unreachable */
+      () => void 0
+    );
   };
   mountEngine(fileEngine);
   steerPresetDefault(fileEngine);
   ctx.effect(() => () => {
+    disposed = true;
     CLEAR_RETRY();
     CLEAR_PRESET_RETRY();
     releaseRoute();
@@ -6791,18 +6320,23 @@ function apply(ctx, config) {
       onChange: () => {
         const next = source().engine;
         if (next === fileEngine) return;
-        if (mountedEngine !== next) {
-          unmountEngine();
-          mountEngine(next);
-        }
         try {
           const updated = applyManagedBlock(readPatchFileSync(patchPath), next);
           writePatchFileSync(patchPath, updated);
-          fileEngine = next;
         } catch (error) {
           ctx.logger.error(`loop-engine: managed block write failed: ${String(error)}`);
+          setTimeout(() => {
+            settingsCtx.settings.mutate(loopEngineSettingsNamespace(), [{ op: "set", path: ["engine"], value: fileEngine }]).catch((revertError) => {
+              ctx.logger.error(`loop-engine: engine selection revert failed: ${String(revertError)}`);
+            });
+          }, 0);
           return;
         }
+        fileEngine = next;
+        if (mountedEngine !== next) {
+          unmountEngine();
+          mountEngine(next);
+        }
         steerPresetDefault(next);
       }
     });