@askdkc/dsh-cli 0.11.7 → 0.12.1

package/node_modules/dsh-working-activity/lib/types/activity-event.js

@@ -0,0 +1,18 @@
+/**
+ * The tracker's own event vocabulary — the only input `ActivityTracker`
+ * understands.
+ *
+ * Why this exists: the state machine used to consume raw DSH `SessionEvent`s,
+ * so every host payload drift silently changed the rendered status (the
+ * current host moved a tool-call id out of `content[]` and replaced the durable
+ * `assistant/chunk` stream with transient frames — both broke the line without
+ * a single failing test). Events here carry **meaning**, never host shape:
+ * `kind` plus already-normalized values, and every one of them is timestamped
+ * by the producer so the clock stays injectable.
+ *
+ * Producers live in `src/compat/*` (durable session events) and
+ * `src/compat/assistant-stream.ts` (live attempt frames). The tracker must
+ * never import a DSH type.
+ * @module @deepseek-ai/dsh-working-activity/activity-event
+ */
+export {};

package/node_modules/dsh-working-activity/lib/types/client/WorkingLine.d.ts

@@ -0,0 +1,8 @@
+import type { PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+/** Full props of the dock entry: the input-zone runtime share (session standard kit). */
+export type WorkingLineProps = PropsRuntime<'conversation.input.dock'>;
+/**
+ * Working-line dock entry: reads the session's latest `workingActivity`
+ * projection value and renders the row, or nothing when idle/absent.
+ */
+export declare function WorkingLine({ useProjection }: WorkingLineProps): import("react").JSX.Element | null;

package/node_modules/dsh-working-activity/lib/types/client/WorkingLine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkingLine.d.ts","sourceRoot":"","sources":["../../../src/client/WorkingLine.tsx"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AAWpE,yFAAyF;AACzF,MAAM,MAAM,gBAAgB,GAAG,YAAY,CAAC,yBAAyB,CAAC,CAAA;AAoCtE;;;GAGG;AACH,wBAAgB,WAAW,CAAC,EAAE,aAAa,EAAE,EAAE,gBAAgB,sCAyB9D"}

package/node_modules/dsh-working-activity/lib/types/client/WorkingLine.js

@@ -0,0 +1,57 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ACTIVITY_PROJECTION_KEY } from './activity.ts';
+import { refreshElapsedSuffix } from './elapsed.js';
+import css from './WorkingLine.module.css';
+/** Tool-count badge copy (no locale seat: the line text itself is host-composed). */
+const TOOLS_LABEL = 'tools this turn';
+/** The one live tick attachment (exactly one dock row exists at a time). */
+let tickAttachment;
+/**
+ * Re-tick the elapsed counter on the mounted text node, once per second.
+ *
+ * The projection only pushes when a committed event folds (measured: three
+ * pushes per turn), so the host-rendered `line` ages between folds — the
+ * elapsed text would freeze for the length of a tool. The row therefore
+ * re-ticks the ONE moving segment locally; only segments matching the host's
+ * elapsed shapes are ever replaced (see ./elapsed.ts).
+ *
+ * Imperative on purpose, and hook-free: the component is also invoked as a
+ * plain function (the bundle gate reads its tree without a renderer), and a
+ * ref callback plus this module-level slot is enough — React detaches a
+ * changed inline ref with `null` first, which is where the previous interval
+ * dies; a settled value simply never attaches a new one.
+ */
+function attachElapsedTick(el, activity) {
+    if (tickAttachment !== undefined && (el === null || tickAttachment.el !== el)) {
+        clearInterval(tickAttachment.timer);
+        tickAttachment = undefined;
+    }
+    if (el === null || activity === undefined || activity.live !== true)
+        return;
+    const paint = () => {
+        el.textContent = refreshElapsedSuffix(activity.line, activity, Date.now());
+    };
+    paint();
+    tickAttachment = { el, timer: setInterval(paint, 1000) };
+}
+/**
+ * Working-line dock entry: reads the session's latest `workingActivity`
+ * projection value and renders the row, or nothing when idle/absent.
+ */
+export function WorkingLine({ useProjection }) {
+    // `undefined` is the uniform absence signal: the host unit is unmounted, no
+    // frame carried the key for this session yet, or no session is current.
+    // Rendering nothing (rather than an empty row) keeps the dock from reserving
+    // space ahead of the first committed event.
+    //
+    // The annotation is load-bearing: `useProjection`'s precise engine type lives
+    // in the session kit's own dependency (`@deepseek-ai/dsh-api-session-controller`),
+    // which this package deliberately does not install (it would drag the whole
+    // client peer closure into the dev tree). The key is pinned in ./activity.ts
+    // against the merged table; this keeps the render body checked against the
+    // host's view type.
+    const activity = useProjection(ACTIVITY_PROJECTION_KEY);
+    if (activity === undefined || activity.phase === 'idle' || activity.line === '')
+        return null;
+    return (_jsxs("div", { className: css.line, "data-activity-phase": activity.phase, children: [_jsx("span", { className: css.marker, "aria-hidden": "true" }), _jsx("span", { className: css.text, ref: el => attachElapsedTick(el, activity), children: activity.line }), activity.toolCount > 0 && (_jsx("span", { className: css.tools, title: `${activity.toolCount} ${TOOLS_LABEL}`, children: activity.toolCount }))] }));
+}

