@khorsheed/dsh-local-agent-dsh 0.2.0-rc.3 → 0.2.0

package/lib/dsh-cli-provider.js

@@ -1,3 +1,3 @@
-import { a as MEMBER_BRIDGE_ENTRY_ENV, c as dshTextTask, d as startDshCliRun, i as DshCliProvider, l as registerMemberRun, n as DEFAULT_DISPOSE_GRACE_MS, o as dshCliVersion, r as DEFAULT_LIVE_MIRROR_INTERVAL_MS, s as dshLaunchArgv, t as CONTAINER_NODE_OPTIONS, u as resolveApiKey } from "./dsh-cli-provider-B7s3zH0m.js";
+import { a as MEMBER_BRIDGE_ENTRY_ENV, c as dshTextTask, d as startDshCliRun, i as DshCliProvider, l as registerMemberRun, n as DEFAULT_DISPOSE_GRACE_MS, o as dshCliVersion, r as DEFAULT_LIVE_MIRROR_INTERVAL_MS, s as dshLaunchArgv, t as CONTAINER_NODE_OPTIONS, u as resolveApiKey } from "./dsh-cli-provider-DYRuRpVz.js";
 import "./provision.js";
 export { CONTAINER_NODE_OPTIONS, DEFAULT_DISPOSE_GRACE_MS, DEFAULT_LIVE_MIRROR_INTERVAL_MS, DshCliProvider, MEMBER_BRIDGE_ENTRY_ENV, dshCliVersion, dshLaunchArgv, dshTextTask, registerMemberRun, resolveApiKey, startDshCliRun };

package/lib/index.js

@@ -1,4 +1,4 @@
-import { f as DEFAULT_LIVE_IDLE_MS, h as localModelLaunch, i as DshCliProvider, m as canInheritModelProvider, o as dshCliVersion, p as DshLiveDriver, t as CONTAINER_NODE_OPTIONS } from "./dsh-cli-provider-B7s3zH0m.js";
+import { f as DEFAULT_LIVE_IDLE_MS, h as localModelLaunch, i as DshCliProvider, m as canInheritModelProvider, o as dshCliVersion, p as DshLiveDriver, t as CONTAINER_NODE_OPTIONS } from "./dsh-cli-provider-DYRuRpVz.js";
 import { DEFAULT_SUB_PROFILE_NAME, provisionDshScope } from "./provision.js";
 import { listDshSessions } from "./records.js";
 import { dirname } from "node:path";

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

