dsh-working-activity 0.2.6 → 0.3.2

package/lib/types/status.js

@@ -5,7 +5,8 @@
  * no timers, no cordis — deterministic given the event stream and a clock.
  * @module @deepseek-ai/dsh-working-activity/status
  */
-import { actionFor, fmtDuration, isGitTool, isNight, pickPhrase, thinkingPhrase, WAITING_PHRASES, DONE_PHRASES, FAIL_PHRASES, } from './phrases.js';
+import { actionFor, compactPhrase, continuePhrase, donePhrase, failPhrase, fmtDuration, holidayPhrase, isGitTool, isNight, isWeekend, modelQuip, overflowPhrase, rarePhrase, RARE_CHANCE, RARE_PHRASES, EN_RARE_PHRASES, thinkingPhrase, weekendPhrase, waitingPhrase, } from './phrases.js';
+import { t } from './lang.js';
 /** Format one tool into its display fragment (`跑个命令 npm test`). */
 function toolFragment(tool) {
     return tool.detail.length === 0 ? tool.action : `${tool.action} ${tool.detail}`;
@@ -94,7 +95,28 @@ export class ActivityTracker {
     /** Total tokens reported across the turn's assistant messages. */
     turnTokens = 0;
     /** Completion prefix drawn ONCE at turn end so the done line stays stable. */
-    donePrefix = '搞定 ✓';
+    donePrefix = t('done-prefix');
+    /** Easter eggs shown once per turn (holiday / rare / weekend). */
+    holidayShown = false;
+    rareShown = false;
+    weekendShown = false;
+    /** One-off copy pinned by an external event (interrupt / model switch /
+     *  compaction / work reminder), shown until it expires. */
+    pendingPhrase = null;
+    pendingUntil = 0;
+    /** Git branch of the session cwd (fed by the host, best-effort). */
+    gitBranch;
+    /** Consecutive fast tool streak (combo). */
+    streak = 0;
+    lastToolEndAt = 0;
+    maxStreak = 0;
+    /** Subagent (agent/task) calls in the current turn. */
+    subagentCount = 0;
+    /** Work-reminder fired once per turn. */
+    reminded = false;
+    /** Streaming token estimate for the tps prefix. */
+    tokBuf = 0;
+    tokWindowStart = 0;
     /**
      * @param config - Behavioral knobs.
      * @param now - Wall-clock supplier (injectable for tests).
@@ -120,6 +142,34 @@ export class ActivityTracker {
             this.waitingFirstToken = true;
         }
     }
+    /** The user interrupted the running turn: show a comeback quip next. */
+    onInterrupted() {
+        if (!this.config.phrases)
+            return;
+        this.pendingPhrase = continuePhrase();
+        this.pendingUntil = this.now() + PENDING_MS;
+    }
+    /** The model was switched: quip for the new model id. */
+    onModelSwitch(modelId) {
+        if (!this.config.phrases)
+            return;
+        const quip = modelQuip(modelId);
+        if (quip !== null) {
+            this.pendingPhrase = quip;
+            this.pendingUntil = this.now() + PENDING_MS;
+        }
+    }
+    /** A context compaction finished (or overflowed): quip about it. */
+    onCompact(kind) {
+        if (!this.config.phrases)
+            return;
+        this.pendingPhrase = kind === 'overflow' ? overflowPhrase() : compactPhrase();
+        this.pendingUntil = this.now() + PENDING_MS;
+    }
+    /** Feed the session cwd's git branch (best-effort, host-resolved). */
+    onGitBranch(branch) {
+        this.gitBranch = branch;
+    }
     /** Consume one durable session event (turn/step/tool/stream). */
     onSessionEvent(event) {
         switch (event.type) {
@@ -137,6 +187,18 @@ export class ActivityTracker {
                 this.narratedText = null;
                 this.lastChunkAt = 0;
                 this.recentStream = '';
+                // Easter eggs are once-per-turn: a fresh turn can roll them again.
+                this.holidayShown = false;
+                this.rareShown = false;
+                this.weekendShown = false;
+                // Per-turn stats reset; the pending quip (interrupt/model/compact)
+                // survives across the turn boundary so it shows on the next think.
+                this.streak = 0;
+                this.maxStreak = 0;
+                this.subagentCount = 0;
+                this.reminded = false;
+                this.tokBuf = 0;
+                this.tokWindowStart = at;
                 this.setPhase('waiting', at);
                 return;
             }
@@ -158,6 +220,8 @@ export class ActivityTracker {
                     const narration = extractNarration(this.recentStream);
                     if (narration !== null)
                         this.narratedText = narration;
+                    // Streaming token estimate for the tps prefix (pi parity).
+                    this.tokBuf += estimateTokens(chunk.text);
                 }
                 return;
             }
@@ -174,6 +238,14 @@ export class ActivityTracker {
                 if (this.phase === 'thinking' || this.phase === 'waiting') {
                     this.thinkingMs += at - this.thinkingStartedAt;
                 }
+                // Combo streak: consecutive tools within COMBO_GAP_MS count up.
+                this.streak = (this.lastToolEndAt > 0 && at - this.lastToolEndAt <= COMBO_GAP_MS)
+                    ? this.streak + 1
+                    : 1;
+                if (this.streak > this.maxStreak)
+                    this.maxStreak = this.streak;
+                if (/^(?:subagent|agent|task)$/i.test(event.data.name))
+                    this.subagentCount += 1;
                 const parsed = parseArguments(event.data.arguments);
                 const action = this.config.phrases ? actionFor(event.data.name, this.customActions) : event.data.name;
                 const detail = detailFor(event.data.name, parsed, this.config.detailLimit);
@@ -202,6 +274,7 @@ export class ActivityTracker {
                 active.endedAt = at;
                 this.toolMs += at - active.startedAt;
                 this.toolCount += 1;
+                this.lastToolEndAt = at;
                 this.doneQueue.push({
                     action: active.action,
                     detail: active.detail,
@@ -231,13 +304,15 @@ export class ActivityTracker {
                     this.thinkingMs += Math.max(0, at - this.thinkingStartedAt);
                 }
                 // Draw the completion prefix ONCE so repeated renders of the done line
-                // stay stable (a fresh random per render would make it flicker).
+                // stay stable (a fresh random per render would make it flicker). The
+                // pools are language-aware, so the line matches the language the turn
+                // ended in.
                 const lastTool = this.doneQueue.at(-1);
                 if (this.config.phrases) {
-                    this.donePrefix = lastTool?.failed ? pickPhrase(FAIL_PHRASES) : pickPhrase(DONE_PHRASES);
+                    this.donePrefix = lastTool?.failed ? failPhrase() : donePhrase();
                 }
                 else {
-                    this.donePrefix = '搞定 ✓';
+                    this.donePrefix = t('done-prefix');
                 }
                 this.setPhase('done', at);
                 return;
@@ -275,11 +350,14 @@ export class ActivityTracker {
                 }
                 const fragment = toolFragment(tool);
                 const elapsed = fmtDuration(Math.max(0, nowMs - tool.startedAt));
-                const git = tool.isGit ? ' · git' : '';
+                const git = tool.isGit
+                    ? (this.gitBranch !== undefined ? ` · git ${this.gitBranch}` : ' · git')
+                    : '';
+                const combo = this.streak >= COMBO_SHOW_AT ? ` · 🔥x${this.streak}` : '';
                 const narration = this.freshNarration(nowMs);
                 const line = narration === null
-                    ? `${fragment} · ${elapsed}${git}`
-                    : `⏵ ${narration} · ${fragment} · ${elapsed}${git}`;
+                    ? `${fragment} · ${elapsed}${git}${combo}`
+                    : `⏵ ${narration} · ${fragment} · ${elapsed}${git}${combo}`;
                 return {
                     phase: 'tool',
                     line,
@@ -314,11 +392,12 @@ export class ActivityTracker {
             ? 0
             : this.thinkingMs + Math.max(0, nowMs - this.thinkingStartedAt);
         const elapsed = fmtDuration(this.turnElapsedMs(nowMs));
+        const elapsedLine = t('line-elapsed', { elapsed });
         const narration = this.freshNarration(nowMs);
         if (narration !== null) {
             return {
                 phase: this.phase,
-                line: `⏵ ${narration} · 总${elapsed}`,
+                line: `⏵ ${narration} · ${elapsedLine}`,
                 phrase: narration,
                 toolCount: this.toolCount,
                 turnElapsedMs: this.turnElapsedMs(nowMs),
@@ -326,49 +405,128 @@ export class ActivityTracker {
             };
         }
         if (this.config.phrases) {
-            if (nowMs - this.phraseChangedAt >= PHRASE_ROTATE_MS) {
+            const pending = this.pendingPhraseAt(nowMs);
+            // Rare eggs linger longer (pi RARE_PHRASE_TICKS ≈ 7.5s).
+            const rotateMs = this.previousPhrase !== undefined && this.isRarePhrase(this.previousPhrase)
+                ? RARE_ROTATE_MS
+                : PHRASE_ROTATE_MS;
+            if (pending !== null) {
+                this.previousPhrase = pending;
+                this.phraseChangedAt = nowMs;
+            }
+            else if (nowMs - this.phraseChangedAt >= rotateMs) {
                 // Waiting (pre-first-token) draws from the waiting pool; thinking
-                // rotates the playful copy pool with night mixing.
+                // rotates the egg-aware lively pool (holiday / rare / weekend /
+                // night). Both pools are language-aware, so a `/lang` switch shows
+                // on the next rotation.
                 this.previousPhrase = this.phase === 'waiting'
-                    ? pickPhrase(WAITING_PHRASES, this.previousPhrase)
-                    : thinkingPhrase(thinkingMs, this.previousPhrase, isNight(new Date(nowMs).getHours()));
+                    ? waitingPhrase(this.previousPhrase)
+                    : this.livelyPhrase(thinkingMs, nowMs);
                 this.phraseChangedAt = nowMs;
             }
             const phrase = this.previousPhrase ?? (this.phase === 'waiting'
-                ? pickPhrase(WAITING_PHRASES)
-                : thinkingPhrase(thinkingMs, undefined, isNight(new Date(nowMs).getHours())));
+                ? waitingPhrase()
+                : this.livelyPhrase(thinkingMs, nowMs));
+            // Ellipsis breathing (pi DOT_FRAMES) + optional estimated tps prefix.
+            const dots = DOT_FRAMES[Math.floor(nowMs / TICK_MS) % DOT_FRAMES.length];
+            const tps = this.tpsPrefix(nowMs);
             return {
                 phase: this.phase,
-                line: `${phrase} · 总${elapsed}`,
+                line: `${tps}${phrase}${dots} · ${elapsedLine}`,
                 phrase,
                 toolCount: this.toolCount,
                 turnElapsedMs: this.turnElapsedMs(nowMs),
                 phaseStartedAt: this.phaseStartedAt,
             };
         }
-        const label = this.phase === 'waiting' ? '等待模型响应' : '思考中';
+        const label = this.phase === 'waiting' ? t('waiting-label') : t('thinking-label');
         return {
             phase: this.phase,
-            line: `${label} · 总${elapsed}`,
+            line: `${label} · ${elapsedLine}`,
             label,
             toolCount: this.toolCount,
             turnElapsedMs: this.turnElapsedMs(nowMs),
             phaseStartedAt: this.phaseStartedAt,
         };
     }
+    /**
+     * Pick the next thinking phrase with the pi extension's egg order:
+     * holiday (once per turn) → rare 1/150 (once per turn) → weekend greeting
+     * (once per turn) → elapsed-time tiers with night mixing. Every egg is
+     * gated by `config.features` (absent flags default to on).
+     */
+    livelyPhrase(thinkingMs, nowMs) {
+        const features = this.config.features ?? {};
+        const now = new Date(nowMs);
+        if (features.holidays !== false && !this.holidayShown) {
+            const holiday = holidayPhrase(now);
+            if (holiday !== null) {
+                this.holidayShown = true;
+                return holiday;
+            }
+        }
+        if (features.rareEggs !== false && !this.rareShown && Math.random() < RARE_CHANCE) {
+            this.rareShown = true;
+            return rarePhrase(this.previousPhrase);
+        }
+        if (features.weekend !== false && !this.weekendShown && isWeekend(now)) {
+            this.weekendShown = true;
+            return weekendPhrase(this.previousPhrase);
+        }
+        return thinkingPhrase(thinkingMs, this.previousPhrase, features.nightPhrases !== false && isNight(now.getHours()), this.config.customPhrases);
+    }
+    /** The pending one-off quip (interrupt / model / compact / work reminder)
+     *  while it is still fresh; expired pending is cleared here. */
+    pendingPhraseAt(nowMs) {
+        if (this.pendingPhrase !== null) {
+            if (nowMs < this.pendingUntil)
+                return this.pendingPhrase;
+            this.pendingPhrase = null;
+        }
+        const remindAt = this.config.workRemindAt ?? 0;
+        if (!this.reminded && remindAt > 0) {
+            const hours = this.turnElapsedMs(nowMs) / 3_600_000;
+            if (hours >= remindAt) {
+                this.reminded = true;
+                return t('work-remind', { hours: Math.floor(hours) });
+            }
+        }
+        return null;
+    }
+    /** Whether a phrase comes from the rare pool (longer display window). */
+    isRarePhrase(phrase) {
+        return RARE_PHRASES.includes(phrase) || EN_RARE_PHRASES.includes(phrase);
+    }
+    /** Estimated tokens/s while the stream is fresh (pi parity, opt-in). */
+    tpsPrefix(nowMs) {
+        if (!this.config.showTokPerSec || this.tokBuf <= 0)
+            return '';
+        if (nowMs - this.lastChunkAt > TPS_WINDOW_MS)
+            return '';
+        const windowSec = Math.max(1, (nowMs - this.tokWindowStart) / 1000);
+        const tps = Math.round(this.tokBuf / windowSec);
+        return tps > 0 ? `~${tps} tok/s · ` : '';
+    }
     doneSummary(nowMs) {
         const { thinkingMs, toolMs, toolCount } = this.stats();
         const tokens = this.turnTokens > 0 ? ` · 🔥 ${fmtTokens(this.turnTokens)}` : '';
-        const base = `${this.donePrefix} · ${toolCount} 工具 · 想${fmtDuration(thinkingMs)} 干${fmtDuration(toolMs)}${tokens}`;
+        const sub = this.subagentCount > 0 ? ` · ${t('subagent-count', { count: this.subagentCount })}` : '';
+        const combo = this.maxStreak >= COMBO_SHOW_AT ? ` · 🔥x${this.maxStreak}` : '';
+        const tools = t(toolCount === 1 ? 'tool-count-one' : 'tool-count-many', { count: toolCount });
+        const summary = t('done-summary', {
+            tools,
+            thinking: fmtDuration(thinkingMs),
+            tooling: fmtDuration(toolMs),
+        });
         if (!this.config.phrases) {
-            return { line: `搞定 ✓ · ${toolCount} 工具 · 想${fmtDuration(thinkingMs)} 干${fmtDuration(toolMs)}${tokens}` };
+            return { line: `${t('done-prefix')} · ${summary}${sub}${combo}${tokens}` };
         }
         const last = this.doneQueue.at(-1);
         if (last !== undefined && nowMs - last.endedAt < DONE_FRAGMENT_MS) {
             const fragment = toolFragment(last);
-            return { line: `${this.donePrefix} · ${fragment} · ${toolCount} 工具${tokens}`, phrase: this.donePrefix };
+            return { line: `${this.donePrefix} · ${fragment} · ${tools}${sub}${combo}${tokens}`, phrase: this.donePrefix };
         }
-        return { line: base, ...(this.donePrefix === '搞定 ✓' ? {} : { phrase: this.donePrefix }) };
+        return { line: `${this.donePrefix} · ${summary}${sub}${combo}${tokens}`, phrase: this.donePrefix };
     }
     /** The fresh self-narration line, or null once the stream has been quiet. */
     freshNarration(nowMs) {
@@ -396,6 +554,20 @@ export class ActivityTracker {
 }
 /** Rotate the thinking phrase every N render ticks (render cadence ≈ 500ms → ~4s). */
 const PHRASE_ROTATE_MS = 4000;
+/** Rare easter-egg phrases linger this long before rotation (pi ≈ 7.5s). */
+const RARE_ROTATE_MS = 7500;
+/** One-off quips (interrupt / model / compact) display window. */
+const PENDING_MS = 6000;
+/** Tools closer than this count as one combo streak. */
+const COMBO_GAP_MS = 10_000;
+/** Streak at which the combo badge shows. */
+const COMBO_SHOW_AT = 2;
+/** The tps estimate stays fresh this long after the last chunk. */
+const TPS_WINDOW_MS = 3500;
+/** Render tick cadence (matches the TUI's 500ms activity timer). */
+const TICK_MS = 500;
+/** Ellipsis breathing frames appended to thinking lines (pi parity). */
+const DOT_FRAMES = ['', ' ·', ' ··', ' ···', ' ··', ' ·'];
 /** Cap on replayed done cards; older entries drop. */
 const DONE_QUEUE_MAX = 6;
 /** Show the last tool's fragment in the done line for this long after it ends. */
@@ -423,6 +595,14 @@ function fmtTokens(tokens) {
         return `${(tokens / 1000).toFixed(1)}k`;
     return String(tokens);
 }
+/** Coarse streaming token estimate (pi parity: CJK ×1.5, others ÷4). */
+function estimateTokens(text) {
+    const compact = text.replace(/\s/g, '');
+    if (compact.length === 0)
+        return 0;
+    const cjkCount = (compact.match(/[\u3400-\u9fff]/g) ?? []).length;
+    return Math.max(1, Math.ceil(cjkCount * 1.5 + (compact.length - cjkCount) / 4));
+}
 /** Parse a tool call's raw arguments JSON defensively. */
 function parseArguments(raw) {
     if (raw.trim().length === 0)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-working-activity",
   "description": "Live model working-status line: playful copy, running tool, turn elapsed — for TUI prompt and Web UI",
-  "version": "0.2.6",
+  "version": "0.3.2",
   "type": "module",
   "main": "lib/types/index.js",
   "types": "lib/types/index.d.ts",
@@ -14,10 +14,18 @@
       "types": "./lib/types/client/index.d.ts",
       "default": "./lib/client.js"
     },
+    "./config": {
+      "types": "./lib/types/config.d.ts",
+      "default": "./lib/types/config.js"
+    },
     "./events": {
       "types": "./lib/types/events.d.ts",
       "default": "./lib/types/events.js"
     },
+    "./frames": {
+      "types": "./lib/types/frames.d.ts",
+      "default": "./lib/types/frames.js"
+    },
     "./invariant": {
       "types": "./lib/types/invariant.d.ts",
       "default": "./lib/types/invariant.js"
@@ -41,6 +49,7 @@
   "scripts": {
     "build": "tsc -p tsconfig.json && tsc -p tsconfig.client.json",
     "build:client": "tsdown -c tsdown.config.ts",
+    "test": "vitest run",
     "verify:deps": "node scripts/verify-manifest-deps.mjs",
     "verify:lockfiles": "node scripts/verify-lockfiles.mjs",
     "prepublishOnly": "npm run verify:deps && npm run verify:lockfiles && npm run build && npm run build:client"
@@ -98,7 +107,8 @@
     "lightningcss": "^1.32.0",
     "react": "^18.2.0",
     "tsdown": "^0.22.2",
-    "typescript": "^6.0.3"
+    "typescript": "^6.0.3",
+    "vitest": "^3.2.4"
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/dsh-client-runtime": {

package/src/client/WorkingLine.module.css

@@ -1,74 +1,74 @@
-/* Working line row: one dim line with a phase-colored breathing marker and
-   the turn's tool-count badge, sized to the composer dock inset like the
-   queue strip. Mirrors the pre-slots patch's WorkingLine visuals, re-targeted
-   at the rc.6 design tokens. */
-
-.line {
-  box-sizing: border-box;
-  display: flex;
-  align-items: center;
-  gap: 8px;
-  width: 100%;
-  max-width: var(--dsh-composer-card-max-width);
-  margin: 0 auto;
-  padding: 4px 16px 0;
-  font-family: var(--dsw-font-family);
-  font-size: 13px;
-  line-height: 18px;
-  color: var(--dsw-alias-label-secondary);
-}
-
-.marker {
-  flex: none;
-  width: 7px;
-  height: 7px;
-  border-radius: 50%;
-  background: var(--dsw-alias-label-tertiary);
-  animation: working-pulse 1.6s ease-in-out infinite;
-}
-
-/* The model's turn is done: steady marker in the brand tone, no pulse. */
-.line[data-activity-phase='done'] .marker {
-  background: var(--dsw-alias-state-business-primary);
-  animation: none;
-}
-
-/* A tool is actually executing: brand-tone pulse. */
-.line[data-activity-phase='tool'] .marker {
-  background: var(--dsw-alias-state-business-primary);
-}
-
-/* Waiting for the first token: muted pulse. */
-.line[data-activity-phase='waiting'] .marker {
-  background: var(--dsw-alias-label-tertiary);
-  opacity: 0.6;
-}
-
-.text {
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-}
-
-.tools {
-  flex: none;
-  min-width: 18px;
-  padding: 0 5px;
-  border-radius: 9px;
-  background: var(--dsw-alias-surface-tertiary);
-  color: var(--dsw-alias-label-secondary);
-  font-size: 11px;
-  line-height: 18px;
-  text-align: center;
-}
-
-@keyframes working-pulse {
-  0%,
-  100% {
-    opacity: 1;
-  }
-
-  50% {
-    opacity: 0.35;
-  }
-}
+/* Working line row: one dim line with a phase-colored breathing marker and
+   the turn's tool-count badge, sized to the composer dock inset like the
+   queue strip. Mirrors the pre-slots patch's WorkingLine visuals, re-targeted
+   at the rc.6 design tokens. */
+
+.line {
+  box-sizing: border-box;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  width: 100%;
+  max-width: var(--dsh-composer-card-max-width);
+  margin: 0 auto;
+  padding: 4px 16px 0;
+  font-family: var(--dsw-font-family);
+  font-size: 13px;
+  line-height: 18px;
+  color: var(--dsw-alias-label-secondary);
+}
+
+.marker {
+  flex: none;
+  width: 7px;
+  height: 7px;
+  border-radius: 50%;
+  background: var(--dsw-alias-label-tertiary);
+  animation: working-pulse 1.6s ease-in-out infinite;
+}
+
+/* The model's turn is done: steady marker in the brand tone, no pulse. */
+.line[data-activity-phase='done'] .marker {
+  background: var(--dsw-alias-state-business-primary);
+  animation: none;
+}
+
+/* A tool is actually executing: brand-tone pulse. */
+.line[data-activity-phase='tool'] .marker {
+  background: var(--dsw-alias-state-business-primary);
+}
+
+/* Waiting for the first token: muted pulse. */
+.line[data-activity-phase='waiting'] .marker {
+  background: var(--dsw-alias-label-tertiary);
+  opacity: 0.6;
+}
+
+.text {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.tools {
+  flex: none;
+  min-width: 18px;
+  padding: 0 5px;
+  border-radius: 9px;
+  background: var(--dsw-alias-surface-tertiary);
+  color: var(--dsw-alias-label-secondary);
+  font-size: 11px;
+  line-height: 18px;
+  text-align: center;
+}
+
+@keyframes working-pulse {
+  0%,
+  100% {
+    opacity: 1;
+  }
+
+  50% {
+    opacity: 0.35;
+  }
+}

package/src/client/WorkingLine.tsx

@@ -1,42 +1,42 @@
-// Working-line dock entry: one dim full-width row above the composer card
-// showing the live working-activity snapshot — phase-colored breathing
-// marker, the host-composed status line, and the turn's tool count badge.
-// Renders for every live phase (waiting/thinking/tool) and the done summary;
-// hides while idle or before the first publish.
-//
-// The 'conversation.input.dock' SlotMap declaration lives in
-// @deepseek-ai/dsh-client-ui-conversation/client (contract/slots.ts); this
-// entry contributes into it without owning it.
-import type { PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots'
-import css from './WorkingLine.module.css'
-
-/** Full props of the dock entry: the input-zone runtime share (session standard kit). */
-export type WorkingLineProps = PropsRuntime<'conversation.input.dock'>
-
-/** Tool-count badge copy (no locale seat: the line text itself is host-composed). */
-const TOOLS_LABEL = 'tools this turn'
-
-/**
- * Working-line dock entry: reads the latest activity snapshot off the
- * conversation snapshot and renders the row, or nothing when idle/absent.
- */
-export function WorkingLine({ useSession }: WorkingLineProps) {
-  // Defensive read: the runtime patch that puts `activity` onto the
-  // conversation snapshot ships separately — on an unpatched host the field
-  // is absent (undefined), not null, and this component must render nothing
-  // instead of crashing into the slot error boundary. Same never-throw
-  // discipline as the node side's registration.js.
-  const activity = useSession(s => s.activity ?? null)
-  if (activity === null || activity.phase === 'idle' || activity.line === '') return null
-  return (
-    <div className={css.line} data-activity-phase={activity.phase}>
-      <span className={css.marker} aria-hidden="true" />
-      <span className={css.text}>{activity.line}</span>
-      {activity.toolCount > 0 && (
-        <span className={css.tools} title={`${activity.toolCount} ${TOOLS_LABEL}`}>
-          {activity.toolCount}
-        </span>
-      )}
-    </div>
-  )
-}
+// Working-line dock entry: one dim full-width row above the composer card
+// showing the live working-activity snapshot — phase-colored breathing
+// marker, the host-composed status line, and the turn's tool count badge.
+// Renders for every live phase (waiting/thinking/tool) and the done summary;
+// hides while idle or before the first publish.
+//
+// The 'conversation.input.dock' SlotMap declaration lives in
+// @deepseek-ai/dsh-client-ui-conversation/client (contract/slots.ts); this
+// entry contributes into it without owning it.
+import type { PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots'
+import css from './WorkingLine.module.css'
+
+/** Full props of the dock entry: the input-zone runtime share (session standard kit). */
+export type WorkingLineProps = PropsRuntime<'conversation.input.dock'>
+
+/** Tool-count badge copy (no locale seat: the line text itself is host-composed). */
+const TOOLS_LABEL = 'tools this turn'
+
+/**
+ * Working-line dock entry: reads the latest activity snapshot off the
+ * conversation snapshot and renders the row, or nothing when idle/absent.
+ */
+export function WorkingLine({ useSession }: WorkingLineProps) {
+  // Defensive read: the runtime patch that puts `activity` onto the
+  // conversation snapshot ships separately — on an unpatched host the field
+  // is absent (undefined), not null, and this component must render nothing
+  // instead of crashing into the slot error boundary. Same never-throw
+  // discipline as the node side's registration.js.
+  const activity = useSession(s => s.activity ?? null)
+  if (activity === null || activity.phase === 'idle' || activity.line === '') return null
+  return (
+    <div className={css.line} data-activity-phase={activity.phase}>
+      <span className={css.marker} aria-hidden="true" />
+      <span className={css.text}>{activity.line}</span>
+      {activity.toolCount > 0 && (
+        <span className={css.tools} title={`${activity.toolCount} ${TOOLS_LABEL}`}>
+          {activity.toolCount}
+        </span>
+      )}
+    </div>
+  )
+}