package/node_modules/dsh-working-activity/lib/types/client/activity.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Client-side contract of the working-activity Web half: the `workingActivity`
+ * key of the session-projection type table.
+ *
+ * The browser reads the line through the session standard kit's
+ * `useProjection('workingActivity')` — the host folds the projection from
+ * committed session events and ships the whole value, so no client-side domain
+ * folding exists and nothing is appended to the session log.
+ *
+ * The runtime patch that used to carry the value on the conversation snapshot
+ * (`ConversationSnapshot.activity`, declared against `@deepseek-ai/dsh-client-runtime`)
+ * is obsolete for the current host line: that package is frozen at `0.1.1-rc.2`
+ * and absent from the `0.1.7-rc.2` client cohort.
+ *
+ * {@link WorkingActivityView} is imported from the host half on purpose — one
+ * definition of the wire value, so the two halves cannot drift. The import is
+ * TYPE-ONLY: a value import would pull host-only code (zod, node builtins) into
+ * the browser bundle, which the build's purity gate rejects.
+ * @module @deepseek-ai/dsh-working-activity/client/activity
+ */
+import type { WorkingActivityView } from '../projection.js';
+declare module '@deepseek-ai/dsh-session-projection/types' {
+    interface SessionProjectionMap {
+        /**
+         * Latest folded working line for the current session, or absent while the
+         * host unit is unmounted or no committed event has folded yet.
+         */
+        workingActivity: WorkingActivityView;
+    }
+}
+/**
+ * The projection key this package reads, checked against the merged table: a
+ * rename on the host side, or a merge that silently failed to land, is a
+ * compile error here instead of a dock row that never renders.
+ */
+export declare const ACTIVITY_PROJECTION_KEY = "workingActivity";
+export type { WorkingActivityView };

package/node_modules/dsh-working-activity/lib/types/client/activity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity.d.ts","sourceRoot":"","sources":["../../../src/client/activity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAE3D,OAAO,QAAQ,2CAA2C,CAAC;IACzD,UAAU,oBAAoB;QAC5B;;;WAGG;QACH,eAAe,EAAE,mBAAmB,CAAA;KACrC;CACF;AAED;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,oBACqC,CAAA;AAEzE,YAAY,EAAE,mBAAmB,EAAE,CAAA"}

package/node_modules/dsh-working-activity/lib/types/client/activity.js

