@askdkc/dsh-cli 0.11.7 → 0.12.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","names":["css"],"sources":["../src/client/activity.ts","../src/client/elapsed.ts","../src/client/WorkingLine.tsx","../src/client/index.ts"],"sourcesContent":["/**\n * Client-side contract of the working-activity Web half: the `workingActivity`\n * key of the session-projection type table.\n *\n * The browser reads the line through the session standard kit's\n * `useProjection('workingActivity')` — the host folds the projection from\n * committed session events and ships the whole value, so no client-side domain\n * folding exists and nothing is appended to the session log.\n *\n * The runtime patch that used to carry the value on the conversation snapshot\n * (`ConversationSnapshot.activity`, declared against `@deepseek-ai/dsh-client-runtime`)\n * is obsolete for the current host line: that package is frozen at `0.1.1-rc.2`\n * and absent from the `0.1.7-rc.2` client cohort.\n *\n * {@link WorkingActivityView} is imported from the host half on purpose — one\n * definition of the wire value, so the two halves cannot drift. The import is\n * TYPE-ONLY: a value import would pull host-only code (zod, node builtins) into\n * the browser bundle, which the build's purity gate rejects.\n * @module @deepseek-ai/dsh-working-activity/client/activity\n */\n\nimport type { SessionProjectionMap } from '@deepseek-ai/dsh-session-projection/types'\nimport type { WorkingActivityView } from '../projection.js'\n\ndeclare module '@deepseek-ai/dsh-session-projection/types' {\n  interface SessionProjectionMap {\n    /**\n     * Latest folded working line for the current session, or absent while the\n     * host unit is unmounted or no committed event has folded yet.\n     */\n    workingActivity: WorkingActivityView\n  }\n}\n\n/**\n * The projection key this package reads, checked against the merged table: a\n * rename on the host side, or a merge that silently failed to land, is a\n * compile error here instead of a dock row that never renders.\n */\nexport const ACTIVITY_PROJECTION_KEY =\n  'workingActivity' satisfies Extract<keyof SessionProjectionMap, string>\n\nexport type { WorkingActivityView }\n","/**\n * Client-side elapsed re-tick for the working line.\n *\n * The projection is event-driven: the host pushes a value when a committed\n * event folds, and `view` renders at read time. The TUI creates its own\n * cadence by re-reading; a browser cannot, so between folds the shipped\n * `line` ages — measured on the rc.2 corridor, one turn carried three\n * pushes, freezing the elapsed text for the length of a tool. While `live`\n * is true, the dock row therefore re-ticks the ONE moving segment locally:\n * the elapsed counter.\n *\n * Safety: a segment is replaced only when it matches the shapes the host\n * emits (`总1m23s` / `total 5s` / a bare `87ms`). Any format drift on the\n * host side makes the matcher miss and the row falls back to the host's\n * (aging) text — stale, but never wrong. Settled `✓` lines carry a fixed\n * duration, not a counter, and are left alone. This module is deliberately\n * dependency-free: the host's `phrases.ts` reaches node builtins for\n * language detection, which the client bundle's purity gate rejects.\n * @module @deepseek-ai/dsh-working-activity/client/elapsed\n */\n\n/** What the caller knows about the value whose line is displayed. */\nexport interface ElapsedTickView {\n  /** Current phase; only live phases carry a moving counter. */\n  readonly phase: 'idle' | 'waiting' | 'thinking' | 'tool' | 'done'\n  /** Wall clock the current phase began (the tool counter counts from it). */\n  readonly phaseStartedAt: number\n  /** Wall clock the current turn began (the elapsed counter counts from it). */\n  readonly turnStartedAt: number\n  /** Language the host rendered `line` in. */\n  readonly lang: 'zh' | 'en'\n}\n\n/** The duration shapes the host emits: `87ms`, `5s`, `1m23s`, `4h0m`. */\nconst DURATION = /^\\d+(?:ms|s|m\\d+s|h\\d+m)$/\n/** The localized elapsed segment: `总5s`, `total 1m23s`. */\nconst ELAPSED = /^(?:总|total )\\d+(?:ms|s|m\\d+s|h\\d+m)$/\n/** The segment separator the host composes the line with. */\nconst SEP = ' · '\n\n/** Mirror of the host's `fmtDuration` (second granularity and shapes). */\nfunction formatDuration(ms: number): string {\n  if (ms < 1000) return '0s'\n  const total = Math.floor(ms / 1000)\n  if (total < 60) return `${total}s`\n  const minutes = Math.floor(total / 60)\n  const seconds = total % 60\n  if (minutes < 60) return `${minutes}m${seconds}s`\n  return `${Math.floor(minutes / 60)}h${minutes % 60}m`\n}\n\n/** Mirror of the host's `durationLabel` (sub-second reads in milliseconds). */\nfunction formatCounter(ms: number): string {\n  return ms < 1000 ? `${Math.max(0, Math.floor(ms))}ms` : formatDuration(ms)\n}\n\n/**\n * Replace the line's elapsed segment with one computed at `nowMs`.\n *\n * @param line - The host-rendered line (aged to the last fold).\n * @param view - The value's phase, counters and language.\n * @param nowMs - Wall clock to re-tick to.\n * @returns the line with a current counter, or the input when there is\n * nothing safe to replace.\n */\nexport function refreshElapsedSuffix(line: string, view: ElapsedTickView, nowMs: number): string {\n  if (view.phase === 'idle' || view.phase === 'done') return line\n  // A settled tool's `✓ … · 887ms` is a fixed fact, not a counter.\n  if (line.startsWith('✓ ')) return line\n  // The tool counter counts from the phase's entry; with concurrent tools the\n  // host's own counter tracks the OLDEST one, so this may trail it by the\n  // overlap — a display nuance, not a wrong number.\n  const since = view.phase === 'tool' ? view.phaseStartedAt : view.turnStartedAt\n  if (!(since > 0)) return line\n  const elapsed = Math.max(0, nowMs - since)\n  const replacement = view.phase === 'tool'\n    ? formatCounter(elapsed)\n    : (view.lang === 'en' ? `total ${formatDuration(elapsed)}` : `总${formatDuration(elapsed)}`)\n  const segments = line.split(SEP)\n  for (let i = segments.length - 1; i > 0; i--) {\n    const segment = segments[i]\n    if (segment !== undefined && (DURATION.test(segment) || ELAPSED.test(segment))) {\n      segments[i] = replacement\n      return segments.join(SEP)\n    }\n  }\n  return line\n}\n","// Working-line dock entry: one dim full-width row above the composer card\n// showing the live working-activity line — phase-colored breathing marker,\n// the host-composed status line, and the turn's tool count badge.\n// Renders for every live phase (waiting/thinking/tool) and the done summary;\n// hides while idle or before the first frame.\n//\n// Data path: the host folds the `workingActivity` session projection and ships\n// the whole value to clients; the session standard kit's `useProjection` reads\n// it by key. Nothing is appended to the session log, and no client-runtime\n// patch is involved — the old `ConversationSnapshot.activity` transport is dead\n// on the current host line.\n//\n// The 'conversation.input.dock' SlotMap declaration lives in\n// @deepseek-ai/dsh-client-ui-conversation/client (contract/slots.ts) and the\n// `useProjection` standard seat in @deepseek-ai/dsh-client-ui-session/client;\n// this entry contributes into the slot without owning it.\nimport type { PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots'\n// Type-only merges, erased at build time and never required by the bundle:\n// the ui-conversation SlotMap entry (the dock seat's owner props) and the\n// ui-session standard kit (`useProjection`). ./activity.ts carries this\n// package's own projection-key merge, the key constant, and the view type.\nimport type {} from '@deepseek-ai/dsh-client-ui-conversation/client'\nimport type {} from '@deepseek-ai/dsh-client-ui-session/client'\nimport { ACTIVITY_PROJECTION_KEY, type WorkingActivityView } from './activity.ts'\nimport { refreshElapsedSuffix } from './elapsed.js'\nimport css from './WorkingLine.module.css'\n\n/** Full props of the dock entry: the input-zone runtime share (session standard kit). */\nexport type WorkingLineProps = PropsRuntime<'conversation.input.dock'>\n\n/** Tool-count badge copy (no locale seat: the line text itself is host-composed). */\nconst TOOLS_LABEL = 'tools this turn'\n\n/** The one live tick attachment (exactly one dock row exists at a time). */\nlet tickAttachment: { readonly el: HTMLElement; readonly timer: ReturnType<typeof setInterval> } | undefined\n\n/**\n * Re-tick the elapsed counter on the mounted text node, once per second.\n *\n * The projection only pushes when a committed event folds (measured: three\n * pushes per turn), so the host-rendered `line` ages between folds — the\n * elapsed text would freeze for the length of a tool. The row therefore\n * re-ticks the ONE moving segment locally; only segments matching the host's\n * elapsed shapes are ever replaced (see ./elapsed.ts).\n *\n * Imperative on purpose, and hook-free: the component is also invoked as a\n * plain function (the bundle gate reads its tree without a renderer), and a\n * ref callback plus this module-level slot is enough — React detaches a\n * changed inline ref with `null` first, which is where the previous interval\n * dies; a settled value simply never attaches a new one.\n */\nfunction attachElapsedTick(el: HTMLElement | null, activity: WorkingActivityView | undefined): void {\n  if (tickAttachment !== undefined && (el === null || tickAttachment.el !== el)) {\n    clearInterval(tickAttachment.timer)\n    tickAttachment = undefined\n  }\n  if (el === null || activity === undefined || activity.live !== true) return\n  const paint = (): void => {\n    el.textContent = refreshElapsedSuffix(activity.line, activity, Date.now())\n  }\n  paint()\n  tickAttachment = { el, timer: setInterval(paint, 1000) }\n}\n\n/**\n * Working-line dock entry: reads the session's latest `workingActivity`\n * projection value and renders the row, or nothing when idle/absent.\n */\nexport function WorkingLine({ useProjection }: WorkingLineProps) {\n  // `undefined` is the uniform absence signal: the host unit is unmounted, no\n  // frame carried the key for this session yet, or no session is current.\n  // Rendering nothing (rather than an empty row) keeps the dock from reserving\n  // space ahead of the first committed event.\n  //\n  // The annotation is load-bearing: `useProjection`'s precise engine type lives\n  // in the session kit's own dependency (`@deepseek-ai/dsh-api-session-controller`),\n  // which this package deliberately does not install (it would drag the whole\n  // client peer closure into the dev tree). The key is pinned in ./activity.ts\n  // against the merged table; this keeps the render body checked against the\n  // host's view type.\n  const activity: WorkingActivityView | undefined = useProjection(ACTIVITY_PROJECTION_KEY)\n  if (activity === undefined || activity.phase === 'idle' || activity.line === '') return null\n  return (\n    <div className={css.line} data-activity-phase={activity.phase}>\n      <span className={css.marker} aria-hidden=\"true\" />\n      <span className={css.text} ref={el => attachElapsedTick(el, activity)}>{activity.line}</span>\n      {activity.toolCount > 0 && (\n        <span className={css.tools} title={`${activity.toolCount} ${TOOLS_LABEL}`}>\n          {activity.toolCount}\n        </span>\n      )}\n    </div>\n  )\n}\n","/**\n * Working-activity surface plugin, browser half: the working-line entry in\n * the conversation.input.dock strip.\n *\n * The node half folds every committed session event into the `workingActivity`\n * session projection and the host ships that value to clients; this dock entry\n * reads it through the session standard kit's `useProjection` and owns no\n * store, no refresh chain, and no event listener. Nothing is appended to the\n * session log — the reason dsh-tui mounts this plugin with `publish: false`.\n *\n * Mount contract (see the root README's \"Web UI 集成\" section): the web\n * client's client-modules host scans loader entries for `dsh.client`\n * declarations and serves this package's `./client` bundle at\n * /plugins/dsh-working-activity/client.js. The entry contributes into the\n * input dock — no official-source patch is involved.\n */\nimport type { Context } from '@deepseek-ai/cordis'\n// Type-only merges: the ui-conversation SlotMap entry (the dock seat) and the\n// ui-renderer `slots` service on the client Context. Both are erased at build\n// time and never required by the bundle.\nimport type {} from '@deepseek-ai/dsh-client-ui-conversation/client'\nimport type {} from '@deepseek-ai/dsh-client-ui-renderer/client'\nimport { WorkingLine } from './WorkingLine.tsx'\n\nexport { WorkingLine, type WorkingLineProps } from './WorkingLine.tsx'\nexport type { WorkingActivityView } from './activity.ts'\n\n/** Required services for the dock registration. */\nexport const inject = ['slots']\n\n/**\n * Client plugin body: the working-line dock entry.\n * @param ctx - client root context.\n */\nexport function apply(ctx: Context): void {\n  ctx.slots.inject('conversation.input.dock', () => ctx.slots.register({\n    name: 'conversation.input.dock',\n    // The pre-slots patch used the same id in ui-conversation; entries with\n    // equal order render in registration order, and goal (10) / queue (20)\n    // keep their seats — this row sits between them.\n    id: 'activity',\n    order: 15,\n    registrant: 'dsh-working-activity',\n  }, WorkingLine))\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,147 @@
+/**
+ * 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
+ */
+/** Token counters reported by one settled assistant message. */
+export interface ActivityUsage {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly cacheReadTokens?: number;
+    readonly cacheWriteTokens?: number;
+}
+/** Which stream a delta came from (reasoning and text both drive narration). */
+export type ActivityStreamKind = 'text' | 'reasoning';
+/**
+ * Why the model is not making progress even though the turn is open: the
+ * provider asked for a retry, a tool is parked on the user's approval, or the
+ * host is compacting the context. Without this the line cannot tell "waiting
+ * on the model" from "the model is waiting on YOU".
+ */
+export type WaitingReason = 'retry' | 'approval' | 'compaction';
+/**
+ * Why provisional stream state was dropped: the attempt was abandoned (its
+ * output will never be settled) or only a partial settlement was committed
+ * (`assistant/attempt`). Both clear the buffer; they are not the same event.
+ */
+export type ActivityStreamResetReason = 'abandoned' | 'attempt-settled';
+/** One normalized activity event. */
+export type ActivityEvent = 
+/** Accepted human text from the durable session log. */
+{
+    readonly kind: 'user-prompt';
+    readonly at: number;
+    readonly text: string;
+}
+/** A new turn opened: per-turn counters reset, phase → waiting. */
+ | {
+    readonly kind: 'turn-start';
+    readonly at: number;
+}
+/** A step opened. Carries no phase change on its own. */
+ | {
+    readonly kind: 'step-start';
+    readonly at: number;
+}
+/** A live model attempt opened; later deltas belong to `attemptId`. */
+ | {
+    readonly kind: 'stream-start';
+    readonly at: number;
+    readonly attemptId?: string;
+}
+/** One streamed delta with non-empty text. */
+ | {
+    readonly kind: 'stream-delta';
+    readonly at: number;
+    readonly stream: ActivityStreamKind;
+    readonly text: string;
+}
+/** Drop provisional stream state for the attempt that just ended. */
+ | {
+    readonly kind: 'stream-reset';
+    readonly at: number;
+    readonly reason: ActivityStreamResetReason;
+}
+/** One assistant message settled with authoritative usage (and its text). */
+ | {
+    readonly kind: 'assistant-settled';
+    readonly at: number;
+    readonly usage?: ActivityUsage;
+    /**
+     * The settled message's text, when it has any.
+     *
+     * Live narration arrives on stream frames, which only a live host sees; a
+     * projection (or a replayed log) folds durable events alone, so the same
+     * `⏵` line must be recoverable from the message that carries it.
+     */
+    readonly text?: string;
+}
+/** A tool started running. */
+ | {
+    readonly kind: 'tool-start';
+    readonly at: number;
+    readonly callId: string;
+    readonly name: string;
+    readonly arguments: string;
+}
+/** A tool settled; `callId` is the exact id its start carried. */
+ | {
+    readonly kind: 'tool-end';
+    readonly at: number;
+    readonly callId: string;
+    readonly failed: boolean;
+}
+/** The model route changed to `model`. */
+ | {
+    readonly kind: 'route-change';
+    readonly at: number;
+    readonly model: string;
+}
+/** Context compaction finished, or overflowed while trying. */
+ | {
+    readonly kind: 'compaction';
+    readonly at: number;
+    readonly overflow?: boolean;
+}
+/**
+ * The turn is stalled for `reason`. Stays until the stall resolves: a delta
+ * (the model is producing again), an approval decision, the compaction
+ * settling, or the turn closing.
+ */
+ | {
+    readonly kind: 'waiting-reason';
+    readonly at: number;
+    readonly reason: WaitingReason;
+}
+/** A stall resolved (e.g. `approval/decided`): back to the normal pools. */
+ | {
+    readonly kind: 'waiting-cleared';
+    readonly at: number;
+}
+/** The agent entered another lifecycle status. */
+ | {
+    readonly kind: 'agent-status';
+    readonly at: number;
+    readonly status: 'idle' | 'running';
+}
+/**
+ * The turn closed. `interrupted` is already derived by the producer from the
+ * host's reason vocabulary, so the tracker never learns those spellings.
+ */
+ | {
+    readonly kind: 'turn-end';
+    readonly at: number;
+    readonly interrupted?: boolean;
+};

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;