dsh-loop-engine 0.1.5-rc5 → 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) {
@@ -1508,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" });
           }
@@ -2037,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 };
         },
@@ -2913,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. */
@@ -3964,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;
   }
   /**
@@ -5299,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" });
           }
@@ -5693,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({
@@ -5701,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 --";
@@ -5841,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;
@@ -5856,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";
@@ -6757,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;
@@ -7341,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;
@@ -7541,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;
@@ -7562,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);
   };
@@ -7623,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;
 }

package/lib/types/client/turn-status.d.ts

@@ -20,8 +20,8 @@
  * default, a session running pi included.
  *
  * The reflection's SUBJECT is still a document-level attribute rather than the
- * row's own element: the sheet has to reach a class the harness hashes
- * (`[class$="_turnStatus"]`), which takes an attribute selector on an ancestor,
+ * row's own element: the sheet has to reach a class the harness hashes (see
+ * {@link ROW_SELECTORS}), which takes an attribute selector on an ancestor,
  * and the row offers no session-scoped hook for a plugin to hang it on. A
  * document-level attribute has exactly ONE owner at a time, though — and on this
  * page the WRITERS outnumber the reader: the chip and the composer of every
@@ -47,10 +47,24 @@
  * paints by it, and a leftover attribute is inert on a page whose turn-status row
  * is not rendered.
  *
+ * The paint is also gated on the session being MID-TURN, through a second
+ * document-level attribute ({@link RUNNING_ATTR}, written from the same
+ * reflection). On the 0.1.5 line the row only exists while a turn is in flight,
+ * so the engine attribute alone was enough; on the 0.1.7 line that same button
+ * stays on screen after the turn ends, as the collapsed summary that reads
+ * "用时 4秒" — an engine-only gate leaves the glyph and the sweep animating on a
+ * finished turn, which is not what the live line means. The gate is a surface's
+ * own answer (`session.running`, which every session-scoped seat receives), so a
+ * surface that cannot answer passes nothing and leaves it alone rather than
+ * guessing.
+ *
  * Three facts about the harness markup make that safe and specific:
- *   - the row carries exactly one class whose `[hash]_turnStatus` suffix is
- *     stable across rebuilds (the hash in front is not), so
- *     `[class$="_turnStatus"]` matches it and not the sibling clock;
+ *   - the row has one stable handle per harness generation — an
+ *     `[hash]_turnStatus` class suffix on the 0.1.5 line, and, on the 0.1.7
+ *     line, the `data-turn-process` button whose text is a `<span>` whose hashed
+ *     class ends `_label` — so each generation gets its own copy of the sheet
+ *     ({@link ROW_SELECTORS}) and the one the running app renders matches while
+ *     the other stays inert;
  *   - its gradient paints through the `--dsw-static-deepseek-*` custom
  *     properties, so recoloring is a variable override rather than a fight
  *     over `background` and `background-clip`;
@@ -93,6 +107,11 @@ import type { LoopEngineId } from '../agent-preset-ids.ts';
  * clears the attribute, because the sibling surface of the same session is still
  * on screen painting through it.
  *
+ * The MID-TURN gate is written from here as well, but only by a surface that can
+ * answer it (`running` given): the sheet is gated on both, because the 0.1.7 row
+ * outlives its turn, and a surface with no answer must leave the gate as the
+ * surface that has one left it rather than guess.
+ *
  * The NO-OP covers the late reflection as well — the one from the session the
  * user has just left, whose own answer landing after the switch used to paint
  * over the session that replaced it.
@@ -101,8 +120,10 @@ import type { LoopEngineId } from '../agent-preset-ids.ts';
  *   row): such a page has nothing to say about the row, so nothing is written and
  *   nothing is withdrawn — it leaves the row it found alone.
  * @param engine - the engine that session runs, when it is known.
+ * @param running - whether that session is mid-turn, when the surface knows;
+ *   omitted by a surface with no answer, which leaves the gate alone.
  */
-export declare function reflectTurnStatusEngine(sessionId: string | undefined, engine: LoopEngineId | undefined): void;
+export declare function reflectTurnStatusEngine(sessionId: string | undefined, engine: LoopEngineId | undefined, running?: boolean): void;
 /**
  * Declare which session's surfaces are on screen — the row's one subject.
  *

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

@@ -55,12 +55,20 @@ import type { SessionEngineCache } from './session-engine.ts';
  *
  * One effect does the whole thing, so the three steps cannot come apart: declare
  * this session as the row's subject (`focusTurnStatusSession`), reflect its
- * engine by that declaration (`reflectTurnStatusEngine`), and release the
- * declaration when this surface goes away (`blurTurnStatusSession`, which
- * withdraws it only while it is still this session's).
+ * engine and its mid-turn gate by that declaration (`reflectTurnStatusEngine`),
+ * and release the declaration when this surface goes away
+ * (`blurTurnStatusSession`, which withdraws it only while it is still this
+ * session's).
+ *
+ * `running` is the session's own live state (`session.running`, from the
+ * session-scoped standard kit) and it is part of the effect's key: the 0.1.7 row
+ * stays on screen after the turn ends, so the paint has to come off when the turn
+ * does — a surface that does not know the state passes nothing and leaves the
+ * gate alone.
  * @param cache - the cache the plugin mounted.
  * @param sessionId - the session to follow, or undefined off a session scope.
+ * @param running - whether that session is mid-turn, when the surface knows.
  * @returns the engine report, or undefined while it is unknown.
  */
-export declare function useEngineOfSession(cache: SessionEngineCache, sessionId: string | undefined): SessionEngineReport | undefined;
+export declare function useEngineOfSession(cache: SessionEngineCache, sessionId: string | undefined, running?: boolean): SessionEngineReport | undefined;
 //# sourceMappingURL=use-session-engine.d.ts.map

package/lib/types/compat.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Runtime harness-generation probe. One released build must serve the 0.1.5
+ * line (`0.1.5-rc.1` … `0.1.5-rc.3`, all sharing the OLD settings API) and the
+ * 0.1.7 line (`0.1.7-rc.1`), which rewrote the settings host and client and
+ * turned the agent-creation announcement async. The differences are not
+ * version strings but API SHAPES, so the switch is a structural probe of the
+ * imported module rather than a semver parse: `@deepseek-ai/dsh-settings`
+ * exported a named `SettingsProvider` class on the 0.1.5 line, and the 0.1.7
+ * rewrite deleted it in favour of `SettingsForms` plus per-entry volatile
+ * Config fields.
+ *
+ * The probe resolves to whichever `@deepseek-ai/dsh-settings` the running
+ * profile actually provides. It is host-side only: the browser bundle must not
+ * import host packages, so `src/client/*` never imports this module.
+ *
+ * @module dsh-loop-engine/compat
+ */
+/**
+ * Whether the running harness predates the profile-backed settings rewrite
+ * (the 0.1.5 line). `true` selects the legacy settings host/client, the
+ * synchronous agent-creation announcement, and the legacy tool-result message
+ * introspection.
+ */
+export declare const LEGACY_HARNESS: boolean;
+//# sourceMappingURL=compat.d.ts.map