@@ -1,6 +1,6 @@
 /**
  * Generated by scripts/sync-icon-artwork.mts from @deepseek-ai/dsh-client-ui-primitives
- * (v0.1.7-rc.1, harness 46a7f68b09) — do not edit by hand. The 0.1.5 and rc.1 host lines
+ * (v0.2.1-rc.1, harness 1600d8a1e1) — do not edit by hand. The 0.1.5 and rc.1 host lines
  * share no icon export name, so the rc.1 artwork is inlined here: pure SVG,
  * no host runtime identity, identical on every line. Re-run the generator
  * after adding an icon import or bumping the harness checkout.

package/lib/types/dsh-cli-provider.js

@@ -15,11 +15,11 @@ import { randomUUID } from 'node:crypto';
 import { credentialRef } from '@deepseek-ai/dsh-credentials';
 import { SessionId } from '@deepseek-ai/dsh-session';
 import { NO_START_CAPABILITIES, SUBAGENT_DESCRIPTOR_VERSION, settleRunResult, subprocessRunHandle, } from '@deepseek-ai/dsh-subagent';
-import { assertResumeCwdUnchanged, assertResumeScopeUnchanged, resolveRoundModel, containerExecSpawn, containerScopedHome, delegationEnv, establishSubagentCatalogChild, probeCliVersion, resolveChildCwd, subagentDelegationLabel, } from '@khorsheed/dsh-local-agent';
+import { assertResumeCwdUnchanged, assertResumeScopeUnchanged, resolveRoundModel, containerExecSpawn, containerScopedHome, delegationEnv, establishSubagentCatalogChild, persistChildSession, probeCliVersion, resolveChildCwd, subagentDelegationLabel, } from '@khorsheed/dsh-local-agent';
 import { MEMBER_BRIDGE_SOCKET_ENV, MEMBER_BRIDGE_TOKEN_ENV } from '@khorsheed/dsh-local-agent/types';
 import { LiveChannelUnavailableError } from './live-driver.js';
 import { DEFAULT_SUB_PROFILE_NAME, provisionDshScope, unitSubProfileName } from './provision.js';
-import { mirrorDshSession } from './session-mirror.js';
+import { closeMirroredOpenStep, mirrorDshSession } from './session-mirror.js';
 /**
  * Spawn-env name carrying the bridge entry path into the sub-dsh process,
  * where the headless bundle's mcp-client row reads it (`!!js`). The name is a
@@ -685,39 +685,61 @@ export async function startDshCliRun(request, spec) {
         // reached its endpoint and produced an answer.
         if (settled.stopReason === 'completed')
             markCredentialVerified(ctx, spec.scope);
-        // The turn closes at the real settle moment, so the timing projection's
-        // duration equals the actual CLI runtime. Every terminal path closes the
-        // window — a failed or cancelled run settles 'error'/'aborted' instead of
-        // leaving the turn open with a distorted tiny duration.
-        if (spec.childSession !== undefined) {
-            if (settled.stopReason === 'completed') {
-                spec.childSession.append('turn/end', { turn, reason: { kind: 'completed' } });
-            }
-            else if (settled.stopReason === 'aborted') {
-                spec.childSession.append('turn/end', { turn, reason: { kind: 'aborted', reason: { kind: 'parent' } } });
-            }
-            else {
-                spec.childSession.append('turn/end', {
-                    turn,
-                    reason: { kind: 'error', error: { message: 'dsh exited before the run completed', code: 'UNKNOWN' } },
-                });
-            }
-        }
+        // The turn does NOT close here: turn/end lands in the mirror queue after
+        // the settle pass (see below), so every mirrored event precedes it in the
+        // stored log — the released-log reader rejects content outside an open
+        // turn on every cold read.
         return settled;
     });
     // After the child EXITS — however it ended (completed, killed by dispose, or
     // crashed) — mirror whatever the sub-dsh session already produced into the
     // dsh subagent session, so every round preserves its conversation and real
     // token usage instead of showing turn boundaries only. Waits for the settle
-    // chain first (so turn/end is already appended) AND for the process to
-    // actually exit (the sub-dsh flushed its session before exiting) before
-    // reading.
+    // chain first AND for the process to actually exit (the sub-dsh flushed its
+    // session before exiting) before reading. The turn closes INSIDE the mirror
+    // queue, after the settle pass: the copied tail's open step first receives
+    // its closure (an interrupted sub-dsh leaves its step — and any advertised
+    // tool calls — open, and the released-log reader rejects a turn/end over
+    // it), then turn/end lands and is persisted explicitly (the mirror's own
+    // persist skips a no-op pass, which is exactly the case that needs the
+    // boundary written). Every terminal path closes the window — a failed or
+    // cancelled run settles 'error'/'aborted' instead of leaving the turn open.
     void result.then(() => child.done).then(() => {
         if (spec.childSession !== undefined) {
             const childSession = spec.childSession;
             // The settle pass reports the final mirror count even when polling
             // already covered the round (empty delta): it is authoritative.
-            return enqueueMirror(() => mirrorAndReport(childSession, true));
+            return enqueueMirror(async () => {
+                const settled = await result;
+                try {
+                    await mirrorAndReport(childSession, true);
+                }
+                catch (error) {
+                    // The mirror degrades to a warn; the turn boundary still closes —
+                    // an open turn at EOF reads as an interrupted tail only until the
+                    // next resume round tries to open its turn over it.
+                    ctx.logger.warn(`subagent-dsh: settle mirror failed: ${error instanceof Error ? error.message : String(error)}`);
+                }
+                closeMirroredOpenStep(childSession);
+                // The turn closes at the real settle moment (plus the settle-mirror
+                // quiescence), so the timing projection's duration equals the actual
+                // CLI runtime.
+                if (settled.stopReason === 'completed') {
+                    childSession.append('turn/end', { turn, reason: { kind: 'completed' } });
+                }
+                else if (settled.stopReason === 'aborted') {
+                    childSession.append('turn/end', { turn, reason: { kind: 'aborted', reason: { kind: 'parent' } } });
+                }
+                else {
+                    childSession.append('turn/end', {
+                        turn,
+                        reason: { kind: 'error', error: { message: 'dsh exited before the run completed', code: 'UNKNOWN' } },
+                    });
+                }
+                await persistChildSession(ctx, childSession).catch((error) => {
+                    ctx.logger.warn(`subagent-dsh: turn/end persistence failed: ${error instanceof Error ? error.message : String(error)}`);
+                });
+            });
         }
         return undefined;
     }, () => { });

package/lib/types/live-driver.js

@@ -28,7 +28,7 @@ import { LIVE_SERVER_NAME, LIVE_WIRE_PROTOCOL_VERSION, } from '@khorsheed/dsh-lo
 import { DEFAULT_DISPOSE_GRACE_MS, dshLaunchArgv, dshTextTask, registerMemberRun, } from './dsh-cli-provider.js';
 import { localModelLaunch } from './model-launch.js';
 import { DEFAULT_SUB_PROFILE_NAME, provisionDshScope } from './provision.js';
-import { mirrorDshLiveEvent, mirrorDshSession } from './session-mirror.js';
+import { mirrorDshLiveEvent, mirrorDshSession, closeMirroredOpenStep, mirroredOpenStep } from './session-mirror.js';
 /** Default idle lifetime of an unused resident runtime before reclaim. */
 export const DEFAULT_LIVE_IDLE_MS = 30 * 60_000;
 /** Default timeout for a wire request acknowledgement. */