@@ -0,0 +1,26 @@
+/**
+ * Client-side contract of the working-activity Web half: the `workingActivity`
+ * key of the session-projection type table.
+ *
+ * The browser reads the line through the session standard kit's
+ * `useProjection('workingActivity')` — the host folds the projection from
+ * committed session events and ships the whole value, so no client-side domain
+ * folding exists and nothing is appended to the session log.
+ *
+ * The runtime patch that used to carry the value on the conversation snapshot
+ * (`ConversationSnapshot.activity`, declared against `@deepseek-ai/dsh-client-runtime`)
+ * is obsolete for the current host line: that package is frozen at `0.1.1-rc.2`
+ * and absent from the `0.1.7-rc.2` client cohort.
+ *
+ * {@link WorkingActivityView} is imported from the host half on purpose — one
+ * definition of the wire value, so the two halves cannot drift. The import is
+ * TYPE-ONLY: a value import would pull host-only code (zod, node builtins) into
+ * the browser bundle, which the build's purity gate rejects.
+ * @module @deepseek-ai/dsh-working-activity/client/activity
+ */
+/**
+ * The projection key this package reads, checked against the merged table: a
+ * rename on the host side, or a merge that silently failed to land, is a
+ * compile error here instead of a dock row that never renders.
+ */
+export const ACTIVITY_PROJECTION_KEY = 'workingActivity';

package/node_modules/dsh-working-activity/lib/types/client/elapsed.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Client-side elapsed re-tick for the working line.
+ *
+ * The projection is event-driven: the host pushes a value when a committed
+ * event folds, and `view` renders at read time. The TUI creates its own
+ * cadence by re-reading; a browser cannot, so between folds the shipped
+ * `line` ages — measured on the rc.2 corridor, one turn carried three
+ * pushes, freezing the elapsed text for the length of a tool. While `live`
+ * is true, the dock row therefore re-ticks the ONE moving segment locally:
+ * the elapsed counter.
+ *
+ * Safety: a segment is replaced only when it matches the shapes the host
+ * emits (`总1m23s` / `total 5s` / a bare `87ms`). Any format drift on the
+ * host side makes the matcher miss and the row falls back to the host's
+ * (aging) text — stale, but never wrong. Settled `✓` lines carry a fixed
+ * duration, not a counter, and are left alone. This module is deliberately
+ * dependency-free: the host's `phrases.ts` reaches node builtins for
+ * language detection, which the client bundle's purity gate rejects.
+ * @module @deepseek-ai/dsh-working-activity/client/elapsed
+ */
+/** What the caller knows about the value whose line is displayed. */
+export interface ElapsedTickView {
+    /** Current phase; only live phases carry a moving counter. */
+    readonly phase: 'idle' | 'waiting' | 'thinking' | 'tool' | 'done';
+    /** Wall clock the current phase began (the tool counter counts from it). */
+    readonly phaseStartedAt: number;
+    /** Wall clock the current turn began (the elapsed counter counts from it). */
+    readonly turnStartedAt: number;
+    /** Language the host rendered `line` in. */
+    readonly lang: 'zh' | 'en';
+}
+/**
+ * Replace the line's elapsed segment with one computed at `nowMs`.
+ *
+ * @param line - The host-rendered line (aged to the last fold).
+ * @param view - The value's phase, counters and language.
+ * @param nowMs - Wall clock to re-tick to.
+ * @returns the line with a current counter, or the input when there is
+ * nothing safe to replace.
+ */
+export declare function refreshElapsedSuffix(line: string, view: ElapsedTickView, nowMs: number): string;

package/node_modules/dsh-working-activity/lib/types/client/elapsed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elapsed.d.ts","sourceRoot":"","sources":["../../../src/client/elapsed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,qEAAqE;AACrE,MAAM,WAAW,eAAe;IAC9B,8DAA8D;IAC9D,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM,CAAA;IACjE,4EAA4E;IAC5E,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,8EAA8E;IAC9E,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,4CAA4C;IAC5C,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAAA;CAC3B;AAyBD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAsB/F"}

package/node_modules/dsh-working-activity/lib/types/client/elapsed.js

