dsh-loop-engine 0.1.5-rc2 → 0.1.5-rc4

package/lib/index.js

@@ -1,7 +1,51 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __knownSymbol = (name2, symbol) => (symbol = Symbol[name2]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name2);
 var __typeError = (msg) => {
   throw TypeError(msg);
 };
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name2, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name: name2, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name2, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name2]() {
+    return __privateGet(this, extra);
+  }, set [name2](x) {
+    return __privateSet(this, extra, x);
+  } }, name2));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name2) : __name(target, name2);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name2, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name2 in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name2];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name2] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name2, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 var __using = (stack, value, async) => {
   if (value != null) {
     if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
@@ -45,12 +89,135 @@ var __callDispose = (stack, error, hasError) => {
 };
 
 // src/index.ts
-import { mkdirSync, readFileSync as readFileSync3, renameSync, writeFileSync } from "node:fs";
+import { readFileSync as readFileSync4 } from "node:fs";
 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 dirname5, join as join12 } from "node:path";
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { dirname as dirname6, join as join14 } from "node:path";
 import z6 from "@deepseek-ai/schemastery";
-import { resolveDshHome } from "@deepseek-ai/dsh-home-paths";
+import { resolveDshHome as resolveDshHome2 } from "@deepseek-ai/dsh-home-paths";
+
+// src/agent-preset-ids.ts
+var LOOP_ENGINE_IDS = ["in-process", "claude-code", "codex", "pi", "kimi"];
+var HOSTED_ENGINE_IDS = LOOP_ENGINE_IDS.filter(
+  (id) => id !== "in-process"
+);
+var HOSTED_ROUTE_LABEL = "external";
+var HOSTED_ROUTE_NAME = "external";
+var HOSTED_DEFAULT_MODEL = "default";
+var HOSTED_PRESET_PREFIX = "loop-engine-";
+var SOURCE_PRESET_ID = "standard";
+var LEGACY_HOSTED_PRESET_ID = "loop-engine";
+function enginePresetId(engine) {
+  return engine === "in-process" ? SOURCE_PRESET_ID : `${HOSTED_PRESET_PREFIX}${engine}`;
+}
+function isLoopEngineId(value) {
+  return LOOP_ENGINE_IDS.includes(value);
+}
+function engineOfPreset(presetId) {
+  if (presetId === void 0) return void 0;
+  const engine = presetId.startsWith(HOSTED_PRESET_PREFIX) ? presetId.slice(HOSTED_PRESET_PREFIX.length) : "";
+  return HOSTED_ENGINE_IDS.includes(engine) ? engine : void 0;
+}
+function sessionEngineOf(presetId) {
+  if (typeof presetId !== "string") return { kind: "unset" };
+  if (presetId === LEGACY_HOSTED_PRESET_ID) return { kind: "legacy" };
+  return { kind: "engine", engine: engineOfPreset(presetId) ?? "in-process" };
+}
+function hostedEngineOf(session) {
+  if (session.kind !== "engine" || session.engine === "in-process") return void 0;
+  return session.engine;
+}
+
+// src/engine-of-session.ts
+async function engineOfSession(ctx, sessionId, records) {
+  var _stack = [];
+  try {
+    const recorded = records.engineOf(sessionId);
+    if (recorded !== void 0) return { kind: "engine", engine: recorded };
+    const query = ctx.get("sessionQuery");
+    if (query === void 0) return { kind: "unset" };
+    const observation = __using(_stack, await query.observeSession(sessionId, { projectionMode: "all" }));
+    return sessionEngineOf(observation.projections?.values.agentPreset);
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+async function engineReportOfSession(ctx, sessionId, records, liveEngineOf) {
+  const live = liveEngineOf(sessionId);
+  if (live === void 0) return { engine: await engineOfSession(ctx, sessionId, records) };
+  const engine = { kind: "engine", engine: live };
+  const recorded = records.engineOf(sessionId);
+  return recorded === void 0 || recorded === live ? { engine } : { engine, pending: recorded };
+}
+
+// src/engine-remote.ts
+import { Remote, RemoteError, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import { SessionId } from "@deepseek-ai/dsh-session";
+var LOOP_ENGINE_REMOTE_KEY = "loopEngine";
+var LOOP_ENGINE_REMOTE_METHOD = "engine";
+var LOOP_ENGINE_REMOTE_SELECT_METHOD = "select";
+var _select_dec, _engine_dec, _a, _init;
+var LoopEngineRemote = class extends (_a = TypertRemoteService, _engine_dec = [Remote(LOOP_ENGINE_REMOTE_METHOD)], _select_dec = [Remote(LOOP_ENGINE_REMOTE_SELECT_METHOD)], _a) {
+  /**
+   * @param ctx - the context the service (and its lifetime) belongs to.
+   * @param resolve - the router-less read; normally
+   *   `engineOfSession(ctx, sessionId, records)`.
+   * @param router - where both endpoints find the mounted loop router.
+   * @param warn - diagnostic sink for a session that could not be read.
+   */
+  constructor(ctx, resolve5, router, warn) {
+    super(ctx, LOOP_ENGINE_REMOTE_KEY);
+    __runInitializers(_init, 5, this);
+    __publicField(this, "resolve");
+    __publicField(this, "router");
+    __publicField(this, "warn");
+    this.resolve = resolve5;
+    this.router = router;
+    this.warn = warn;
+  }
+  async engine(request) {
+    const sessionId = request?.sessionId;
+    if (typeof sessionId !== "string" || sessionId.length === 0) {
+      throw new RemoteError("gateway/bad-request", "sessionId must be a non-empty string", {});
+    }
+    const router = this.router.current;
+    try {
+      return router === void 0 ? { engine: await this.resolve(SessionId(sessionId)) } : await router.reportEngine(SessionId(sessionId));
+    } catch (error) {
+      this.warn(`loop-engine: could not read the engine of session "${sessionId}": ${String(error)}`);
+      return { engine: { kind: "unset" } };
+    }
+  }
+  async select(request) {
+    const sessionId = request?.sessionId;
+    if (typeof sessionId !== "string" || sessionId.length === 0) {
+      throw new RemoteError("gateway/bad-request", "sessionId must be a non-empty string", {});
+    }
+    const engine = request?.engine;
+    if (!isLoopEngineId(engine)) {
+      throw new RemoteError(
+        "gateway/bad-request",
+        `engine must be one of ${LOOP_ENGINE_IDS.join(", ")}`,
+        {}
+      );
+    }
+    const router = this.router.current;
+    if (router === void 0) {
+      return {
+        ok: false,
+        code: "router-unmounted",
+        reason: "this process cannot switch engines yet: the loop router is not mounted"
+      };
+    }
+    return await router.selectEngine(SessionId(sessionId), engine);
+  }
+};
+_init = __decoratorStart(_a);
+__decorateElement(_init, 1, "engine", _engine_dec, LoopEngineRemote);
+__decorateElement(_init, 1, "select", _select_dec, LoopEngineRemote);
+__decoratorMetadata(_init, LoopEngineRemote);
 
 // src/engine-claude/loop.ts
 import z from "@deepseek-ai/schemastery";
@@ -60,7 +227,7 @@ import { MAX_TIMER_DELAY_MS } from "@deepseek-ai/dsh-timeout";
 import { agentEvents } from "@deepseek-ai/dsh-agent";
 import {
   AssistantStreamAccumulator as AssistantStreamAccumulator2,
-  LlmError,
+  LlmError as LlmError2,
   createAssistantMessage,
   createUserMessage,
   errorChain
@@ -243,6 +410,19 @@ function renderToolResult(message) {
   const tag = block.isError === true ? "tool-result-error" : "tool-result";
   return frame(tag, body || "(no content)");
 }
+var ENGINE_SLASH_LINE = /^\/[^\s/]+(?:[ \t]+.*)?$/;
+function engineSlashPrompt(messages) {
+  const last = messages.at(-1);
+  if (last === void 0 || last.role !== "user") return void 0;
+  const user = last;
+  if (user.source.kind !== "user") return void 0;
+  if (user.content.length !== 1) return void 0;
+  const block = user.content[0];
+  if (block?.type !== "text") return void 0;
+  const text = block.text;
+  if (text.includes("\n")) return void 0;
+  return ENGINE_SLASH_LINE.test(text) ? text : void 0;
+}
 function serializeHistory(messages) {
   const sections = [];
   for (const message of messages) {
@@ -444,6 +624,139 @@ var DriverInbox = class {
   }
 };
 
+// src/provider-route.ts
+import { LlmAdapter, LlmError } from "@deepseek-ai/dsh-llm";
+function hostedRouteLabelOf(_engine) {
+  return HOSTED_ROUTE_LABEL;
+}
+var HOSTED_PROVIDER_LABELS = [HOSTED_ROUTE_LABEL, "claude-code", "codex", "pi", "kimi"];
+function isHostedProviderRoute(provider) {
+  return HOSTED_PROVIDER_LABELS.includes(provider);
+}
+var HostedEngineRouteAdapter = class extends LlmAdapter {
+  /**
+   * Name the route's one entry.
+   *
+   * `id` must equal the provider the adapter was registered for (the registry
+   * rejects a mismatch — `packages/llm/llm/src/index.ts` `prepareRoutes`), so it
+   * is echoed back; `name` is the one localized string the catalog carries.
+   * @param provider - the route this adapter is registered for.
+   * @returns the route's display metadata.
+   */
+  providerInfo(provider) {
+    return { id: provider, name: HOSTED_ROUTE_NAME };
+  }
+  /**
+   * Advertise the route's single entry.
+   *
+   * The id is the model label the engine logs, so the picker resolves a hosted
+   * session's selection to this entry (and highlights its row) rather than
+   * falling through to the raw composite string; the name is the same word,
+   * rendered as-is.
+   * @returns the one entry this route advertises.
+   */
+  listModels(_provider) {
+    return Promise.resolve([{ provider: HOSTED_ROUTE_LABEL, id: HOSTED_DEFAULT_MODEL, name: HOSTED_DEFAULT_MODEL }]);
+  }
+  stream(_options) {
+    throw new LlmError(
+      `provider "${HOSTED_ROUTE_LABEL}" is a hosted loop engine route, not a model endpoint`,
+      "HOSTED_ENGINE_ROUTE"
+    );
+  }
+};
+
+// src/driver-core/session-model.ts
+function currentSelection(session, projections) {
+  const pending = projections?.stateOf(session, "modelSelection")?.pending ?? null;
+  if (pending !== null) return pending;
+  const header = session.requestHeader()?.config;
+  return header === void 0 ? void 0 : { provider: header.provider, model: header.model };
+}
+function sessionModelOverride(selection) {
+  if (selection === void 0) return void 0;
+  if (isHostedProviderRoute(selection.provider)) return void 0;
+  return { provider: selection.provider, model: selection.model };
+}
+function sessionModelOverrideOf(ctx, session) {
+  return sessionModelOverride(
+    currentSelection(session, ctx.get("sessionProjections"))
+  );
+}
+
+// src/driver-core/model-handover.ts
+var warned = /* @__PURE__ */ new WeakMap();
+function warnOnce(ctx, key, message) {
+  let seen = warned.get(ctx);
+  if (seen === void 0) {
+    seen = /* @__PURE__ */ new Set();
+    warned.set(ctx, seen);
+  }
+  if (seen.has(key)) return;
+  seen.add(key);
+  ctx.logger.warn(message);
+}
+function settingsAddress(ctx, provider) {
+  const llm = ctx.get("llm");
+  return llm?.listConfigurableProviders?.().find((entry) => entry.provider === provider);
+}
+function readProviderProfile(ctx, address) {
+  const settings = ctx.get("settings");
+  let node = settings?.get?.(address.settingsNs);
+  for (const segment of address.settingsPath) {
+    if (node === null || typeof node !== "object") return void 0;
+    node = node[segment];
+  }
+  if (node === null || typeof node !== "object") return void 0;
+  const record = node;
+  const { baseURL, api, apiKeyEnv } = record;
+  if (typeof baseURL !== "string" || baseURL.length === 0) return void 0;
+  if (typeof api !== "string" || api.length === 0) return void 0;
+  return {
+    baseURL,
+    api,
+    apiKeyEnv: typeof apiKeyEnv === "string" && apiKeyEnv.length > 0 ? apiKeyEnv : void 0
+  };
+}
+async function readApiKey(ctx, apiKeyEnv) {
+  if (apiKeyEnv === void 0) return void 0;
+  const credentials = ctx.get("credentials");
+  const stored = credentials === void 0 ? void 0 : (await credentials.resolve(apiKeyEnv))?.value;
+  if (stored !== void 0 && stored.length > 0) return stored;
+  const ambient = process.env[apiKeyEnv];
+  return ambient !== void 0 && ambient.length > 0 ? ambient : void 0;
+}
+async function resolveModelHandover(ctx, override) {
+  if (override === void 0) return void 0;
+  const address = settingsAddress(ctx, override.provider);
+  if (address === void 0) {
+    return refuse(ctx, override, `no llm registry route maps it to a settings namespace`);
+  }
+  const profile = readProviderProfile(ctx, address);
+  if (profile === void 0) {
+    return refuse(ctx, override, `the "${address.settingsNs}" settings section names no baseURL and wire protocol for it`);
+  }
+  const apiKey = await readApiKey(ctx, profile.apiKeyEnv);
+  if (apiKey === void 0) {
+    return refuse(ctx, override, "no credential resolves for its apiKeyEnv");
+  }
+  return {
+    provider: override.provider,
+    model: override.model,
+    baseURL: profile.baseURL,
+    api: profile.api,
+    apiKey
+  };
+}
+function refuse(ctx, override, reason) {
+  warnOnce(
+    ctx,
+    `${override.provider}/${override.model}:${reason}`,
+    `loop-engine: the session selected the dsh model "${override.provider}/${override.model}", but its endpoint could not be resolved (${reason}); the engine keeps its own provider configuration`
+  );
+  return void 0;
+}
+
 // src/driver-core/assistant-stream.ts
 import {
   AssistantStreamAccumulator,
@@ -549,6 +862,95 @@ var DriverAssistantStream = class {
   }
 };
 
+// src/driver-core/hosted-tool-vocabulary.ts
+var TODO_STATUSES = /* @__PURE__ */ new Set(["pending", "in_progress", "completed"]);
+function recordOf(argumentsJson) {
+  let parsed;
+  try {
+    parsed = JSON.parse(argumentsJson);
+  } catch {
+    return void 0;
+  }
+  return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : void 0;
+}
+function stringField(value) {
+  return typeof value === "string" ? value : void 0;
+}
+var CLAUDE_NAMES = {
+  Write: "write",
+  Edit: "edit",
+  Read: "read",
+  Bash: "bash",
+  TodoWrite: "todo_write"
+};
+var KIMI_NAMES = {
+  Bash: "bash",
+  Read: "read",
+  Write: "write",
+  Edit: "edit"
+};
+var CODEX_NAMES = {
+  command_execution: "bash"
+};
+function withoutPath(args) {
+  const rest = { ...args };
+  delete rest.path;
+  return rest;
+}
+function piReshape(engineName, args) {
+  const path = stringField(args.path);
+  if (path === void 0) return void 0;
+  if (engineName === "write") {
+    const content = stringField(args.content);
+    return content === void 0 ? void 0 : { file_path: path, ...withoutPath(args), content };
+  }
+  if (engineName === "read") return { file_path: path, ...withoutPath(args) };
+  if (engineName !== "edit") return void 0;
+  const edits = args.edits;
+  if (!Array.isArray(edits) || edits.length !== 1) return void 0;
+  const edit = edits[0];
+  if (typeof edit !== "object" || edit === null) return void 0;
+  const oldText = stringField(edit.oldText);
+  const newText = stringField(edit.newText);
+  return oldText === void 0 || newText === void 0 ? void 0 : { file_path: path, old_string: oldText, new_string: newText };
+}
+function claudePlan(engineName, args) {
+  if (engineName !== "TodoWrite") return void 0;
+  const todos = args.todos;
+  if (!Array.isArray(todos)) return void 0;
+  const entries = [];
+  for (const entry of todos) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const content = stringField(entry.content);
+    const status = entry.status;
+    if (content === void 0 || typeof status !== "string" || !TODO_STATUSES.has(status)) continue;
+    entries.push({ content, status });
+  }
+  return entries;
+}
+var VOCABULARIES = {
+  "claude-code": { names: CLAUDE_NAMES, plan: claudePlan },
+  codex: { names: CODEX_NAMES },
+  pi: { names: {}, reshape: piReshape },
+  kimi: { names: KIMI_NAMES }
+};
+function normalizeHostedToolCall(engine, name2, argumentsJson) {
+  const vocabulary = VOCABULARIES[engine];
+  const dshName = vocabulary.names[name2] ?? name2;
+  const args = recordOf(argumentsJson);
+  const reshaped = args === void 0 ? void 0 : vocabulary.reshape?.(name2, args);
+  return {
+    name: dshName,
+    arguments: reshaped === void 0 ? argumentsJson : JSON.stringify(reshaped)
+  };
+}
+function planTodosOfHostedTool(engine, name2, argumentsJson) {
+  const plan = VOCABULARIES[engine].plan;
+  if (plan === void 0) return void 0;
+  const args = recordOf(argumentsJson);
+  return args === void 0 ? void 0 : plan(name2, args);
+}
+
 // src/driver-core/permission-knobs.ts
 var SANDBOX_MODES = ["read-only", "workspace-write", "danger-full-access"];
 var APPROVAL_POLICIES = ["ask", "never"];
@@ -798,8 +1200,7 @@ function invokedSkillNames(messages) {
 }
 
 // src/engine-claude/agent.ts
-var PROVIDER = "claude-code";
-var NATIVE_MODEL_LABEL = "claude-code-native";
+var PROVIDER = HOSTED_ROUTE_LABEL;
 function failureCode(subtype) {
   switch (subtype) {
     case "error_during_execution":
@@ -812,12 +1213,13 @@ function failureCode(subtype) {
   }
 }
 var ClaudeCodeAgent = class {
-  constructor(loopCtx, id, options, session, config) {
+  constructor(loopCtx, id, options, session, config, spawn4) {
     this.loopCtx = loopCtx;
     this.id = id;
     this.options = options;
     this.session = session;
     this.config = config;
+    this.spawn = spawn4;
     this.dispatch = agentEvents(loopCtx, this);
     this.inbox = new DriverInbox(session, {
       inserted: (message) => {
@@ -840,6 +1242,7 @@ var ClaudeCodeAgent = class {
   options;
   session;
   config;
+  spawn;
   inbox;
   phase;
   activityDone = Promise.resolve();
@@ -1126,7 +1529,7 @@ var ClaudeCodeAgent = class {
       }
       turnEnds = {
         kind: "error",
-        error: error instanceof LlmError ? error.failure : { message: errorChain(error), code: "UNKNOWN" }
+        error: error instanceof LlmError2 ? error.failure : { message: errorChain(error), code: "UNKNOWN" }
       };
       this.throwError(error);
     } finally {
@@ -1162,7 +1565,7 @@ var ClaudeCodeAgent = class {
   }
   /** Model label recorded in the request header for one lifecycle. */
   modelLabel() {
-    return this.config.model ?? NATIVE_MODEL_LABEL;
+    return this.config.model ?? HOSTED_DEFAULT_MODEL;
   }
   /** Append the request header snapshot once per loop instance. */
   assertRequestHeader() {
@@ -1190,7 +1593,7 @@ var ClaudeCodeAgent = class {
       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);
+    const prompt = engineSlashPrompt(history) ?? serializeHistory(history);
     if (prompt.length === 0) {
       throw new Error(`agent "${this.id}": cannot derive a prompt from an empty session log`);
     }
@@ -1206,14 +1609,21 @@ var ClaudeCodeAgent = class {
     const diagnostics = [];
     let live;
     try {
+      const override = sessionModelOverrideOf(this.loopCtx, this.session);
+      const handover = await resolveModelHandover(this.loopCtx, override);
+      const model = handover?.model ?? override?.model ?? this.config.model;
       const options = claudeQueryOptions({
         cwd,
         ...this.queryPermission(),
-        env: this.config.env,
+        env: handover === void 0 ? this.config.env : {
+          ...this.config.env,
+          ANTHROPIC_BASE_URL: handover.baseURL,
+          ANTHROPIC_AUTH_TOKEN: handover.apiKey
+        },
         disposeGraceMs: this.config.disposeGraceMs,
-        ...this.config.model === void 0 ? {} : { model: this.config.model },
+        ...model === void 0 ? {} : { model },
         ...this.config.maxTurns === void 0 ? {} : { maxTurns: this.config.maxTurns },
-        spawn: (spec) => this.loopCtx.subprocess.spawn(spec),
+        spawn: this.spawn,
         onUnattended: (line) => {
           diagnostics.push(line);
         }
@@ -1297,13 +1707,16 @@ var ClaudeCodeAgent = class {
               }
             }
             for (const call of mapped.toolCalls) {
+              const normalized = normalizeHostedToolCall("claude-code", call.name, call.arguments);
               this.session.append("tool/call", {
                 turn: phase.turn,
                 step: phase.step,
                 callId: call.callId,
-                name: call.name,
-                arguments: call.arguments
+                name: normalized.name,
+                arguments: normalized.arguments
               });
+              const todos = planTodosOfHostedTool("claude-code", call.name, call.arguments);
+              if (todos !== void 0) this.session.append("todo/write", { todos: [...todos] });
             }
             break;
           }
@@ -1325,7 +1738,7 @@ var ClaudeCodeAgent = class {
                 step: phase.step,
                 message: createAssistantMessage({
                   content: trailing,
-                  source: { provider: PROVIDER, model: NATIVE_MODEL_LABEL }
+                  source: { provider: PROVIDER, model: HOSTED_DEFAULT_MODEL }
                 }),
                 ...pendingUsage === void 0 ? {} : { usage: pendingUsage },
                 stream: attempt?.stream ?? []
@@ -1352,7 +1765,7 @@ var ClaudeCodeAgent = class {
               finished = true;
             } else {
               const summary = message.errors[0] ?? `claude code query failed (${message.subtype})`;
-              throw new LlmError(summary, failureCode(message.subtype));
+              throw new LlmError2(summary, failureCode(message.subtype));
             }
             break;
           }
@@ -1361,7 +1774,7 @@ var ClaudeCodeAgent = class {
         }
       }
       if (!finished) {
-        throw new LlmError(
+        throw new LlmError2(
           `agent "${this.id}": claude-code query ended without a result message`,
           "CLAUDE_CODE_NO_RESULT"
         );
@@ -1376,8 +1789,7 @@ var ClaudeCodeAgent = class {
   }
 };
 
-// src/driver-core/hosted-loop-factory.ts
-import { Service } from "@deepseek-ai/cordis";
+// src/driver-core/hosted-engine-runtime.ts
 import { emitAgentEvent } from "@deepseek-ai/dsh-agent";
 import { interruptedTurnClosers, SessionLogOffset, SessionPreparation } from "@deepseek-ai/dsh-session";
 
@@ -1469,35 +1881,83 @@ async function raceAbortCall(operation, signal, id, releaseAbandoned) {
   }
 }
 
-// src/driver-core/hosted-loop-factory.ts
-var HostedLoopFactory = class extends Service {
-  /** Validated configuration owned by the loop plugin. */
+// src/driver-core/session-lifetime.ts
+var SessionLifetime = class {
+  /** The live session these resources belong to. */
+  session;
+  /** The write handle this lifetime owns, or `undefined` when no persistence backend is mounted. */
+  handle;
+  /** The store's detacher; `undefined` until the entry is bound by the transaction that entered the session. */
+  detach;
+  /**
+   * @param session - the live session whose entry and write handle these are.
+   * @param handle - the write handle the transaction acquired, if a backend is mounted.
+   */
+  constructor(session, handle) {
+    this.session = session;
+    this.handle = handle;
+  }
+  /**
+   * Whether the session's store entry is already held: true for a lifetime a
+   * retiring machine handed over, false for one whose transaction still has to
+   * enter the session it prepared.
+   */
+  get entered() {
+    return this.detach !== void 0;
+  }
+  /**
+   * Bind the store entry this lifetime owns. Called once, by the transaction
+   * that enters the session; a joined session's entry is already bound.
+   * @param detach - the detacher the session's own `enter` returned.
+   */
+  bind(detach) {
+    this.detach = detach;
+  }
+  /** Drain and close the write handle — the durability barrier that precedes leaving the store. */
+  async closeHandle() {
+    await this.handle?.close();
+  }
+  /** Remove the session from the store, publishing its paired disposal exactly once. */
+  leaveStore() {
+    this.detach?.();
+  }
+};
+
+// src/driver-core/hosted-engine-runtime.ts
+var HostedEngineRuntime = class {
+  /** Validated configuration owned by this engine instance. */
   config;
-  ownership;
+  /** Effect-label prefix; also identifies the engine in diagnostics. */
+  label;
   /** Plain holder prevents Cordis from re-tracing the factory's dependency context through a caller shadow. */
   runtime;
-  /** Cordis service name, also the prefix of every effect label. */
-  label;
+  ownership;
+  /**
+   * @param ctx - the owning context; its fiber's unload tears every live agent down.
+   * @param label - effect-label prefix, e.g. `agentLoopKimi`.
+   * @param config - already-resolved engine configuration.
+   */
   constructor(ctx, label, config) {
-    super(ctx, label);
     this.label = label;
     this.config = config;
     this.ownership = new FactoryOwnership(ctx.fiber);
     this.runtime = { ctx };
+    ctx.reflect.provide(label, this);
     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);
   }
   /**
    * 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.
+   *
+   * `lifetime` carries the session's store entry and write handle rather than
+   * this body owning them: a fresh transaction binds them when it publishes,
+   * while a swap publishes a session whose entry another machine already bound
+   * and whose write handle another machine already opened.
    */
-  /* jscpd:ignore-start -- ownership/transaction machinery mirrors the default agent-loop factory; depending on agent-loop is forbidden. */
-  prepare(ownerCtx, id, options, session, callerSignal, handle, parentAgent) {
+  /* jscpd:ignore-start -- ownership/transaction machinery mirrors the default agent-loop factory: the harness exports the loop as a plugin, not as reusable transaction helpers, so the body is replicated rather than delegated to. */
+  prepare(ownerCtx, id, options, session, callerSignal, lifetime, parentAgent) {
     ownerCtx.fiber.assertActive();
     if (!this.ownership.isActive()) throw new Error("agent loop is not active");
     if (callerSignal?.aborted) {
@@ -1514,9 +1974,9 @@ var HostedLoopFactory = class extends Service {
     callerSignal?.addEventListener("abort", onCallerAbort, { once: true });
     this.ownership.signal.addEventListener("abort", onFactoryTeardown, { once: true });
     let machine;
-    let detachSession;
     let detachAgent;
     let disposing;
+    let handedOver = false;
     const machineReady = Promise.withResolvers();
     const dispose = (ownerTriggered = false) => disposing ??= (async () => {
       abort.abort(new Error(`agent "${id}" lifecycle disposed`));
@@ -1531,14 +1991,17 @@ var HostedLoopFactory = class extends Service {
         }
       } finally {
         try {
-          await handle?.close();
+          if (!handedOver) await lifetime.closeHandle();
         } finally {
           try {
             detachAgent?.();
-            detachSession?.();
           } finally {
-            untrack();
-            if (!ownerTriggered) await unfollowOwner();
+            try {
+              if (!handedOver) lifetime.leaveStore();
+            } finally {
+              untrack();
+              if (!ownerTriggered) await unfollowOwner();
+            }
           }
         }
       }
@@ -1561,6 +2024,10 @@ var HostedLoopFactory = class extends Service {
       if (!abort.signal.aborted) return;
       throw abort.signal.reason instanceof Error ? abort.signal.reason : new Error(String(abort.signal.reason));
     };
+    const retire = async () => {
+      handedOver = true;
+      await dispose();
+    };
     try {
       const agent = machine = this.buildAgent(loopCtx, id, options, session);
       machineReady.resolve();
@@ -1570,15 +2037,16 @@ var HostedLoopFactory = class extends Service {
         signal: abort.signal,
         publish: (source) => {
           assertLive();
-          detachSession = agent.ctx.sessions.enter(session);
+          const joining = lifetime.entered;
+          if (!joining) lifetime.bind(agent.ctx.sessions.enter(session));
           detachAgent = loopCtx.agents.enter(agent, parentAgent);
-          agent.ctx.sessions.announce(session);
+          if (!joining) agent.ctx.sessions.announce(session);
           assertLive();
           loopCtx.agents.announce(agent);
           assertLive();
           emitAgentEvent(loopCtx, agent, "agent/session-start", { source });
           assertLive();
-          return { agent, dispose };
+          return { agent, dispose, retire, lifetime };
         },
         dispose
       };
@@ -1589,33 +2057,24 @@ var HostedLoopFactory = class extends Service {
     }
   }
   /** 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 = [];
+  async setupAndPublish(ownerCtx, id, session, agentOptions, setup, signal, source, lifetime, parentAgent, stored) {
+    let prepared;
     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);
+      prepared = this.prepare(ownerCtx, id, agentOptions, session, signal, lifetime, 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;
     }
   }
   /**
@@ -1644,21 +2103,21 @@ var HostedLoopFactory = class extends Service {
             });
           }
         );
-      } catch (error) {
+        return await this.setupAndPublish(
+          ownerCtx,
+          options.sessionId,
+          preparation.session,
+          options.agentOptions ?? {},
+          options.setup,
+          options.signal,
+          "startup",
+          new SessionLifetime(preparation.session, stored?.handle),
+          options.parentAgent,
+          stored
+        );
+      } finally {
         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;
@@ -1710,6 +2169,37 @@ var HostedLoopFactory = class extends Service {
     }
     return this.resumeWith(ownerCtx, persistence, options);
   }
+  /**
+   * Build this engine's agent onto a LIVE session another engine's agent left,
+   * taking the session's lifetime over.
+   *
+   * The counterpart of {@link HostedAgentHandle.retire}: together they are an
+   * in-place engine swap, and the harness's own factory contract has neither.
+   * Nothing is read from persistence and nothing is created in the store — the
+   * successor drives the Session object that is already live and already
+   * entered, so a browser half attached to that session sees no lifecycle edge
+   * at all. The lifetime carries the still-open write handle, so the session
+   * keeps being stored through the same channel it was already using.
+   * @param ownerCtx - caller context that structurally owns the lifecycle.
+   * @param options - the live session's lifetime, loop options, setup, and parent.
+   * @returns the published handle, which owns the session from here on.
+   */
+  async swap(ownerCtx, options) {
+    const session = options.lifetime.session;
+    const published = (async () => await this.setupAndPublish(
+      ownerCtx,
+      session.id,
+      session,
+      options.agentOptions ?? {},
+      options.setup,
+      void 0,
+      "resume",
+      options.lifetime,
+      options.parentAgent
+    ))();
+    this.ownership.trackWrapper(published);
+    return published;
+  }
   /** Resume through an explicit persistence service. */
   resumeWith(ownerCtx, persistence, options) {
     const id = options.resumeSessionId;
@@ -1759,13 +2249,14 @@ var HostedLoopFactory = class extends Service {
         return await this.setupAndPublish(
           ownerCtx,
           id,
-          preparation,
+          preparation.session,
           options.agentOptions ?? {},
           options.setup,
           options.signal,
           "resume",
-          owned,
-          options.parentAgent
+          new SessionLifetime(preparation.session, owned?.handle),
+          options.parentAgent,
+          owned
         );
       } finally {
         preparation?.[Symbol.dispose]();
@@ -1811,15 +2302,21 @@ function resolveConfig(config) {
     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"];
+var CLAUDE_CODE_ENGINE_LABEL = "agentLoopClaudeCode";
+var ClaudeCodeLoop = class extends HostedEngineRuntime {
+  /** Process-spawn capability handed to every agent, sandboxed by the subprocess seam. */
+  spawn;
   constructor(ctx, config) {
-    super(ctx, "agentLoopClaudeCode", resolveConfig(config));
+    super(ctx, CLAUDE_CODE_ENGINE_LABEL, resolveConfig(config));
+    const subprocess = ctx.get("subprocess");
+    if (subprocess === void 0) {
+      throw new Error("loop-engine: the claude-code engine needs the dsh subprocess service on this context");
+    }
+    this.spawn = (spec) => subprocess.spawn(spec);
   }
   /** Construct the Claude Code driver for one prepared session. */
   buildAgent(loopCtx, id, options, session) {
-    return new ClaudeCodeAgent(loopCtx, id, options, session, this.config);
+    return new ClaudeCodeAgent(loopCtx, id, options, session, this.config, this.spawn);
   }
 };
 
@@ -1828,10 +2325,38 @@ import z2 from "@deepseek-ai/schemastery";
 
 // src/engine-codex/agent.ts
 import { agentEvents as agentEvents2 } from "@deepseek-ai/dsh-agent";
-import { LlmError as LlmError2, createAssistantMessage as createAssistantMessage2, createUserMessage as createUserMessage2, errorChain as errorChain2 } from "@deepseek-ai/dsh-llm";
+import { LlmError as LlmError3, createAssistantMessage as createAssistantMessage2, createUserMessage as createUserMessage2, errorChain as errorChain2 } from "@deepseek-ai/dsh-llm";
 import { createScope as createScope2 } from "@deepseek-ai/dsh-scope";
 import { canonicalHeader as canonicalHeader2 } from "@deepseek-ai/dsh-session";
 
+// src/engine-codex/model-handover.ts
+var CODEX_DSH_PROVIDER = "dsh";
+var CODEX_DSH_API_KEY_ENV = "DSH_LOOP_ENGINE_API_KEY";
+var CODEX_WIRE_APIS = {
+  "openai-responses": "responses",
+  "openai-completions": "chat"
+};
+function tomlString(value) {
+  return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+function codexModelConfig(handover) {
+  const wire = CODEX_WIRE_APIS[handover.api];
+  const profile = [
+    `base_url=${tomlString(handover.baseURL)}`,
+    ...wire === void 0 ? [] : [`wire_api=${tomlString(wire)}`],
+    `env_key=${tomlString(CODEX_DSH_API_KEY_ENV)}`
+  ].join(",");
+  return {
+    argv: [
+      "-c",
+      `model_provider=${tomlString(CODEX_DSH_PROVIDER)}`,
+      "-c",
+      `model_providers.${CODEX_DSH_PROVIDER}={${profile}}`
+    ],
+    env: { [CODEX_DSH_API_KEY_ENV]: handover.apiKey }
+  };
+}
+
 // src/engine-codex/permission.ts
 var DEFAULT_CODEX_PERMISSION = {
   sandboxMode: "read-only",
@@ -1987,10 +2512,24 @@ var AppServerClient = class _AppServerClient {
       this.pending.clear();
     });
   }
-  /** Spawn the pinned app-server dependency and initialize the client. */
-  static async create() {
-    const proc = spawn(process.execPath, [codexCliEntrypoint(), "app-server"], {
-      stdio: ["pipe", "pipe", "pipe"]
+  /**
+   * Spawn the pinned app-server dependency and initialize the client.
+   *
+   * `argv` appends the driver's own overrides to the bare `app-server`
+   * subcommand (codex's `-c key=value` configuration), and `env` layers the
+   * driver's explicit entries over the ambient environment — the child still
+   * needs `PATH` and, under a user's own codex setup, the ambient auth facts its
+   * configuration reads, so this is an overlay, not a replacement. Both default
+   * to nothing, which is the bare `codex app-server` the driver used before a
+   * dsh endpoint was ever handed over.
+   * @param argv - extra arguments after the `app-server` subcommand.
+   * @param env - explicit environment entries layered over the ambient one.
+   * @returns the initialized client.
+   */
+  static async create(argv = [], env = {}) {
+    const proc = spawn(process.execPath, [codexCliEntrypoint(), "app-server", ...argv], {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, ...env }
     });
     const client = new _AppServerClient(proc);
     await client.initialize();
@@ -2302,8 +2841,7 @@ function mapMcpToolCall(item) {
 }
 
 // src/engine-codex/agent.ts
-var PROVIDER2 = "codex";
-var NATIVE_MODEL_LABEL2 = "codex-native";
+var PROVIDER2 = HOSTED_ROUTE_LABEL;
 function nonEmptyText(parts) {
   return parts !== void 0 && parts.some((part) => part.length > 0) ? parts.join("\n") : void 0;
 }
@@ -2377,10 +2915,30 @@ var CodexAgent = class {
   }
   /** 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();
+  /**
+   * The spawn configuration (`argv` + `env`) the cached client was built from.
+   * Codex's endpoint lives in the child's own command line, so a handover change
+   * must respawn the child rather than reuse one configured for another endpoint.
+   */
+  appServerConfig;
+  /**
+   * Return the cached app-server client, spawning one on first use, after a dead
+   * process, or when the resolved dsh endpoint changed since the last spawn.
+   *
+   * A handover is codex's own `-c` configuration for a dsh provider, so a
+   * different endpoint (different provider, base URL, protocol, or credential)
+   * needs a different child — the config is fixed when the process starts.
+   * @param handover - the session's resolved dsh endpoint, or undefined to leave codex to its own configuration.
+   */
+  async appServerClient(handover) {
+    const modeled = handover === void 0 ? { argv: [], env: {} } : codexModelConfig(handover);
+    const config = JSON.stringify(modeled);
+    if (this.appServer !== void 0 && !this.appServer.closed && this.appServerConfig === config) {
+      return this.appServer;
+    }
+    this.appServer?.dispose();
+    this.appServer = await AppServerClient.create(modeled.argv, { ...this.config.env, ...modeled.env });
+    this.appServerConfig = config;
     this.appServer.onRequest((method, params) => this.answerRequest(method, params));
     return this.appServer;
   }
@@ -2694,7 +3252,7 @@ var CodexAgent = class {
       }
       turnEnds = {
         kind: "error",
-        error: error instanceof LlmError2 ? error.failure : { message: errorChain2(error), code: "UNKNOWN" }
+        error: error instanceof LlmError3 ? error.failure : { message: errorChain2(error), code: "UNKNOWN" }
       };
       this.throwError(error);
     } finally {
@@ -2712,7 +3270,7 @@ var CodexAgent = class {
   }
   /** Model label recorded in the request header for one lifecycle. */
   modelLabel() {
-    return this.config.model ?? NATIVE_MODEL_LABEL2;
+    return this.config.model ?? HOSTED_DEFAULT_MODEL;
   }
   /** Append the request header snapshot once per loop instance. */
   assertRequestHeader() {
@@ -2755,12 +3313,15 @@ var CodexAgent = class {
     let live;
     try {
       const permission = this.queryPermission();
-      const client = await this.appServerClient();
+      const override = sessionModelOverrideOf(this.loopCtx, this.session);
+      const handover = await resolveModelHandover(this.loopCtx, override);
+      const client = await this.appServerClient(handover);
+      const model = override?.model ?? this.config.model;
       const threadParams = {
         cwd,
         sandbox: permission.sandboxMode,
         approvalPolicy: permission.approvalPolicy,
-        ...this.config.model === void 0 ? {} : { model: this.config.model }
+        ...model === void 0 ? {} : { model }
       };
       const thread = await AppServerThread.create(client, threadParams);
       const input = [{ type: "text", text: prompt }];
@@ -2768,7 +3329,7 @@ var CodexAgent = class {
         signal: controller.signal,
         params: {
           approvalPolicy: permission.approvalPolicy,
-          ...this.config.model === void 0 ? {} : { model: this.config.model }
+          ...model === void 0 ? {} : { model }
         }
       });
       let finished = false;
@@ -2899,12 +3460,13 @@ var CodexAgent = class {
               const activity = mapCommandExecution(item);
               foldToolCall(activity.call);
               flushHeld();
+              const normalizedCall = normalizeHostedToolCall("codex", activity.call.name, activity.call.arguments);
               this.session.append("tool/call", {
                 turn: phase.turn,
                 step: phase.step,
                 callId: activity.call.callId,
-                name: activity.call.name,
-                arguments: activity.call.arguments
+                name: normalizedCall.name,
+                arguments: normalizedCall.arguments
               });
               this.session.append("tool/result", { turn: phase.turn, step: phase.step, message: activity.result }, { surfaceOp: "append" });
               this.stepSettledTools += 1;
@@ -2913,12 +3475,13 @@ var CodexAgent = class {
               const activity = mapFileChange(item);
               foldToolCall(activity.call);
               flushHeld();
+              const normalizedCall = normalizeHostedToolCall("codex", activity.call.name, activity.call.arguments);
               this.session.append("tool/call", {
                 turn: phase.turn,
                 step: phase.step,
                 callId: activity.call.callId,
-                name: activity.call.name,
-                arguments: activity.call.arguments
+                name: normalizedCall.name,
+                arguments: normalizedCall.arguments
               });
               this.session.append("tool/result", { turn: phase.turn, step: phase.step, message: activity.result }, { surfaceOp: "append" });
               this.stepSettledTools += 1;
@@ -2927,12 +3490,13 @@ var CodexAgent = class {
               const activity = mapMcpToolCall(item);
               foldToolCall(activity.call);
               flushHeld();
+              const normalizedCall = normalizeHostedToolCall("codex", activity.call.name, activity.call.arguments);
               this.session.append("tool/call", {
                 turn: phase.turn,
                 step: phase.step,
                 callId: activity.call.callId,
-                name: activity.call.name,
-                arguments: activity.call.arguments
+                name: normalizedCall.name,
+                arguments: normalizedCall.arguments
               });
               this.session.append("tool/result", { turn: phase.turn, step: phase.step, message: activity.result }, { surfaceOp: "append" });
               this.stepSettledTools += 1;
@@ -2947,7 +3511,7 @@ var CodexAgent = class {
           }
           case "error":
             flushHeld();
-            throw new LlmError2(event.error.message, "CODEX_ERROR");
+            throw new LlmError3(event.error.message, "CODEX_ERROR");
           /* v8 ignore next -- AppServerEvent is a closed union; no unknown kinds */
           default:
             break;
@@ -2955,7 +3519,7 @@ var CodexAgent = class {
       }
       flushHeld();
       if (!finished) {
-        throw new LlmError2(
+        throw new LlmError3(
           `agent "${this.id}": codex query ended without a completed turn`,
           "CODEX_NO_RESULT"
         );
@@ -2995,11 +3559,10 @@ function resolveConfig2(config) {
     model: config.model
   };
 }
-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"];
+var CODEX_ENGINE_LABEL = "agentLoopCodex";
+var CodexLoop = class extends HostedEngineRuntime {
   constructor(ctx, config) {
-    super(ctx, "agentLoopCodex", resolveConfig2(config));
+    super(ctx, CODEX_ENGINE_LABEL, resolveConfig2(config));
   }
   /** Construct the Codex driver for one prepared session. */
   buildAgent(loopCtx, id, options, session) {
@@ -3009,16 +3572,68 @@ var CodexLoop = class extends HostedLoopFactory {
 
 // src/engine-pi/loop.ts
 import { readFileSync } from "node:fs";
-import { dirname as dirname2, join as join2 } from "node:path";
+import { dirname as dirname2, join as join3 } from "node:path";
 import { fileURLToPath } from "node:url";
 import z3 from "@deepseek-ai/schemastery";
 
 // src/engine-pi/agent.ts
 import { agentEvents as agentEvents3 } from "@deepseek-ai/dsh-agent";
-import { ToolCallId as ToolCallId5, LlmError as LlmError3, createAssistantMessage as createAssistantMessage3, createUserMessage as createUserMessage3, errorChain as errorChain3 } from "@deepseek-ai/dsh-llm";
+import { ToolCallId as ToolCallId5, LlmError as LlmError4, 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/model-handover.ts
+import { createHash } from "node:crypto";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join2 } from "node:path";
+var AGENT_ROOT = join2(tmpdir(), "dsh-loop-engine-pi-agent");
+var materialized = /* @__PURE__ */ new Set();
+process.once("exit", () => {
+  for (const dir of materialized) {
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  materialized.clear();
+});
+function piAgentDir(handover) {
+  const dir = join2(
+    AGENT_ROOT,
+    createHash("sha256").update(JSON.stringify({
+      provider: handover.provider,
+      baseURL: handover.baseURL,
+      api: handover.api,
+      apiKey: handover.apiKey,
+      model: handover.model
+    })).digest("hex").slice(0, 32)
+  );
+  if (!materialized.has(dir)) {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+    writeFileSync(
+      join2(dir, "models.json"),
+      `${JSON.stringify(modelsDocument(handover), null, 2)}
+`,
+      { mode: 384 }
+    );
+    materialized.add(dir);
+  }
+  return dir;
+}
+function modelsDocument(handover) {
+  return {
+    providers: {
+      [handover.provider]: {
+        baseUrl: handover.baseURL,
+        api: handover.api,
+        apiKey: handover.apiKey,
+        models: [{ id: handover.model, name: handover.model }]
+      }
+    }
+  };
+}
+
 // src/engine-pi/permission.ts
 var DEFAULT_PI_PERMISSION = {
   sandboxMode: "read-only",
@@ -3273,11 +3888,10 @@ function mapToolResult(ev) {
 }
 
 // src/engine-pi/agent.ts
-var PROVIDER3 = "pi";
-var NATIVE_MODEL_LABEL3 = "pi-native";
+var PROVIDER3 = HOSTED_ROUTE_LABEL;
 var TOOLS_FLAG = "--tools";
 var PiAgent = class {
-  constructor(loopCtx, id, options, session, config, spawn4, bin, catalog) {
+  constructor(loopCtx, id, options, session, config, spawn4, bin) {
     this.loopCtx = loopCtx;
     this.id = id;
     this.options = options;
@@ -3285,7 +3899,6 @@ var PiAgent = class {
     this.config = config;
     this.spawn = spawn4;
     this.bin = bin;
-    this.catalog = catalog;
     this.dispatch = agentEvents3(loopCtx, this);
     this.inbox = new DriverInbox(session, {
       inserted: (message) => {
@@ -3314,7 +3927,6 @@ var PiAgent = class {
   config;
   spawn;
   bin;
-  catalog;
   inbox;
   phase;
   activityDone = Promise.resolve();
@@ -3357,8 +3969,8 @@ var PiAgent = class {
    * 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);
+  rpcClient(cwd, handover) {
+    const client = PiRpcClient.create(this.spawnSpec(cwd, handover), this.spawn);
     this.rpc = client;
     return client;
   }
@@ -3608,7 +4220,7 @@ var PiAgent = class {
       }
       turnEnds = {
         kind: "error",
-        error: error instanceof LlmError3 ? error.failure : { message: errorChain3(error), code: "UNKNOWN" }
+        error: error instanceof LlmError4 ? error.failure : { message: errorChain3(error), code: "UNKNOWN" }
       };
       this.throwError(error);
     } finally {
@@ -3626,7 +4238,7 @@ var PiAgent = class {
   }
   /** Model label recorded in the request header for one lifecycle. */
   modelLabel() {
-    return this.config.model ?? NATIVE_MODEL_LABEL3;
+    return this.config.model ?? HOSTED_DEFAULT_MODEL;
   }
   /** Append the request header snapshot once per loop instance. */
   assertRequestHeader() {
@@ -3642,46 +4254,29 @@ var PiAgent = class {
     this.requestHeaderLogged = true;
   }
   /**
-   * The harness Session's web-side model selection, if any was stored. The
-   * durable `model/selection` event carries `{ provider, model, ... }`; when a
-   * user picked a model via `/model`, this is the newest pick, and it overrides
-   * the deployment config (which stays the fallback). Returns `undefined` when
-   * no selection was stored, so the deployment config governs.
-   */
-  dynamicModel() {
-    for (const event of [...this.session.snapshotEvents()].reverse()) {
-      const type = event.type;
-      if (type !== "model/selection") continue;
-      const data = event.data;
-      const model = data?.model;
-      if (typeof model === "string" && model.length > 0) return model;
-    }
-    return void 0;
-  }
-  /** Build the `pi --mode rpc` argv/cwd/env for one step's child process. */
-  /**
-   * Resolve the `--model` for the RPC child. The session-selected model (last
-   * `model/selection` event) is honored only when it is one of pi's discovered
-   * models; an unknown harness model (e.g. another provider's model such as
-   * `anyai-v1`, which pi cannot serve) is dropped so the child falls back to pi's
-   * own default instead of exiting with "Model ... not found". An empty catalog
-   * (probe not concluded) keeps the candidate, matching prior behavior.
+   * Build the `pi --mode rpc` argv/cwd/env for one step's child process.
+   *
+   * The model comes from the session's own selection when it names a real dsh
+   * model, else from the deployment's pinned configuration
+   * ({@link sessionModelOverrideOf}). Pi's `--model` flag is
+   * `"provider/id"`-qualified, so a session pick travels as the composite —
+   * which also carries the provider, leaving the deployment's `--provider` out
+   * of the argv for that step. A step with neither a selection nor a pin sends
+   * no `--model` at all and lets Pi's own configuration decide. Read every step,
+   * so a model picked mid-conversation lands on the next child.
+   *
+   * When dsh also discloses that model's ENDPOINT, the child is pointed at it:
+   * `--provider` names the provider pi's `models.json` declares, `--api-key`
+   * carries the credential, and `PI_CODING_AGENT_DIR` redirects pi's agent
+   * directory to the plugin-owned one holding that `models.json`
+   * ({@link piAgentDir}) — so the child runs on dsh's endpoint instead of its
+   * own `~/.pi` configuration, which is never touched.
    */
-  pickModel() {
-    const candidate = this.dynamicModel() ?? this.config.model;
-    if (candidate === void 0) return void 0;
-    if (this.catalog.entries.length > 0) {
-      const known = this.catalog.entries.some(
-        (entry) => entry.model === candidate || `${entry.provider}/${entry.model}` === candidate
-      );
-      if (!known) return void 0;
-    }
-    return candidate;
-  }
-  spawnSpec(cwd) {
+  spawnSpec(cwd, handover) {
     const argv = [];
-    const model = this.pickModel();
-    if (this.config.provider !== void 0) argv.push("--provider", this.config.provider);
+    const override = sessionModelOverrideOf(this.loopCtx, this.session);
+    const model = override === void 0 ? this.config.model : `${override.provider}/${override.model}`;
+    if (override === void 0 && this.config.provider !== void 0) argv.push("--provider", this.config.provider);
     if (model !== void 0 && this.config.thinkingLevel !== void 0) {
       argv.push("--model", `${model}:${this.config.thinkingLevel}`);
     } else if (model !== void 0) {
@@ -3689,6 +4284,7 @@ var PiAgent = class {
     } else if (this.config.thinkingLevel !== void 0) {
       argv.push("--model", `:${this.config.thinkingLevel}`);
     }
+    if (handover !== void 0) argv.push("--provider", handover.provider, "--api-key", handover.apiKey);
     const permission = this.queryPermission();
     if (permission.tools.length > 0) argv.push(TOOLS_FLAG, permission.tools.join(","));
     return {
@@ -3700,7 +4296,7 @@ var PiAgent = class {
         ...argv
       ],
       cwd,
-      env: this.config.env
+      env: handover === void 0 ? this.config.env : { ...this.config.env, PI_CODING_AGENT_DIR: piAgentDir(handover) }
     };
   }
   /**
@@ -3723,12 +4319,16 @@ var PiAgent = class {
       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);
+    const prompt = engineSlashPrompt(history) ?? 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 handover = await resolveModelHandover(
+      this.loopCtx,
+      sessionModelOverrideOf(this.loopCtx, this.session)
+    );
     const controller = new AbortController();
     const cancel = () => {
       if (!controller.signal.aborted) {
@@ -3752,7 +4352,7 @@ var PiAgent = class {
         }
         return live;
       };
-      const client = this.rpcClient(cwd);
+      const client = this.rpcClient(cwd, handover);
       signal.throwIfAborted();
       await client.newSession();
       client.clearEvents();
@@ -3791,12 +4391,13 @@ var PiAgent = class {
         }
         held = void 0;
         for (const call of callsToLog) {
+          const normalized = normalizeHostedToolCall("pi", call.name, call.arguments);
           this.session.append("tool/call", {
             turn: phase.turn,
             step: phase.step,
             callId: ToolCallId5(call.callId),
-            name: call.name,
-            arguments: call.arguments
+            name: normalized.name,
+            arguments: normalized.arguments
           });
         }
         callsToLog = [];
@@ -3954,7 +4555,7 @@ var PiAgent = class {
       }
       flushHeld(lastUsage);
       if (!finished) {
-        throw new LlmError3(
+        throw new LlmError4(
           `agent "${this.id}": pi query ended without an agent settle`,
           "PI_NO_RESULT"
         );
@@ -3983,73 +4584,6 @@ var PiAgent = class {
   }
 };
 
-// src/engine-pi/probe.ts
-function waitForExit(child) {
-  return new Promise((resolve5) => {
-    ;
-    child.onExit(
-      (code) => resolve5(code ?? 0)
-    );
-  });
-}
-function collectOutput(child) {
-  return new Promise((resolve5) => {
-    if (child.stdout.on === void 0 || child.stderr.on === void 0) {
-      resolve5("");
-      return;
-    }
-    let text = "";
-    let pending = 2;
-    const finish = () => {
-      pending -= 1;
-      if (pending === 0) resolve5(text);
-    };
-    const out = child.stdout;
-    const err = child.stderr;
-    out.setEncoding("utf8");
-    out.on("data", (data) => {
-      text += String(data);
-    });
-    out.on("close", finish);
-    err.setEncoding("utf8");
-    err.on("data", (data) => {
-      text += String(data);
-    });
-    err.on("close", finish);
-  });
-}
-function parsePiModelList(output) {
-  const entries = [];
-  for (const line of output.split("\n")) {
-    const trimmed = line.trim();
-    if (trimmed.length === 0) continue;
-    const match = /^(\S+)\s{2,}(\S+)/.exec(trimmed);
-    if (match === null) continue;
-    const provider = match[1];
-    if (provider === "provider") continue;
-    entries.push({ provider, model: match[2] });
-  }
-  return entries;
-}
-async function probePiModels(bin, spawn4) {
-  const spec = {
-    argv: [bin, "--mode", "rpc", "--list-models"],
-    cwd: process.cwd(),
-    env: {}
-  };
-  let child;
-  try {
-    child = spawn4(spec);
-  } catch {
-    return [];
-  }
-  const outputPromise = collectOutput(child);
-  const exitCode = await waitForExit(child);
-  if (exitCode !== 0) return [];
-  const output = await outputPromise;
-  return parsePiModelList(output);
-}
-
 // src/engine-pi/loop.ts
 var PI_SANDBOX_MODES = [
   "read-only",
@@ -4062,8 +4596,7 @@ var Config3 = z3.object({
   provider: z3.string(),
   model: z3.string(),
   thinkingLevel: z3.string(),
-  env: z3.dict(z3.string()).default({}),
-  piCatalogHolder: z3.any()
+  env: z3.dict(z3.string()).default({})
 });
 function resolveConfig3(config) {
   return {
@@ -4077,10 +4610,10 @@ function resolveConfig3(config) {
 function piCliEntrypoint() {
   const mainUrl = import.meta.resolve("@earendil-works/pi-coding-agent");
   const root = dirname2(dirname2(fileURLToPath(mainUrl)));
-  const pkg = JSON.parse(readFileSync(join2(root, "package.json"), "utf8"));
+  const pkg = JSON.parse(readFileSync(join3(root, "package.json"), "utf8"));
   const bin = pkg.bin;
   const rel = typeof bin === "string" ? bin : bin?.["pi"] ?? Object.values(bin ?? {})[0] ?? "bin/pi.js";
-  return join2(root, rel);
+  return join3(root, rel);
 }
 function piSubprocessSpec(spec, graceMs) {
   return {
@@ -4102,34 +4635,25 @@ function fromSubprocess(handle) {
     stdout,
     stderr,
     onExit: (handler) => {
-      const onExit = handler;
-      void handle.done.then((outcome) => onExit(outcome.exitCode), handler);
+      void handle.done.then(handler, handler);
     },
     terminate: () => handle.terminate()
   };
 }
-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"];
+var PI_ENGINE_LABEL = "agentLoopPi";
+var PiLoop = class extends HostedEngineRuntime {
   /** 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. */
   bin;
-  /** 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", 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)));
-    const holder = config.piCatalogHolder;
-    if (holder !== void 0) {
-      void probePiModels(this.bin, (spec) => this.spawn(spec)).then((models) => {
-        holder.entries = [...models];
-      }).catch(() => {
-        holder.entries = [];
-      });
+    super(ctx, PI_ENGINE_LABEL, resolveConfig3(config));
+    const subprocess = ctx.get("subprocess");
+    if (subprocess === void 0) {
+      throw new Error("loop-engine: the pi engine needs the dsh subprocess service on this context");
     }
+    this.bin = piCliEntrypoint();
+    this.spawn = (spec) => fromSubprocess(subprocess.spawn(piSubprocessSpec(spec, PI_DISPOSE_GRACE_MS)));
   }
   /** Construct the Pi RPC driver for one prepared session. */
   buildAgent(loopCtx, id, options, session) {
@@ -4140,8 +4664,7 @@ var PiLoop = class extends HostedLoopFactory {
       session,
       this.config,
       this.spawn,
-      this.bin,
-      this.catalog
+      this.bin
     );
   }
 };
@@ -4151,22 +4674,38 @@ import z4 from "@deepseek-ai/schemastery";
 
 // src/engine-kimi/agent.ts
 import { agentEvents as agentEvents4 } from "@deepseek-ai/dsh-agent";
-import { ToolCallId as ToolCallId7, LlmError as LlmError4, createAssistantMessage as createAssistantMessage4, createUserMessage as createUserMessage4, errorChain as errorChain4 } from "@deepseek-ai/dsh-llm";
+import { ToolCallId as ToolCallId7, LlmError as LlmError5, 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";
 
+// src/engine-kimi/model-handover.ts
+var KIMI_PROVIDER_TYPES = {
+  "anthropic-messages": "anthropic",
+  "openai-completions": "openai",
+  "openai-responses": "openai"
+};
+function kimiModelEnv(handover) {
+  const type = KIMI_PROVIDER_TYPES[handover.api];
+  return {
+    KIMI_MODEL_NAME: handover.model,
+    KIMI_MODEL_API_KEY: handover.apiKey,
+    KIMI_MODEL_BASE_URL: handover.baseURL,
+    ...type === void 0 ? {} : { KIMI_MODEL_PROVIDER_TYPE: type }
+  };
+}
+
 // src/engine-kimi/process.ts
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 function kimiHomeDir() {
   const envHome = process.env.KIMI_CODE_HOME;
-  return envHome !== void 0 && envHome !== "" ? envHome : join3(homedir(), ".kimi-code");
+  return envHome !== void 0 && envHome !== "" ? envHome : join4(homedir(), ".kimi-code");
 }
 function kimiBinResolver(configBin) {
   if (configBin !== void 0 && configBin !== "") return configBin;
   const executable = process.platform === "win32" ? "kimi.exe" : "kimi";
-  const candidate = join3(kimiHomeDir(), "bin", executable);
+  const candidate = join4(kimiHomeDir(), "bin", executable);
   return existsSync(candidate) ? candidate : "kimi";
 }
 function kimiAcpArgv(bin) {
@@ -4320,6 +4859,18 @@ var AcpClient = class _AcpClient {
     }
     return sessionId;
   }
+  /**
+   * Select the model for one ACP session. The agent answers with an error frame
+   * when it cannot serve the id, and {@link request} rejects on that frame — so
+   * an engine that refuses the model fails the step loud rather than silently
+   * running its own default.
+   * @param sessionId - the ACP session the model applies to.
+   * @param modelId - the model id to select.
+   * @returns the agent's response to `session/set_model`.
+   */
+  setModel(sessionId, modelId) {
+    return this.request("session/set_model", { sessionId, modelId });
+  }
   /** Prompt the agent in a session and resolve when the turn completes. */
   prompt(sessionId, text) {
     return this.request("session/prompt", { sessionId, prompt: [{ type: "text", text }] });
@@ -4476,8 +5027,7 @@ function resolveToolApproval(events) {
 }
 
 // src/engine-kimi/agent.ts
-var PROVIDER4 = "kimi";
-var NATIVE_MODEL_LABEL4 = "kimi-native";
+var PROVIDER4 = HOSTED_ROUTE_LABEL;
 var KimiAgent = class {
   constructor(loopCtx, id, options, session, config, spawn4, bin) {
     this.loopCtx = loopCtx;
@@ -4531,6 +5081,13 @@ var KimiAgent = class {
   acp;
   /** The spawn spec the cached client was built from; a change forces a respawn. */
   lastSpec;
+  /**
+   * The environment the last handover produced, memoized by its own content so
+   * an unchanged endpoint reuses ONE object: `specsEqual` compares environments
+   * by reference, and a fresh object per step would otherwise respawn the child
+   * every step.
+   */
+  handoverEnvCache;
   get status() {
     return this.phase.kind === "idle" || this.phase.kind === "maintenance" ? "idle" : "running";
   }
@@ -4762,7 +5319,7 @@ var KimiAgent = class {
       }
       turnEnds = {
         kind: "error",
-        error: error instanceof LlmError4 ? error.failure : { message: errorChain4(error), code: "UNKNOWN" }
+        error: error instanceof LlmError5 ? error.failure : { message: errorChain4(error), code: "UNKNOWN" }
       };
       this.throwError(error);
     } finally {
@@ -4780,7 +5337,7 @@ var KimiAgent = class {
   }
   /** Model label recorded in the request header for one lifecycle. */
   modelLabel() {
-    return this.config.model ?? NATIVE_MODEL_LABEL4;
+    return this.config.model ?? HOSTED_DEFAULT_MODEL;
   }
   /** Append the request header snapshot once per loop instance. */
   assertRequestHeader() {
@@ -4801,8 +5358,8 @@ var KimiAgent = class {
     return a.cwd === b.cwd && a.env === b.env && a.argv.length === b.argv.length && a.argv.every((value, index) => value === b.argv[index]);
   }
   /** Return the cached ACP client, respawning when the spec or process changed. */
-  async acpClient(cwd) {
-    const spec = this.spawnSpec(cwd);
+  async acpClient(cwd, handover) {
+    const spec = this.spawnSpec(cwd, handover);
     if (this.acp !== void 0 && !this.acp.closed && this.specsEqual(this.lastSpec, spec)) return this.acp;
     this.acp?.dispose();
     const client = AcpClient.create(spec, this.spawn);
@@ -4819,13 +5376,25 @@ var KimiAgent = class {
     return client;
   }
   /** Build the `kimi acp` argv/cwd/env for the persistent child. */
-  spawnSpec(cwd) {
+  spawnSpec(cwd, handover) {
     return {
       argv: kimiAcpArgv(this.bin),
       cwd,
-      env: this.config.env
+      env: this.handoverEnv(handover)
     };
   }
+  /**
+   * The child environment for one handover, memoized by content so an unchanged
+   * endpoint yields the SAME object across steps (see {@link handoverEnvCache}).
+   */
+  handoverEnv(handover) {
+    if (handover === void 0) return this.config.env;
+    const key = JSON.stringify(handover);
+    if (this.handoverEnvCache?.key === key) return this.handoverEnvCache.env;
+    const env = { ...this.config.env, ...kimiModelEnv(handover) };
+    this.handoverEnvCache = { key, env };
+    return 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`);
@@ -4843,17 +5412,22 @@ var KimiAgent = class {
       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);
+    const prompt = engineSlashPrompt(history) ?? 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);
+    const override = sessionModelOverrideOf(this.loopCtx, this.session);
+    const handover = await resolveModelHandover(this.loopCtx, override);
+    const client = await this.acpClient(cwd, handover);
     signal.throwIfAborted();
     client.onPermission(() => resolveToolApproval(this.session.snapshotEvents()));
     const acpSessionId = await client.newSession(cwd);
     signal.throwIfAborted();
+    const model = override?.model ?? this.config.model;
+    if (handover === void 0 && model !== void 0) await client.setModel(acpSessionId, model);
+    signal.throwIfAborted();
     try {
       client.onUpdate((update) => this.applyUpdate(phase, update));
       const cancel = () => {
@@ -4871,7 +5445,7 @@ var KimiAgent = class {
       this.pendingCalls.clear();
       this.flushSegment(phase);
       if (!this.producedOutput) {
-        throw new LlmError4(
+        throw new LlmError5(
           `agent "${this.id}": kimi query produced no assistant output`,
           "KIMI_NO_RESULT"
         );
@@ -5028,7 +5602,8 @@ var KimiAgent = class {
     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 });
+      const normalized = normalizeHostedToolCall("kimi", call.name, call.arguments);
+      this.session.append("tool/call", { turn: phase.turn, step: phase.step, callId: ToolCallId7(call.callId), name: normalized.name, arguments: normalized.arguments });
     }
   }
   /**
@@ -5093,14 +5668,17 @@ function resolveConfig4(config) {
     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"];
+var KIMI_ENGINE_LABEL = "agentLoopKimi";
+var KimiLoop = class extends HostedEngineRuntime {
   /** 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)));
+    super(ctx, KIMI_ENGINE_LABEL, resolveConfig4(config));
+    const subprocess = ctx.get("subprocess");
+    if (subprocess === void 0) {
+      throw new Error("loop-engine: the kimi engine needs the dsh subprocess service on this context");
+    }
+    this.spawn = (spec) => fromSubprocess2(subprocess.spawn(kimiSubprocessSpec(spec, KIMI_DISPOSE_GRACE_MS)));
   }
   /** Construct the Kimi ACP driver for one prepared session. */
   buildAgent(loopCtx, id, options, session) {
@@ -5108,22 +5686,511 @@ var KimiLoop = class extends HostedLoopFactory {
   }
 };
 
-// src/engine-kimi/skills.ts
-import { homedir as homedir3 } from "node:os";
-import { join as join7, resolve as resolve3 } from "node:path";
+// src/settings.ts
+import z5 from "@deepseek-ai/schemastery";
 
-// 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/namespace.ts
+var LOOP_ENGINE_SETTINGS_NAMESPACE_LITERAL = "agent-loop-engine";
 
-// src/driver-core/context-files.ts
-import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
-import { join as join5, resolve as resolve2 } from "node:path";
+// src/settings.ts
+var LOOP_ENGINE_SETTINGS_SCHEMA = z5.object({
+  engine: z5.union(LOOP_ENGINE_IDS.map((id) => z5.const(id))).default("in-process"),
+  showInComposer: z5.boolean().default(true)
+});
+function loopEngineSettingsNamespace() {
+  return LOOP_ENGINE_SETTINGS_NAMESPACE_LITERAL;
+}
 
-// src/skills.ts
-import { readFile, readdir, stat } from "node:fs/promises";
+// src/patch-manager.ts
+var MANAGED_BLOCK_BEGIN = "# -- dsh-loop-engine managed block --";
+var LEGACY_MANAGED_BLOCK_BEGIN = "# -- dsh-loop-engine managed block: ";
+var MANAGED_BLOCK_END = "# -- /dsh-loop-engine managed block --";
+var END_MARKER_LINE = `${MANAGED_BLOCK_END}
+`;
+function renderManagedBlock() {
+  return [
+    MANAGED_BLOCK_BEGIN,
+    "- id: agent-loop",
+    "  disabled: true",
+    "- id: command-goal",
+    "  disabled: true",
+    END_MARKER_LINE
+  ].join("\n");
+}
+function hasLegacyManagedBlock(text) {
+  return text.includes(LEGACY_MANAGED_BLOCK_BEGIN);
+}
+function hasManagedBlock(text) {
+  return text.includes("# -- dsh-loop-engine managed block");
+}
+var LEGACY_BEGIN_MARKER_RE = /^# -- dsh-loop-engine managed block: (\S+) --$/m;
+function legacyBlockEngineOf(text) {
+  const engine = LEGACY_BEGIN_MARKER_RE.exec(text)?.[1];
+  return LOOP_ENGINE_IDS.includes(engine ?? "") ? engine : void 0;
+}
+function managedSpan(text) {
+  const begin = text.indexOf("# -- dsh-loop-engine managed block");
+  if (begin === -1) return { head: text, tail: "", present: false, blankBefore: false };
+  const afterBegin = begin + LEGACY_MANAGED_BLOCK_BEGIN.length;
+  const endAt = text.indexOf(MANAGED_BLOCK_END, afterBegin);
+  const spanEnd = endAt === -1 ? text.length : endAt + END_MARKER_LINE.length;
+  const before = text.slice(0, begin);
+  const blankBefore = before.endsWith("\n\n");
+  return {
+    head: blankBefore ? before.slice(0, -1) : before,
+    tail: text.slice(spanEnd),
+    present: true,
+    blankBefore
+  };
+}
+function ensureTrailingNewline(text) {
+  return text.endsWith("\n") ? text : `${text}
+`;
+}
+function dropSeedPlaceholder(text) {
+  return text.replace(/^\[\]\n/m, "");
+}
+function applyManagedBlock(text) {
+  const block = renderManagedBlock();
+  const span = managedSpan(text);
+  if (!span.present) {
+    if (text === "") return block;
+    return dropSeedPlaceholder(`${ensureTrailingNewline(text)}
+${block}`);
+  }
+  return dropSeedPlaceholder(`${span.head}${span.blankBefore ? "\n" : ""}${block}${span.tail}`);
+}
+
+// src/preset.ts
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { dirname as dirname3, join as join5 } from "node:path";
+var USER_PRESET_DIR = ".agent-presets";
+var COMPOSITION_FILE = "agent.cordis.yml";
+var METADATA_FILE = "preset.yml";
+var HOSTED_PRESET_IDS = HOSTED_ENGINE_IDS.map((engine) => enginePresetId(engine));
+var STRIPPED_ROWS = ["skill-filesystem", "tool-skill", "tool-goal", "command-goal", "planning", "compaction"];
+var MANAGED_HEADER = `# Managed by dsh-loop-engine: the deployment's "${SOURCE_PRESET_ID}" preset minus
+# the dsh-native command/skill rows a hosted loop engine replaces. Regenerated
+# from "${SOURCE_PRESET_ID}" on boot \u2014 hand edits are overwritten. The preset id
+# names the engine this session runs.
+`;
+function managedMetadata(engine) {
+  return `name: ${ENGINE_DISPLAY_NAMES[engine]}
+description: ${ENGINE_DISPLAY_NAMES[engine]}, with the dsh-native commands and skills it replaces removed.
+`;
+}
+var ENGINE_DISPLAY_NAMES = {
+  "claude-code": "Claude Code",
+  codex: "Codex",
+  pi: "Pi",
+  kimi: "Kimi Code"
+};
+function isEntryStart(line) {
+  return line.startsWith("- ");
+}
+function entryId(line) {
+  return /^- id:\s*(\S+)\s*$/.exec(line)?.[1];
+}
+function stripPresetRows(text, ids = STRIPPED_ROWS) {
+  const lines = text.split("\n");
+  const starts = [];
+  for (const [index, line] of lines.entries()) {
+    if (isEntryStart(line)) starts.push(index);
+  }
+  if (starts.length === 0) return text;
+  const drop = new Set(ids);
+  const entries = [];
+  let heading = lines.slice(0, starts[0]);
+  for (const [index, start] of starts.entries()) {
+    const end = index + 1 < starts.length ? starts[index + 1] : lines.length;
+    const span = lines.slice(start, end);
+    let bodyEnd = span.length;
+    while (bodyEnd > 1) {
+      const line = span[bodyEnd - 1];
+      if (line.trim() !== "" && !line.trimStart().startsWith("#")) break;
+      bodyEnd -= 1;
+    }
+    entries.push({ id: entryId(span[0]), heading, body: span.slice(0, bodyEnd) });
+    heading = span.slice(bodyEnd);
+  }
+  const out = [];
+  out.push(...entries[0].heading);
+  let lastKept = -1;
+  for (const [index, entry] of entries.entries()) {
+    if (entry.id !== void 0 && drop.has(entry.id)) continue;
+    if (index > 0) out.push(...entry.heading);
+    out.push(...entry.body);
+    lastKept = index;
+  }
+  if (lastKept === entries.length - 1) out.push(...heading);
+  if (out.length > 0 && out[out.length - 1] !== "") out.push("");
+  return out.join("\n");
+}
+async function writeIfDifferent(path, text) {
+  try {
+    if (await readFile(path, "utf8") === text) return false;
+  } catch {
+  }
+  await mkdir(dirname3(path), { recursive: true });
+  const tmp = `${path}.tmp-${randomUUID()}`;
+  await writeFile(tmp, text, "utf8");
+  await rename(tmp, path);
+  return true;
+}
+async function ensureEnginePresets(dshHome, source) {
+  const composition = await source.read(SOURCE_PRESET_ID);
+  const stripped = `${MANAGED_HEADER}
+${stripPresetRows(composition)}`;
+  let changed = false;
+  for (const engine of HOSTED_ENGINE_IDS) {
+    const dir = join5(dshHome, USER_PRESET_DIR, enginePresetId(engine));
+    const compositionChanged = await writeIfDifferent(join5(dir, COMPOSITION_FILE), stripped);
+    const metadataChanged = await writeIfDifferent(join5(dir, METADATA_FILE), managedMetadata(engine));
+    changed = changed || compositionChanged || metadataChanged;
+  }
+  return changed;
+}
+
+// src/router-loop.ts
+import AgentLoop from "@deepseek-ai/dsh-agent-loop";
+
+// src/model-selection-reset.ts
+var AGENT_DEFAULT_MODEL_NS = "agent-default-model";
+var ModelSelectionReset = class {
+  /**
+   * @param ctx - context carrying the host's default-model service, its settings
+   *   (for the configured default), and the session-projection registry.
+   * @param warn - diagnostic sink, used at most once per problem.
+   */
+  constructor(ctx, warn) {
+    this.ctx = ctx;
+    this.warn = warn;
+  }
+  ctx;
+  warn;
+  /** Whether the one warning this deployment is owed has been reported. */
+  warned = false;
+  /** Whether the one report that the deployment default names a hosted route has been made. */
+  reportedHostedDefault = false;
+  /**
+   * Give one session the selection the engine it is being SWITCHED TO owns,
+   * unless its log already names a real model of its own.
+   *
+   * The switch trigger. A session whose log names no selection at all is left
+   * alone: a switch rewrites a seat an engine already put there, and naming a
+   * session's first seat belongs to the build of a session being created
+   * ({@link guardFor}) rather than to a change of engine.
+   * @param session - the live Session the engine switch is being recorded for.
+   * @param engine - the engine the session is being moved to.
+   * @returns whether a `model/selection` event was appended.
+   */
+  resetFor(session, engine) {
+    if (engine !== "in-process" && this.currentSelection(session) === void 0) return false;
+    return this.appendSeat(session, engine);
+  }
+  /**
+   * Give one session the selection the engine BUILDING it owns, inside the
+   * router's wrapped `setup` — before the caller's own setup installs the
+   * session's selection — so a selection written here is the one the host reads
+   * back for the agent being built.
+   *
+   * The harness loop's own build keeps its narrower precondition: it makes real
+   * model calls, so it is the one build that must not be left selecting a
+   * placeholder route, and a session whose own log already names a real model
+   * needs nothing written for it. A hosted engine is being given its seat here,
+   * which is what a new session on it starts from.
+   * @param session - the session whose agent is being composed.
+   * @param engine - the engine composing it.
+   * @returns whether a `model/selection` event was appended.
+   */
+  guardFor(session, engine) {
+    if (engine === "in-process" && !this.selectsHostedRoute(session)) return false;
+    return this.appendSeat(session, engine);
+  }
+  /**
+   * Whether the selection this session's next request would use names one of
+   * the hosted engines' provider routes — a label this plugin serves as a
+   * placeholder and cannot answer a real model call on.
+   *
+   * The read is the host's own (`selectionFor`): a pending selection, else the
+   * logged header, else the deployment's default. A session with nothing in its
+   * log is therefore judged on the deployment default — the value the model menu
+   * can write a hosted label into — and that default is read AS IT IS, never as
+   * {@link defaultSelection} would substitute it: the substitution only exists
+   * once it is written into the session, so judging the substitute would skip
+   * the write that makes it real.
+   * @param session - the session whose selection is being judged.
+   * @returns whether that selection names a hosted engine route.
+   */
+  selectsHostedRoute(session) {
+    const selected = this.currentSelection(session) ?? this.deploymentDefault();
+    return selected !== void 0 && isHostedProviderRoute(selected.provider);
+  }
+  /**
+   * Append the selection one engine's seat carries, by the judgements both
+   * triggers share.
+   *
+   * A real model selection is never overwritten — the provider is the test,
+   * because only a label some hosted engine logs is a seat this module owns — and
+   * a session that already selects the target route is left alone. Provider and
+   * model are the comparison: a reasoning effort the target carries is not a
+   * reason to log a second event for a session that already selects the same
+   * route, and re-appending would only grow the log on every switch.
+   * @param session - the session whose selection is being written.
+   * @param engine - the engine whose seat the session should select.
+   * @returns whether a `model/selection` event was appended.
+   */
+  appendSeat(session, engine) {
+    const target = this.seatOf(engine);
+    if (target === void 0) return false;
+    const current = this.currentSelection(session);
+    if (current !== void 0) {
+      if (!isHostedProviderRoute(current.provider)) return false;
+      if (current.provider === target.provider && current.model === target.model) return false;
+    }
+    session.append("model/selection", {
+      provider: target.provider,
+      model: target.model,
+      ...target.reasoningEffort === void 0 ? {} : { reasoningEffort: target.reasoningEffort }
+    });
+    return true;
+  }
+  /**
+   * The selection one engine's seat carries: a hosted engine's shared
+   * `external/default`, or — for the harness loop — the deployment's default,
+   * with the substitution {@link defaultSelection} documents.
+   * @param engine - the engine a session runs, or is being moved to.
+   * @returns the selection to write, or undefined when this process cannot name
+   *   one for that engine.
+   */
+  seatOf(engine) {
+    if (engine === "in-process") return this.defaultSelection();
+    return { provider: hostedRouteLabelOf(engine), model: HOSTED_DEFAULT_MODEL };
+  }
+  /**
+   * The selection the host will use for this session, by the host's own read —
+   * the shared read in `driver-core/session-model.ts` (`currentSelection`),
+   * which the four hosted drivers also use to resolve the model they hand over.
+   * @param session - the session whose selection is being read.
+   * @returns the current selection, or undefined when the log records none.
+   */
+  currentSelection(session) {
+    return currentSelection(session, this.projections());
+  }
+  /**
+   * The selection the deployment's own `agentDefaultModel` service answers, or
+   * undefined when this process cannot read one (reported once).
+   *
+   * Read twice for two different questions — as the selection a session with
+   * nothing in its log would use ({@link selectsHostedRoute}), and as the value
+   * this plugin restores ({@link defaultSelection}) — so the substitution below
+   * never hides the fact that the saved default itself is unusable.
+   * @returns the validated default, or undefined when it cannot be named.
+   */
+  deploymentDefault() {
+    const service = this.ctx.get("agentDefaultModel");
+    if (service === void 0) return this.unavailable("this deployment composes no agentDefaultModel service");
+    let answered;
+    try {
+      answered = service.currentSelection();
+    } catch (error) {
+      return this.unavailable(`agentDefaultModel.currentSelection() failed: ${String(error)}`);
+    }
+    const named = usableSelection(answered);
+    if (named === void 0) {
+      return this.unavailable("agentDefaultModel.currentSelection() named no usable provider/model");
+    }
+    return named;
+  }
+  /**
+   * The selection this plugin restores: the deployment's default, or — when that
+   * default names a hosted engine ROUTE — the model the deployment's own
+   * composition declares instead.
+   *
+   * The route case is not hypothetical: `session.selectModel` saves whatever the
+   * model menu submitted as the deployment default, and the menu carries the
+   * hosted route as an entry, so one pick made while a hosted session was open
+   * puts a label there that no adapter serves a real model on — handing it to a
+   * session the harness loop drives would fail that session's first request
+   * loud. The composed default is a real model the deployment itself asked for,
+   * so nothing is guessed on its behalf.
+   * @returns the restored selection, or undefined to skip the write.
+   */
+  defaultSelection() {
+    const named = this.deploymentDefault();
+    if (named === void 0) return void 0;
+    if (!isHostedProviderRoute(named.provider)) return named;
+    const configured = this.configuredDefault();
+    if (configured === void 0) {
+      return this.unavailable(`the deployment default model is the hosted engine route "${named.provider}/${named.model}", and this deployment composes no usable default model to replace it with`);
+    }
+    if (!this.reportedHostedDefault) {
+      this.reportedHostedDefault = true;
+      this.warn(
+        `loop-engine: the deployment default model is the hosted engine route "${named.provider}/${named.model}", which no adapter serves; sessions the in-process engine drives are given the deployment's configured default model "${configured.provider}/${configured.model}" instead \u2014 pick a real model to make that the default again`
+      );
+    }
+    return configured;
+  }
+  /**
+   * The model the DEPLOYMENT's own composition declares as its default, read
+   * from the settings descriptor's `base` layer — the value a saved (user-layer)
+   * default overrode.
+   *
+   * This is what replaces a default that names a hosted route, and it is read
+   * live because the composition is what the deployment itself configured:
+   * `packages/bundle/base/cordis.patch.yml` gives the `agent-default-model` row
+   * a real provider and model, and only the user layer can hold a pick made from
+   * the model menu.
+   * @returns the configured default, or undefined when this deployment composes
+   *   no default-model section, cannot enumerate settings, configured no usable
+   *   provider/model, or configured a hosted route there too.
+   */
+  configuredDefault() {
+    const settings = this.ctx.get("settings");
+    if (settings?.describe === void 0) return void 0;
+    const base = settings.describe().find((entry) => entry.ns === AGENT_DEFAULT_MODEL_NS)?.base;
+    const named = usableSelection(base);
+    return named === void 0 || isHostedProviderRoute(named.provider) ? void 0 : named;
+  }
+  /** Read the host session-projection registry, structurally. */
+  projections() {
+    return this.ctx.get("sessionProjections");
+  }
+  /**
+   * Report the one thing this read could not answer, once per plugin lifetime.
+   *
+   * Repeated triggers must not repeat it: a deployment without the service would
+   * otherwise log a line per session built for as long as it runs.
+   * @param problem - what this process cannot read, with the reason.
+   * @returns undefined, so callers can `return this.unavailable(…)` to skip.
+   */
+  unavailable(problem) {
+    if (this.warned) return void 0;
+    this.warned = true;
+    this.warn(`loop-engine: a session on the in-process engine cannot be given a real model selection: ${problem}; it keeps the selection its log records, which no adapter serves a real model on`);
+    return void 0;
+  }
+};
+function usableSelection(answered) {
+  const provider = answered?.provider;
+  const model = answered?.model;
+  if (typeof provider !== "string" || provider.length === 0 || typeof model !== "string" || model.length === 0) {
+    return void 0;
+  }
+  const effort = answered?.reasoningEffort;
+  return {
+    provider,
+    model,
+    ...typeof effort !== "string" || effort.length === 0 ? {} : { reasoningEffort: effort }
+  };
+}
+
+// src/commands.ts
+import { readdirSync, readFileSync as readFileSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join4, resolve } from "node:path";
+import { join as join6 } from "node:path";
+import { createUserMessage as createUserMessage5 } from "@deepseek-ai/dsh-llm";
+var COMMAND_NAME = /^[a-z][a-z0-9_-]*$/;
+function forwardClaudeCodeCommand(name2) {
+  return (invocation) => {
+    invocation.agent.followup(createUserMessage5({
+      content: [{ type: "text", text: `/${name2}${invocation.rawInput}` }],
+      source: { kind: "user" }
+    }));
+    return { kind: "success" };
+  };
+}
+function builtin(name2, description) {
+  return { name: name2, description, handler: forwardClaudeCodeCommand(name2) };
+}
+var CLAUDE_CODE_COMMANDS = [
+  builtin("help", "Show help about Claude Code commands"),
+  builtin("compact", "Compact the conversation to reduce context usage"),
+  builtin("clear", "Clear the conversation and start fresh"),
+  builtin("review", "Review recent changes (git diff)")
+];
+function discoverUserSlashCommands() {
+  let entries;
+  try {
+    entries = readdirSync(userCommandsDir(), { encoding: "utf8" });
+  } catch {
+    return [];
+  }
+  const definitions = [];
+  const seen = new Set(CLAUDE_CODE_COMMANDS.map((command) => command.name));
+  for (const entry of entries.sort()) {
+    if (!entry.endsWith(".md")) continue;
+    const name2 = entry.slice(0, -".md".length);
+    if (!COMMAND_NAME.test(name2) || seen.has(name2)) continue;
+    const path = join6(userCommandsDir(), entry);
+    let raw;
+    try {
+      raw = readFileSync2(path, "utf8");
+    } catch {
+      continue;
+    }
+    const description = commandDescription(raw);
+    if (description === void 0) continue;
+    seen.add(name2);
+    definitions.push({ name: name2, description, handler: forwardClaudeCodeCommand(name2) });
+  }
+  return definitions;
+}
+function userCommandsDir() {
+  return join6(homedir2(), ".claude", "commands");
+}
+function commandDescription(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return void 0;
+  let body = trimmed;
+  if (trimmed.startsWith("---\n")) {
+    const closing = trimmed.indexOf("\n---");
+    if (closing <= 0) return void 0;
+    for (const line of trimmed.slice(4, closing).split("\n")) {
+      const colon = line.indexOf(":");
+      if (colon < 0 || line.slice(0, colon).trim() !== "description") continue;
+      const value = line.slice(colon + 1).trim().replace(/^["']|["']$/g, "");
+      if (value.length > 0) return value;
+    }
+    body = trimmed.slice(closing + 4);
+  }
+  for (const line of body.split("\n")) {
+    const candidate = line.trim();
+    if (candidate.length === 0 || candidate.startsWith("#")) continue;
+    return candidate.length > 120 ? `${candidate.slice(0, 119)}\u2026` : candidate;
+  }
+  return void 0;
+}
+
+// src/engine-kimi/commands.ts
+import { createUserMessage as createUserMessage6 } from "@deepseek-ai/dsh-llm";
+function forwardKimiCommand(name2) {
+  return (invocation) => {
+    invocation.agent.followup(createUserMessage6({
+      content: [{ type: "text", text: `/${name2}${invocation.rawInput}` }],
+      source: { kind: "user" }
+    }));
+    return { kind: "success" };
+  };
+}
+function builtin2(name2, description) {
+  return { name: name2, description, handler: forwardKimiCommand(name2) };
+}
+var KIMI_COMMANDS = [
+  builtin2("compact", "Compact the conversation context"),
+  builtin2("status", "Show current session status"),
+  builtin2("usage", "Show session token usage"),
+  builtin2("mcp", "Show MCP server status"),
+  builtin2("tasks", "List background tasks"),
+  builtin2("help", "Show available ACP commands")
+];
+
+// src/skills.ts
+import { readFile as readFile2, readdir, stat } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { join as join7, resolve } from "node:path";
 var SKILL_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 var PROVIDER_NAME = "claude-code";
 var CLAUDE_CODE_RANK = 150;
@@ -5190,8 +6257,8 @@ function findClosingFrontmatter(raw, start) {
 function parseSkillFile(raw) {
   const parsed = parseFrontmatter(raw);
   if (parsed === void 0) return void 0;
-  const name2 = stringField(parsed.data, "name");
-  const description = stringField(parsed.data, "description");
+  const name2 = stringField2(parsed.data, "name");
+  const description = stringField2(parsed.data, "description");
   if (name2 === void 0 || description === void 0 || !SKILL_NAME.test(name2)) return void 0;
   const disableModelInvocation = booleanField(parsed.data, "disable-model-invocation");
   const userInvocable = booleanField(parsed.data, "user-invocable");
@@ -5207,7 +6274,7 @@ function parseSkillFile(raw) {
     content: parsed.body.trim()
   };
 }
-function stringField(data, key) {
+function stringField2(data, key) {
   const value = data[key];
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
@@ -5233,17 +6300,17 @@ var ClaudeCodeSkillProvider = class {
     const cwd = options.cwd;
     if (cwd !== void 0) {
       const projectRoot = await findProjectRoot(resolve(cwd));
-      await collectSkillsDir(join4(projectRoot, ".claude", "skills"), CLAUDE_CODE_RANK, candidates);
+      await collectSkillsDir(join7(projectRoot, ".claude", "skills"), CLAUDE_CODE_RANK, candidates);
       await collectClaudeMd(projectRoot, candidates);
     }
-    await collectSkillsDir(join4(homedir2(), ".claude", "skills"), CLAUDE_CODE_USER_RANK, candidates);
+    await collectSkillsDir(join7(homedir3(), ".claude", "skills"), CLAUDE_CODE_USER_RANK, candidates);
     if (this.control.signal.aborted) return [];
     return candidates;
   }
   async get(candidate, _options) {
     const locator = candidate.locator;
     try {
-      const raw = await readFile(locator.path, { encoding: "utf8" });
+      const raw = await readFile2(locator.path, { encoding: "utf8" });
       const parsed = parseSkillFile(raw);
       if (parsed === void 0) return void 0;
       return {
@@ -5270,11 +6337,11 @@ async function collectSkillsDir(skillsDir, rank, candidates) {
     return;
   }
   for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-    const entryPath = join4(skillsDir, entry.name);
+    const entryPath = join7(skillsDir, entry.name);
     const info = await stat(entryPath).catch(() => void 0);
     if (info === void 0) continue;
     if (info.isDirectory()) {
-      const path = join4(entryPath, "SKILL.md");
+      const path = join7(entryPath, "SKILL.md");
       const skill2 = await tryParseSkill(path);
       if (skill2 === void 0) continue;
       candidates.push(toCandidate(skill2, path, rank, entryPath));
@@ -5287,7 +6354,7 @@ async function collectSkillsDir(skillsDir, rank, candidates) {
   }
 }
 async function collectClaudeMd(projectRoot, candidates) {
-  const claudeMd = join4(projectRoot, "CLAUDE.md");
+  const claudeMd = join7(projectRoot, "CLAUDE.md");
   try {
     const info = await stat(claudeMd);
     if (!info.isFile()) return;
@@ -5314,7 +6381,7 @@ function toCandidate(skill, path, rank, resourceBaseDir) {
 }
 async function tryParseSkill(path) {
   try {
-    const raw = await readFile(path, { encoding: "utf8" });
+    const raw = await readFile2(path, { encoding: "utf8" });
     return parseSkillFile(raw);
   } catch {
     return void 0;
@@ -5324,7 +6391,7 @@ async function findProjectRoot(cwd) {
   let current = cwd;
   while (true) {
     try {
-      await stat(join4(current, ".git"));
+      await stat(join7(current, ".git"));
       return current;
     } catch {
     }
@@ -5334,7 +6401,17 @@ async function findProjectRoot(cwd) {
   }
 }
 
+// src/engine-codex/skills.ts
+import { homedir as homedir4 } from "node:os";
+import { join as join10 } from "node:path";
+
+// src/driver-core/agents-md-skill-provider.ts
+import { readdir as readdir2, readFile as readFile4, stat as stat3 } from "node:fs/promises";
+import { dirname as dirname4, join as join9 } from "node:path";
+
 // src/driver-core/context-files.ts
+import { readFile as readFile3, stat as stat2 } from "node:fs/promises";
+import { join as join8, resolve as resolve2 } from "node:path";
 async function projectAncestors(cwd) {
   const root = await findProjectRoot(resolve2(cwd));
   const dirs = [];
@@ -5355,11 +6432,11 @@ async function collectProjectContextFiles(cwd, policy) {
 }
 async function dirContextFile(dir, policy) {
   if (policy.override !== void 0) {
-    const override = join5(dir, policy.override);
+    const override = join8(dir, policy.override);
     if (await pathExists(override)) return override;
   }
   for (const name2 of policy.primary) {
-    const candidate = join5(dir, name2);
+    const candidate = join8(dir, name2);
     if (await pathExists(candidate)) return candidate;
   }
   return void 0;
@@ -5374,7 +6451,7 @@ async function pathExists(path) {
 }
 async function readOptionalFile(path) {
   try {
-    return await readFile2(path, { encoding: "utf8" });
+    return await readFile3(path, { encoding: "utf8" });
   } catch {
     return void 0;
   }
@@ -5419,18 +6496,18 @@ var AgentsMdSkillProvider = class {
       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(join9(dir, ...catalog.project), catalog.projectRank, candidates);
         }
       }
     }
     const userDir = this.spec.userDir();
     const userContext = this.spec.userContext;
     if (userContext !== void 0) {
-      const userFile = join6(userDir, userContext.file);
+      const userFile = join9(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);
+      await this.collectSkillsDir(join9(userDir, this.spec.skills.userDir), this.spec.skills.userRank, candidates);
     }
     if (this.control.signal.aborted) return [];
     return candidates;
@@ -5449,7 +6526,7 @@ var AgentsMdSkillProvider = class {
         provider: this.name,
         content: parsed.content,
         path: locator.path,
-        resourceBase: { kind: "directory", path: dirname3(locator.path) }
+        resourceBase: { kind: "directory", path: dirname4(locator.path) }
       };
     }
     const content = await readSources(locator.paths);
@@ -5490,11 +6567,11 @@ var AgentsMdSkillProvider = class {
       return;
     }
     for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-      const entryPath = join6(skillsDir, entry.name);
+      const entryPath = join9(skillsDir, entry.name);
       const info = await stat3(entryPath).catch(() => void 0);
       if (info === void 0) continue;
       if (info.isDirectory()) {
-        const path = join6(entryPath, "SKILL.md");
+        const path = join9(entryPath, "SKILL.md");
         const parsed2 = await this.tryParse(path);
         if (parsed2 === void 0) continue;
         candidates.push(this.skillCandidate(parsed2, path, rank, entryPath));
@@ -5521,18 +6598,74 @@ var AgentsMdSkillProvider = class {
       resourceBase: { kind: "directory", path: resourceDir }
     };
   }
-  /** Parse one SKILL.md file, or `undefined` when it is unreadable or invalid. */
-  async tryParse(path) {
-    try {
-      const raw = await readFile3(path, { encoding: "utf8" });
-      return parseSkillFile(raw);
-    } catch {
-      return void 0;
-    }
+  /** Parse one SKILL.md file, or `undefined` when it is unreadable or invalid. */
+  async tryParse(path) {
+    try {
+      const raw = await readFile4(path, { encoding: "utf8" });
+      return parseSkillFile(raw);
+    } catch {
+      return void 0;
+    }
+  }
+};
+
+// src/engine-codex/skills.ts
+var CODEX_PROJECT_RANK = 140;
+var CODEX_USER_RANK = 160;
+var CODEX_CONTEXT_POLICY = { primary: ["AGENTS.md"] };
+var CODEX_SPEC = {
+  name: "codex",
+  agentsMdDescription: "Codex project/user instructions (AGENTS.md)",
+  contextPolicy: CODEX_CONTEXT_POLICY,
+  userDir: () => join10(homedir4(), ".codex"),
+  projectRank: CODEX_PROJECT_RANK,
+  userContext: { file: "AGENTS.md", rank: CODEX_USER_RANK }
+};
+var CodexSkillProvider = class extends AgentsMdSkillProvider {
+  constructor(control) {
+    super(CODEX_SPEC, control);
+  }
+};
+
+// src/engine-pi/skills.ts
+import { homedir as homedir5 } from "node:os";
+import { join as join11, resolve as resolve3 } from "node:path";
+var PI_AGENTS_PROJECT_RANK = 140;
+var PI_SKILL_PROJECT_RANK = 150;
+var PI_AGENTS_USER_RANK = 160;
+var PI_SKILL_USER_RANK = 170;
+var PI_CONTEXT_POLICY = {
+  override: "AGENTS.override.md",
+  primary: ["AGENTS.md", "CLAUDE.md"]
+};
+function piAgentDir2() {
+  const override = process.env.PI_CODING_AGENT_DIR;
+  if (override !== void 0 && override.length > 0) return resolve3(override);
+  return join11(homedir5(), ".pi", "agent");
+}
+var PI_SPEC = {
+  name: "pi",
+  agentsMdDescription: "Pi project/user instructions (AGENTS.md / CLAUDE.md)",
+  contextPolicy: PI_CONTEXT_POLICY,
+  userDir: piAgentDir2,
+  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
+  }
+};
+var PiSkillProvider = class extends AgentsMdSkillProvider {
+  constructor(control) {
+    super(PI_SPEC, control);
   }
 };
 
 // src/engine-kimi/skills.ts
+import { homedir as homedir6 } from "node:os";
+import { join as join12, resolve as resolve4 } from "node:path";
 var KIMI_AGENTS_PROJECT_RANK = 140;
 var KIMI_SKILL_PROJECT_RANK = 150;
 var KIMI_SKILL_USER_RANK = 160;
@@ -5541,8 +6674,8 @@ var KIMI_CONTEXT_POLICY = {
 };
 function kimiAgentDir() {
   const override = process.env.KIMI_CODE_HOME;
-  if (override !== void 0 && override.length > 0) return resolve3(override);
-  return join7(homedir3(), ".kimi-code");
+  if (override !== void 0 && override.length > 0) return resolve4(override);
+  return join12(homedir6(), ".kimi-code");
 }
 var KIMI_SPEC = {
   name: "kimi",
@@ -5563,390 +6696,635 @@ var KimiSkillProvider = class extends AgentsMdSkillProvider {
   }
 };
 
-// src/engine-kimi/commands.ts
-import { createUserMessage as createUserMessage5 } from "@deepseek-ai/dsh-llm";
-function forwardKimiCommand(name2) {
-  return (invocation) => {
-    invocation.agent.followup(createUserMessage5({
-      content: [{ type: "text", text: `/${name2}${invocation.rawInput}` }],
-      source: { kind: "user" }
-    }));
-    return { kind: "success" };
-  };
-}
-function builtin(name2, description) {
-  return { name: name2, description, handler: forwardKimiCommand(name2) };
-}
-var KIMI_COMMANDS = [
-  builtin("help", "Show available Kimi Code commands"),
-  builtin("status", "Show the current session runtime state"),
-  builtin("compact", "Compact the conversation context to free token usage"),
-  builtin("clear", "Start a fresh session, discarding the current context"),
-  builtin("plan", "Toggle plan (read-only exploration) mode"),
-  builtin("auto", "Toggle auto permission mode"),
-  builtin("usage", "Show token usage, context, and quota information"),
-  builtin("version", "Display the Kimi Code CLI version number"),
-  builtin("goal", "Start or manage an autonomous goal")
-];
-
-// src/settings.ts
-import z5 from "@deepseek-ai/schemastery";
-
-// src/namespace.ts
-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(LOOP_ENGINE_IDS.map((id) => z5.const(id))).default("in-process"),
-  showInComposer: z5.boolean().default(true)
-});
-function loopEngineSettingsNamespace() {
-  return LOOP_ENGINE_SETTINGS_NAMESPACE_LITERAL;
-}
-
-// src/patch-manager.ts
-var MANAGED_BLOCK_BEGIN = "# -- dsh-loop-engine managed block: ";
-var MANAGED_BLOCK_END = "# -- /dsh-loop-engine managed block --";
-var END_MARKER_LINE = `${MANAGED_BLOCK_END}
-`;
-function renderManagedBlock(engine) {
-  if (engine === "in-process") return "";
-  return [
-    `${MANAGED_BLOCK_BEGIN}${engine} --`,
-    "- id: agent-loop",
-    "  disabled: true",
-    "- id: command-goal",
-    "  disabled: true",
-    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 managedBlockEngineOf(text) {
-  const engine = BEGIN_MARKER_RE.exec(text)?.[1];
-  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);
-  if (begin === -1) return { head: text, tail: "", present: false, blankBefore: false };
-  const afterBegin = begin + MANAGED_BLOCK_BEGIN.length;
-  const endAt = text.indexOf(MANAGED_BLOCK_END, afterBegin);
-  const spanEnd = endAt === -1 ? text.length : endAt + END_MARKER_LINE.length;
-  const before = text.slice(0, begin);
-  const blankBefore = before.endsWith("\n\n");
-  return {
-    head: blankBefore ? before.slice(0, -1) : before,
-    tail: text.slice(spanEnd),
-    present: true,
-    blankBefore
-  };
-}
-function ensureTrailingNewline(text) {
-  return text.endsWith("\n") ? text : `${text}
-`;
-}
-function hasRootEntry(text) {
-  return /^(?:- |\[)/m.test(text);
-}
-function dropSeedPlaceholder(text) {
-  return text.replace(/^\[\]\n/m, "");
-}
-function seedEmptyArray(text) {
-  const head = text.replace(/\n+$/, "");
-  return head === "" ? "[]\n" : `${head}
-[]
-`;
-}
-function applyManagedBlock(text, engine) {
-  const block = renderManagedBlock(engine);
-  const span = managedSpan(text);
-  let result;
-  if (!span.present) {
-    if (block === "") {
-      result = text;
-    } else {
-      const base = ensureTrailingNewline(text);
-      result = `${base}
-${block}`;
+// src/engine-surface.ts
+var SURFACES = {
+  "claude-code": {
+    commands: () => [...CLAUDE_CODE_COMMANDS, ...discoverUserSlashCommands()],
+    skills: (control) => new ClaudeCodeSkillProvider(control)
+  },
+  codex: {
+    skills: (control) => new CodexSkillProvider(control)
+  },
+  pi: {
+    skills: (control) => new PiSkillProvider(control)
+  },
+  kimi: {
+    commands: () => KIMI_COMMANDS,
+    skills: (control) => new KimiSkillProvider(control)
+  }
+};
+function registerEngineSurface(agent, engine, warn) {
+  const surface = SURFACES[engine];
+  const commands = agent.ctx.get("commands");
+  if (commands !== void 0 && surface.commands !== void 0) {
+    for (const command of surface.commands()) {
+      try {
+        commands.register(command);
+      } catch (error) {
+        warn(`loop-engine: skip ${engine} command /${command.name}: ${String(error)}`);
+      }
     }
-  } else if (block === "") {
-    result = span.tail.startsWith("\n") ? `${span.head}${span.tail.slice(1)}` : `${span.head}${span.tail}`;
-  } else {
-    result = `${span.head}${span.blankBefore ? "\n" : ""}${block}${span.tail}`;
   }
-  if (block !== "") return dropSeedPlaceholder(result);
-  if (text.trim() === "") return result;
-  return hasRootEntry(result) ? result : seedEmptyArray(result);
+  const skills = agent.ctx.get("skills");
+  if (skills !== void 0 && surface.skills !== void 0) {
+    skills.registerProvider(surface.skills);
+  }
 }
 
-// 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 join8 } from "node:path";
-var HOSTED_PRESET_ID = "loop-engine";
-var USER_PRESET_DIR = ".agent-presets";
-var COMPOSITION_FILE = "agent.cordis.yml";
-var METADATA_FILE = "preset.yml";
-var SOURCE_PRESET_ID = "standard";
-var STRIPPED_ROWS = ["skill-filesystem", "tool-skill", "tool-goal", "planning", "compaction"];
-var MANAGED_HEADER = `# Managed by dsh-loop-engine: the deployment's "${SOURCE_PRESET_ID}" preset minus
-# the dsh-native command/skill rows a hosted loop engine replaces. Regenerated
-# from "${SOURCE_PRESET_ID}" on boot \u2014 hand edits are overwritten.
-`;
-var MANAGED_METADATA = "name: Hosted Engine\ndescription: Standard preset minus the dsh-native commands and skills a hosted loop engine replaces.\n";
-function isEntryStart(line) {
-  return line.startsWith("- ");
-}
-function entryId(line) {
-  return /^- id:\s*(\S+)\s*$/.exec(line)?.[1];
-}
-function stripPresetRows(text, ids = STRIPPED_ROWS) {
-  const lines = text.split("\n");
-  const starts = [];
-  for (const [index, line] of lines.entries()) {
-    if (isEntryStart(line)) starts.push(index);
+// src/router-loop.ts
+var ROUTER_SERVICES = [...AgentLoop.inject];
+var RouterLoop = class extends AgentLoop {
+  engines = /* @__PURE__ */ new Map();
+  live = /* @__PURE__ */ new Map();
+  build;
+  records;
+  warn;
+  /**
+   * The model-selection half of routing: the seat a session's engine owns, moved
+   * at a switch ({@link RouterLoop.moveModelSelection}) and written at a build
+   * ({@link RouterLoop.engineOptions}). Owned here because each warning it owes
+   * is owed once per process, not once per session.
+   */
+  selectionReset;
+  /**
+   * @param ctx - the context the router's effects belong to.
+   * @param build - memoized builder for one hosted engine's runtime.
+   * @param records - the plugin's own per-session engine record, which outranks
+   *   every preset-derived answer and is what {@link selectEngine} writes.
+   * @param warn - diagnostic sink for a skipped engine command.
+   */
+  constructor(ctx, build, records, warn) {
+    super(ctx, { agents: [] });
+    this.build = build;
+    this.records = records;
+    this.warn = warn;
+    this.selectionReset = new ModelSelectionReset(ctx, warn);
+    this.rebuildOnEngineChange();
+  }
+  /** The engine that drives one session's agent. */
+  async engineFor(presetId, parent) {
+    const named = engineOfPreset(presetId);
+    if (named !== void 0) return named;
+    if (parent !== void 0) {
+      const inherited = hostedEngineOf(await engineOfSession(this.ctx, parent.id, this.records));
+      if (inherited !== void 0) return inherited;
+    }
+    return "in-process";
+  }
+  /** The engine's runtime, built on first use and kept for the plugin's lifetime. */
+  runtimeOf(engine) {
+    const existing = this.engines.get(engine);
+    if (existing !== void 0) return existing;
+    const created = this.build(engine);
+    this.engines.set(engine, created);
+    return created;
   }
-  if (starts.length === 0) return text;
-  const drop = new Set(ids);
-  const entries = [];
-  let heading = lines.slice(0, starts[0]);
-  for (const [index, start] of starts.entries()) {
-    const end = index + 1 < starts.length ? starts[index + 1] : lines.length;
-    const span = lines.slice(start, end);
-    let bodyEnd = span.length;
-    while (bodyEnd > 1) {
-      const line = span[bodyEnd - 1];
-      if (line.trim() !== "" && !line.trimStart().startsWith("#")) break;
-      bodyEnd -= 1;
+  /**
+   * Record one published agent so a later engine change can rebuild it, and
+   * bridge the engine's command/skill surface into its session.
+   * @param engine - the engine that built the handle.
+   * @param handle - the published handle.
+   * @param recipe - how it was built, for a hot swap's successor.
+   * @param handover - a hosted handle's session handover; absent for the
+   *   harness loop, whose handle carries neither the session's lifetime nor a
+   *   way to retire the machine without releasing it.
+   * @returns the handle the harness tracks.
+   */
+  adopt(engine, handle, recipe, handover) {
+    if (engine !== "in-process") registerEngineSurface(handle.agent, engine, this.warn);
+    const entry = {
+      engine,
+      agent: handle.agent,
+      dispose: () => handle.dispose(),
+      recipe,
+      ...handover === void 0 ? {} : { handover }
+    };
+    this.live.set(handle.agent.id, entry);
+    return {
+      agent: handle.agent,
+      dispose: async () => {
+        this.forget(entry);
+        await handle.dispose();
+      }
+    };
+  }
+  /** Drop one tracked session, if the record still points at that exact agent. */
+  forget(entry) {
+    if (this.live.get(entry.agent.id) === entry) this.live.delete(entry.agent.id);
+  }
+  /**
+   * Create a session's agent on the engine it runs.
+   *
+   * The plugin's own record is consulted FIRST, ahead of the preset the caller
+   * composed with: a session that already has a record must be built on the
+   * engine the plugin reports for it, or the router and the Remote would answer
+   * differently about one session. Only a session with no record — every session
+   * this plugin has never switched, including every brand-new one — falls
+   * through to the preset.
+   * @param ownerCtx - caller context that owns the lifecycle.
+   * @param options - identities, metadata (carrying the preset), and setup.
+   * @returns the published handle.
+   */
+  async createAgent(ownerCtx, options) {
+    const recipe = recipeOf(ownerCtx, options);
+    const engine = this.records.engineOf(options.sessionId) ?? await this.engineFor(options.meta?.agentPreset, options.parentAgent);
+    if (engine === "in-process") {
+      return this.adopt(engine, await super.createAgent(ownerCtx, this.engineOptions(options, engine)), recipe);
     }
-    entries.push({ id: entryId(span[0]), heading, body: span.slice(0, bodyEnd) });
-    heading = span.slice(bodyEnd);
+    const handle = await this.runtimeOf(engine).createAgent(ownerCtx, this.engineOptions(options, engine));
+    return this.adopt(engine, handle, recipe, handoverOf(handle));
   }
-  const out = [];
-  out.push(...entries[0].heading);
-  let lastKept = -1;
-  for (const [index, entry] of entries.entries()) {
-    if (entry.id !== void 0 && drop.has(entry.id)) continue;
-    if (index > 0) out.push(...entry.heading);
-    out.push(...entry.body);
-    lastKept = index;
+  /**
+   * Resume a persisted session on the engine it runs.
+   *
+   * The read is {@link engineOfSession}: the plugin's own record first, then the
+   * durable `agentPreset` projection, which folds the session header together
+   * with every committed `agent-preset/selected`. The session header alone would
+   * name the preset the session was CREATED with, which is exactly the wrong
+   * answer for a session that switched engine while it was blank — and the
+   * record is the only answer for one that switched after it started, which no
+   * preset can express.
+   *
+   * A resume is not a create: the session's seat is one a previous build already
+   * put in its log (`model-selection-reset.ts`, the switch and build triggers), so
+   * a hosted engine's resume leaves the selection exactly as it finds it. Only
+   * the harness loop's own resume is wrapped, with the narrower trigger that
+   * applies to it — it makes real model calls, so it must not be left selecting a
+   * placeholder route.
+   * @param ownerCtx - caller context that owns load, setup, and the lifecycle.
+   * @param options - persisted identity, loop options, and setup.
+   * @returns the published handle.
+   */
+  async resume(ownerCtx, options) {
+    const recipe = recipeOf(ownerCtx, options);
+    const engine = hostedEngineOf(
+      await engineOfSession(this.ctx, options.resumeSessionId, this.records)
+    ) ?? await this.engineFor(void 0, options.parentAgent);
+    if (engine === "in-process") {
+      return this.adopt(engine, await super.resume(ownerCtx, this.engineOptions(options, engine)), recipe);
+    }
+    const handle = await this.runtimeOf(engine).resume(ownerCtx, options);
+    return this.adopt(engine, handle, recipe, handoverOf(handle));
   }
-  if (lastKept === entries.length - 1) out.push(...heading);
-  if (out.length > 0 && out[out.length - 1] !== "") out.push("");
-  return out.join("\n");
-}
-async function writeIfDifferent(path, text) {
-  try {
-    if (await readFile4(path, "utf8") === text) return false;
-  } catch {
+  /**
+   * Wrap the caller's setup so the session's ENGINE gets its model seat written
+   * before the host installs the session's selection, and hand a hosted engine
+   * the `agentOptions` that seat names.
+   *
+   * The wrap is what makes the write land at all: the host installs the session's
+   * model selection from INSIDE the caller's own setup
+   * (`ApiSessionAgentController.selectionFor`), and that read takes the log's
+   * pending `model/selection` — so the write has to happen before it, and the
+   * caller's setup has to run unchanged afterwards. Both of the router's engines
+   * are wrapped, each with its own trigger: the harness loop's build keeps the
+   * narrow one (only a session that would otherwise select a placeholder route),
+   * while a hosted engine's build is where a NEW session gets its seat. The
+   * resume path calls this with `in-process` alone (see {@link resume}).
+   *
+   * The `agentOptions` half keeps the two answers consistent: a hosted engine is
+   * handed the very selection written into the session (`external/default`), not
+   * the deployment default that seat replaced. In-process keeps the caller's own
+   * options, which ARE its route.
+   *
+   * The caller's setup is copied, never mutated: the same options object is the
+   * router's rebuild recipe, which replays the caller's own closure.
+   * @param options - the create or resume options the caller supplied.
+   * @param engine - the engine building this session.
+   * @returns a copy whose setup writes the seat first, then the caller's own.
+   */
+  engineOptions(options, engine) {
+    const setup = options.setup;
+    const guarded = async (agentCtx, agent) => {
+      this.selectionReset.guardFor(agent.session, engine);
+      return await setup?.(agentCtx, agent);
+    };
+    return {
+      ...options,
+      setup: guarded,
+      ...engine === "in-process" ? {} : { agentOptions: engineRouteOptions(engine) }
+    };
   }
-  await mkdir(dirname4(path), { recursive: true });
-  const tmp = `${path}.tmp-${randomUUID()}`;
-  await writeFile(tmp, text, "utf8");
-  await rename(tmp, path);
-  return true;
-}
-async function ensureHostedPreset(dshHome, source) {
-  const composition = await source.read(SOURCE_PRESET_ID);
-  const stripped = `${MANAGED_HEADER}
-${stripPresetRows(composition)}`;
-  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;
-}
-
-// src/provider-route.ts
-import { LlmAdapter, LlmError as LlmError5 } from "@deepseek-ai/dsh-llm";
-var HOSTED_PROVIDER_ROUTES = {
-  "claude-code": PROVIDER,
-  codex: PROVIDER2,
-  pi: PROVIDER3,
-  kimi: PROVIDER4
-};
-var HostedEngineRouteAdapter = class extends LlmAdapter {
   /**
-   * @param label - the provider route label this placeholder serves.
-   * @param options - optional catalog source; omit for an empty catalog.
+   * Report what one session ACTUALLY runs, and — when they differ — the engine
+   * its record names.
+   *
+   * This is the read the plugin's own Remote publishes, and the reason it is the
+   * router's to make is the live bookkeeping below: for a session with an agent
+   * this router built, {@link RouterLoop.live} says which engine built it, and
+   * that beats every record — it is what is running. A session this router does
+   * not drive (cold, or still on the base loop's slot during the mount window)
+   * has no live fact to report, so the record answers, exactly as it does for a
+   * session about to be built; and since every switch this plugin performs
+   * either swaps the agent in place or releases it, the two facts differ only
+   * for a release that did not take.
+   * @param sessionId - the session to report on.
+   * @returns the engine driving it now, plus the engine its record names for its
+   * next build when the two differ.
    */
-  constructor(label, options = {}) {
-    super();
-    this.label = label;
-    this.options = options;
+  async reportEngine(sessionId) {
+    return await engineReportOfSession(
+      this.ctx,
+      sessionId,
+      this.records,
+      (id) => this.live.get(id)?.engine
+    );
+  }
+  /**
+   * Move one live session to another engine.
+   *
+   * The one entry point that makes "switch this session's engine" possible after
+   * a session has started, which the harness's own preset channel refuses
+   * (`agent-preset/locked`, `packages/preset/agent-presets/src/index.ts`). The
+   * order below is load-bearing:
+   *
+   *  1. the checks, so a session that cannot be moved is refused with a reason
+   *     instead of half-moved;
+   *  2. the record, because it is the answer the router, the Remote, and the
+   *     host's next resolve all read — and a record that could not be written
+   *     must leave the session where it is;
+   *  3. the session's model seat, which moves with the choice
+   *     ({@link moveModelSelection}) — before the move below, because the move is
+   *     what detaches (or re-installs) the agent that reads it;
+   *  4. the move itself: an in-place swap between two hosted engines, or — when
+   *     the harness loop is on either side — a release of the session's agent
+   *     plus a request that the page reload (`reload: true`), which is what
+   *     makes the host build the session again on the recorded engine.
+   *
+   * A session already on the requested engine is recorded and left running: the
+   * record is the user's explicit choice, while tearing an untouched agent down
+   * would cost the session's rebuild for no change at all. "Already on" is
+   * judged on the LIVE AGENT's engine, not on the record: the two can differ
+   * while a released agent is still in flight, and then re-selecting the engine
+   * the session is actually running is how a user takes that record back — the
+   * record follows the agent back, and nothing is torn down.
+   * @param sessionId - the session to move.
+   * @param engine - the engine it should run.
+   * @returns the engine now recorded for it, whether the page must reload for it
+   *   to be built, or — as `ok: false` — the {@link LoopEngineRefusalCode} of the
+   *   branch that refused it plus its own sentence about this session. Every
+   *   refusal this method produces carries a code; the browser half localizes
+   *   from it and keeps the sentence as detail.
+   */
+  async selectEngine(sessionId, engine) {
+    const agent = this.ctx.agents.get(sessionId);
+    if (agent === void 0) {
+      return refuse2("session-closed", `session "${sessionId}" is not open; open it first, then switch its engine`);
+    }
+    if (agent.status === "running") {
+      return refuse2("turn-running", `session "${sessionId}" is running; switch its engine after this turn ends`);
+    }
+    if (agent.session.header.origin === "subagent") {
+      return refuse2("subagent-session", `session "${sessionId}" is a subagent session; its agent belongs to subagent routing`);
+    }
+    const entry = this.live.get(sessionId);
+    if (entry === void 0) {
+      return refuse2("not-driven", `session "${sessionId}" is not driven by this plugin's loop router`);
+    }
+    try {
+      this.records.record(sessionId, engine);
+    } catch (error) {
+      return refuse2("record-failed", `could not record the engine of session "${sessionId}": ${String(error)}`);
+    }
+    this.moveModelSelection(entry, engine);
+    if (entry.engine === engine) return { ok: true, engine };
+    return await this.move(entry, engine);
+  }
+  /**
+   * Make a just-recorded engine change take effect on the live session.
+   *
+   * Between two hosted engines the change is an IN-PLACE SWAP
+   * ({@link hotSwap}): the session's `Session` object is kept, its agent is
+   * replaced, and the browser half attached to that session sees no lifecycle
+   * edge at all.
+   *
+   * A change with the harness loop on EITHER side cannot be done in place, and
+   * this is a limit of the harness rather than a choice: `AgentLoop` neither
+   * hands a live session over nor accepts one it did not create. Its factory
+   * holds the session's store entry and write handle in private closure state
+   * (`agent-loop/src/index.ts` `prepare`), its publication enters the session
+   * (`sessions.enter`, which refuses an id already in the store), and its own
+   * agent class is not exported. So the session's agent is RELEASED instead
+   * ({@link release}) and the change lands on the session's next build, which
+   * the returned `reload: true` puts in the user's hands: the session goes cold
+   * with the record already naming its engine, and the page — reloaded, and
+   * reopening that session — is what makes the host resolve it again, on the
+   * engine the record names.
+   *
+   * The page really does have to reload, and that is the one cost of this path:
+   * a release emits `session/disposed`, and the browser half reads that as this
+   * session being gone, with no way back in that page's lifetime
+   * (`session.ts` `handleRemoved` sets a `removed` flag nothing ever clears), so
+   * a page that stayed put would show a session that can no longer be typed
+   * into. The alternative — leaving the live agent alone and letting the record
+   * wait for a process restart — is what this plugin used to do, and it cost the
+   * user a restart for a switch the host can perform itself.
+   * @param entry - the live session's record; the caller verified it is movable.
+   * @param engine - the engine just recorded for it.
+   * @returns the switch outcome, asking for the page reload that builds the
+   *   session again when its agent had to be released.
+   */
+  async move(entry, engine) {
+    const handover = entry.handover;
+    if (handover === void 0 || engine === "in-process") {
+      await this.release(entry);
+      return { ok: true, engine, reload: true };
+    }
+    return await this.hotSwap(entry, handover, engine);
+  }
+  /**
+   * Replace one live session's agent with a machine the incoming engine builds
+   * onto the SAME `Session`.
+   *
+   * The order is load-bearing. The outgoing machine is retired FIRST and
+   * completely: only one agent may be registered per session id (`agents.enter`
+   * refuses a duplicate), and two machines folded over one session's inbox would
+   * splice each other's queued messages, so the outgoing machine must be settled
+   * before any input can reach the successor. The SESSION is never released:
+   * its store entry and write handle travel in the lifetime the outgoing machine
+   * hands over, which is exactly why the page attached to this session stays
+   * usable across the swap.
+   *
+   * A failure after the handover cannot be undone — the outgoing machine is
+   * gone and the successor never published. The lifetime is then released, so
+   * the session goes cold and reopens on the recorded engine the way any session
+   * the host has not loaded does, and the refusal says what happened.
+   * @param entry - the live session's record; the caller verified it is movable.
+   * @param handover - the outgoing machine's session handover.
+   * @param engine - the hosted engine to build the successor on.
+   * @returns the switch outcome.
+   */
+  async hotSwap(entry, handover, engine) {
+    const sessionId = entry.agent.id;
+    try {
+      await handover.retire();
+    } catch (error) {
+      this.warn(`loop-engine: could not fully retire the ${entry.engine} agent of "${sessionId}" before switching it to ${engine}: ${String(error)}`);
+    }
+    try {
+      const handle = await this.runtimeOf(engine).swap(entry.recipe.ownerCtx, {
+        lifetime: handover.lifetime,
+        agentOptions: entry.recipe.agentOptions,
+        setup: entry.recipe.setup,
+        parentAgent: entry.recipe.parentAgent
+      });
+      this.adopt(engine, handle, entry.recipe, handoverOf(handle));
+      return { ok: true, engine };
+    } catch (error) {
+      this.forget(entry);
+      try {
+        await handover.lifetime.closeHandle();
+      } catch (closeFailure) {
+        this.warn(`loop-engine: could not close the write handle of session "${sessionId}" after a failed switch: ${String(closeFailure)}`);
+      }
+      handover.lifetime.leaveStore();
+      return refuse2("rebuild-failed", `could not rebuild session "${sessionId}" on ${engine}: ${String(error)}`);
+    }
+  }
+  /** Read the host session-projection registry, structurally. */
+  projections() {
+    return this.ctx.get("sessionProjections");
+  }
+  /**
+   * Drop one tracked session's agent so the host's next resolve rebuilds it.
+   *
+   * Two callers, and they both want the engine change to land at the session's
+   * next build rather than in place:
+   *
+   *  - {@link move}, the engine picker's path involving the harness loop, which
+   *    WAITS for the teardown (the outcome it is about to return says the
+   *    session is cold, and that must be true when it says so);
+   *  - the harness's own preset switch on a blank session, which fire-and-forgets
+   *    it because it runs inside a synchronous event handler. It is the one
+   *    engine change this plugin still makes by releasing the session rather
+   *    than by moving it: the successor's composition is the NEW preset's, which
+   *    only the API layer composes (a preset the harness mounted itself reaches
+   *    the plugin as an id, not as a composition callback), so the plugin cannot
+   *    build a correctly-composed successor in place.
+   *
+   * The record is forgotten before the teardown runs, so a teardown-driven event
+   * can never find the entry it is releasing and start a second teardown of the
+   * same agent; a failure is reported rather than thrown, and the returned
+   * promise settles either way.
+   * @param entry - the live session record to release.
+   * @returns the teardown, once it settled.
+   */
+  release(entry) {
+    this.forget(entry);
+    return entry.dispose().catch((error) => {
+      this.warn(`loop-engine: could not release the ${entry.engine} agent of "${entry.agent.id}": ${String(error)}`);
+    });
+  }
+  /**
+   * Follow the harness's own preset switch, for a BLANK session.
+   *
+   * The harness's preset switch on a blank session re-parents the live agent's
+   * scope and records the choice; it does not rebuild the agent, so the engine
+   * would keep running the one the session was created with. Dropping the agent
+   * instead lets the host's own next resolve fall back to a resume
+   * (`ApiSessionAgentController.resolve`), which composes from the recorded
+   * preset and lands on the new engine — the same path a reopened session
+   * takes, with the durable log as the only carry-over.
+   *
+   * LAST USER ACTION WINS: for a session this plugin already holds a record
+   * for, the harness's picker is an engine choice too, so the record follows it
+   * before the agent is released. Without that, the two entry points would
+   * contradict each other — the picker would rebuild the session on the preset's
+   * engine, while the very next resume would read the plugin's record and move
+   * it back. A session with NO record keeps reading its engine off the preset,
+   * exactly as before, and gets none: only an explicit choice is recorded.
+   *
+   * A session that has already run a turn is left alone — its live engine and
+   * its record both stay where they are, so the router and the Remote keep
+   * agreeing about it. (A started session cannot reach here through the
+   * harness's picker anyway: the roster refuses with `agent-preset/locked`.)
+   *
+   * The session's model seat moves with the choice, before the release
+   * ({@link moveModelSelection}) — the picker is an engine change like the
+   * picker's own switcher, and this is the one place the harness can make it.
+   */
+  rebuildOnEngineChange() {
+    this.ctx.on("agent-preset/selected", (sessionId, preset) => {
+      const entry = this.live.get(sessionId);
+      if (entry === void 0) return;
+      const next = engineOfPreset(preset) ?? "in-process";
+      if (next === entry.engine) return;
+      const boundary = this.projections().stateOf(entry.agent.session, "turnBoundary");
+      if (boundary !== void 0 && (boundary.openTurnStartSeq !== null || boundary.lastTurn > 0)) {
+        this.warn(`loop-engine: session "${sessionId}" has already started; its engine stays ${entry.engine}`);
+        return;
+      }
+      if (this.records.engineOf(sessionId) !== void 0) {
+        try {
+          this.records.record(sessionId, next);
+        } catch (error) {
+          this.warn(`loop-engine: could not record the engine of "${sessionId}": ${String(error)}`);
+        }
+      }
+      this.moveModelSelection(entry, next);
+      void this.release(entry);
+    });
   }
-  label;
-  options;
   /**
-   * Advertise the injected Pi models (if any) under this route's provider label.
+   * Hand one session's model seat to the engine it is being switched to.
+   *
+   * A session's selection follows its engine: a hosted engine owns its model
+   * natively and the shared provider label it logs is served only by this
+   * plugin's placeholder route (which fails loud, `HOSTED_ENGINE_ROUTE`, when a
+   * real model call reaches it), while the harness loop DOES make real calls and therefore needs
+   * a real model selected. So a switch moves the seat — the shared
+   * `external/default` for a hosted engine, the deployment default for the
+   * harness loop. A selection that
+   * names a real model of its own is never touched: the model notice the browser
+   * half shows beside a hosted engine says that selection is inert there, not
+   * that it is gone. The write itself, its judgements, and why an engine change
+   * with no logged selection writes nothing are in `model-selection-reset.ts`;
+   * this method is only the router's half.
    *
-   * 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.
+   * The selection is written at the moment of the switch, not at the moment the
+   * engine changes. Between two hosted engines the move is an in-place swap whose
+   * `setup` installs the selection onto the successor, and for anything involving
+   * the harness loop the switch releases the session's agent and the page reloads
+   * ({@link move}) — either way the write has to be in the log before the move
+   * runs, which is what this ordering buys.
+   * @param entry - the live session being switched.
+   * @param engine - the engine it is being switched to.
+   * @returns nothing; a selection this process cannot name is skipped with one
+   *   warning, and the session keeps what its log records.
    */
-  async listModels(_provider) {
-    const catalog = this.options.listModels?.() ?? [];
-    return catalog.map((entry) => ({
-      provider: this.label,
-      id: `${entry.provider}/${entry.model}`,
-      name: entry.model
-    }));
-  }
-  stream(_options) {
-    throw new LlmError5(
-      `provider "${this.label}" is a hosted loop engine route, not a model endpoint`,
-      "HOSTED_ENGINE_ROUTE"
-    );
+  moveModelSelection(entry, engine) {
+    this.selectionReset.resetFor(entry.agent.session, engine);
   }
 };
-
-// src/commands.ts
-import { readdirSync, readFileSync as readFileSync2 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-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) {
-  return (invocation) => {
-    invocation.agent.followup(createUserMessage6({
-      content: [{ type: "text", text: `/${name2}${invocation.rawInput}` }],
-      source: { kind: "user" }
-    }));
-    return { kind: "success" };
+function engineRouteOptions(engine) {
+  return { provider: hostedRouteLabelOf(engine), model: HOSTED_DEFAULT_MODEL };
+}
+function refuse2(code, reason) {
+  return { ok: false, code, reason };
+}
+function recipeOf(ownerCtx, options) {
+  return {
+    ownerCtx,
+    agentOptions: options.agentOptions ?? {},
+    setup: options.setup,
+    parentAgent: options.parentAgent
   };
 }
-function builtin2(name2, description) {
-  return { name: name2, description, handler: forwardClaudeCodeCommand(name2) };
+function handoverOf(handle) {
+  return { lifetime: handle.lifetime, retire: () => handle.retire() };
 }
-var CLAUDE_CODE_COMMANDS = [
-  builtin2("help", "Show help about Claude Code commands"),
-  builtin2("compact", "Compact the conversation to reduce context usage"),
-  builtin2("clear", "Clear the conversation and start fresh"),
-  builtin2("review", "Review recent changes (git diff)"),
-  builtin2("explain", "Explain the selected code"),
-  builtin2("fix", "Fix issues in the code"),
-  builtin2("tests", "Add tests for the selected code")
-];
-function discoverUserSlashCommands() {
-  let entries;
+
+// src/session-engine-store.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { dirname as dirname5, join as join13 } from "node:path";
+import { resolveDshHome } from "@deepseek-ai/dsh-home-paths";
+var ENGINE_RECORD_DIR = ".loop-engine";
+var ENGINE_RECORD_FILE = "engines.json";
+var ENGINE_RECORD_VERSION = 1;
+function resolveEngineRecordPath() {
+  return join13(resolveDshHome(), ENGINE_RECORD_DIR, ENGINE_RECORD_FILE);
+}
+function isMissing(error) {
+  return error?.code === "ENOENT";
+}
+function writeFileAtomicSync(path, text) {
+  mkdirSync2(dirname5(path), { recursive: true });
+  const tmp = `${path}.tmp-${randomUUID2()}`;
+  writeFileSync2(tmp, text, "utf8");
+  renameSync(tmp, path);
+}
+function parseEngineRecord(text) {
+  let parsed;
   try {
-    entries = readdirSync(userCommandsDir(), { encoding: "utf8" });
+    parsed = JSON.parse(text);
   } catch {
-    return [];
-  }
-  const definitions = [];
-  const seen = new Set(CLAUDE_CODE_COMMANDS.map((command) => command.name));
-  for (const entry of entries.sort()) {
-    if (!entry.endsWith(".md")) continue;
-    const name2 = entry.slice(0, -".md".length);
-    if (!COMMAND_NAME.test(name2) || seen.has(name2)) continue;
-    const path = join9(userCommandsDir(), entry);
-    let raw;
-    try {
-      raw = readFileSync2(path, "utf8");
-    } catch {
-      continue;
-    }
-    const description = commandDescription(raw);
-    if (description === void 0) continue;
-    seen.add(name2);
-    definitions.push({ name: name2, description, handler: forwardClaudeCodeCommand(name2) });
+    return void 0;
   }
-  return definitions;
-}
-function userCommandsDir() {
-  return join9(homedir4(), ".claude", "commands");
-}
-function commandDescription(raw) {
-  const trimmed = raw.trim();
-  if (trimmed.length === 0) return void 0;
-  let body = trimmed;
-  if (trimmed.startsWith("---\n")) {
-    const closing = trimmed.indexOf("\n---");
-    if (closing <= 0) return void 0;
-    for (const line of trimmed.slice(4, closing).split("\n")) {
-      const colon = line.indexOf(":");
-      if (colon < 0 || line.slice(0, colon).trim() !== "description") continue;
-      const value = line.slice(colon + 1).trim().replace(/^["']|["']$/g, "");
-      if (value.length > 0) return value;
-    }
-    body = trimmed.slice(closing + 4);
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+  const document = parsed;
+  const engines = document.engines;
+  if (document.version !== ENGINE_RECORD_VERSION || typeof engines !== "object" || engines === null || Array.isArray(engines)) {
+    return void 0;
   }
-  for (const line of body.split("\n")) {
-    const candidate = line.trim();
-    if (candidate.length === 0 || candidate.startsWith("#")) continue;
-    return candidate.length > 120 ? `${candidate.slice(0, 119)}\u2026` : candidate;
+  const entries = /* @__PURE__ */ new Map();
+  for (const [sessionId, engine] of Object.entries(engines)) {
+    if (isLoopEngineId(engine)) entries.set(sessionId, engine);
   }
-  return void 0;
+  return entries;
 }
-
-// src/engine-codex/skills.ts
-import { homedir as homedir5 } from "node:os";
-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 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) {
-    super(CODEX_SPEC, control);
+var SessionEngineStore = class {
+  /**
+   * @param path - the record document's absolute path.
+   * @param warn - diagnostic sink for a record this build cannot read.
+   */
+  constructor(path, warn) {
+    this.path = path;
+    this.warn = warn;
   }
-};
-
-// src/engine-pi/skills.ts
-import { homedir as homedir6 } from "node:os";
-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;
-var PI_SKILL_USER_RANK = 170;
-var PI_CONTEXT_POLICY = {
-  override: "AGENTS.override.md",
-  primary: ["AGENTS.md", "CLAUDE.md"]
-};
-function piAgentDir() {
-  const override = process.env.PI_CODING_AGENT_DIR;
-  if (override !== void 0 && override.length > 0) return resolve4(override);
-  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
+  path;
+  warn;
+  entries;
+  /**
+   * The engine this plugin's record names for one session.
+   * @param sessionId - the session to look up.
+   * @returns the recorded engine, or undefined when there is no usable record.
+   */
+  engineOf(sessionId) {
+    return this.load().get(String(sessionId));
   }
-};
-var PiSkillProvider = class extends AgentsMdSkillProvider {
-  constructor(control) {
-    super(PI_SPEC, control);
+  /**
+   * Record one session's engine, replacing any earlier record for it.
+   *
+   * The write commits before the in-memory view moves, so a caller that sees a
+   * rejection knows the store still answers what it answered before.
+   * @param sessionId - the session whose engine is recorded.
+   * @param engine - the engine that session now runs.
+   * @throws when the document could not be written; the previous file is intact.
+   */
+  record(sessionId, engine) {
+    const next = new Map(this.load());
+    next.set(String(sessionId), engine);
+    writeFileAtomicSync(this.path, formatEngineRecord(next));
+    this.entries = next;
+  }
+  /** The in-memory record, read from disk on first use. */
+  load() {
+    this.entries ??= this.read();
+    return this.entries;
+  }
+  /** Read the document once, degrading to an empty record. */
+  read() {
+    let text;
+    try {
+      text = readFileSync3(this.path, "utf8");
+    } catch (error) {
+      if (isMissing(error)) return /* @__PURE__ */ new Map();
+      return this.degrade(`could not read "${this.path}": ${String(error)}`);
+    }
+    return parseEngineRecord(text) ?? this.degrade(`"${this.path}" is not a version ${ENGINE_RECORD_VERSION} engine record`);
+  }
+  /**
+   * Report one unusable record and answer "no record".
+   *
+   * The load is memoized, so this runs at most once per store — once per process
+   * for a path — rather than once per lookup: a broken record costs one line, and
+   * the degraded view serves every later read.
+   * @param problem - what is wrong with the record, with the path.
+   * @returns the empty record.
+   */
+  degrade(problem) {
+    this.warn(`loop-engine: ${problem}; sessions without a record fall back to their agent preset`);
+    return /* @__PURE__ */ new Map();
   }
 };
+function formatEngineRecord(entries) {
+  return `${JSON.stringify({ version: ENGINE_RECORD_VERSION, engines: Object.fromEntries(entries) }, void 0, 2)}
+`;
+}
 
 // src/index.ts
 var name = "loop-engine";
 var inject = [];
-var MAX_MOUNT_ATTEMPTS = 40;
-var MOUNT_RETRY_MS = 50;
 var Config5 = z6.object({
   profile: z6.string(),
   patchFilename: z6.string(),
@@ -5964,48 +7342,46 @@ var Config5 = z6.object({
 });
 function resolvePatchPath(config) {
   if (config.patchPath !== void 0 && config.patchPath !== "") return config.patchPath;
-  return join12(
-    resolveDshHome(),
+  return join14(
+    resolveDshHome2(),
     "profiles",
     config.profile ?? "web",
     config.patchFilename ?? "cordis.patch.yml"
   );
 }
-function isMissing(error) {
+function isMissing2(error) {
   return error?.code === "ENOENT";
 }
 async function readPatchOrUndefined(path) {
   try {
     return await readFile5(path, "utf8");
   } catch (error) {
-    if (isMissing(error)) return void 0;
+    if (isMissing2(error)) return void 0;
     throw error;
   }
 }
 async function writePatchFile(path, text) {
-  await mkdir2(dirname5(path), { recursive: true });
-  const tmp = `${path}.tmp-${randomUUID2()}`;
+  await mkdir2(dirname6(path), { recursive: true });
+  const tmp = `${path}.tmp-${randomUUID3()}`;
   await writeFile2(tmp, text, "utf8");
   await rename2(tmp, path);
 }
 function writePatchFileSync(path, text) {
-  mkdirSync(dirname5(path), { recursive: true });
-  const tmp = `${path}.tmp-${randomUUID2()}`;
-  writeFileSync(tmp, text, "utf8");
-  renameSync(tmp, path);
+  writeFileAtomicSync(path, text);
 }
-async function syncManagedBlock(path, engine) {
+async function syncManagedBlock(path) {
   const current = await readPatchOrUndefined(path);
-  if (current !== void 0 && currentEngineOf(current) === engine) return false;
-  const next = applyManagedBlock(current ?? "", engine);
-  await writePatchFile(path, next);
+  if (current !== void 0 && hasManagedBlock(current) && !hasLegacyManagedBlock(current)) {
+    return false;
+  }
+  await writePatchFile(path, applyManagedBlock(current ?? ""));
   return true;
 }
 function readPatchFileSync(path) {
   try {
-    return readFileSync3(path, "utf8");
+    return readFileSync4(path, "utf8");
   } catch (error) {
-    if (isMissing(error)) return "";
+    if (isMissing2(error)) return "";
     throw error;
   }
 }
@@ -6045,51 +7421,37 @@ function kimiConfig(config) {
 function apply(ctx, config) {
   const patchPath = resolvePatchPath(config);
   const patchText = readPatchFileSync(patchPath);
-  let fileEngine = currentEngineOf(patchText);
-  if (hasManagedBlock(patchText) && managedBlockEngineOf(patchText) === void 0) {
+  const legacyEngine = legacyBlockEngineOf(patchText);
+  const needsWrite = hasLegacyManagedBlock(patchText) || !hasManagedBlock(patchText);
+  if (needsWrite) {
     try {
-      writePatchFileSync(patchPath, applyManagedBlock(patchText, "in-process"));
-      fileEngine = "in-process";
+      writePatchFileSync(patchPath, applyManagedBlock(patchText));
+    } catch (error) {
       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."
+        `loop-engine: could not write the managed block to "${patchPath}": ${String(error)}. The base agent loop still owns the factory slot; restart \`dsh web\` after fixing the path.`
       );
-    } 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;
+  const ROUTE_ATTEMPTS = 30;
+  const ROUTE_RETRY_MS = 100;
+  const ROUTER_ATTEMPTS = 40;
+  const ROUTER_RETRY_MS = 50;
+  let routerAttempts = 0;
+  let routerRetry;
+  const CLEAR_ROUTER_RETRY = () => {
+    if (routerRetry !== void 0) {
+      clearTimeout(routerRetry);
+      routerRetry = void 0;
+    }
+  };
   let disposed = false;
   const retryLater = (run, ms) => setTimeout(() => {
     if (!disposed) run();
   }, ms);
-  let commandDisposers;
-  let skillDisposer;
-  const piCatalogHolder = { entries: [] };
-  let mountAttempts = 0;
-  let mountRetry;
-  const CLEAR_RETRY = () => {
-    if (mountRetry !== void 0) {
-      clearTimeout(mountRetry);
-      mountRetry = void 0;
-    }
-  };
-  let savedPresetDefault;
-  let presetRetry;
-  const CLEAR_PRESET_RETRY = () => {
-    if (presetRetry !== void 0) {
-      clearTimeout(presetRetry);
-      presetRetry = void 0;
-    }
-  };
-  const ROUTE_ATTEMPTS = 30;
-  const ROUTE_RETRY_MS = 100;
-  let routeHandle;
-  let routeEngine;
+  let routeDisposers;
   let routeRetry;
   const CLEAR_ROUTE_RETRY = () => {
     if (routeRetry !== void 0) {
@@ -6097,38 +7459,65 @@ function apply(ctx, config) {
       routeRetry = void 0;
     }
   };
-  const releaseRoute = () => {
-    CLEAR_ROUTE_RETRY();
-    const handle = routeHandle;
-    routeHandle = void 0;
-    routeEngine = void 0;
-    handle?.();
-  };
-  const mountProviderRoute = (engine, attempt = 0) => {
-    if (engine === "in-process") return;
-    if (routeEngine === engine && routeHandle !== void 0) return;
+  const mountProviderRoutes = (attempt = 0) => {
     CLEAR_ROUTE_RETRY();
-    const label = HOSTED_PROVIDER_ROUTES[engine];
     const llm = ctx.get("llm");
     if (llm === void 0) {
       if (attempt < ROUTE_ATTEMPTS) {
-        routeRetry = retryLater(() => mountProviderRoute(engine, attempt + 1), ROUTE_RETRY_MS);
+        routeRetry = retryLater(() => mountProviderRoutes(attempt + 1), ROUTE_RETRY_MS);
       }
       return;
     }
+    const registered = [];
     try {
-      const options = engine === "pi" ? { listModels: () => piCatalogHolder.entries } : void 0;
-      routeHandle = llm.registerAdapter([label], new HostedEngineRouteAdapter(label, options));
-      routeEngine = engine;
+      registered.push(llm.registerAdapter([HOSTED_ROUTE_LABEL], new HostedEngineRouteAdapter()));
     } catch (error) {
       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;
+        ctx.logger.warn(`loop-engine: provider route "${HOSTED_ROUTE_LABEL}" is already served by another adapter`);
+      } else {
+        ctx.logger.error(`loop-engine: provider route "${HOSTED_ROUTE_LABEL}" registration failed: ${String(error)}`);
+      }
+    }
+    routeDisposers = registered;
+  };
+  const releaseRoutes = () => {
+    CLEAR_ROUTE_RETRY();
+    const disposers = routeDisposers;
+    routeDisposers = void 0;
+    for (const dispose of disposers ?? []) dispose();
+  };
+  let presetRetry;
+  let authorRetry;
+  const CLEAR_PRESET_RETRY = () => {
+    if (presetRetry !== void 0) {
+      clearTimeout(presetRetry);
+      presetRetry = void 0;
+    }
+  };
+  const CLEAR_AUTHOR_RETRY = () => {
+    if (authorRetry !== void 0) {
+      clearTimeout(authorRetry);
+      authorRetry = void 0;
+    }
+  };
+  const authorEnginePresets = (attempt = 0) => {
+    CLEAR_AUTHOR_RETRY();
+    const presets = ctx.get("agentPresets");
+    if (presets === void 0) {
+      if (attempt < PRESET_DEFAULT_ATTEMPTS) {
+        authorRetry = retryLater(() => authorEnginePresets(attempt + 1), PRESET_DEFAULT_RETRY_MS);
       }
-      ctx.logger.error(`loop-engine: provider route "${label}" registration failed: ${String(error)}`);
+      return void 0;
     }
+    const settled = authoring ??= ensureEnginePresets(resolveDshHome2(), presets).catch((error) => {
+      ctx.logger.error(`loop-engine: engine preset authoring failed: ${String(error)}`);
+      authoring = void 0;
+      return false;
+    });
+    return { presets, settled };
   };
+  let authoring;
   const mutatePresetDefault = (op, attempt = 0) => {
     const settings = ctx.get("settings");
     if (settings === void 0) return;
@@ -6148,198 +7537,107 @@ function apply(ctx, config) {
       ctx.logger.error(`loop-engine: preset default switch failed: ${String(error)}`);
     });
   };
-  const restorePresetDefault = (attempt = 0) => {
-    const presets = ctx.get("agentPresets");
-    if (presets === void 0) return;
-    if (presets.defaultId === HOSTED_PRESET_ID) {
-      const saved = savedPresetDefault;
-      savedPresetDefault = void 0;
-      mutatePresetDefault(saved === void 0 ? { op: "unset", path: ["default"] } : { op: "set", path: ["default"], value: saved });
-      return;
-    }
-    if (attempt < PRESET_DEFAULT_ATTEMPTS) {
-      presetRetry = retryLater(() => restorePresetDefault(attempt + 1), PRESET_DEFAULT_RETRY_MS);
-    }
-  };
+  let savedPresetDefault;
+  let steeredEngine;
   const steerPresetDefault = (engine) => {
-    const presets = ctx.get("agentPresets");
-    if (presets === void 0) return;
+    steeredEngine = engine;
     if (engine === "in-process") {
-      restorePresetDefault();
+      const saved = savedPresetDefault;
+      savedPresetDefault = void 0;
+      if (saved === void 0) return;
+      mutatePresetDefault({ op: "set", path: ["default"], value: saved });
       return;
     }
-    void (async () => {
-      try {
-        await ensureHostedPreset(resolveDshHome(), presets);
-      } catch (error) {
-        ctx.logger.error(`loop-engine: hosted preset authoring failed: ${String(error)}`);
-        return;
-      }
-      const current = presets.defaultId;
-      if (current === HOSTED_PRESET_ID) return;
-      savedPresetDefault = current;
-      mutatePresetDefault({ op: "set", path: ["default"], value: HOSTED_PRESET_ID });
-    })();
-  };
-  const cleanupEngineRegistrations = () => {
-    if (commandDisposers !== void 0) {
-      for (const dispose of commandDisposers) dispose();
-      commandDisposers = void 0;
-    }
-    if (skillDisposer !== void 0) {
-      skillDisposer();
-      skillDisposer = void 0;
-    }
-  };
-  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;
-      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 = 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)} \u2014 restart \`dsh web\` to release the factory slot`
-      );
+    const started = authorEnginePresets();
+    if (started === void 0) return;
+    void started.settled.then((authored) => {
+      if (!authored) return;
+      const current = started.presets.defaultId;
+      const target = enginePresetId(engine);
+      if (current === target) return;
+      if (!current.startsWith("loop-engine-")) savedPresetDefault = current;
+      mutatePresetDefault({ op: "set", path: ["default"], value: target });
     });
   };
-  const mountClaude = () => {
-    if (engineFiber !== void 0) return;
-    const commands = ctx.get("commands");
-    if (commands !== void 0) {
-      const disposers = [];
-      for (const command of [...CLAUDE_CODE_COMMANDS, ...discoverUserSlashCommands()]) {
-        try {
-          disposers.push(commands.register(command));
-        } catch (error) {
-          ctx.logger.warn(`loop-engine: skip claude-code command /${command.name}: ${String(error)}`);
-        }
-      }
-      commandDisposers = disposers;
-    }
-    const skills = ctx.get("skills");
-    if (skills !== void 0) {
-      skillDisposer = skills.registerProvider((control) => new ClaudeCodeSkillProvider(control));
-    }
-    hostFactory("claude-code", () => ctx.plugin(ClaudeCodeLoop, claudeCodeConfig(config)));
+  const seedEngine = legacyEngine ?? "in-process";
+  const pluginWarn = (message) => {
+    ctx.logger.warn(message);
   };
-  const mountCodex = () => {
-    const skills = ctx.get("skills");
-    if (skills !== void 0) {
-      skillDisposer = skills.registerProvider((control) => new CodexSkillProvider(control));
+  const engineRecords = new SessionEngineStore(resolveEngineRecordPath(), pluginWarn);
+  const routerHolder = { current: void 0 };
+  const buildEngine = (engineCtx, engine) => {
+    switch (engine) {
+      case "claude-code":
+        return new ClaudeCodeLoop(engineCtx, claudeCodeConfig(config));
+      case "codex":
+        return new CodexLoop(engineCtx, codexConfig(config));
+      case "pi":
+        return new PiLoop(engineCtx, piConfig(config));
+      case "kimi":
+        return new KimiLoop(engineCtx, kimiConfig(config));
     }
-    hostFactory("codex", () => ctx.plugin(CodexLoop, codexConfig(config)));
   };
-  const mountPi = () => {
-    const skills = ctx.get("skills");
-    if (skills !== void 0) {
-      skillDisposer = skills.registerProvider((control) => new PiSkillProvider(control));
-    }
-    hostFactory("pi", () => ctx.plugin(PiLoop, {
-      ...piConfig(config),
-      piCatalogHolder
-    }));
-  };
-  const mountKimi = () => {
-    const commands = ctx.get("commands");
-    if (commands !== void 0) {
-      const disposers = [];
-      for (const command of KIMI_COMMANDS) {
-        try {
-          disposers.push(commands.register(command));
-        } catch (error) {
-          ctx.logger.warn(`loop-engine: skip kimi command /${command.name}: ${String(error)}`);
+  const mountRouter = () => {
+    const fiber = ctx.inject(ROUTER_SERVICES, (routerCtx) => {
+      try {
+        const router = new RouterLoop(
+          routerCtx,
+          (engine) => buildEngine(routerCtx, engine),
+          engineRecords,
+          pluginWarn
+        );
+        routerHolder.current = router;
+      } catch (error) {
+        routerHolder.current = void 0;
+        if (ctx.get("agentLoop") !== void 0 && routerAttempts < ROUTER_ATTEMPTS) {
+          routerAttempts += 1;
+          routerRetry = retryLater(() => {
+            void Promise.resolve(fiber.dispose()).then(mountRouter, mountRouter);
+          }, ROUTER_RETRY_MS);
+          return;
         }
+        ctx.logger.error(`loop-engine: could not start the loop router: ${String(error)}`);
       }
-      commandDisposers = disposers;
-    }
-    const skills = ctx.get("skills");
-    if (skills !== void 0) {
-      skillDisposer = skills.registerProvider((control) => new KimiSkillProvider(control));
-    }
-    hostFactory("kimi", () => ctx.plugin(KimiLoop, kimiConfig(config)));
-  };
-  const mountEngine = (engine) => {
-    mountProviderRoute(engine);
-    if (engine === "claude-code") mountClaude();
-    else if (engine === "codex") mountCodex();
-    else if (engine === "pi") mountPi();
-    else if (engine === "kimi") mountKimi();
+    });
   };
-  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) => {
-        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
+  mountRouter();
+  const mountEngineRemote = () => {
+    new LoopEngineRemote(
+      ctx,
+      (sessionId) => engineOfSession(ctx, sessionId, engineRecords),
+      routerHolder,
+      pluginWarn
     );
   };
-  mountEngine(fileEngine);
-  steerPresetDefault(fileEngine);
+  mountEngineRemote();
+  mountProviderRoutes();
+  authorEnginePresets();
   ctx.effect(() => () => {
     disposed = true;
-    CLEAR_RETRY();
+    CLEAR_ROUTE_RETRY();
     CLEAR_PRESET_RETRY();
-    releaseRoute();
-  }, "loop-engine: retry cleanup");
+    CLEAR_AUTHOR_RETRY();
+    CLEAR_ROUTER_RETRY();
+    releaseRoutes();
+  }, "loop-engine: cleanup");
   let source;
   ctx.inject(["settings"], (settingsCtx) => {
-    settingsCtx.settings.installSection(ctx, loopEngineSettingsNamespace(), LOOP_ENGINE_SETTINGS_SCHEMA, { engine: fileEngine, showInComposer: true }, {
-      setSource: (current) => {
-        source = current;
-      },
-      onChange: () => {
-        const next = source().engine;
-        if (next === fileEngine) return;
-        try {
-          const updated = applyManagedBlock(readPatchFileSync(patchPath), next);
-          writePatchFileSync(patchPath, updated);
-        } 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);
+    settingsCtx.settings.installSection(
+      ctx,
+      loopEngineSettingsNamespace(),
+      LOOP_ENGINE_SETTINGS_SCHEMA,
+      { engine: seedEngine, showInComposer: true },
+      {
+        setSource: (current) => {
+          source = current;
+        },
+        onChange: () => {
+          const next = source().engine;
+          if (next === steeredEngine) return;
+          steerPresetDefault(next);
         }
-        steerPresetDefault(next);
       }
-    });
+    );
   });
 }
 export {