@@ -785,7 +785,13 @@ export class DshLiveDriver {
         }).then(async (settled) => {
             roundSettled = true;
             liveFlush.dispose();
-            if (turnOpened && streaming !== undefined && streamPublisher !== undefined) {
+            // The interrupted stream's partial content folds durably only while its
+            // step is still OPEN: a graceful sub-dsh unwind writes its own
+            // interrupted assistant/message and step/end (both crossed the wire),
+            // and an append at the closed step would fail the released-log reader.
+            const openStep = turnOpened ? mirroredOpenStep(childSession) : undefined;
+            if (turnOpened && streaming !== undefined && streamPublisher !== undefined
+                && openStep !== undefined && openStep.step === streaming.step) {
                 const blocks = streaming.assembler.interruptedBlocks();
                 if (blocks.length > 0) {
                     childSession.append('assistant/message', {
@@ -798,22 +804,6 @@ export class DshLiveDriver {
                 }
             }
             streamPublisher?.dispose();
-            // Identical turn/end bookkeeping to the exec path — but only for a turn
-            // that actually opened (a pre-accept cancel records no turn at all).
-            if (turnOpened) {
-                if (settled.stopReason === 'completed') {
-                    childSession.append('turn/end', { turn, reason: { kind: 'completed' } });
-                }
-                else if (settled.stopReason === 'aborted') {
-                    childSession.append('turn/end', { turn, reason: { kind: 'aborted', reason: { kind: 'parent' } } });
-                }
-                else {
-                    childSession.append('turn/end', {
-                        turn,
-                        reason: { kind: 'error', error: nativeFailure ?? { message: 'the live round did not complete', code: 'UNKNOWN' } },
-                    });
-                }
-            }
             // Settlement clears the round's handlers: a late notification drops at
             // the runtime frame instead of landing in a dead closure.
             if (runtime !== undefined) {
@@ -821,24 +811,18 @@ export class DshLiveDriver {
                 runtime.onEvent = undefined;
                 runtime.onIdle = undefined;
             }
-            // A completed answer is not a durable turn until its final boundary
-            // and any closing stream checkpoints have reached the child store.
             if (turnOpened) {
-                persist();
-                await persistQueue;
-            }
-            return settled;
-        });
-        // Settle reconciliation: the file-based mirror pass (the serve side flushed
-        // before its idle notification) dedupes against the live-mirrored prefix
-        // and catches anything the wire dropped; the final mirror progress report
-        // is authoritative, exactly as in the exec path. Then re-arm the reaper. A
-        // round that never opened owns no span — skip the pass entirely (it would
-        // re-scan the previous round or, under exec fallback, fight its polling).
-        void result.then(async () => {
-            try {
-                if (turnOpened) {
-                    await persistQueue;
+                // Settle reconciliation IN-CHAIN: the file-based mirror pass (the serve
+                // side flushed before its idle notification) dedupes against the
+                // live-mirrored prefix and catches anything the wire dropped; the
+                // final mirror progress report is authoritative, exactly as in the
+                // exec path. It runs before turn/end so every mirrored event lands
+                // inside the turn window — the released-log reader rejects content
+                // outside an open turn on every cold read — and inside the result
+                // chain so the round serializer (and a resume round's turn/start)
+                // never overtakes the boundary. A mirror fault degrades to a warn;
+                // the boundary still closes.
+                try {
                     if (mirroredMessages > 0)
                         persist();
                     await persistQueue.catch(() => { });
@@ -863,13 +847,35 @@ export class DshLiveDriver {
                         registry?.recordRoundSettled?.(childSession.id, round);
                     }
                 }
+                catch (error) {
+                    this.ctx.logger.warn(`subagent-dsh: live settle mirror failed: ${thrown(error).message}`);
+                }
+                // The copied tail's open step (an interrupted round leaves it open —
+                // the reader rejects a turn/end over it) receives its closure first.
+                closeMirroredOpenStep(childSession);
+                // Identical turn/end bookkeeping to the exec path — a completed,
+                // interrupted, or failed round each closes its window.
+                if (settled.stopReason === 'completed') {
+                    childSession.append('turn/end', { turn, reason: { kind: 'completed' } });
+                }
+                else if (settled.stopReason === 'aborted') {
+                    childSession.append('turn/end', { turn, reason: { kind: 'aborted', reason: { kind: 'parent' } } });
+                }
+                else {
+                    childSession.append('turn/end', {
+                        turn,
+                        reason: { kind: 'error', error: nativeFailure ?? { message: 'the live round did not complete', code: 'UNKNOWN' } },
+                    });
+                }
+                // A completed answer is not a durable turn until its final boundary
+                // and any closing stream checkpoints have reached the child store.
+                persist();
+                await persistQueue;
             }
-            catch (error) {
-                this.ctx.logger.warn(`subagent-dsh: live settle mirror failed: ${thrown(error).message}`);
-            }
-            finally {
-                this.armIdleTimer(spec.sessionId);
-            }
+            // Re-arm the idle reaper for every settled round — including one that
+            // never opened its turn (the runtime is up and must not leak).
+            this.armIdleTimer(spec.sessionId);
+            return settled;
         });
         // Publication gate: hold start() until the turn is accepted (channel
         // errors still throw for the provider's exec fallback), but NEVER hold it

package/lib/types/session-mirror.d.ts

@@ -29,6 +29,19 @@
  * passes never duplicate an identical snapshot and the child's `todos`
  * projection (and the official TodoPanel in non-takeover views) reads the
  * member's task list for free.
+ *
+ * Interrupted-tail closure: a sub-dsh that dies mid-step (the exec kill
+ * ladder, a live-runtime crash) leaves its log's step — and any advertised
+ * tool calls — OPEN, and the verbatim copy carries that open tail into the
+ * child session. The released-log reader (harness
+ * session-format-v3-to-v4/relationships.ts) rejects a `turn/end` over an open
+ * step on every cold read, so the provider's settle flow calls
+ * {@link closeMirroredOpenStep} after the settle mirror pass and before its
+ * own `turn/end`: each advertised-but-unresolved call receives a synthesized
+ * interrupted `tool/result` (the family's shared placeholder for a started
+ * call, the validator's exact TOOL_NOT_STARTED repair for one that never
+ * started) and the copied step receives its `step/end`. Mid-round the open
+ * pair still crosses as-is — the sub-dsh may yet write its end.
  * @module @khorsheed/dsh-local-agent-dsh/session-mirror
  */
 import type { DshSessionLog } from './session-log.ts';
@@ -98,6 +111,48 @@ export interface DshMirrorDelta {
 }
 /** How much of the live event stream crosses into the child session. */
 export type DshLiveMirrorGranularity = 'event' | 'token';
+/**
+ * The placeholder text of the synthesized result for a tool call the sub-dsh
+ * started but never resolved (its process died between `tool/call` and
+ * `tool/result`). Shared verbatim with the kimi family's fold.
+ */
+export declare const DSH_INTERRUPTED_TOOL_RESULT = "\uFF08\u5DE5\u5177\u8C03\u7528\u88AB\u4E2D\u65AD\uFF0C\u672A\u80FD\u8BB0\u5F55\u8FD4\u56DE\u7ED3\u679C\uFF09";
+/** What {@link closeMirroredOpenStep} synthesized, when it closed anything. */
+export interface DshMirrorTailClosure {
+    /** The copied open step this closure ended. */
+    readonly step: {
+        turn: number;
+        step: number;
+    };
+    /** The advertised calls that received a synthesized interrupted result, in advertisement order. */
+    readonly repairedCalls: readonly string[];
+}
+/**
+ * The child session's currently-open copied step: the (turn, step) of a
+ * `step/start` whose `step/end` has not crossed, inside a turn the provider
+ * has not closed. Undefined when nothing is open. The live driver's
+ * interrupted-stream fold consults it: the fold's assistant/message may land
+ * only while its step is still open (a graceful sub-dsh unwind writes its own
+ * message and step/end, and the fold must not append at the closed step).
+ */
+export declare function mirroredOpenStep(childSession: Session): {
+    turn: number;
+    step: number;
+} | undefined;
+/**
+ * Close the copied open tail of the child session's current turn at settle,
+ * before the provider's `turn/end`: the released-log reader rejects a
+ * `turn/end` over an open step ('turn/end does not match the open turn with
+ * no open step') and a step/end leaving an advertised call unresolved, so an
+ * interrupted sub-dsh's open step is ended here — each advertised-but-
+ * unresolved tool call first receiving its synthesized interrupted result
+ * (the family's placeholder for a started call; the validator's exact
+ * TOOL_NOT_STARTED repair for one that never started). Mid-round transports
+ * never call this: the sub-dsh may yet write its own end, and a synthesized
+ * step/end would collide with it on a later pass. Returns what it
+ * synthesized, or undefined when the copied tail was already balanced.
+ */
+export declare function closeMirroredOpenStep(childSession: Session): DshMirrorTailClosure | undefined;
 /**
  * Mirror ONE live-pushed sub-dsh session event (the serve mode's
  * `session/event` wire notification) into the child session. This is the

package/lib/types/session-mirror.js

@@ -29,6 +29,19 @@
  * passes never duplicate an identical snapshot and the child's `todos`
  * projection (and the official TodoPanel in non-takeover views) reads the
  * member's task list for free.
+ *
+ * Interrupted-tail closure: a sub-dsh that dies mid-step (the exec kill
+ * ladder, a live-runtime crash) leaves its log's step — and any advertised
+ * tool calls — OPEN, and the verbatim copy carries that open tail into the
+ * child session. The released-log reader (harness
+ * session-format-v3-to-v4/relationships.ts) rejects a `turn/end` over an open
+ * step on every cold read, so the provider's settle flow calls
+ * {@link closeMirroredOpenStep} after the settle mirror pass and before its
+ * own `turn/end`: each advertised-but-unresolved call receives a synthesized
+ * interrupted `tool/result` (the family's shared placeholder for a started
+ * call, the validator's exact TOOL_NOT_STARTED repair for one that never
+ * started) and the copied step receives its `step/end`. Mid-round the open
+ * pair still crosses as-is — the sub-dsh may yet write its end.
  * @module @khorsheed/dsh-local-agent-dsh/session-mirror
  */
 import { readFile, readdir } from 'node:fs/promises';
@@ -247,7 +260,9 @@ function appendMirroredToolEvent(childSession, event) {
  * index registers the same step the sub-dsh wrote. Shared by the file
  * mirror's span loop and the live driver's per-event mirror. An interrupted
  * step crosses as an OPEN pair (start without end): the location resolves to
- * the step either way, and no boundary is ever synthesized.
+ * the step either way, and mid-round no boundary is synthesized — the sub-dsh
+ * may yet write its end. At settle the provider closes the copied tail with
+ * {@link closeMirroredOpenStep} before its own `turn/end`.
  */
 function appendMirroredStepBoundary(childSession, event) {
     if (event.type === 'step/start') {
@@ -274,6 +289,145 @@ function appendMirroredMessageEvent(childSession, event) {
     }
     return mirroredEventText(event);
 }
+/**
+ * The placeholder text of the synthesized result for a tool call the sub-dsh
+ * started but never resolved (its process died between `tool/call` and
+ * `tool/result`). Shared verbatim with the kimi family's fold.
+ */
+export const DSH_INTERRUPTED_TOOL_RESULT = '（工具调用被中断，未能记录返回结果）';
+/**
+ * The released-log reader's exact repair text for a call that was advertised
+ * but never recorded as started: relationships.ts's notStartedRepair admits
+ * only that shape (the `interrupted-tool-result-<callId>-<n>` id, the
+ * ToolNotStartedError/TOOL_NOT_STARTED error, no sourceEventSeqs, and this
+ * single text block) — no other wording resolves the call.
+ */
+const TOOL_NOT_STARTED_REPAIR_TEXT = 'The tool call was interrupted before the Harness recorded it as started. Retry it if it is still needed.';
+/**
+ * The child session's currently-open copied step: the (turn, step) of a
+ * `step/start` whose `step/end` has not crossed, inside a turn the provider
+ * has not closed. Undefined when nothing is open. The live driver's
+ * interrupted-stream fold consults it: the fold's assistant/message may land
+ * only while its step is still open (a graceful sub-dsh unwind writes its own
+ * message and step/end, and the fold must not append at the closed step).
+ */
+export function mirroredOpenStep(childSession) {
+    const events = childSession.snapshotEvents();
+    // Backward: the latest boundary event says the state — a step/start opens,
+    // a step/end or any turn boundary closes the question.
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const type = events[index]?.type;
+        if (type === 'step/start')
+            return events[index]?.data;
+        if (type === 'step/end' || type === 'turn/start' || type === 'turn/end')
+            return undefined;
+    }
+    return undefined;
+}
+/**
+ * Close the copied open tail of the child session's current turn at settle,
+ * before the provider's `turn/end`: the released-log reader rejects a
+ * `turn/end` over an open step ('turn/end does not match the open turn with
+ * no open step') and a step/end leaving an advertised call unresolved, so an
+ * interrupted sub-dsh's open step is ended here — each advertised-but-
+ * unresolved tool call first receiving its synthesized interrupted result
+ * (the family's placeholder for a started call; the validator's exact
+ * TOOL_NOT_STARTED repair for one that never started). Mid-round transports
+ * never call this: the sub-dsh may yet write its own end, and a synthesized
+ * step/end would collide with it on a later pass. Returns what it
+ * synthesized, or undefined when the copied tail was already balanced.
+ */
+export function closeMirroredOpenStep(childSession) {
+    const events = childSession.snapshotEvents();
+    // Only the current (last) turn can hold the copied open tail: an earlier
+    // turn closed with the provider's turn/end, which no valid prefix crossed
+    // with open state.
+    let turnStart = -1;
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const type = events[index]?.type;
+        if (type === 'turn/end')
+            return undefined;
+        if (type === 'turn/start') {
+            turnStart = index;
+            break;
+        }
+    }
+    if (turnStart < 0)
+        return undefined;
+    let openStep;
+    // The turn's tool-call ledger: an assistant/message's tool-call blocks
+    // advertise, a tool/call starts, a tool/result resolves — its message names
+    // the call at the top level (the V4 tool-role shape) or in its single
+    // content block (the pre-V4 user-role shape); read both, a mirrored log may
+    // predate the upgrade.
+    const advertised = new Set();
+    const started = new Map();
+    const resolved = new Set();
+    for (const event of events.slice(turnStart + 1)) {
+        if (event.type === 'step/start') {
+            openStep = event.data;
+        }
+        else if (event.type === 'step/end') {
+            openStep = undefined;
+        }
+        else if (event.type === 'assistant/message') {
+            const content = event.data.message?.content ?? [];
+            for (const block of content) {
+                if (block?.type === 'tool-call' && typeof block.id === 'string')
+                    advertised.add(block.id);
+            }
+        }
+        else if (event.type === 'tool/call') {
+            const callId = event.data.callId;
+            if (typeof callId === 'string')
+                started.set(callId, event.seq);
+        }
+        else if (event.type === 'tool/result') {
+            const message = event.data.message;
+            const id = message?.toolCallId ?? message?.content?.[0]?.toolCallId;
+            if (typeof id === 'string')
+                resolved.add(id);
+        }
+    }
+    if (openStep === undefined)
+        return undefined;
+    const step = openStep;
+    const repaired = [];
+    // The seq the next appended event occupies (seq == log length), so the
+    // synthesized ids carry the harness's repair-id convention.
+    let nextSeq = events.length;
+    for (const callId of advertised) {
+        if (resolved.has(callId))
+            continue;
+        const callSeq = started.get(callId);
+        const message = {
+            id: `interrupted-tool-result-${callId}-${nextSeq}`,
+            role: 'tool',
+            toolCallId: callId,
+            isError: true,
+            source: { kind: 'tool', callId },
+            content: [{ type: 'text', text: callSeq === undefined ? TOOL_NOT_STARTED_REPAIR_TEXT : DSH_INTERRUPTED_TOOL_RESULT }],
+        };
+        nextSeq += 1;
+        childSession.append('tool/result', {
+            turn: step.turn,
+            step: step.step,
+            message,
+            error: callSeq === undefined
+                ? { name: 'ToolNotStartedError', code: 'TOOL_NOT_STARTED' }
+                : { name: 'ToolOutcomeUnknownError', code: 'TOOL_OUTCOME_UNKNOWN' },
+        }, {
+            surfaceOp: 'append',
+            // The not-started repair must carry NO sourceEventSeqs (the reader
+            // admits exactly that shape); the started repair pairs with the copied
+            // call event, exactly as a real mirrored result does.
+            ...callSeq === undefined ? {} : { sourceEventSeqs: [callSeq] },
+        });
+        repaired.push(callId);
+    }
+    childSession.append('step/end', { turn: step.turn, step: step.step });
+    return { step, repairedCalls: repaired };
+}
 /**
  * Mirror ONE live-pushed sub-dsh session event (the serve mode's
  * `session/event` wire notification) into the child session. This is the

package/package.json

@@ -8,7 +8,7 @@
     "local-agent",
     "subagent"
   ],
-  "version": "0.2.0-rc.3",
+  "version": "0.2.0",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -75,8 +75,8 @@
     "dsh": ">=0.1.5-rc.1 <0.3.0-0"
   },
   "dependencies": {
-    "@khorsheed/dsh-local-agent": "^0.2.0-rc.3",
-    "@khorsheed/dsh-local-agent-dsh-headless": "^0.2.0-rc.3",
+    "@khorsheed/dsh-local-agent": "^0.2.0",
+    "@khorsheed/dsh-local-agent-dsh-headless": "^0.2.0",
     "js-yaml": "^4.3.1"
   },
   "peerDependencies": {