@@ -0,0 +1,78 @@
+/**
+ * Client-side elapsed re-tick for the working line.
+ *
+ * The projection is event-driven: the host pushes a value when a committed
+ * event folds, and `view` renders at read time. The TUI creates its own
+ * cadence by re-reading; a browser cannot, so between folds the shipped
+ * `line` ages — measured on the rc.2 corridor, one turn carried three
+ * pushes, freezing the elapsed text for the length of a tool. While `live`
+ * is true, the dock row therefore re-ticks the ONE moving segment locally:
+ * the elapsed counter.
+ *
+ * Safety: a segment is replaced only when it matches the shapes the host
+ * emits (`总1m23s` / `total 5s` / a bare `87ms`). Any format drift on the
+ * host side makes the matcher miss and the row falls back to the host's
+ * (aging) text — stale, but never wrong. Settled `✓` lines carry a fixed
+ * duration, not a counter, and are left alone. This module is deliberately
+ * dependency-free: the host's `phrases.ts` reaches node builtins for
+ * language detection, which the client bundle's purity gate rejects.
+ * @module @deepseek-ai/dsh-working-activity/client/elapsed
+ */
+/** The duration shapes the host emits: `87ms`, `5s`, `1m23s`, `4h0m`. */
+const DURATION = /^\d+(?:ms|s|m\d+s|h\d+m)$/;
+/** The localized elapsed segment: `总5s`, `total 1m23s`. */
+const ELAPSED = /^(?:总|total )\d+(?:ms|s|m\d+s|h\d+m)$/;
+/** The segment separator the host composes the line with. */
+const SEP = ' · ';
+/** Mirror of the host's `fmtDuration` (second granularity and shapes). */
+function formatDuration(ms) {
+    if (ms < 1000)
+        return '0s';
+    const total = Math.floor(ms / 1000);
+    if (total < 60)
+        return `${total}s`;
+    const minutes = Math.floor(total / 60);
+    const seconds = total % 60;
+    if (minutes < 60)
+        return `${minutes}m${seconds}s`;
+    return `${Math.floor(minutes / 60)}h${minutes % 60}m`;
+}
+/** Mirror of the host's `durationLabel` (sub-second reads in milliseconds). */
+function formatCounter(ms) {
+    return ms < 1000 ? `${Math.max(0, Math.floor(ms))}ms` : formatDuration(ms);
+}
+/**
+ * Replace the line's elapsed segment with one computed at `nowMs`.
+ *
+ * @param line - The host-rendered line (aged to the last fold).
+ * @param view - The value's phase, counters and language.
+ * @param nowMs - Wall clock to re-tick to.
+ * @returns the line with a current counter, or the input when there is
+ * nothing safe to replace.
+ */
+export function refreshElapsedSuffix(line, view, nowMs) {
+    if (view.phase === 'idle' || view.phase === 'done')
+        return line;
+    // A settled tool's `✓ … · 887ms` is a fixed fact, not a counter.
+    if (line.startsWith('✓ '))
+        return line;
+    // The tool counter counts from the phase's entry; with concurrent tools the
+    // host's own counter tracks the OLDEST one, so this may trail it by the
+    // overlap — a display nuance, not a wrong number.
+    const since = view.phase === 'tool' ? view.phaseStartedAt : view.turnStartedAt;
+    if (!(since > 0))
+        return line;
+    const elapsed = Math.max(0, nowMs - since);
+    const replacement = view.phase === 'tool'
+        ? formatCounter(elapsed)
+        : (view.lang === 'en' ? `total ${formatDuration(elapsed)}` : `总${formatDuration(elapsed)}`);
+    const segments = line.split(SEP);
+    for (let i = segments.length - 1; i > 0; i--) {
+        const segment = segments[i];
+        if (segment !== undefined && (DURATION.test(segment) || ELAPSED.test(segment))) {
+            segments[i] = replacement;
+            return segments.join(SEP);
+        }
+    }
+    return line;
+}

