dsh-loop-engine 0.1.5-rc4 → 0.1.7-rc1

package/lib/index.js

@@ -395,21 +395,30 @@ function renderAssistantBlocks(blocks) {
   }
   return sections.join("\n\n");
 }
-function renderToolResult(message) {
-  const block = message.content[0];
-  const body = block.content.map((child) => {
-    switch (child.type) {
+function renderTextBlocks(blocks) {
+  return blocks.map((block) => {
+    switch (block.type) {
       case "text":
-        return child.text;
+        return block.text;
       case "image":
         return OMITTED_IMAGE_TEXT;
       default:
         return "";
     }
   }).filter((section) => section !== "").join("\n\n");
-  const tag = block.isError === true ? "tool-result-error" : "tool-result";
+}
+function renderToolResult(blocks, isError) {
+  const body = renderTextBlocks(blocks);
+  const tag = isError === true ? "tool-result-error" : "tool-result";
   return frame(tag, body || "(no content)");
 }
+function renderModernToolResult(message) {
+  return renderToolResult(message.content, message.isError);
+}
+function renderLegacyToolResult(message) {
+  const block = message.content[0];
+  return renderToolResult(block?.content ?? [], block?.isError);
+}
 var ENGINE_SLASH_LINE = /^\/[^\s/]+(?:[ \t]+.*)?$/;
 function engineSlashPrompt(messages) {
   const last = messages.at(-1);
@@ -433,24 +442,18 @@ function serializeHistory(messages) {
         break;
       }
       case "user": {
-        const user = message;
-        if (user.source.kind === "tool") {
-          sections.push(renderToolResult(user));
+        if (message.source.kind === "tool") {
+          sections.push(renderLegacyToolResult(message));
         } else {
-          const body = user.content.map((block) => {
-            switch (block.type) {
-              case "text":
-                return block.text;
-              case "image":
-                return OMITTED_IMAGE_TEXT;
-              default:
-                return "";
-            }
-          }).filter((section) => section !== "").join("\n\n");
+          const body = renderTextBlocks(message.content);
           sections.push(frame("user", body || "(no content)"));
         }
         break;
       }
+      case "tool": {
+        sections.push(renderModernToolResult(message));
+        break;
+      }
       default:
         break;
     }
@@ -624,6 +627,29 @@ var DriverInbox = class {
   }
 };
 
+// src/driver-core/system-head.ts
+import { createSystemMessage } from "@deepseek-ai/dsh-llm";
+
+// src/compat.ts
+import * as dshSettings from "@deepseek-ai/dsh-settings";
+var LEGACY_HARNESS = "SettingsProvider" in dshSettings;
+
+// src/driver-core/system-head.ts
+var SURFACE_TYPES = /* @__PURE__ */ new Set([
+  "system/message",
+  "user/message",
+  "developer/message",
+  "assistant/message",
+  "tool/result"
+]);
+function appendSystemHeadIfMissing(session, turn, step) {
+  if (LEGACY_HARNESS) return;
+  for (const event of session.snapshotEvents()) {
+    if (SURFACE_TYPES.has(event.type) && event.surfaceOp !== void 0) return;
+  }
+  session.append("system/message", { turn, step, message: createSystemMessage("") }, { surfaceOp: "append" });
+}
+
 // src/provider-route.ts
 import { LlmAdapter, LlmError } from "@deepseek-ai/dsh-llm";
 function hostedRouteLabelOf(_engine) {
@@ -685,6 +711,9 @@ function sessionModelOverrideOf(ctx, session) {
 }
 
 // src/driver-core/model-handover.ts
+var SHIPPED_ROUTE_APIS = {
+  "deepseek-official": "openai-completions"
+};
 var warned = /* @__PURE__ */ new WeakMap();
 function warnOnce(ctx, key, message) {
   let seen = warned.get(ctx);
@@ -711,10 +740,9 @@ function readProviderProfile(ctx, address) {
   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,
+    api: typeof api === "string" && api.length > 0 ? api : void 0,
     apiKeyEnv: typeof apiKeyEnv === "string" && apiKeyEnv.length > 0 ? apiKeyEnv : void 0
   };
 }
@@ -734,7 +762,7 @@ async function resolveModelHandover(ctx, override) {
   }
   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`);
+    return refuse(ctx, override, `the "${address.settingsNs}" settings section names no baseURL for it`);
   }
   const apiKey = await readApiKey(ctx, profile.apiKeyEnv);
   if (apiKey === void 0) {
@@ -744,7 +772,7 @@ async function resolveModelHandover(ctx, override) {
     provider: override.provider,
     model: override.model,
     baseURL: profile.baseURL,
-    api: profile.api,
+    api: profile.api ?? SHIPPED_ROUTE_APIS[override.provider],
     apiKey
   };
 }
@@ -1506,6 +1534,7 @@ var ClaudeCodeAgent = class {
         this.session.append("step/start", { turn, step });
         phase.step = step;
         try {
+          appendSystemHeadIfMissing(this.session, turn, step);
           for (const message of decision.messages) {
             this.session.append("user/message", message, { surfaceOp: "append" });
           }
@@ -2035,16 +2064,21 @@ var HostedEngineRuntime = class {
       return {
         agent,
         signal: abort.signal,
-        publish: (source) => {
+        publish: async (source) => {
           assertLive();
           const joining = lifetime.entered;
           if (!joining) lifetime.bind(agent.ctx.sessions.enter(session));
           detachAgent = loopCtx.agents.enter(agent, parentAgent);
           if (!joining) agent.ctx.sessions.announce(session);
           assertLive();
-          loopCtx.agents.announce(agent);
-          assertLive();
-          emitAgentEvent(loopCtx, agent, "agent/session-start", { source });
+          if (LEGACY_HARNESS) {
+            ;
+            loopCtx.agents.announce(agent);
+            assertLive();
+            emitAgentEvent(loopCtx, agent, "agent/session-start", { source });
+          } else {
+            await loopCtx.agents.announce(agent, source, abort.signal);
+          }
           assertLive();
           return { agent, dispose, retire, lifetime };
         },
@@ -2333,15 +2367,15 @@ import { canonicalHeader as canonicalHeader2 } from "@deepseek-ai/dsh-session";
 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"
+  "openai-responses": "responses"
 };
 function tomlString(value) {
   return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
 }
 function codexModelConfig(handover) {
-  const wire = CODEX_WIRE_APIS[handover.api];
+  const wire = handover.api === void 0 ? void 0 : CODEX_WIRE_APIS[handover.api];
   const profile = [
+    `name=${tomlString(CODEX_DSH_PROVIDER)}`,
     `base_url=${tomlString(handover.baseURL)}`,
     ...wire === void 0 ? [] : [`wire_api=${tomlString(wire)}`],
     `env_key=${tomlString(CODEX_DSH_API_KEY_ENV)}`
@@ -2911,6 +2945,7 @@ var CodexAgent = class {
     this.session.append("step/end", { turn: phase.turn, step: phase.step });
     phase.step += 1;
     this.session.append("step/start", { turn: phase.turn, step: phase.step });
+    appendSystemHeadIfMissing(this.session, phase.turn, phase.step);
     this.stepSettledTools = 0;
   }
   /** Lazily created app-server client, reused across steps and released on scope teardown. */
@@ -3962,6 +3997,7 @@ var PiAgent = class {
     this.session.append("step/end", { turn: phase.turn, step: phase.step });
     phase.step += 1;
     this.session.append("step/start", { turn: phase.turn, step: phase.step });
+    appendSystemHeadIfMissing(this.session, phase.turn, phase.step);
     this.stepSettledTools = 0;
   }
   /**
@@ -4325,10 +4361,11 @@ var PiAgent = class {
     }
     this.assertRequestHeader();
     signal.throwIfAborted();
-    const handover = await resolveModelHandover(
+    const resolved = await resolveModelHandover(
       this.loopCtx,
       sessionModelOverrideOf(this.loopCtx, this.session)
     );
+    const handover = resolved?.api === void 0 ? void 0 : resolved;
     const controller = new AbortController();
     const cancel = () => {
       if (!controller.signal.aborted) {
@@ -4685,7 +4722,7 @@ var KIMI_PROVIDER_TYPES = {
   "openai-responses": "openai"
 };
 function kimiModelEnv(handover) {
-  const type = KIMI_PROVIDER_TYPES[handover.api];
+  const type = handover.api === void 0 ? void 0 : KIMI_PROVIDER_TYPES[handover.api];
   return {
     KIMI_MODEL_NAME: handover.model,
     KIMI_MODEL_API_KEY: handover.apiKey,
@@ -5296,6 +5333,7 @@ var KimiAgent = class {
         this.session.append("step/start", { turn, step });
         phase.step = step;
         try {
+          appendSystemHeadIfMissing(this.session, turn, step);
           for (const message of decision.messages) {
             this.session.append("user/message", message, { surfaceOp: "append" });
           }
@@ -5690,7 +5728,7 @@ var KimiLoop = class extends HostedEngineRuntime {
 import z5 from "@deepseek-ai/schemastery";
 
 // src/namespace.ts
-var LOOP_ENGINE_SETTINGS_NAMESPACE_LITERAL = "agent-loop-engine";
+var LEGACY_LOOP_ENGINE_SETTINGS_NAMESPACE_LITERAL = "agent-loop-engine";
 
 // src/settings.ts
 var LOOP_ENGINE_SETTINGS_SCHEMA = z5.object({
@@ -5698,8 +5736,16 @@ var LOOP_ENGINE_SETTINGS_SCHEMA = z5.object({
   showInComposer: z5.boolean().default(true)
 });
 function loopEngineSettingsNamespace() {
-  return LOOP_ENGINE_SETTINGS_NAMESPACE_LITERAL;
+  return LEGACY_LOOP_ENGINE_SETTINGS_NAMESPACE_LITERAL;
+}
+function withVolatile(schema) {
+  const volatile = schema.volatile;
+  return volatile === void 0 ? schema : volatile.call(schema);
 }
+var LOOP_ENGINE_ENGINE_SCHEMA = withVolatile(
+  z5.union(LOOP_ENGINE_IDS.map((id) => z5.const(id))).default("in-process")
+);
+var LOOP_ENGINE_SHOW_IN_COMPOSER_SCHEMA = withVolatile(z5.boolean().default(true));
 
 // src/patch-manager.ts
 var MANAGED_BLOCK_BEGIN = "# -- dsh-loop-engine managed block --";
@@ -5838,8 +5884,13 @@ async function writeIfDifferent(path, text) {
   await rename(tmp, path);
   return true;
 }
+async function readComposition(source, id) {
+  if (source.readDocument !== void 0) return (await source.readDocument(id)).content;
+  if (source.read !== void 0) return source.read(id);
+  throw new Error("loop-engine: the preset roster exposes neither readDocument() nor read()");
+}
 async function ensureEnginePresets(dshHome, source) {
-  const composition = await source.read(SOURCE_PRESET_ID);
+  const composition = await readComposition(source, SOURCE_PRESET_ID);
   const stripped = `${MANAGED_HEADER}
 ${stripPresetRows(composition)}`;
   let changed = false;
@@ -5853,7 +5904,7 @@ ${stripPresetRows(composition)}`;
 }
 
 // src/router-loop.ts
-import AgentLoop from "@deepseek-ai/dsh-agent-loop";
+import AgentLoop, { DEFAULT_MAX_PARALLEL_TOOL_CALLS } from "@deepseek-ai/dsh-agent-loop";
 
 // src/model-selection-reset.ts
 var AGENT_DEFAULT_MODEL_NS = "agent-default-model";
@@ -6754,7 +6805,10 @@ var RouterLoop = class extends AgentLoop {
    * @param warn - diagnostic sink for a skipped engine command.
    */
   constructor(ctx, build, records, warn) {
-    super(ctx, { agents: [] });
+    super(ctx, LEGACY_HARNESS ? { agents: [] } : {
+      agents: [],
+      maxParallelToolCalls: { get: () => DEFAULT_MAX_PARALLEL_TOOL_CALLS }
+    });
     this.build = build;
     this.records = records;
     this.warn = warn;
@@ -7338,7 +7392,13 @@ var Config5 = z6.object({
   approvalPolicy: z6.union(CODEX_APPROVAL_POLICIES.map((policy) => z6.const(policy))),
   piProvider: z6.string(),
   piThinking: z6.string(),
-  kimiBin: z6.string()
+  kimiBin: z6.string(),
+  // The live fields exist only on the 0.1.7 line; the 0.1.5 line carries the
+  // selection in a settings section instead. The empty arm never runs when the
+  // coverage job is on 0.1.7; the 0.1.5 dep set is exercised by
+  // vitest.config.compat015.ts, which takes it.
+  /* v8 ignore next -- legacy arm, exercised by vitest.config.compat015.ts */
+  ...LEGACY_HARNESS ? {} : { engine: LOOP_ENGINE_ENGINE_SCHEMA, showInComposer: LOOP_ENGINE_SHOW_IN_COMPOSER_SCHEMA }
 });
 function resolvePatchPath(config) {
   if (config.patchPath !== void 0 && config.patchPath !== "") return config.patchPath;
@@ -7538,9 +7598,7 @@ function apply(ctx, config) {
     });
   };
   let savedPresetDefault;
-  let steeredEngine;
   const steerPresetDefault = (engine) => {
-    steeredEngine = engine;
     if (engine === "in-process") {
       const saved = savedPresetDefault;
       savedPresetDefault = void 0;
@@ -7559,7 +7617,6 @@ function apply(ctx, config) {
       mutatePresetDefault({ op: "set", path: ["default"], value: target });
     });
   };
-  const seedEngine = legacyEngine ?? "in-process";
   const pluginWarn = (message) => {
     ctx.logger.warn(message);
   };
@@ -7620,25 +7677,47 @@ function apply(ctx, config) {
     CLEAR_ROUTER_RETRY();
     releaseRoutes();
   }, "loop-engine: cleanup");
-  let source;
-  ctx.inject(["settings"], (settingsCtx) => {
-    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);
+  if (LEGACY_HARNESS) {
+    let source;
+    let steered;
+    ctx.inject(["settings"], (settingsCtx) => {
+      const settings = settingsCtx.settings;
+      settings.installSection(
+        ctx,
+        loopEngineSettingsNamespace(),
+        LOOP_ENGINE_SETTINGS_SCHEMA,
+        // The managed block's engine survives the upgrade as the section's seed;
+        // a deployment with no block keeps the in-process default.
+        { engine: legacyEngine ?? "in-process", showInComposer: true },
+        {
+          setSource: (current) => {
+            source = current;
+          },
+          onChange: () => {
+            const next = source().engine;
+            if (next === steered) return;
+            steered = next;
+            steerPresetDefault(next);
+          }
         }
-      }
+      );
+    });
+    return;
+  }
+  ctx.inject(["settings"], (settingsCtx) => {
+    settingsCtx.effect(
+      () => settingsCtx.settings.configure({ auto: false }, ctx.fiber),
+      "loop-engine: settings page policy"
     );
   });
+  let observedEngine = config.engine.get();
+  ctx.on("settings/document-updated", () => {
+    const next = config.engine.get();
+    if (next === observedEngine) return;
+    observedEngine = next;
+    steerPresetDefault(next);
+  });
+  steerPresetDefault(legacyEngine ?? observedEngine);
 }
 export {
   Config5 as Config,

package/lib/invariant.js

@@ -12,6 +12,14 @@ var LOOP_ENGINE_SETTINGS_SCHEMA = z.object({
   engine: z.union(LOOP_ENGINE_IDS.map((id) => z.const(id))).default("in-process"),
   showInComposer: z.boolean().default(true)
 });
+function withVolatile(schema) {
+  const volatile = schema.volatile;
+  return volatile === void 0 ? schema : volatile.call(schema);
+}
+var LOOP_ENGINE_ENGINE_SCHEMA = withVolatile(
+  z.union(LOOP_ENGINE_IDS.map((id) => z.const(id))).default("in-process")
+);
+var LOOP_ENGINE_SHOW_IN_COMPOSER_SCHEMA = withVolatile(z.boolean().default(true));
 
 // src/patch-manager.ts
 var MANAGED_BLOCK_BEGIN = "# -- dsh-loop-engine managed block --";

package/lib/types/client/index.d.ts

@@ -1,7 +1,12 @@
 /**
- * Loop engine settings plugin, browser half. Registers the "Loop engine"
- * page under the settings section slot once the settings shell declares it,
- * binding one store to the duplicated `agent-loop-engine` settings scope.
+ * Loop engine settings plugin, browser half. Registers the "Loop engine" page
+ * under the settings section slot and binds one store to whichever settings
+ * client the running harness serves: the 0.1.7 `configForms` form for the
+ * plugin's own `loop-engine` profile entry, or the 0.1.5 `settingsScope` for its
+ * `agent-loop-engine` settings section. Two inject callbacks register the page,
+ * one per generation — whichever service exists fires, and the client bundle
+ * never imports a host package, so it cannot probe the generation like the node
+ * half does.
  * Export discipline: packages/client/AGENTS.md.
  * @module dsh-loop-engine/client
  */
@@ -17,12 +22,17 @@ declare module '@deepseek-ai/dsh-client-ui-slots' {
         'settings.loop-engine': LoopEngineKey;
     }
 }
-/** Required services (cordis fiber inject). The target slot is declared by
- * ui-settings' apply; registration depends on it through `slots.inject()`. */
+/**
+ * Required services (cordis fiber inject). Only the services BOTH generations
+ * provide are listed statically: `configForms` (0.1.7) and `settingsScope`
+ * (0.1.5) are mutually exclusive, so each is injected inside its own callback
+ * rather than named here. The target slot is declared by ui-settings' apply;
+ * registration depends on it through `slots.inject()`.
+ */
 export declare const inject: string[];
 /**
  * Register the Loop engine section once the `settings.section` declaration is
- * on the ledger and bind its store to the duplicated settings scope.
+ * on the ledger and bind its store to whichever settings client is present.
  * @param ctx - client root context.
  */
 export declare function apply(ctx: ClientContext): void;

package/lib/types/client/session-engine.d.ts

@@ -82,8 +82,9 @@ export type { SessionEngineReport } from '../agent-preset-ids.ts';
 /**
  * The standard seat members this half reads off a session-scope slot.
  *
- * Only the identity: the engine itself is no longer read from a framework hook,
- * it is asked of the host through this plugin's own Remote.
+ * The identity, plus the one live fact the turn-status row needs: whether the
+ * session is mid-turn. The engine itself is no longer read from a framework
+ * hook, it is asked of the host through this plugin's own Remote.
  */
 export interface SessionSeat {
     /**
@@ -92,6 +93,23 @@ export interface SessionSeat {
      * (which only ever renders with a session) shows nothing.
      */
     sessionId?: string;
+    /**
+     * Selector hook over the current Session's snapshot (`SessionStandardProps` of
+     * every session-scoped seat). Optional for the same reason as the identity: a
+     * caller with no such seat — or a test rendering one directly — has none, and
+     * the turn-status gate is then left alone rather than guessed.
+     */
+    useSession?: SnapshotSelector;
+}
+/**
+ * The selector-hook shape this half needs from `useSession`: a read of one field
+ * of the Session snapshot, with no equality function of its own.
+ */
+export type SnapshotSelector = <S>(select: (snapshot: SessionRunningState) => S) => S;
+/** The one field of the Session snapshot the turn-status row reads. */
+export interface SessionRunningState {
+    /** Whether a turn is in flight for this session. */
+    readonly running: boolean;
 }
 /** Cordis service key AND wire namespace of the plugin's own Remote. */
 export declare const LOOP_ENGINE_REMOTE_NAMESPACE = "loopEngine";
@@ -239,14 +257,30 @@ export declare function engineSwitchReady(report: SessionEngineReport | undefine
  * this page.
  */
 export declare function switchNeedsReload(current: SessionEngine, target: LoopEngineId): boolean;
-/** A codec of one wire field (harness: `TypertCodec`, strict branch). */
+/** One boundary schema of a wire field (a zod schema, as the Gateway holds it). */
+interface RemoteSchema {
+    parse(value: unknown): unknown;
+}
+/**
+ * A codec of one wire field (harness: `TypertCodec`, strict branch).
+ *
+ * The two harness generations read DIFFERENT members of this object and each
+ * validates only its own: the 0.1.5 line's registry and client parse through
+ * `schema`, while the 0.1.7 line's registry requires a `create()` factory and
+ * parses through `codec.create()` (`typert: … strict codec has no create()
+ * factory`). One build serves both, so the codec carries both fields.
+ */
 interface RemoteCodec {
     readonly mode: 'strict';
     /** Stable identity of the field's declared type, for diagnostics. */
     readonly typeSymbol: string;
-    readonly schema: {
-        parse(value: unknown): unknown;
-    };
+    /** The 0.1.5 line's read: the boundary schema itself. */
+    readonly schema: RemoteSchema;
+    /**
+     * The 0.1.7 line's read: a factory returning the boundary schema.
+     * @returns the same boundary schema.
+     */
+    readonly create: () => RemoteSchema;
 }
 /** One ordered business parameter (harness: `InvocationParameterDescriptor`). */
 interface RemoteParameter {

package/lib/types/client/store.d.ts

@@ -1,11 +1,14 @@
 /**
- * Loop engine selection store: the durable settings scope is the transport,
- * and the store publishes a render-safe snapshot plus the write path.
+ * Loop engine selection store: a settings transport is the channel, and the
+ * store publishes a render-safe snapshot plus the write path. The transport is
+ * abstracted so one store follows either generation's client service — the
+ * 0.1.7 `ConfigForm` for the plugin's own profile entry, or the 0.1.5
+ * `SettingsScope` for its `agent-loop-engine` settings section.
  * @module dsh-loop-engine/client/store
  */
-import type { SettingsScope } from '@deepseek-ai/dsh-client-ui-settings/client';
 import type { SnapshotStore } from '@deepseek-ai/dsh-client-store';
 import type { LoopEngineId } from '../agent-preset-ids.ts';
+import type { LoopEngineSettings } from '../settings.ts';
 /** State rendered by the loop engine section. */
 export interface LoopEngineState {
     status: 'loading' | 'ready' | 'unavailable' | 'saving';
@@ -14,44 +17,76 @@ export interface LoopEngineState {
     writable: boolean;
     error: string | null;
 }
-/** Narrow a wire section to the stored engine id and display toggle; an invalid one reads default. */
+/** The render-relevant slice of a settings snapshot, shared by both generations' transports. */
+export interface LoopEngineSettingsSnapshot {
+    status: 'loading' | 'ready' | 'unavailable';
+    value: LoopEngineSettings | undefined;
+    writable: boolean;
+}
+/**
+ * The settings channel the store follows. Satisfied by the 0.1.7 `ConfigForm`
+ * and by the 0.1.5 `SettingsScope` (through a thin adapter in `./index.ts`); the
+ * write's boolean is optional because the 0.1.5 scope reports acceptance only
+ * through the snapshot it leaves behind.
+ */
+export interface LoopEngineSettingsTransport {
+    /** @returns the current sync snapshot. */
+    getSnapshot(): LoopEngineSettingsSnapshot;
+    /**
+     * Observe snapshot replacements.
+     * @param listener - invoked after each snapshot change.
+     * @returns the disposer removing the listener.
+     */
+    subscribe(listener: () => void): () => void;
+    /**
+     * Persist one field.
+     * @param field - the field to write.
+     * @param value - the value to write.
+     * @returns whether the write was accepted, when the transport reports it.
+     */
+    set(field: 'engine' | 'showInComposer', value: unknown): Promise<boolean | void>;
+}
+/**
+ * Narrow a wire section to the stored engine id and display toggle; an invalid
+ * one reads default. Used by the 0.1.5 `settingsScope.bind` decoder, whose scope
+ * receives raw wire sections.
+ * @param section - the wire section value.
+ * @returns the decoded selection, or `undefined` when the section is unusable.
+ */
 export declare function decodeLoopEngine(section: unknown): {
     engine: LoopEngineId;
     showInComposer: boolean;
 } | undefined;
 /** Coordinates the settings-backed loop engine selection. */
 export declare class LoopEngineStore {
-    private readonly scope;
+    private readonly transport;
     /** uSES-safe state source shared by the registered settings section. */
     readonly store: SnapshotStore<LoopEngineState>;
     private following;
     private saving;
     /**
-     * @param scope - the loop engine settings namespace scope.
+     * @param transport - the settings channel the store follows.
      */
-    constructor(scope: SettingsScope<{
-        engine: LoopEngineId;
-        showInComposer: boolean;
-    }>);
-    /** Begin following the bound scope and publish its current answer. */
+    constructor(transport: LoopEngineSettingsTransport);
+    /** Begin following the transport and publish its current answer. */
     load(): void;
     /**
-     * Persist the selected engine. Success is judged against the snapshot the
-     * write left behind, so a refused write reports error after its recovery.
+     * Persist the selected engine. Success is the transport's accepted answer
+     * (when it reports one) checked against the snapshot the write left behind,
+     * so a refused write reports error after its recovery.
      * @param engine - the engine to select for future Agent turns.
      * @returns whether the write landed.
      */
     setEngine(engine: LoopEngineId): Promise<boolean>;
     /**
-     * Persist whether the composer shows the engine picker. Success is judged
-     * against the snapshot the write left behind, so a refused write reports
-     * error after its recovery. Unlike {@link setEngine}, landing does not reload
-     * the page — the toggle only changes composer visibility.
+     * Persist whether the composer shows the engine picker. Unlike
+     * {@link setEngine}, landing does not reload the page — the toggle only
+     * changes composer visibility.
      * @param show - whether the chat page composer reveals the engine picker.
      * @returns whether the write landed.
      */
     setShowInComposer(show: boolean): Promise<boolean>;
-    /** Stop following the scope. */
+    /** Stop following the transport. */
     dispose(): void;
     private derive;
 }