package/node_modules/dsh-working-activity/lib/types/client/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Working-activity surface plugin, browser half: the working-line entry in
+ * the conversation.input.dock strip.
+ *
+ * The node half folds every committed session event into the `workingActivity`
+ * session projection and the host ships that value to clients; this dock entry
+ * reads it through the session standard kit's `useProjection` and owns no
+ * store, no refresh chain, and no event listener. Nothing is appended to the
+ * session log — the reason dsh-tui mounts this plugin with `publish: false`.
+ *
+ * Mount contract (see the root README's "Web UI 集成" section): the web
+ * client's client-modules host scans loader entries for `dsh.client`
+ * declarations and serves this package's `./client` bundle at
+ * /plugins/dsh-working-activity/client.js. The entry contributes into the
+ * input dock — no official-source patch is involved.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+export { WorkingLine, type WorkingLineProps } from './WorkingLine.tsx';
+export type { WorkingActivityView } from './activity.ts';
+/** Required services for the dock registration. */
+export declare const inject: string[];
+/**
+ * Client plugin body: the working-line dock entry.
+ * @param ctx - client root context.
+ */
+export declare function apply(ctx: Context): void;

package/node_modules/dsh-working-activity/lib/types/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAQlD,OAAO,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AACtE,YAAY,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAA;AAExD,mDAAmD;AACnD,eAAO,MAAM,MAAM,UAAY,CAAA;AAE/B;;;GAGG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI,CAUxC"}

package/node_modules/dsh-working-activity/lib/types/client/index.js

@@ -0,0 +1,19 @@
+import { WorkingLine } from './WorkingLine.tsx';
+export { WorkingLine } from './WorkingLine.tsx';
+/** Required services for the dock registration. */
+export const inject = ['slots'];
+/**
+ * Client plugin body: the working-line dock entry.
+ * @param ctx - client root context.
+ */
+export function apply(ctx) {
+    ctx.slots.inject('conversation.input.dock', () => ctx.slots.register({
+        name: 'conversation.input.dock',
+        // The pre-slots patch used the same id in ui-conversation; entries with
+        // equal order render in registration order, and goal (10) / queue (20)
+        // keep their seats — this row sits between them.
+        id: 'activity',
+        order: 15,
+        registrant: 'dsh-working-activity',
+    }, WorkingLine));
+}

package/node_modules/dsh-working-activity/lib/types/compat/assistant-stream.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Live `agent/assistant-stream` frame → {@link ActivityEvent} normalization.
+ *
+ * This is the realtime half of the plugin's input. On the current host line the
+ * durable `assistant/chunk` event no longer exists (it is absent from
+ * `SessionEventMap` and from `KNOWN_SESSION_EVENT_TYPES`) and streamed output
+ * arrives as transient frames published on the agent scope instead, so without
+ * this module the line has no first-token promotion, no `⏵` narration and no
+ * tok/s estimate — it only moves when durable tool events arrive.
+ *
+ * Measured frame shape (`@deepseek-ai/dsh-agent@0.1.7-rc.2`,
+ * `lib/types/runtime-types.d.ts`):
+ *
+ * ```text
+ * start { attemptId, revision, turn, step }
+ * chunk { attemptId, revision, index, time, chunk }   chunk: StreamChunk
+ * end   { attemptId, revision, index, outcome }       outcome: committed{eventType,seq} | abandoned
+ * ```
+ *
+ * The fields stay read tolerantly rather than through a host type import: the
+ * package still compiles against `@deepseek-ai/dsh-agent@0.1.0-rc.6`, which has
+ * no `AssistantStreamFrame` declaration at all. Reading structurally is also
+ * what keeps the next reshape a one-file fix here.
+ *
+ * ## Why the cursor is keyed by the agent, not by the session
+ * `revision` is documented as "monotone within one attached Agent lifecycle;
+ * replacement restarts at 1". A single counter would therefore drop every frame
+ * of a replacement agent (`1 <= 100`) and silence the line forever, so the
+ * cursor lives in a `WeakMap` keyed by the emitting agent — a new agent is a new
+ * key and starts at its own revision 1 with no explicit reset anywhere.
+ * @module @deepseek-ai/dsh-working-activity/compat/assistant-stream
+ */
+import type { ActivityEvent } from '../activity-event.js';
+/** Identity of one agent lifecycle. Frames of different owners never share a cursor. */
+export type StreamOwner = object;
+/**
+ * Normalize one live frame for the agent that published it.
+ *
+ * Returns zero events for anything the tracker does not model: unknown frame
+ * types, non-delta chunks (block boundaries, tool-call deltas, usage, finish),
+ * empty delta text, and any frame the owner's revision cursor has already seen.
+ *
+ * @param owner - The agent lifecycle that published the frame (cursor key).
+ * @param frame - Raw `agent/assistant-stream` frame, or any host payload.
+ * @returns the domain events this frame carries, in order.
+ */
+export declare function frameToActivityEvents(owner: StreamOwner, frame: unknown): readonly ActivityEvent[];
+/**
+ * Feed one live frame into any domain-event consumer.
+ *
+ * Kept as a free function so the tracker never learns a host type: the plugin
+ * subscribes to `agent/assistant-stream` and calls this.
+ * @param tracker - Consumer of normalized events.
+ * @param owner - The agent lifecycle that published the frame.
+ * @param frame - Raw frame payload.
+ */
+export declare function feedStreamFrame(tracker: {
+    onEvent(event: ActivityEvent): void;
+}, owner: StreamOwner, frame: unknown): void;

package/node_modules/dsh-working-activity/lib/types/compat/assistant-stream.js

@@ -0,0 +1,189 @@
+/**
+ * Live `agent/assistant-stream` frame → {@link ActivityEvent} normalization.
+ *
+ * This is the realtime half of the plugin's input. On the current host line the
+ * durable `assistant/chunk` event no longer exists (it is absent from
+ * `SessionEventMap` and from `KNOWN_SESSION_EVENT_TYPES`) and streamed output
+ * arrives as transient frames published on the agent scope instead, so without
+ * this module the line has no first-token promotion, no `⏵` narration and no
+ * tok/s estimate — it only moves when durable tool events arrive.
+ *
+ * Measured frame shape (`@deepseek-ai/dsh-agent@0.1.7-rc.2`,
+ * `lib/types/runtime-types.d.ts`):
+ *
+ * ```text
+ * start { attemptId, revision, turn, step }
+ * chunk { attemptId, revision, index, time, chunk }   chunk: StreamChunk
+ * end   { attemptId, revision, index, outcome }       outcome: committed{eventType,seq} | abandoned
+ * ```
+ *
+ * The fields stay read tolerantly rather than through a host type import: the
+ * package still compiles against `@deepseek-ai/dsh-agent@0.1.0-rc.6`, which has
+ * no `AssistantStreamFrame` declaration at all. Reading structurally is also
+ * what keeps the next reshape a one-file fix here.
+ *
+ * ## Why the cursor is keyed by the agent, not by the session
+ * `revision` is documented as "monotone within one attached Agent lifecycle;
+ * replacement restarts at 1". A single counter would therefore drop every frame
+ * of a replacement agent (`1 <= 100`) and silence the line forever, so the
+ * cursor lives in a `WeakMap` keyed by the emitting agent — a new agent is a new
+ * key and starts at its own revision 1 with no explicit reset anywhere.
+ * @module @deepseek-ai/dsh-working-activity/compat/assistant-stream
+ */
+/** Frame types this adapter understands. */
+const FRAME_TYPES = ['start', 'chunk', 'end'];
+const cursors = new WeakMap();
+/** The cursor for one agent lifecycle, created on first use. */
+function cursorFor(owner) {
+    let cursor = cursors.get(owner);
+    if (cursor === undefined) {
+        cursor = {};
+        cursors.set(owner, cursor);
+    }
+    return cursor;
+}
+/**
+ * Whether one frame is new for its owner's cursor, updating the cursor.
+ *
+ * Ordering is enforced only when both sides carry a usable revision: a host
+ * that stops timestamping frames must degrade to "accept" rather than "drop
+ * everything", because a silently frozen line is the exact failure this module
+ * exists to prevent. Duplicate delivery in that degraded mode costs a repeated
+ * delta, which the narration buffer tolerates.
+ */
+function accept(cursor, revision) {
+    if (typeof revision !== 'number' || !Number.isFinite(revision))
+        return true;
+    if (cursor.revision !== undefined && revision <= cursor.revision)
+        return false;
+    cursor.revision = revision;
+    return true;
+}
+/** Narrow `unknown` to a plain record: objects only, never `null`, never an array. */
+function asRecord(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return undefined;
+    return value;
+}
+/** A usable attempt id: a non-empty string, returned verbatim. */
+function asAttemptId(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value : undefined;
+}
+/** A frame timestamp, falling back to the wall clock when the host omits one. */
+function frameTime(frame) {
+    const time = frame.time;
+    return typeof time === 'number' && Number.isFinite(time) ? time : Date.now();
+}
+/**
+ * Normalize one live frame for the agent that published it.
+ *
+ * Returns zero events for anything the tracker does not model: unknown frame
+ * types, non-delta chunks (block boundaries, tool-call deltas, usage, finish),
+ * empty delta text, and any frame the owner's revision cursor has already seen.
+ *
+ * @param owner - The agent lifecycle that published the frame (cursor key).
+ * @param frame - Raw `agent/assistant-stream` frame, or any host payload.
+ * @returns the domain events this frame carries, in order.
+ */
+export function frameToActivityEvents(owner, frame) {
+    const record = asRecord(frame);
+    if (record === undefined)
+        return [];
+    const type = typeof record.type === 'string' ? record.type : undefined;
+    if (type === undefined || !FRAME_TYPES.includes(type))
+        return [];
+    const cursor = cursorFor(owner);
+    if (!accept(cursor, record.revision))
+        return [];
+    if (type === 'start') {
+        const attemptId = asAttemptId(record.attemptId);
+        cursor.attemptId = attemptId;
+        return [{
+                kind: 'stream-start',
+                at: frameTime(record),
+                ...(attemptId === undefined ? {} : { attemptId }),
+            }];
+    }
+    if (type === 'chunk')
+        return chunkEvents(cursor, record);
+    return endEvents(cursor, record);
+}
+/**
+ * One `chunk` frame: open the attempt first when the frame announces one the
+ * cursor has not seen, then the delta itself.
+ *
+ * Adoption matters after a reattach/resume, where the stream is joined
+ * mid-attempt and no `start` frame is redelivered: the first chunk a plugin
+ * sees would otherwise be unusable. Safety comes from the revision cursor
+ * instead — a late chunk of a superseded attempt carries a lower revision and
+ * never reaches this point.
+ */
+function chunkEvents(cursor, frame) {
+    const at = frameTime(frame);
+    const attempts = asAttemptId(frame.attemptId);
+    const events = [];
+    if (attempts !== undefined && attempts !== cursor.attemptId) {
+        cursor.attemptId = attempts;
+        events.push({ kind: 'stream-start', at, attemptId: attempts });
+    }
+    const chunk = asRecord(frame.chunk);
+    const delta = deltaOf(chunk);
+    if (delta !== undefined && delta.text.length > 0) {
+        events.push({ kind: 'stream-delta', at, stream: delta.stream, text: delta.text });
+    }
+    return events;
+}
+/**
+ * One `end` frame. Both terminal outcomes clear the cursor's attempt, but only
+ * the ones whose committed output can differ from what was streamed ask the
+ * tracker to drop its provisional state:
+ *
+ * - `abandoned` — no settlement at all, so the provisional narration is wrong;
+ * - `committed` + `assistant/attempt` — a PARTIAL settlement, so the streamed
+ *   text may exceed what was committed. This is not an abandonment and is not
+ *   reported as one;
+ * - `committed` + `assistant/message` — the streamed text IS the committed
+ *   message, so its narration may keep its freshness window (the durable
+ *   settlement already carried the same content);
+ * - an unrecognized outcome — cleared, but no reset event, so a future terminal
+ *   kind cannot accidentally discard narration it did commit.
+ */
+function endEvents(cursor, frame) {
+    const at = frameTime(frame);
+    cursor.attemptId = undefined;
+    const outcome = asRecord(frame.outcome);
+    const kind = typeof outcome?.kind === 'string' ? outcome.kind : undefined;
+    if (kind === 'abandoned')
+        return [{ kind: 'stream-reset', at, reason: 'abandoned' }];
+    const eventType = typeof outcome?.eventType === 'string' ? outcome.eventType : undefined;
+    if (kind === 'committed' && eventType === 'assistant/attempt') {
+        return [{ kind: 'stream-reset', at, reason: 'attempt-settled' }];
+    }
+    return [];
+}
+/** The stream kind and text of one chunk, when it is a displayable delta. */
+function deltaOf(chunk) {
+    if (chunk === undefined)
+        return undefined;
+    const text = chunk.text;
+    if (typeof text !== 'string')
+        return undefined;
+    if (chunk.type === 'text-delta')
+        return { stream: 'text', text };
+    if (chunk.type === 'reasoning-delta')
+        return { stream: 'reasoning', text };
+    return undefined;
+}
+/**
+ * Feed one live frame into any domain-event consumer.
+ *
+ * Kept as a free function so the tracker never learns a host type: the plugin
+ * subscribes to `agent/assistant-stream` and calls this.
+ * @param tracker - Consumer of normalized events.
+ * @param owner - The agent lifecycle that published the frame.
+ * @param frame - Raw frame payload.
+ */
+export function feedStreamFrame(tracker, owner, frame) {
+    for (const activityEvent of frameToActivityEvents(owner, frame))
+        tracker.onEvent(activityEvent);
+}

package/node_modules/dsh-working-activity/lib/types/compat/session-events.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Durable `SessionEvent` → {@link ActivityEvent} normalization.
+ *
+ * Every host-shape guess for the durable log lives here (plus
+ * `./tool-result.ts` for the tool-result payload), so a host-line change stays
+ * a one-file fix and the state machine keeps consuming meaning only.
+ *
+ * Measured on the DSH `0.1.7-rc.2` line: `assistant/chunk` no longer exists in
+ * `SessionEventMap` or in `KNOWN_SESSION_EVENT_TYPES` (live deltas arrive as
+ * transient `agent/assistant-stream` frames instead), so the mapping below is
+ * the legacy path kept for replaying older logs. It must stay: sessions
+ * written by pre-0.1.5 hosts still carry those events, and replaying them is
+ * the only way a resuming user sees the same line they would have seen live.
+ * @module @deepseek-ai/dsh-working-activity/compat/session-events
+ */
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+import type { ActivityEvent } from '../activity-event.js';
+/**
+ * Normalize one durable session event.
+ *
+ * Returns zero events for anything the tracker does not model (including a
+ * tool result whose call id cannot be resolved — an unpaired result is
+ * dropped, never guessed at).
+ * @param event - Raw durable session event.
+ * @returns the domain events this host event carries, in order.
+ */
+export declare function toActivityEvents(event: SessionEvent): readonly ActivityEvent[];
+/**
+ * Feed one durable session event into any domain-event consumer.
+ *
+ * Kept as a free function so the tracker itself never learns a host type: the
+ * published `onSessionEvent` method delegates here.
+ * @param tracker - Consumer of normalized events.
+ * @param event - Raw durable session event.
+ */
+export declare function feedSessionEvent(tracker: {
+    onEvent(event: ActivityEvent): void;
+}, event: SessionEvent): void;