Merge origin/master into worktree/web-plugin-config

Master moved every workspace edge to workspace:^ and added release-member
fields; this branch's manifests follow, keeping only the dependency edges it
contributes. The client-runtime README keeps this branch's paragraph: master
did not touch it, and the base/user layers and `unset` it describes are what
this branch added.

.agents/notes/implemented/architecture/2026-08-09-client-conversation-node-assembly.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write .agents/notes/implemented/architecture/2026-08-09-client-conversation-node-assembly.md
-2026-08-09-client-conversation-node-assembly.md: 16a39539064644e5467f701789a7e2ef1f7ff172
-2026-08-09-client-conversation-node-assembly.zh.md: 0e0fbdf8f3320393022528e6e3fe2cf0d492a1d3
+2026-08-09-client-conversation-node-assembly.md: f6cd7ea94d485d92fd4ea178751c08bd01ecb4b2
+2026-08-09-client-conversation-node-assembly.zh.md: e550b7870a611ec625d7c2a738bf71947825ea58

.agents/notes/implemented/architecture/2026-08-09-client-conversation-node-assembly.md

@@ -148,7 +148,7 @@ The Assembler verifies `node.key === context.key` and `node.target === target`.
 
 `current` lets a Definition distinguish "never materialized" from "already materialized and now hidden." Assistant retry and Turn Error suppression use it to avoid illegal Node withdrawal.
 
-A Definition may branch by target to construct different data, while matching, Context identity, and State remain target-neutral. This change registers only the `chat` builder; Trajectory remains on its independent `session-history` fold until it gains a registered target.
+A Definition owns at most one view target; state-only Definitions omit both `target` and `buildViewNode()`. Chat and Trajectory register separate business Definitions even when they recognize the same durable Event family, while the shared Assembler supplies the same matching, replay, Location, and publication mechanics to both targets.
 
 #### No generic `end()`
 
@@ -328,7 +328,9 @@ When business logic deliberately changes a materialized Node to hidden, it leave
 
 The concrete Tool renderer remains governed by the [`ui-tool ownership decision`](2026-08-08-client-tool-presentation-ownership.md). Tool Definition supplies recursive root/subcall data, and `ui-tool` dispatches concrete presentation by the Tool-name keyed slot.
 
-Trajectory has no registered target and does not consume the Chat Builder's legacy slice. Its activated `SessionHistoryInspection` keeps an independent history fold, while the ordinary Session snapshot no longer runs a second transcript fold. The Chat Builder retains its legacy slice for StatsLine and the top-level public compatibility fields; a future Trajectory migration does not change the Event Definition, Context, Reader, or Location contracts.
+Trajectory registers its own target and business Definitions against the same Assembler and Session event window as Chat. Its target builder preserves the stage-oriented read model without consuming the Chat Builder's legacy slice or running an independent history fold. The Chat Builder retains its legacy slice for StatsLine and the top-level public compatibility fields; target-specific Definitions do not change the shared Context, Reader, or Location contracts.
+
+The target-specific Trajectory Definitions, retained stage model, Steering adaptation, complexity bounds, and presentation hot paths are owned by the [Trajectory Context assembly decision](2026-08-11-trajectory-conversation-context-assembly.md).
 
 ## Runtime and render path
 
@@ -339,20 +341,17 @@ Session Event window
        -> Context matches + State + Location
        -> Definition.buildLocationData(step -> turn)
             -> StepLocation.data / TurnLocation.data
-       -> Definition.buildViewNode(target = chat)
-  -> ChatSnapshotBuilder
-       -> order[] + keyed Node store + Location index + timeline
-  -> ChatView
-       -> ChatNodeSeat(key)
-       -> conversation.chat.node(entryKey = node.kind, hookContext = key)
-            -> slot-level useTurnData(businessKey)
+       -> Definition.buildViewNode() for its declared target
+  -> target View Builder
+       -> chat: ChatSnapshotBuilder -> ChatView -> keyed ChatNodeSeat
+       -> trajectory: TrajectorySnapshotBuilder -> stages/layout/table
 ```
 
 ## Verification
 
 Runtime tests pin Definition lifecycle registration, exact-ID append, update-before-start collection followed by forward replay after start, prepend identity, Reader window-gap repair, transitive dependencies, Location closure, Step→Turn data phase order, Location data replacement, publication cadence, illegal withdrawal, and per-target Builders.
 
-Conversation tests cover every built-in Definition, Assistant Step data, Turn Tail and Deliverables Turn data, Chat ordering and structural sharing, selector isolation, Assistant and Tool running-to-settled identity, nested Code Dispatch, steering, Compaction, Retry, interruption, load-older anchoring, and slot dispatch.
+Conversation tests cover every built-in Chat Definition, Assistant Step data, Turn Tail and Deliverables Turn data, Chat ordering and structural sharing, selector isolation, Assistant and Tool running-to-settled identity, nested Code Dispatch, steering, Compaction, Retry, interruption, load-older anchoring, and slot dispatch. Trajectory tests cover its independently registered Message, Assistant, Tool, Compaction, Request-header, and boundary Definitions together with the preserved stage-oriented view model.
 
 Slot type/runtime tests pin required parent-provided common inject, the `hookContext` type, Hook isolation across Node contexts, stable factory/Hook identity, and the absence of business-renderer rerenders for unrelated Session publications. Existing entry-owned Observable Hook tests continue to pin the path that does not use a contextual factory.
 
@@ -382,7 +381,7 @@ History-path tests cover complete replace, non-overlapping prepend, overlapping-
 
 **Add generic `end()`, prepared, or window-reset lifecycles.** Rejected: businesses have different completion conditions, and a pagination gap is not a business lifecycle. Business Events update State, Location close triggers replay/build, and Reader dependencies own pagination invalidation.
 
-**Register separate Event Definitions for Chat and Trajectory.** Rejected: identity, State, and Location are target-neutral. `buildViewNode(target)` and each Builder express view differences; Trajectory's independent history fold remains until it registers its own Builder.
+**Reuse one Event Definition across Chat and Trajectory by branching in `buildViewNode(target)`.** Rejected: the views require different business State and intermediate records, so a shared Definition would make each package carry the other's conditions and payloads. Separate target-owned Definitions keep those choices local while sharing the Assembler's ingestion and lifecycle contracts.
 
 **Add a generic layout model above final business Nodes.** Rejected: activity, tail candidacy, and layout enums would centralize current Chat business semantics in the engine again. Final Nodes carry renderer-required data directly and share only identity, ordering, and Location facts.
 
@@ -406,4 +405,4 @@ Steps and Turns become stable homes for cross-business aggregates. Turn Tail and
 
 The cost is new Runtime contracts for Registry, Assembler, Location data, dependency replay, and per-target Builders, plus parent-owned common inject and per-occurrence `hookContext` in UI Slots. Definition authors must understand stable IDs, unique starts, forward replay, Step→Turn publication order, read-only Reader access, and the prohibition on Node withdrawal.
 
-`useTurnData()` does not revoke the standard `useSession` capability from session-scoped renderers, so this boundary relies on API guidance and tests rather than capability isolation. Registry changes remain low-frequency full rebuilds; the Chat Builder still maintains a legacy slice for StatsLine and the top-level public fields, Trajectory still owns an independent history fold, and built-in Definitions currently remain centralized in `ui-conversation`. These compatibility boundaries do not return business interpretation to Session.
+`useTurnData()` does not revoke the standard `useSession` capability from session-scoped renderers, so this boundary relies on API guidance and tests rather than capability isolation. Registry changes remain low-frequency full rebuilds; the Chat Builder still maintains a legacy slice for StatsLine and the top-level public fields, while Trajectory owns target-specific Definitions and a Builder over the shared Session window. Built-in Definitions remain in their respective UI packages, and these compatibility boundaries do not return business interpretation to Session.

.agents/notes/implemented/architecture/2026-08-09-client-conversation-node-assembly.zh.md

@@ -148,7 +148,7 @@ Assembler 校验 Node `key === context.key` 且 Node `target === target`。业
 
 `current` 让 Definition 区分“从未生成”与“已经生成后需要隐藏”。Assistant retry 和 Turn Error suppression 使用它避免非法的 Node 撤回。
 
-Definition 可以针对 target 分支构造不同 data，但匹配、Context identity 和 State 保持 target-neutral。本次只注册 `chat` builder；在拥有注册 target 之前，Trajectory 继续使用独立的 `session-history` fold。
+一个 Definition 最多拥有一个 view target；仅维护状态的 Definition 同时省略 `target` 与 `buildViewNode()`。即使 Chat 与 Trajectory 识别同一持久 Event 族，它们也分别注册自己的业务 Definition；共享 Assembler 则为两个 target 提供相同的匹配、replay、Location 与发布机制。
 
 #### 不提供通用 `end()`
 
@@ -328,7 +328,9 @@ Assistant streaming 到 final、Tool running 到 settled 只更新同一个 Seat
 
 具体 Tool renderer 仍由 [`ui-tool ownership decision`](2026-08-08-client-tool-presentation-ownership.md) 约束。Tool Definition 只交付递归 root/subcall data，`ui-tool` 再按 Tool name keyed slot 分发具体表现。
 
-Trajectory 尚未注册 target，也不消费 Chat Builder 的 legacy slice。它已激活的 `SessionHistoryInspection` 继续维护独立 history fold，而普通 Session snapshot 不再运行第二套 transcript fold。Chat Builder 为 StatsLine 和顶层公共兼容字段保留 legacy slice；未来迁移 Trajectory 不改变 Event Definition、Context、Reader 或 Location 契约。
+Trajectory 针对与 Chat 相同的 Assembler 和 Session 事件窗口注册自己的 target 与业务 Definition。它的 target builder 保留 stage-oriented read model，既不消费 Chat Builder 的 legacy slice，也不运行独立 history fold。Chat Builder 为 StatsLine 和顶层公共兼容字段保留 legacy slice；target 专属 Definition 不改变共享的 Context、Reader 或 Location 契约。
+
+target 专属 Trajectory Definition、保留的 stage model、Steering 适配、复杂度上界与表现层热点由 [Trajectory Context 组装决策](2026-08-11-trajectory-conversation-context-assembly.md)负责。
 
 ## Runtime and render path
 
@@ -339,20 +341,17 @@ Session Event window
        -> Context matches + State + Location
        -> Definition.buildLocationData(step -> turn)
             -> StepLocation.data / TurnLocation.data
-       -> Definition.buildViewNode(target = chat)
-  -> ChatSnapshotBuilder
-       -> order[] + keyed Node store + Location index + timeline
-  -> ChatView
-       -> ChatNodeSeat(key)
-       -> conversation.chat.node(entryKey = node.kind, hookContext = key)
-            -> slot-level useTurnData(businessKey)
+       -> Definition.buildViewNode() for its declared target
+  -> target View Builder
+       -> chat: ChatSnapshotBuilder -> ChatView -> keyed ChatNodeSeat
+       -> trajectory: TrajectorySnapshotBuilder -> stages/layout/table
 ```
 
 ## Verification
 
 Runtime tests 固定 Definition 生命周期注册、exact-ID append、update-before-start 收集与 start 后正序 replay、prepend identity、Reader window-gap 修复、传递依赖、Location closure、Step→Turn data phase order、Location data replacement、publication cadence、非法撤回和 per-target Builder。
 
-Conversation tests 覆盖全部内建 Definition、Assistant Step data、Turn Tail 与 Deliverables Turn data、Chat 排序和结构共享、selector isolation、Assistant/Tool running-to-settled identity、nested Code Dispatch、steering、Compaction、Retry、interruption、load-older anchoring 和 slot dispatch。
+Conversation tests 覆盖全部内建 Chat Definition、Assistant Step data、Turn Tail 与 Deliverables Turn data、Chat 排序和结构共享、selector isolation、Assistant/Tool running-to-settled identity、nested Code Dispatch、steering、Compaction、Retry、interruption、load-older anchoring 和 slot dispatch。Trajectory tests 则覆盖它独立注册的 Message、Assistant、Tool、Compaction、Request-header 与 boundary Definition，以及继续保留的 stage-oriented view model。
 
 Slot type/runtime tests 固定父注册必须提供声明的 common inject、`hookContext` 类型、不同 Node context 的 Hook 隔离、factory/Hook identity 稳定，以及无关 Session publication 不重渲染业务 renderer。原 entry-owned Observable Hook 测试继续固定未使用 contextual factory 的路径。
 
@@ -382,7 +381,7 @@ Assembled Web snapshot、GUI 和浏览器场景覆盖真实 plugin graph。浏
 
 **增加通用 `end()`、prepared 或 window reset 生命周期。** 拒绝：不同业务完成条件不同，分页缺口也不是业务生命周期。业务 Event 更新 State，Location close 触发 replay/build，Reader dependency 负责补页失效。
 
-**为 Chat 与 Trajectory 注册两套 Event Definition。** 拒绝：identity、State 和 Location 与 target 无关。视图差异由 `buildViewNode(target)` 和各自 Builder 表达；Trajectory 在注册自己的 Builder 之前继续使用独立 history fold。
+**在同一个 Event Definition 内通过 `buildViewNode(target)` 为 Chat 与 Trajectory 分支。** 拒绝：两种视图需要不同的业务 State 与中间记录，共用 Definition 会迫使每个 package 携带另一边的条件与 payload。target 自有的 Definition 把这些选择留在本地，同时复用 Assembler 的摄入与生命周期契约。
 
 **在最终业务 Node 上再叠一层通用 layout model。** 拒绝：activity、tail candidacy 和 layout enum 会把当前 Chat 的业务语义重新集中到引擎。最终 Node 直接携带 renderer 所需 data，只共享 identity、排序和 Location 事实。
 
@@ -406,4 +405,4 @@ Step/Turn 成为业务间共享聚合的稳定宿主。Turn Tail 和 Deliverable
 
 代价是 Runtime 新增 Registry、Assembler、Location data、依赖重放和 per-target Builder 契约，UI Slots 也新增 parent-owned common inject 与 per-occurrence `hookContext`。Definition 作者必须理解稳定 ID、唯一 start、正序 replay、Step→Turn 发布顺序、只读 Reader 和 Node 不撤回规则。
 
-`useTurnData()` 不撤销 session-scoped renderer 的标准 `useSession`，因此该边界依靠 API 引导和测试，而不是能力隔离。Registry 变化仍是低频完整 rebuild；Chat Builder 继续为 StatsLine 和顶层公共字段维护 legacy slice，Trajectory 继续拥有独立 history fold，内建 Definitions 暂时集中在 `ui-conversation`。这些是兼容边界，不把业务解释权交还给 Session。
+`useTurnData()` 不撤销 session-scoped renderer 的标准 `useSession`，因此该边界依靠 API 引导和测试，而不是能力隔离。Registry 变化仍是低频完整 rebuild；Chat Builder 继续为 StatsLine 和顶层公共字段维护 legacy slice，Trajectory 则在共享 Session 窗口上拥有 target 专属 Definition 与 Builder。内建 Definition 分别留在所属 UI package；这些兼容边界不把业务解释权交还给 Session。

.agents/notes/implemented/architecture/2026-08-11-trajectory-conversation-context-assembly.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# side as of the last confirmed-consistent state. Both languages carry equal authority;
+# after editing either side, bring the other along and re-record with:
+#   pnpm run verify-translation-pairing --write .agents/notes/implemented/architecture/2026-08-11-trajectory-conversation-context-assembly.md
+2026-08-11-trajectory-conversation-context-assembly.md: 7d0aea2fc09f0f04bd5de923bee15c42a773489a
+2026-08-11-trajectory-conversation-context-assembly.zh.md: be3903bc62a8b1cc21bd9ddac450541ad4679ff0

.agents/notes/implemented/architecture/2026-08-11-trajectory-conversation-context-assembly.md

@@ -0,0 +1,105 @@
+# Agent Note: Trajectory assembly from registered Conversation Contexts
+
+Status: implemented
+
+English | [中文](2026-08-11-trajectory-conversation-context-assembly.zh.md)
+
+## Problem
+
+Trajectory maintained an independent Session History source and folded the complete loaded Event window into Assistant, Tool, message, Request-header, and Compaction state. Chat already assembled the same Event families through registered Conversation Definitions. The two paths duplicated business correlation and pagination behavior, and a Trajectory structural update copied or rescanned work proportional to the raw Event count even when one business object changed.
+
+Reusing Chat's final Nodes would not solve the ownership problem. Trajectory needs request lifecycles, running Assistant state, prompt inheritance, Tool schemas, timing records, and a stage-oriented read model that Chat does not consume. Sharing final Node payloads would couple both views to the union of their requirements.
+
+The migration also had to preserve durable steering classification. A `user/message` does not say whether it opened a Turn or was claimed from the `next-step` inbox, and an older page can supply the missing inbox predecessor or Location after the message has already materialized.
+
+## Decision
+
+Trajectory registers target-owned Conversation Definitions and a `trajectory` View Builder against the shared [`ConversationNodeAssembler`](2026-08-09-client-conversation-node-assembly.md). Session owns one contiguous Event window and publishes both Chat and Trajectory snapshots through `Session.views`; it does not run a second Trajectory history source or business fold.
+
+Each Definition belongs to one target. Chat and Trajectory may recognize the same durable Event family, but they keep separate State and final Node payloads. They share only the Assembler's exact-ID matching, ordered Matches, Location facts, Reader dependencies, publication scheduling, and replace/prepend/append lifecycle.
+
+The existing [Trajectory inspection ledger](../feature/2026-07-27-trajectory-inspection-ledger.md) remains the view model. The Trajectory Builder converts materialized target Nodes into its established `eventNodes`, Requests, Tool schemas, running calls, and Location map; layout, table virtualization, selection, Overview, and inspector behavior do not become generic Conversation contracts.
+
+### Business Definitions
+
+| Business | Context identity | State assembly | Trajectory contribution |
+|---|---|---|---|
+| `next-step` inbox | splice Event seq | Apply the splice to the nearest preceding inbox Context | State only; no visible Node |
+| User, steering, or injected message | message Event seq | Read the preceding inbox State and classify the durable message | Input or context Node |
+| Assistant and ordinary Request | `turn:step` | Fold `step/start`, chunks, final message, retry, and `step/end` | Final Assistant, partial Assistant, and Request |
+| Root Tool call | root call ID | Fold root call/result and nested Code Dispatch events into one call tree | Final or running Tool tree |
+| Compaction | compaction ID | Fold start, summary, end, and replacement checkpoint | Compaction Request |
+| Request header | header Event seq | Read the preceding header and retain effective prompt plus the actual change | Prompt and Tool-schema source |
+| Session and Turn boundaries | boundary Event seq | Retain closure time and error facts | Interrupted Compaction or failed ordinary Request |
+
+Every correlating Event must expose the same business ID directly. Code Dispatch uses `rootCallId`, Compaction uses its compaction ID, and ordinary Tool and retry events retain their protocol identities even when a specific Definition correlates by `turn:step`. Legacy records that lack the required correlation ID are ignored by that Definition rather than merged into an `undefined` Context or crashing the Session.
+
+Assistant chunks update only their `turn:step` Context. Content-bearing chunks request animation-frame publication; usage and finish chunks update State without forcing their own frame. A final message, retry, or boundary publishes immediately. Completed Assistant State retains assembled blocks, timing, usage, and retry facts rather than copying the raw chunk ledger into the target snapshot.
+
+### Steering from predecessor Contexts
+
+Trajectory reconstructs steering from durable inbox history, using the same identity rule as the [Chat steering decision](../feature/2026-08-04-web-context-source-and-steer-marks.md) without sharing Chat's final Node.
+
+Each `agent/inbox/spliced` Event targeting `next-step` starts an invisible Context identified by its Event seq. Its `start()` reads the nearest earlier inbox Context, applies the splice, and stores the pending identities plus the cumulative set of claimed message IDs. A later user-origin `user/message` reads the nearest earlier inbox Context: a claimed ID produces a Steering Node, while every other user-origin message produces an ordinary User Node.
+
+A Reader miss while older history remains records a window-gap dependency. When prepend supplies the missing predecessor, the Assembler replays the affected inbox chain and message Contexts in forward Event order. Historical page direction therefore cannot permanently misclassify a message.
+
+The message Event's Location places steering in the owning Step. If the loaded history window lacks enough boundary Events to resolve that Location, layout uses the following Assistant step as the positional fallback. A running Request marker follows leading steering input in the same Step, so the marker denotes the model Request caused by that input rather than appearing before it.
+
+### Window paths and complexity
+
+Let `E` be the loaded raw Event count, `P` one newly prepended page, `D` the number of Trajectory Definitions, `C` the number of materialized Trajectory Context contributions, and `Mᵣ` the total Matches held by Contexts invalidated by a prepend. `D` is a small registered set; streaming chunks aggregate into one Assistant Context, so `C` is normally much smaller than `E`.
+
+| Path | Context work | Target snapshot work | Result |
+|---|---|---|---|
+| Initial tail or reconnect replace | Match the loaded window in `O(E × D)` and build State in forward Event order | Build and order `C` contributions | A full replace remains proportional to the loaded window |
+| Older-page prepend | Match only fresh Events and replay only Contexts whose Match, Location, or Reader answer changed, in `O(P × D + Mᵣ)` | Rebuild the stage snapshot from `C` contributions | Business folding does not restart over all `E` Events |
+| Live append | Match in `O(D)`, locate the keyed Context in `O(1)`, and update only that State | Replace a same-anchor contribution in `O(1)` before snapshot assembly | Business correlation is independent of loaded Event history |
+
+The Builder stores contributions by Context key and keeps a key-to-position index. A content update with the same anchor replaces one contribution in place; a new contribution or anchor change rebuilds and sorts contribution order. Snapshot assembly then walks `C` contributions, indexes Request headers and Tool schemas with Maps, and handles Compaction boundaries and Turn errors with linear cursors or indexes.
+
+Final Event and Request ordering keeps a publication's current upper bound at `O(C log C)`. The migration removes repeated reverse lookups and the old raw-history refold, but it does not claim end-to-end `O(1)` publication. Chat retains its existing keyed snapshot behavior and complexity; adding the Trajectory target does not make Chat scan Trajectory Contexts or Nodes.
+
+### Independent presentation hot paths
+
+The Context migration and the following presentation optimizations solve different costs. These reductions preserve the existing view model and are theoretical from call counts and asymptotic behavior; this decision does not claim benchmark measurements.
+
+| Hot path | Retained behavior | Expected reduction |
+|---|---|---|
+| Markdown summaries | Layout retains source Markdown; each stable Table record memoizes its displayed summary by content, while Detail parses only the selected record | A one-record append reparses the changed visible record instead of every Markdown record |
+| Search text | `TrajectorySearchIndex` linearly checks stable Record IDs and source signatures, but normalizes Markdown only for changed records and commits updates in three-second batches | Signature comparison remains `O(C)`; expensive normalization follows the changed-record count, and continuous frame updates collapse into one batch per interval |
+| Timeline tooltip | Timing text is computed after the delayed tooltip opens | A render with no open tooltip performs no per-span label formatting |
+| Following Assistant lookup | One reverse pass records the next Assistant for every input position | The former repeated forward lookup falls from worst-case `O(C²)` to `O(C)` |
+| Group duration | Fixed decimal grouping replaces `toLocaleString('en-US')` for the invariant English numeric shape | Complexity remains linear in Groups, but the Intl formatter leaves the repeated render path |
+
+Display memoization and search indexing stay separate. Search must include off-screen records and may lag live changes by the throttle interval; Table rendering must update the visible changed record immediately and must not inherit the index's commit cadence.
+
+## Alternatives considered
+
+**Keep the independent Session History fold and optimize it locally.** Rejected: caches could reduce selected hot paths, but Trajectory would still own a second Event window, pagination repair, request inspection fold, and business-correlation implementation beside Chat.
+
+**Reuse Chat Definitions and branch on a `target` argument in `buildViewNode()`.** Rejected: Trajectory needs different State and intermediate records, not only another React renderer. One Definition would carry both views' payloads and conditionals and would invalidate unrelated target data when either view changed.
+
+**Create a Trajectory-specific Assembler.** Rejected: exact-ID routing, update-before-start collection, prepend replay, Location repair, Reader dependencies, and publication cadence are not Trajectory-specific. A second engine would recreate the lifecycle duplication this change removes.
+
+**Add generic Surface, rewind, fanout, or settled lifecycle concepts.** Rejected: the current durable Event stream does not require a generic Surface branch, and Session or Turn boundaries are target business inputs rather than a reason to fan out one Event over every historical Context. Completion remains business State interpreted with Location closure.
+
+**Replace the Trajectory stages with generic Conversation Nodes.** Rejected: stages organize requests, timing, schemas, and table layout for one view. Making them engine contracts would constrain a future plain Session-log view and return view-specific composition to Client Runtime.
+
+**Share one Markdown cache between display and search.** Rejected: display is immediate and viewport-bound, while search covers the complete loaded record set and intentionally batches updates. A shared cache would couple correctness and scheduling across unrelated consumers.
+
+## Verification
+
+Runtime tests pin target registration, exact-ID append, update-before-start replay, prepend identity, Reader window-gap repair, Location replay, and isolation between Chat and Trajectory snapshots.
+
+Trajectory Definition and Builder tests pin Assistant streaming and interruption, nested Tool calls and parallel interruption, Compaction and prompt inheritance, Steering classification and Step placement, Request marker order, stable contribution replacement, and prepend expansion. Table, layout, Timeline, and search tests pin deferred Markdown work, throttled index updates, tooltip-time formatting, and stable search results across append and prepend.
+
+## Consequences
+
+Trajectory business assembly now scales with the changed page or keyed Context instead of restarting from the complete raw Event window. Target-owned Definitions can evolve independently from Chat while retaining one Session window and one set of lifecycle rules. Steering becomes a first-class Trajectory record at its actual Step position without adding steering-specific state to Session.
+
+The retained stage-oriented Builder still performs work proportional to materialized Trajectory contributions and may sort on publication. The search index still performs a light linear signature pass when its input layout changes. These costs are explicit target-view work, not hidden full Event refolding.
+
+Definition authors must provide stable protocol identities. Old Events without a required ID can disappear from the affected Trajectory business view, which is preferable to joining unrelated records or failing history load; producers that require faithful display must log the identity.
+
+The [Conversation assembly decision](2026-08-09-client-conversation-node-assembly.md) remains the authority for the generic Context, Reader, Location, and publication contracts. The [Trajectory ledger decision](../feature/2026-07-27-trajectory-inspection-ledger.md) remains the authority for table hierarchy, virtualization, inspector, and interaction behavior. This Note owns how Trajectory adapts those two decisions and why the adaptation does not share final Nodes with Chat.

.agents/notes/implemented/architecture/2026-08-11-trajectory-conversation-context-assembly.zh.md

@@ -0,0 +1,105 @@
+# Agent Note: Trajectory 基于注册式 Conversation Context 组装数据
+
+Status: implemented
+
+[English](2026-08-11-trajectory-conversation-context-assembly.md) | 中文
+
+## 问题
+
+Trajectory 曾维护独立的 Session History 数据源，并把完整的已加载 Event 窗口折叠为 Assistant、Tool、消息、Request header 和 Compaction 状态。Chat 已经通过注册式 Conversation Definition 组装相同的 Event 族。两条链路重复实现业务关联与分页行为；即使只改变一个业务对象，Trajectory 的结构更新仍会复制或重新扫描与原始 Event 数量成正比的数据。
+
+复用 Chat 的最终 Node 无法解决职责问题。Trajectory 需要请求生命周期、运行中 Assistant 状态、提示词继承、Tool schema、计时记录和 stage-oriented read model，而 Chat 不消费这些数据。共享最终 Node payload 会让两个视图都依赖双方需求的并集。
+
+本次迁移还必须保留持久 steering（中途引导）分类。`user/message` 本身不说明它是开启了一个 Turn，还是从 `next-step` inbox 被领取；更早页面还可能在消息已经物化后，才补齐缺失的 inbox 前驱或 Location。
+
+## 决策
+
+Trajectory 针对共享的 [`ConversationNodeAssembler`](2026-08-09-client-conversation-node-assembly.md) 注册 target 自有的 Conversation Definition 和 `trajectory` View Builder。Session 只维护一份连续 Event 窗口，并通过 `Session.views` 发布 Chat 与 Trajectory 快照；它不再运行第二套 Trajectory history source 或业务 fold。
+
+每个 Definition 只属于一个 target。Chat 与 Trajectory 可以识别同一持久 Event 族，但分别维护自己的 State 和最终 Node payload。它们只共享 Assembler 的精确 ID 匹配、有序 Match、Location 事实、Reader 依赖、发布调度，以及 replace/prepend/append 生命周期。
+
+既有的 [Trajectory 检查记录表](../feature/2026-07-27-trajectory-inspection-ledger.md)继续作为视图模型。Trajectory Builder 把已物化的 target Node 转换为原有的 `eventNodes`、Requests、Tool schema、运行中调用和 Location map；layout、表格虚拟化、选择、Overview 与检查器行为不会成为通用 Conversation 约定。
+
+### 业务 Definition
+
+| 业务 | Context 标识 | State 组装方式 | Trajectory contribution |
+|---|---|---|---|
+| `next-step` inbox | splice Event seq | 把 splice 应用到最近的前序 inbox Context | 只维护状态，不产生可见 Node |
+| 用户、steering 或注入消息 | message Event seq | 读取前序 inbox State，并对持久消息分类 | Input 或 context Node |
+| Assistant 与普通 Request | `turn:step` | 折叠 `step/start`、chunk、最终消息、retry 和 `step/end` | 最终 Assistant、partial Assistant 与 Request |
+| 根 Tool call | root call ID | 把根 call/result 与嵌套 Code Dispatch Event 折叠为一棵调用树 | 最终或运行中的 Tool tree |
+| Compaction | compaction ID | 折叠 start、summary、end 和 replacement checkpoint | Compaction Request |
+| Request header | header Event seq | 读取前一个 header，保留生效提示词及真实变化 | Prompt 与 Tool-schema 来源 |
+| Session 与 Turn 边界 | boundary Event seq | 保留关闭时间和错误事实 | 被中断的 Compaction 或失败的普通 Request |
+
+每个关联 Event 都必须直接提供相同的业务 ID。Code Dispatch 使用 `rootCallId`，Compaction 使用 compaction ID；即使某个 Definition 按 `turn:step` 关联，普通 Tool 与 retry Event 仍保留各自的协议标识。缺少必要关联 ID 的旧记录由该 Definition 忽略，不会合入 `undefined` Context，也不会导致 Session 崩溃。
+
+Assistant chunk 只更新对应的 `turn:step` Context。带内容的 chunk 请求 animation-frame 发布；usage 与 finish chunk 更新 State，但不单独强制刷新一帧。最终消息、retry 或边界立即发布。已完成 Assistant State 只保留组装后的 block、计时、usage 与 retry 事实，不会把原始 chunk ledger 复制进 target snapshot。
+
+### 通过前序 Context 恢复 steering
+
+Trajectory 从持久 inbox 历史恢复 steering，使用与 [Chat steering 决策](../feature/2026-08-04-web-context-source-and-steer-marks.md)相同的标识规则，但不共享 Chat 的最终 Node。
+
+每条目标为 `next-step` 的 `agent/inbox/spliced` Event 都会启动一个以 Event seq 标识的不可见 Context。它的 `start()` 读取最近的前序 inbox Context，应用 splice，并存储待处理标识以及累计的已领取 message ID 集合。后续用户来源的 `user/message` 读取最近的前序 inbox Context：已领取的 ID 生成 Steering Node，其余用户来源消息生成普通 User Node。
+
+仍有更早历史时，Reader miss 会记录 window-gap 依赖。prepend 补齐缺失的前驱后，Assembler 按 Event 正序重放受影响的 inbox chain 与 message Context。因此，历史分页方向不会永久错误分类消息。
+
+消息 Event 的 Location 会把 steering 放进所属 Step。如果已加载历史窗口缺少足够的边界 Event，无法解析该 Location，layout 就以后续 Assistant step 作为位置回退。同一个 Step 中，运行中 Request 标记排在前置 steering 输入之后，因此该标记表示由这条输入触发的模型 Request，而不会出现在输入前面。
+
+### 窗口链路与复杂度
+
+记 `E` 为已加载原始 Event 数，`P` 为一次新 prepend 的页面，`D` 为 Trajectory Definition 数，`C` 为已物化的 Trajectory Context contribution 数，`Mᵣ` 为一次 prepend 使其失效的 Context 所持有的 Match 总数。`D` 是较小的注册集合；流式 chunk 会聚合到同一个 Assistant Context，因此通常 `C` 明显小于 `E`。
+
+| 链路 | Context 工作量 | Target snapshot 工作量 | 结果 |
+|---|---|---|---|
+| 初始尾页或重连 replace | 以 `O(E × D)` 匹配已加载窗口，并按 Event 正序构造 State | 构造并排序 `C` 个 contribution | 完整 replace 仍与已加载窗口成正比 |
+| 更早页面 prepend | 只匹配新 Event，并只重放 Match、Location 或 Reader 答案发生变化的 Context，成本为 `O(P × D + Mᵣ)` | 从 `C` 个 contribution 重建 stage snapshot | 业务 fold 不会从头重跑全部 `E` 个 Event |
+| 实时 append | 以 `O(D)` 匹配，以 `O(1)` 找到 keyed Context，并只更新对应 State | snapshot 组装前，以 `O(1)` 替换 anchor 未变的 contribution | 业务关联成本与已加载 Event 历史无关 |
+
+Builder 按 Context key 保存 contribution，并维护 key-to-position index。anchor 相同的内容更新会原位替换一个 contribution；新增 contribution 或 anchor 变化才会重建并排序 contribution 顺序。随后，snapshot assembly 遍历 `C` 个 contribution，用 Map 索引 Request header 与 Tool schema，并以线性游标或索引处理 Compaction boundary 与 Turn error。
+
+最终 Event 和 Request 排序使单次发布的当前上界保持为 `O(C log C)`。本次迁移移除了重复反向查找和旧的原始历史 refold，但不声称端到端发布达到 `O(1)`。Chat 保持既有 keyed snapshot 行为与复杂度；增加 Trajectory target 不会让 Chat 扫描 Trajectory Context 或 Node。
+
+### 独立的表现层热点优化
+
+Context 迁移与下列表现层优化解决的是不同成本。这些优化保留既有视图模型；收益来自调用次数和渐进复杂度推算，本决策不声称存在 benchmark 实测结果。
+
+| 热点 | 保留的行为 | 预期减少的工作 |
+|---|---|---|
+| Markdown 摘要 | Layout 只保留源 Markdown；每个稳定 Table record 按内容 memo 展示摘要，Detail 只解析当前选中记录 | 单条 record append 只重解析发生变化的可见记录，而非全部 Markdown record |
+| 搜索文本 | `TrajectorySearchIndex` 仍线性核对稳定 Record ID 与来源签名，但只为变化的 record 标准化 Markdown，并以三秒批次提交更新 | 签名比较仍为 `O(C)`；昂贵标准化只随变化 record 数量增长，持续 frame update 每个时间窗合并成一个批次 |
+| Timeline tooltip | 延迟 Tooltip 打开后才计算计时文案 | 没有打开 Tooltip 的 render 不执行逐 span label 格式化 |
+| 后继 Assistant 查找 | 一次反向遍历为每个输入位置记录后续 Assistant | 原先重复向前查找的最坏复杂度从 `O(C²)` 降为 `O(C)` |
+| Group duration | 以固定十进制分组替代固定英文数字形态下的 `toLocaleString('en-US')` | 复杂度仍与 Group 数线性相关，但重复 render 路径不再调用 Intl formatter |
+
+展示 memo 与搜索索引彼此独立。搜索必须覆盖屏幕外 record，并允许实时变化延迟一个 throttle 周期；Table 必须立即更新发生变化的可见 record，不能继承索引的提交节奏。
+
+## 考虑过的替代方案
+
+**保留独立 Session History fold，只做局部优化。** 不予采纳：缓存可以降低部分热点，但 Trajectory 仍会在 Chat 之外拥有第二套 Event 窗口、分页修复、request inspection fold 与业务关联实现。
+
+**复用 Chat Definition，并在 `buildViewNode()` 中按 `target` 分支。** 不予采纳：Trajectory 需要不同的 State 与中间 record，不只是另一套 React renderer。单一 Definition 会携带两个视图的 payload 与条件，并在任一视图变化时让无关 target 数据失效。
+
+**创建 Trajectory 专属 Assembler。** 不予采纳：精确 ID 路由、先 update 后 start 的收集、prepend replay、Location 修复、Reader 依赖与发布节奏都不是 Trajectory 特有行为。第二套引擎会重新制造本次改造要消除的生命周期重复。
+
+**增加通用 Surface、rewind、fanout 或 settled 生命周期。** 不予采纳：当前持久 Event stream 不需要通用 Surface branch；Session 或 Turn boundary 是 target 业务输入，不构成把一个 Event fanout 到全部历史 Context 的理由。完成条件仍由业务 State 结合 Location closure 判断。
+
+**用通用 Conversation Node 替换 Trajectory stage。** 不予采纳：stage 为单一视图组织 Request、计时、schema 和表格 layout。把它变成引擎约定会限制未来的朴素 Session-log 视图，并把视图专属组合重新放回 Client Runtime。
+
+**在展示与搜索之间共享一套 Markdown cache。** 不予采纳：展示要求立即更新且受 viewport 约束，搜索则覆盖全部已加载 record，并有意批量提交更新。共享 cache 会把两个无关消费方的正确性与调度节奏耦合起来。
+
+## 验证
+
+Runtime 测试固定 target 注册、精确 ID append、先 update 后 start 的 replay、prepend identity、Reader window-gap 修复、Location replay，以及 Chat 与 Trajectory snapshot 隔离。
+
+Trajectory Definition 与 Builder 测试固定 Assistant streaming 与 interruption、嵌套 Tool call 和并行 interruption、Compaction 与 prompt 继承、Steering 分类和 Step 位置、Request 标记顺序、稳定 contribution 替换与 prepend 扩展。Table、layout、Timeline 与搜索测试固定延迟 Markdown 工作、节流索引更新、Tooltip 展示时格式化，以及 append/prepend 期间稳定的搜索结果。
+
+## 后果
+
+Trajectory 业务组装的成本随变化页面或 keyed Context 增长，不再从完整原始 Event 窗口重新开始。target 自有 Definition 可以独立于 Chat 演进，同时继续共享一份 Session 窗口和一套生命周期规则。steering 会在实际所属 Step 位置成为一等 Trajectory record，不需要向 Session 增加 steering 专属状态。
+
+保留的 stage-oriented Builder 仍会执行与已物化 Trajectory contribution 数量成正比的工作，并可能在发布时排序。输入 layout 变化时，搜索索引仍会执行一次轻量线性签名检查。这些成本是显式的 target view 工作，不是隐藏的完整 Event refold。
+
+Definition 作者必须提供稳定的协议标识。缺少必要 ID 的旧 Event 可能不会出现在受影响的 Trajectory 业务视图中；与合并无关记录或让历史加载失败相比，这是更安全的退化方式。要求完整展示的生产方必须记录该标识。
+
+[Conversation assembly 决策](2026-08-09-client-conversation-node-assembly.md)继续作为通用 Context、Reader、Location 与发布约定的真源。[Trajectory ledger 决策](../feature/2026-07-27-trajectory-inspection-ledger.md)继续负责表格层级、虚拟化、检查器和交互行为。本 Note 负责说明 Trajectory 如何适配这两项决策，以及为何该适配不与 Chat 共享最终 Node。

.agents/notes/implemented/feature/2026-07-27-trajectory-inspection-ledger.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write .agents/notes/implemented/feature/2026-07-27-trajectory-inspection-ledger.md
-2026-07-27-trajectory-inspection-ledger.md: a905e65942365c17b7513028b275288c82428221
-2026-07-27-trajectory-inspection-ledger.zh.md: a8dcfa97a89f3adc6ab540f3d6cc5020cbefb53f
+2026-07-27-trajectory-inspection-ledger.md: 74ed1f8ec6f6efcbf77e9caec7e254cb114efbd9
+2026-07-27-trajectory-inspection-ledger.zh.md: c6bb315b72b8a7274ca0e1b245cb2c5583328c8a

.agents/notes/implemented/feature/2026-07-27-trajectory-inspection-ledger.md

@@ -12,20 +12,20 @@ Trajectory has to make prose, machine payloads, token usage, timing, and nested
 
 **Render a compact, turn-aware event ledger with a local record inspector, using the existing DeepSeek design system.**
 
-- The ledger keeps session events in sequence within rewind-delimited branches. Turn boundaries use a slightly heavier rule, the raw Turn id, and a continuous left rail; Request boundaries appear as small points integrated into that structure and use one chronological numbering space across ordinary and compaction requests.
+- The ledger keeps materialized business records in Session Event order within the loaded window. Turn boundaries use a slightly heavier rule, the raw Turn id, and a continuous left rail; Request boundaries appear as small points integrated into that structure and use one chronological numbering space across ordinary and compaction requests.
 - Event kind and content form the two stable columns. Role tags align toward the content, nested subtools receive a small indentation, and CSS truncation preserves the available preview width. Token usage and duration stay in the inspector.
 - Product prose uses the existing sans stack. Turn ids, token counts, durations, tool calls, raw payloads, and other machine data use the existing code stack.
 - Existing theme tokens own both light and dark rendering. Neutral borders and surfaces form the structure; distinct low-emphasis role hues support scanning without carrying success or failure meaning, while business blue identifies selection, links, and focus.
-- The client runtime exposes a read-only history source independent from Session and SessionManager. Each activated source owns its raw entries, paging, live gap repair, and reconnect rebuild; the ordinary conversation snapshot remains the folded Chat projection. Trajectory opens the source's tail while mounted and requests one older page when the user reaches the loaded range's top, then lazily derives event order, context lineage, schema index, and Requests instead of imposing those structures on every conversation consumer.
+- Session owns one contiguous Event window, paging state, live gap repair, and reconnect rebuild. Chat and Trajectory register separate business Definitions against the shared `ConversationNodeAssembler`; Trajectory reads its target snapshot from `Session.views` and requests one older Session page when the user reaches the loaded range's top. The [Trajectory Context assembly decision](../architecture/2026-08-11-trajectory-conversation-context-assembly.md) owns its exact-ID Definitions, stage Builder, and complexity bounds.
 - Ordinary generation and compaction calls form one chronological Request projection, distinguished by purpose rather than separate collections. Effective prompt state and its change ride the Request that introduced them; compaction and prompt changes are not independent inspection entities. Request numbering and cumulative usage cover the loaded history window and expand as older pages arrive.
 - Call schemas come from the active recorded Request header. Keyless snapshot fixtures deliberately replace that catalog with the non-array `{{tools}}` token, which the durable inspection boundary treats as unavailable instead of attempting to project or fabricate schemas.
 - Selecting a record or Request opens an inspector inside Trajectory. Tabs and Summary sections follow the selected entity: Markdown messages expose rendered content, source fields, provider/model fields, and hierarchy views; tools add JSON payload/result and schema views; Requests add options, usage, timing, and result navigation. Scrollable Summary regions keep their scrollbar thumbs transparent until hover or `focus-within`, while retaining the scrollbar reservation and scroll behavior. Images render as media rather than serialized data.
 - Turn folding removes all rows after its first record and replaces them with a compact step/tool-call count; Assistant folding applies the same interaction to its tool-call descendants. Global controls fold or expand both levels.
-- A long ledger initially positions the loaded tail at the bottom and mounts only the viewport's row window plus bounded overscan. Request-only separators join the next measurable virtual item, with a terminal separator retaining its own fixed clearance, so the virtualizer never owns a zero-height item. Semantic DOM-safe row keys and ARIA indexes expose identity independently from mount position. A tail with known older history virtualizes immediately even when its loaded projection is below the ordinary row threshold. Stable-key virtualizer anchoring preserves the visible item across prepends and appends; the manual scroll-height fallback applies only when completing pagination disables virtualization. Selection, timeline focus, folding, search, and bottom following address records by stable event or tool-call identity rather than requiring their DOM rows to exist. An explicit loading row covers records until initial positioning finishes and while an older page is pending. The raw window base sequence detects a prepend even when a page adds no surface-visible node.
-- The separate Waterfall tab is removed. A fixed Overview above the ledger projects every loaded record with known `startedAt` onto three semantic timing lanes using its own duration. While an older prefix remains unloaded and the viewport includes the loaded domain's start, a neutral ellipsis control covers the truncated edge and loads one earlier page without assigning unknown history a fabricated duration; hovering that control suppresses the ordinary timeline cursor. Finalized Assistant spans divide the recorded interval at the first non-empty token delta, so distinct TTFT and decoding colors retain their actual ratio; incomplete timing falls back to one Assistant color. Hovering for 500 ms exposes exact start/end, total duration, TTFT, and decoding time without relying on the browser's native tooltip delay. Dragging left or right commits an inclusive interval filter: any record whose active interval overlaps either boundary remains visible, records without known timing leave the focused ledger, and clearing the selection restores the full branch. Wheel gestures zoom the time domain. A right-button click clears the interval selection; dragging instead pans an already zoomed viewport without mutating it. The Overview keeps the full time domain while focused so the selection can be resized or cleared without losing orientation.
+- A long ledger initially positions the loaded tail at the bottom and mounts only the viewport's row window plus bounded overscan. Request-only separators join the next measurable virtual item, with a terminal separator retaining its own fixed clearance, so the virtualizer never owns a zero-height item. Semantic DOM-safe row keys and ARIA indexes expose identity independently from mount position. A tail with known older history virtualizes immediately even when its loaded projection is below the ordinary row threshold. Stable-key virtualizer anchoring preserves the visible item across prepends and appends; the manual scroll-height fallback applies only when completing pagination disables virtualization. Selection, timeline focus, folding, search, and bottom following address records by stable event or tool-call identity rather than requiring their DOM rows to exist. An explicit loading row covers records until initial positioning finishes and while an older Session page is pending.
+- The separate Waterfall tab is removed. A fixed Overview above the ledger projects every loaded record with known `startedAt` onto three semantic timing lanes using its own duration. While an older prefix remains unloaded and the viewport includes the loaded domain's start, a neutral ellipsis control covers the truncated edge and loads one earlier page without assigning unknown history a fabricated duration; hovering that control suppresses the ordinary timeline cursor. Finalized Assistant spans divide the recorded interval at the first non-empty token delta, so distinct TTFT and decoding colors retain their actual ratio; incomplete timing falls back to one Assistant color. Hovering for 500 ms exposes exact start/end, total duration, TTFT, and decoding time without relying on the browser's native tooltip delay. Dragging left or right commits an inclusive interval filter: any record whose active interval overlaps either boundary remains visible, records without known timing leave the focused ledger, and clearing the selection restores the full loaded ledger. Wheel gestures zoom the time domain. A right-button click clears the interval selection; dragging instead pans an already zoomed viewport without mutating it. The Overview keeps the full time domain while focused so the selection can be resized or cleared without losing orientation.
 - Live history updates retain the ledger's bottom position only while the user is already following its tail. Scrolling upward clears that follow state, so streamed chunks and newly appended records do not interrupt inspection of earlier rows. Tail following and virtualizer measurement react to row keys and heights rather than content identity, so text-only stream frames neither discard the measurement cache nor repeat a DOM scroll write.
-- Token streaming reuses the finalized history inspection, layout, Request numbering, Overview projection, and search results. A frame appends only the current partial Assistant cells and searches that partial when a query is active; text and reasoning deltas do not re-fold or rescan the loaded prefix, while message completion, tool lifecycle, compaction, rewrites, and other structural events rebuild the affected projections. Before those rebuilds, the inspection ledger drops completed-step token payloads that no projection reads while retaining the first visible token for timing, every usage chunk for accounting, and every chunk from unfinished or interrupted steps; the independent history source retains the raw entries.
-- History folding rebases only the loaded surface events into a compact contiguous input for the canonical surface manager, then maps its nodes back to absolute session sequences. Structural events therefore retain canonical replacement validation without replaying token chunks or materializing synthetic events for unloaded sequences.
+- Token streaming updates only the matching Trajectory Assistant Context, while publication is coalesced to at most once per animation frame. The target snapshot preserves the existing stage, layout, Request numbering, Overview, and search inputs; completed Assistant State retains assembled blocks, timing, and usage rather than every raw chunk payload, while Session keeps the raw Event window.
+- Each Trajectory Definition extracts a stable ID from the current Event, and the shared Assembler replays only Contexts affected by matching, Location, or Reader changes. Older Session pages prepend into the same engine window; the Trajectory target builder converts its materialized Nodes into the existing stage-oriented snapshot consumed by the ledger.
 - Trajectory opts into a conversation-owned composer overlay through `data-conversation-composer-overlay`. `ConversationRoot` positions the composer seat and publishes its live height; Trajectory keeps the ledger at full height and reserves that height plus 16 px inside its vertical table and inspector scrollers. Those panes adapt to the available width instead of exposing horizontal scrollbars beneath the overlay.
 - This local inspector remains independent from the conversation-wide Chat details column. At narrow widths it overlays the ledger and remains dismissible by keyboard or pointer.
 
@@ -53,4 +53,4 @@ Trajectory has to make prose, machine payloads, token usage, timing, and nested
 
 ## Consequences
 
-Trajectory shows more useful records per viewport while retaining Turn and Request orientation. Context rewrites and compactions remain inline with their surrounding history, while a rewind begins a successor branch that inherits only the retained prefix. The floating composer leaves the ledger visible to the viewport edge without covering its final rows or hiding horizontal controls. The main ledger omits token usage and duration so content receives the available width; the local inspector exposes those facts together with full payloads, provider/model and source fields, schemas, and request timing. The Overview uses recorded start/duration and token-boundary facts without fabricating live elapsed time, and its inclusive focus behavior matches the interaction users already know from Chrome DevTools Network. Tail-first paging bounds initial transport and projection work, virtualization bounds mounted row elements, incremental partial projection removes loaded-history length from ordinary token-frame work, and completed-step chunk compaction makes structural rebuilds proportional to inspection-relevant entries rather than the raw token count. Focused component tests pin tail-first paging, prepend anchoring and identity retention, the virtual window, tail following, content-only streaming without repeated scroll writes, streaming structural sharing, high-sequence window folding, timing projection, delayed detail disclosure, folding, record and interval selection, entity-specific tabs, and running/error semantics. A real-browser long-ledger contract pins stable prepend geometry, bounded mounting, top/middle/bottom reachability, and bounded scroll writes across a paced stream; the assembled Web snapshot pins the ledger, Overview timing details, composer overlay geometry, and inspector through the real client composition.
+Trajectory shows more useful records per viewport while retaining Turn and Request orientation. Context rewrites and compactions appear as the current materialized business records in sequence with surrounding history. The floating composer leaves the ledger visible to the viewport edge without covering its final rows or hiding horizontal controls. The main ledger omits token usage and duration so content receives the available width; the local inspector exposes those facts together with full payloads, provider/model and source fields, schemas, and request timing. The Overview uses recorded start/duration and token-boundary facts without fabricating live elapsed time, and its inclusive focus behavior matches the interaction users already know from Chrome DevTools Network. Tail-first paging bounds initial transport work, virtualization bounds mounted row elements, exact-ID dispatch avoids re-folding unrelated business Contexts, and animation-frame publication caps streaming snapshot frequency. The retained stage-oriented target builder may still perform work proportional to the loaded materialized Nodes for a publication; this migration does not add a stronger Trajectory-specific complexity guarantee. Focused component tests pin tail-first paging, prepend anchoring and identity retention, the virtual window, tail following, content-only streaming without repeated scroll writes, timing projection, delayed detail disclosure, folding, record and interval selection, entity-specific tabs, and running/error semantics. A real-browser long-ledger contract pins stable prepend geometry, bounded mounting, top/middle/bottom reachability, and bounded scroll writes across a paced stream; the assembled Web snapshot pins the ledger, Overview timing details, composer overlay geometry, and inspector through the real client composition.

.agents/notes/implemented/feature/2026-07-27-trajectory-inspection-ledger.zh.md

@@ -12,20 +12,20 @@ Status: implemented
 
 **使用现有 DeepSeek 设计系统，渲染保留轮次结构的紧凑事件记录表，并提供局部记录检查器。**
 
-- 记录表在以 `rewind` 划分的分支内按会话事件顺序展示。轮次边界由稍粗的分割线、原始轮次 id 和连续的左侧竖线表示；请求边界以融入该结构的小圆点表示，普通请求与压缩（compaction）请求在整个时间序列中共用一套编号。
+- 记录表在已加载窗口内按 Session Event 顺序展示物化后的业务记录。轮次边界由稍粗的分割线、原始轮次 id 和连续的左侧竖线表示；请求边界以融入该结构的小圆点表示，普通请求与压缩（compaction）请求在整个时间序列中共用一套编号。
 - 事件类型与内容构成两个稳定列。角色标签朝内容侧对齐，嵌套子工具略微缩进，内容预览使用 CSS 截断以适应可用宽度。token 用量和耗时留在检查器中。
 - 产品正文使用现有无衬线字体栈。轮次 id、token 数、耗时、工具调用、原始载荷和其他机器数据使用现有代码字体栈。
 - 现有主题 token 同时负责亮色和暗色渲染。中性边框与表面构成整体结构；区分度较低的角色色帮助扫读而不表达成功或失败语义，业务蓝色则标识选择状态、链接和焦点。
-- 客户端运行时提供独立于 Session 和 SessionManager 的只读历史数据源。每个已激活的数据源自行拥有原始条目、分页、实时缺口修复和重连重建；普通会话快照仍然只是 Chat 所需的折叠投影。Trajectory 在挂载期间打开该数据源的尾部，当用户到达已加载范围顶部时请求一页更早的历史，再按需派生事件顺序、上下文谱系、schema 索引和请求，避免让所有会话消费方承担这些结构。
+- Session 统一拥有一份连续 Event 窗口、分页状态、实时缺口修复与重连重建。Chat 与 Trajectory 针对共享的 `ConversationNodeAssembler` 分别注册业务 Definition；Trajectory 从 `Session.views` 读取自己的 target snapshot，并在用户到达已加载范围顶部时请求一页更早的 Session 历史。[Trajectory Context 组装决策](../architecture/2026-08-11-trajectory-conversation-context-assembly.md)负责其精确 ID Definition、stage Builder 与复杂度上界。
 - 普通生成调用与压缩调用形成一条按时间排序的请求投影，以用途区分而不是放入不同集合。生效的提示词状态及其变化附着在引入它们的请求上；压缩和提示词变化都不是独立检查实体。请求编号和累计用量覆盖已加载的历史窗口，并随更早页面到达而扩展。
 - 调用 schema 来自当前生效且已记录的请求头。无密钥快照 fixture（测试前置数据）有意将该目录替换为非数组 token `{{tools}}`，持久化检查边界会将其视为不可用，而不是尝试投影或虚构 schema。
 - 选择记录或请求后，Trajectory 内部会打开检查器，其标签页和概述区域随实体类型变化：Markdown 消息提供渲染内容、来源字段、提供方／模型字段和层级视图；工具提供 JSON 载荷／结果和 schema 视图；请求提供选项、用量、计时和结果跳转。可滚动的概述区域默认保持滚动条滑块透明，直到悬停或 `focus-within` 时才显示，同时保留滚动条预留空间和滚动行为。图片以媒体形式渲染，而不是显示为序列化数据。
 - 折叠轮次时保留其第一条记录，并用紧凑的步骤数和工具调用数替换后续所有行；折叠助手时对其工具调用后代应用相同操作。全局控件会折叠或展开这两个层级。
-- 长记录表初始时将已加载尾部置于底部，只挂载视口对应的行窗口及有界的额外缓冲行。仅含请求的分隔行并入下一个具备可测高度的虚拟项，末尾分隔行则保留固定留白，因此虚拟化器不会管理零高度项。可安全用于 DOM 的语义行键与 ARIA 索引使标识不依赖挂载位置。只要已知尾部之前仍有更早历史，即使当前已加载投影低于常规行数阈值，也会立即启用虚拟化。基于稳定键的虚拟化器锚定会在向前补页和尾部追加时保留当前可见项；只有分页完成导致虚拟化停用时，才使用手动滚动高度兜底。选择、时间线聚焦、折叠、搜索和末尾跟随均按稳定的事件或工具调用标识定位，不要求对应 DOM 行已存在。初始定位完成前以及更早页面仍在等待时，明确的加载行会遮住真实记录。原始窗口的基准序号即使在一页未增加任何 surface 可见节点时，也能检测到这次向前补页。
-- 移除独立的 waterfall（瀑布式事件）标签页。固定在记录表上方的 Overview 区域将所有 `startedAt` 已知的已加载记录按各自耗时投影到三条语义计时轨道。仍有更早前缀尚未加载且 viewport 包含已加载时间域起点时，中性的省略号控件会遮住截断边缘并加载一页更早历史，而不会为未知历史虚构耗时；悬停在该控件上会隐藏普通的时间线光标。已完成的助手时间条以首个非空 token 增量为分界，用不同颜色按真实比例表示 TTFT 与解码时间；计时不完整时退化为单一助手色。悬停 500 ms 后会显示精确起止时刻、总耗时、TTFT 和解码时间，而不依赖浏览器原生 tooltip 的延迟。向左或向右拖动会提交包含边界的区间筛选：任何活动区间与所选区间任一边界重叠的记录都会保留，计时未知的记录会从聚焦后的记录表中移除，清除选择则恢复完整分支。滚轮手势用于缩放时间域。右键单击会清除区间选择；右键拖动则只会平移已放大的 viewport，不会改变该选区。聚焦后，Overview 区域仍保留完整时间范围，以便在不失去方位的情况下调整或清除选择。
+- 长记录表初始时将已加载尾部置于底部，只挂载视口对应的行窗口及有界的额外缓冲行。仅含请求的分隔行并入下一个具备可测高度的虚拟项，末尾分隔行则保留固定留白，因此虚拟化器不会管理零高度项。可安全用于 DOM 的语义行键与 ARIA 索引使标识不依赖挂载位置。只要已知尾部之前仍有更早历史，即使当前已加载投影低于常规行数阈值，也会立即启用虚拟化。基于稳定键的虚拟化器锚定会在向前补页和尾部追加时保留当前可见项；只有分页完成导致虚拟化停用时，才使用手动滚动高度兜底。选择、时间线聚焦、折叠、搜索和末尾跟随均按稳定的事件或工具调用标识定位，不要求对应 DOM 行已存在。初始定位完成前以及更早 Session 页面仍在等待时，明确的加载行会遮住真实记录。
+- 移除独立的 waterfall（瀑布式事件）标签页。固定在记录表上方的 Overview 区域将所有 `startedAt` 已知的已加载记录按各自耗时投影到三条语义计时轨道。仍有更早前缀尚未加载且 viewport 包含已加载时间域起点时，中性的省略号控件会遮住截断边缘并加载一页更早历史，而不会为未知历史虚构耗时；悬停在该控件上会隐藏普通的时间线光标。已完成的助手时间条以首个非空 token 增量为分界，用不同颜色按真实比例表示 TTFT 与解码时间；计时不完整时退化为单一助手色。悬停 500 ms 后会显示精确起止时刻、总耗时、TTFT 和解码时间，而不依赖浏览器原生 tooltip 的延迟。向左或向右拖动会提交包含边界的区间筛选：任何活动区间与所选区间任一边界重叠的记录都会保留，计时未知的记录会从聚焦后的记录表中移除，清除选择则恢复完整的已加载记录表。滚轮手势用于缩放时间域。右键单击会清除区间选择；右键拖动则只会平移已放大的 viewport，不会改变该选区。聚焦后，Overview 区域仍保留完整时间范围，以便在不失去方位的情况下调整或清除选择。
 - 实时历史更新仅在用户已经跟随记录表末尾时保留底部位置。向上滚动会清除跟随状态，因此流式分块和新追加的记录不会打断对旧记录的检查。末尾跟随与虚拟化器测量仅响应行键和高度，而非内容标识，因此仅含文本的流式帧既不会丢弃测量缓存，也不会重复执行 DOM 滚动写入。
-- token 流式输出会复用已完成历史的检查结果、布局、请求编号、Overview 投影和搜索结果。每个帧只追加当前未完成助手的单元格，并在查询处于激活状态时搜索这部分内容；文本与推理（reasoning）增量不会重新折叠或扫描已加载前缀，而消息完成、工具生命周期、压缩、`rewrite` 及其他结构事件会重建受影响的投影。在这些投影重建前，检查记录表会丢弃已完成步骤中没有任何投影读取的 token 载荷，但会保留首个可见 token 用于计时、保留所有用量分片用于核算，并保留未完成或中断步骤的所有分片；独立历史数据源仍保留原始条目。
-- 历史折叠只把已加载的 surface 事件重新编号为紧凑连续的输入并交给规范 surface manager，再将其节点映射回会话绝对序号。因此，结构事件会保留规范的替换校验，而无需重放 token 分片，也不会为未加载的序号实体化合成事件。
+- token 流式输出只更新命中的 Trajectory Assistant Context，发布则合并为每个 animation frame 最多一次。target snapshot 继续提供既有 stage、layout、请求编号、Overview 与搜索输入；已完成的 Assistant State 只保留组装后的 blocks、计时与 usage，不保留每条原始 chunk payload，而 Session 继续保存原始 Event 窗口。
+- 每个 Trajectory Definition 都从当前 Event 提取稳定 ID，共享 Assembler 只 replay 因 Match、Location 或 Reader 变化而受影响的 Context。更早 Session 页面 prepend 到同一个引擎窗口；Trajectory target builder 再把已物化 Node 转换为记录表继续消费的 stage-oriented snapshot。
 - Trajectory 通过 `data-conversation-composer-overlay` 启用由会话持有的 composer 浮层模式。`ConversationRoot` 负责定位 composer seat 并发布其实时高度；Trajectory 让记录表保持全高，并在记录表与检查器的纵向滚动容器内预留该高度加 16 px。这两个窗格会根据可用宽度自适应，而不会在浮层下方暴露横向滚动条。
 - 此局部检查器与会话级 Chat 详情栏相互独立。在窄屏下，检查器会覆盖记录表，并且仍可通过键盘或指针关闭。
 
@@ -53,4 +53,4 @@ Status: implemented
 
 ## 后果
 
-轨迹视图在保留轮次与请求定位的同时，每个视口可以显示更多有效记录。上下文 `rewrite` 与压缩保持在周边历史中的原始位置，`rewind` 则建立仅继承保留前缀的后继分支。浮动 composer 让记录表一直显示到视口边缘，同时不会遮住最后几行，也不会隐藏横向控件。主记录表省略 token 用量和耗时，让内容获得可用宽度；局部检查器展示这些数据以及完整载荷、提供方／模型字段、来源字段、schema 和请求计时。Overview 区域使用记录的开始时间、耗时与 token 边界数据，而不虚构实时流逝时间，其包含边界的聚焦行为与用户熟悉的 Chrome DevTools Network 交互一致。尾部优先分页限制初始传输和投影工作量，虚拟化限制已挂载的行元素数量，未完成部分的增量投影让普通 token 帧的工作量不再随已加载历史长度增长，而已完成步骤的分片压缩则让结构重建的工作量与检查所需条目数量成正比，而非与原始 token 数量成正比。针对性组件测试锁定尾部优先分页、向前补页锚定与标识保持、虚拟窗口、末尾跟随、仅含内容的流式输出不会重复写入滚动位置、流式输出的结构共享、高序号窗口折叠、计时投影、延迟展示详情、折叠、记录与区间选择、实体特定标签页和运行／错误语义。真实浏览器中的长记录表约定锁定向前补页时稳定的几何位置、有界挂载、顶部／中部／底部可达性，以及按节奏进行的流式输出中有界的滚动写入；组装后的 Web 快照则通过真实客户端组合锁定记录表、Overview 计时详情、composer 浮层几何形状与检查器。
+轨迹视图在保留轮次与请求定位的同时，每个视口可以显示更多有效记录。上下文 `rewrite` 与压缩会作为当前物化的业务记录，按顺序出现在周边历史中。浮动 composer 让记录表一直显示到视口边缘，同时不会遮住最后几行，也不会隐藏横向控件。主记录表省略 token 用量和耗时，让内容获得可用宽度；局部检查器展示这些数据以及完整载荷、提供方／模型字段、来源字段、schema 和请求计时。Overview 区域使用记录的开始时间、耗时与 token 边界数据，而不虚构实时流逝时间，其包含边界的聚焦行为与用户熟悉的 Chrome DevTools Network 交互一致。尾部优先分页限制初始传输工作，虚拟化限制已挂载的行元素数量，精确 ID 分发避免重新 fold 无关业务 Context，animation-frame 发布则限制流式 snapshot 频率。保留的 stage-oriented target builder 在一次发布中仍可能执行与已加载物化 Node 数量成比例的工作；本次迁移不额外承诺更强的 Trajectory 专属复杂度。针对性组件测试锁定尾部优先分页、向前补页锚定与标识保持、虚拟窗口、末尾跟随、仅含内容的流式输出不会重复写入滚动位置、计时投影、延迟展示详情、折叠、记录与区间选择、实体特定标签页和运行／错误语义。真实浏览器中的长记录表约定锁定向前补页时稳定的几何位置、有界挂载、顶部／中部／底部可达性，以及按节奏进行的流式输出中有界的滚动写入；组装后的 Web 快照则通过真实客户端组合锁定记录表、Overview 计时详情、composer 浮层几何形状与检查器。

.agents/notes/implemented/feature/2026-08-04-web-context-source-and-steer-marks.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write .agents/notes/implemented/feature/2026-08-04-web-context-source-and-steer-marks.md
-2026-08-04-web-context-source-and-steer-marks.md: 01bdca873a847f70b4b8632b961e01e099ae4f04
-2026-08-04-web-context-source-and-steer-marks.zh.md: b6a9cc5692826b402b5a08ec65a5c8fc3c547b6b
+2026-08-04-web-context-source-and-steer-marks.md: d4fee3ee25aceaf05106d6bd1bdb73e7c51c3f78
+2026-08-04-web-context-source-and-steer-marks.zh.md: 8e0ffa6c15ea7506e1aaed9f0b142925727856aa

.agents/notes/implemented/feature/2026-08-04-web-context-source-and-steer-marks.md

@@ -14,13 +14,13 @@ The distinctions are already durable. Every producer must supply a merge-extensi
 
 The transcript names all three roles a non-prompt message can play — injected context, recalled session, and steering.
 
-`TranscriptAdapter` and the history fold attach a `provenance` view containing the producer role and label to every `ContextMessageNode`; `contextProvenance()` computes it from the durable source alone. It returns a `role` (`inject`, or `recall` for a cross-session snapshot) and a `label` naming the producer. `ContextInjectionRow` titles itself from the role and shows the label beside that title in `ToolRow`'s summary geometry, so the collapsed row already answers what was added and by whom; the 141px scrollport and truncation bound are unchanged from the [archived disclosure decision](../../archived/feature/2026-07-30-web-context-injection-disclosure.md). What renders inside that scrollport is chosen by the independent form axis added in the [context form decision](2026-08-05-context-form-vocabulary.md).
+The Chat Message Definition attaches a `provenance` view containing the producer role and label to every `ContextMessageNode`; `contextProvenance()` computes it from the durable source alone. It returns a `role` (`inject`, or `recall` for a cross-session snapshot) and a `label` naming the producer. `ContextInjectionRow` titles itself from the role and shows the label beside that title in `ToolRow`'s summary geometry, so the collapsed row already answers what was added and by whom; the 141px scrollport and truncation bound are unchanged from the [archived disclosure decision](../../archived/feature/2026-07-30-web-context-injection-disclosure.md). What renders inside that scrollport is chosen by the independent form axis added in the [context form decision](2026-08-05-context-form-vocabulary.md).
 
 **The label is read out of the log, never from a client-side table of producer names.** `workspace-instructions` is named by the distinct instruction paths it reconciled, `session-reference` by the titles of the sessions it read, a plugin source by its logged plugin id, and any other source by its own `kind` — the documented default arm for a merge-extensible union. A source carrying no readable kind degrades to an unnamed injection. A new or renamed producer is therefore identifiable without a client release, no label can go stale against the code, and a resumed, forked, or foreign log projects exactly like a live session.
 
 `recall` covers `session-reference` because that is the one shipped source that lifts another session's material into this one. No Web leaf mounts `dsh-session-reference` today — it had only a terminal host — so the arm exists for log portability rather than for a bundled producer, and it is exercised by unit coverage rather than an assembled Web scenario.
 
-`MessageItem` captions durable and pending steering bubbles with `插话`. The runtime replays durable `agent/inbox/spliced` events and projects a user-origin `user/message` as `SteeringMessageNode` when that same message identity was claimed from `next-step`; a queued-turn claim stays a `UserMessageNode`, and a non-user next-step message stays context. This reverses one clause of the [archived no-steer decision](../../archived/simplification/2026-07-31-web-ui-no-steer-entry-or-interjection-chrome.md), which removed the badge because the composer could not steer and the label named a gesture users could not perform. The composer gained a Steer gesture afterwards without amending that note; this decision supplies the product decision its reintroduction clause required, and corrects the stale facts left in it. The caption is the only steering chrome here: composer modes, the Queue dock's strict-steer action, and pending-steering lifecycle stay with their own owners.
+`MessageItem` captions durable and pending steering bubbles with `插话`. The Chat Inbox and Message Definitions replay durable `agent/inbox/spliced` events and project a user-origin `user/message` as `SteeringMessageNode` when that same message identity was claimed from `next-step`; a queued-turn claim stays a `UserMessageNode`, and a non-user next-step message stays context. This reverses one clause of the [archived no-steer decision](../../archived/simplification/2026-07-31-web-ui-no-steer-entry-or-interjection-chrome.md), which removed the badge because the composer could not steer and the label named a gesture users could not perform. The composer gained a Steer gesture afterwards without amending that note; this decision supplies the product decision its reintroduction clause required, and corrects the stale facts left in it. The caption is the only steering chrome here: composer modes, the Queue dock's strict-steer action, and pending-steering lifecycle stay with their own owners.
 
 ## Alternatives considered
 

.agents/notes/implemented/feature/2026-08-04-web-context-source-and-steer-marks.zh.md

@@ -14,13 +14,13 @@ Status: implemented
 
 transcript 为非提示消息可能承担的三种角色分别命名：注入上下文、召回会话、steering。
 
-`TranscriptAdapter` 与历史折叠为每个 `ContextMessageNode` 附加一份包含生产者角色和名称的 `provenance` 视图；`contextProvenance()` 仅依据持久来源计算该视图。它返回 `role`（`inject`，跨会话快照则为 `recall`）与命名生产者的 `label`。`ContextInjectionRow` 以角色作为标题，并按 `ToolRow` 摘要的几何在标题旁展示该名称，因此折叠态就已经回答了「注入了什么、由谁注入」；141px 滚动视口与截断上限沿用[已归档的展开项决策](../../archived/feature/2026-07-30-web-context-injection-disclosure.md)，未作改动。视口里渲染什么，则由[上下文形态决策](2026-08-05-context-form-vocabulary.md)引入的、相互独立的形态轴决定。
+Chat Message Definition 为每个 `ContextMessageNode` 附加一份包含生产者角色和名称的 `provenance` 视图；`contextProvenance()` 仅依据持久来源计算该视图。它返回 `role`（`inject`，跨会话快照则为 `recall`）与命名生产者的 `label`。`ContextInjectionRow` 以角色作为标题，并按 `ToolRow` 摘要的几何在标题旁展示该名称，因此折叠态就已经回答了「注入了什么、由谁注入」；141px 滚动视口与截断上限沿用[已归档的展开项决策](../../archived/feature/2026-07-30-web-context-injection-disclosure.md)，未作改动。视口里渲染什么，则由[上下文形态决策](2026-08-05-context-form-vocabulary.md)引入的、相互独立的形态轴决定。
 
 **名称从日志中读出，绝不来自客户端维护的生产者名称表。** `workspace-instructions` 以它对账过的去重指令文件路径命名，`session-reference` 以它读取的会话标题命名，插件来源以其记录的插件 id 命名，其余来源则以自身的 `kind` 命名——这正是可合并扩展联合类型有文档记载的默认分支。没有可读 kind 的来源降级为无名注入。于是新增或重命名的生产者无需客户端发版即可辨识，任何名称都不会相对代码变味，恢复、fork 或来自外部的日志与实时会话的投影结果完全一致。
 
 `recall` 覆盖 `session-reference`，因为它是当前唯一会把另一个会话的材料搬进本会话的已发布来源。今天没有任何 Web 叶子挂载 `dsh-session-reference`——它此前只有终端宿主——因此该分支的存在是为了日志可移植性，而不是为了某个已打包的生产方，其覆盖来自单元测试而非组装后的 Web 场景。
 
-`MessageItem` 为持久与待处理的 steering 气泡加上 `插话` 标注。runtime 会重放持久 `agent/inbox/spliced` 事件；如果一条用户来源的消息以相同身份从 `next-step` 被领取，后续 `user/message` 就投影为 `SteeringMessageNode`。从排队轮次领取的消息仍是 `UserMessageNode`，非用户来源的 next-step 消息仍是上下文。这推翻了[已归档的取消 steer 入口与插话装饰决策](../../archived/simplification/2026-07-31-web-ui-no-steer-entry-or-interjection-chrome.md)中的一条结论。当时移除徽章，是因为 composer 无法 steer，标签指向了用户做不到的动作。此后 composer 获得了 Steer 手势，却没有同步修订那份 note；本决策提供了它在「重新引入」条款中要求的产品决策，并订正了其中留下的过时事实。标注是这里唯一的 steering 装饰：composer 模式、Queue dock 的严格 steer 操作、待处理 steering 的生命周期仍归各自的所有者。
+Chat Inbox 与 Message Definition 会重放持久 `agent/inbox/spliced` 事件；如果一条用户来源的消息以相同身份从 `next-step` 被领取，后续 `user/message` 就投影为 `SteeringMessageNode`。`MessageItem` 为这种持久消息与待处理 steering 气泡加上 `插话` 标注。从排队轮次领取的消息仍是 `UserMessageNode`，非用户来源的 next-step 消息仍是上下文。这推翻了[已归档的取消 steer 入口与插话装饰决策](../../archived/simplification/2026-07-31-web-ui-no-steer-entry-or-interjection-chrome.md)中的一条结论。当时移除徽章，是因为 composer 无法 steer，标签指向了用户做不到的动作。此后 composer 获得了 Steer 手势，却没有同步修订那份 note；本决策提供了它在「重新引入」条款中要求的产品决策，并订正了其中留下的过时事实。标注是这里唯一的 steering 装饰：composer 模式、Queue dock 的严格 steer 操作、待处理 steering 的生命周期仍归各自的所有者。
 
 ## 考虑过的替代方案
 

.agents/notes/implemented/process/2026-08-10-npm-release-sequences.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# side as of the last confirmed-consistent state. Both languages carry equal authority;
+# after editing either side, bring the other along and re-record with:
+#   pnpm run verify-translation-pairing --write .agents/notes/implemented/process/2026-08-10-npm-release-sequences.md
+2026-08-10-npm-release-sequences.md: df81756ab84163b21996b5e2f12c5c8db994d9a5
+2026-08-10-npm-release-sequences.zh.md: 03269aeb987509034564bd0cac92f5d26c7f9b58

.agents/notes/implemented/process/2026-08-10-npm-release-sequences.md

@@ -0,0 +1,162 @@
+# Agent Note: Private npm publication as three independent sequences
+
+Status: implemented
+
+English | [中文](2026-08-10-npm-release-sequences.zh.md)
+
+## Problem
+
+This repository held three unrelated groups of publishable packages and no channel that sent any of them to a registry.
+
+`packages/*/*` and `apps/*` form the runtime surface of `@deepseek-ai/dsh`; `vendor/*` holds nine rescoped Cordis framework packages, each carrying its upstream version; `native/landlock-run/packages/*` holds Linux platform packages with their own workflow. The three differ in version baseline, change rate, and build requirements: dsh moves with the product, vendor moves only when upstream is re-synced or a local modification changes, and native needs a musl toolchain and one build per architecture. Forcing them through one pipeline means every product release republishes the framework and the native binaries.
+
+Two hard blockers sat in the way. All 217 workspace manifests set `private: true`, which npm refuses to publish. The subtler one was 933 hand-written `peerDependencies: "^0.0.1"` entries between sibling dsh packages: `pnpm pack` substitutes the `workspace:` protocol but leaves semver ranges alone, and `^0.0.1` means `>=0.0.1 <0.0.2` — it excludes `0.0.2`, and semver excludes prereleases from a range without a prerelease of its own, so it excluded `0.0.1-rc.1` too. Those entries never failed only because the version never left `0.0.1`.
+
+`scripts/publish-npm-baseline.ts` is a local publication script: it packs and publishes in one process, needs a human to authenticate and retry on their own machine, and excludes vendor from its release set. It cannot be the basis for CI publication, though its tarball payload validation and installed-artifact probes are verified parts.
+
+## Decision
+
+### Three independent sequences
+
+`packages/`, `vendor/`, and `native/` each have one bump sequence and one publication, sharing no version, no trigger, and no waiting. Releasing dsh does not republish vendor; releasing vendor does not republish native.
+
+| Sequence | Members | Version baseline | Tag | Workflow |
+|---|---|---|---|---|
+| dsh | `packages/*/*` + `apps/*` (`@deepseek-ai/dsh` and `@deepseek-ai/dsh-frontend`) | one version for the family and the workspace root, `0.0.x` | `dsh-v<version>` | `release.yml` |
+| vendored framework | the nine `vendor/*` packages | each package on its own version line | `vendor-<package>-v<version>` (one per package) | `release-vendor.yml` |
+| native | `native/landlock-run/packages/*` | its own `0.0.x` | `landlock-run-v<version>` | `landlock-run-release.yml` |
+
+All three publish privately to the `@deepseek-ai` scope on npmjs.com. `publishConfig.access` in each manifest is `restricted` and no workflow passes `--access`, because a command-line flag overrides the manifest.
+
+### Versions land in the repository from a local command; CI only checks and uploads
+
+Each sequence has one bump-and-commit command: it derives the target version, writes it into the relevant manifests, runs `pnpm install --lockfile-only`, and commits the manifests with the lockfile. The published version is therefore readable from the repository. A human creates the tag after the commit merges to master; CI never writes to the repository and needs no write permission.
+
+`release:dsh` accepts `major`, `minor`, `patch`, or an explicit version, and writes one version across the family **and the workspace root** — the workspace constraint requires every member's version to equal the root's, so the root carries the family version, and the root check accepts a prerelease segment. A prerelease such as `0.0.1-rc.1` drives pack, the installed-artifact probe, and one real private publication before numbered versions follow. The dist-tag decision is the one `landlock-run-release.yml` already made: a version with a prerelease segment publishes under `--tag next`, anything else takes `latest`.
+
+### vendor: publish what changed, and let tags be the ledger
+
+The vendored packages are decoupled from upstream by their scope but keep their own version lines. The published version is the higher of the manifest version and the last published version, with the patch incremented — which also drops an upstream prerelease segment. The first published versions:
+
+| Package | Upstream version | First published version |
+|---|---|---|
+| `@deepseek-ai/cordis` | 4.0.0-rc.7 | 4.0.1 |
+| `@deepseek-ai/cordis-plugin-loader` | 1.0.0-rc.5 | 1.0.1 |
+| `@deepseek-ai/cosmokit` | 1.8.1 | 1.8.2 |
+| `@deepseek-ai/schemastery` | 3.18.0 | 3.18.1 |
+| `@deepseek-ai/cordis-plugin-hmr` | 1.0.15 | 1.0.16 |
+| `@deepseek-ai/cordis-plugin-include` | 1.0.4 | 1.0.5 |
+| `@deepseek-ai/cordis-plugin-timer` | 1.1.2 | 1.1.3 |
+| `@deepseek-ai/cordis-plugin-group` | 1.0.0 | 1.0.1 |
+| `@deepseek-ai/cordis-plugin-logger-console` | 1.0.0 | 1.0.1 |
+
+Taking the last published version as the baseline is what survives a re-sync: upstream restoring `4.0.0-rc.8` after this repository published `4.0.1` would otherwise compute `4.0.1` again and collide. `--prerelease rc.1` publishes a rehearsal instead, which takes `--tag next` and leaves the release numbers free: a prerelease has lower precedence than the release it precedes, so `4.0.1` still follows `4.0.1-rc.1`. That ordering is computed here rather than read from `git tag --sort=v:refname`, which places a prerelease above its release.
+
+Only changed packages publish, and the change judgement adds no state file: **each package has its own tag, and that tag records the commit it last published from**. For each package, bump reads the newest `vendor-<package>-v*` tag and diffs the package directory against it. A path counts when the manifest's `files` selects it, when npm publishes it regardless (`package.json`, `README*`, `LICENSE*`), or — for a package whose `files` selects `lib/` — when it is a build input (`src/**`, `tsconfig*.json`, a build config). That last rule exists because a built payload is not tracked by git: without it, a real source change reads as "nothing changed" and the next publication fails on a version whose bytes moved.
+
+A tag is a commit pointer, not proof of publication. Bump asks the registry whether the version its newest tag names exists and fails for a human to resolve when it does not, because a tag pushed for a publication that then failed would otherwise read as "already published" and skip the package indefinitely. Querying a private package needs credentials, so an unauthenticated machine reports the gap instead of failing.
+
+`vendor/cordis` publishes `src` as well. Its export map declares `"./src/*"`, so a tarball without those files points consumers at absent paths, and `files` selecting only build output left the change judgement with no tracked path to match.
+
+### Publication runs only on GitHub, and the registry decides what goes out
+
+Publication runs only from GitHub Actions; there is no local publication path. Publish reads no tag and no manifest of "what this release includes". For each packed tarball it compares the version against the registry, in three states:
+
+| State | Action |
+|---|---|
+| the registry does not have that version | publish |
+| the registry has it, and the tarball's sha512 equals the recorded `dist.integrity` | skip: this is a re-run over one artifact |
+| the registry has it, and the integrity differs | fail, reporting content changed without a version bump |
+
+The third state catches code that changed without a version bump. The first two provide idempotence — re-running publish over one artifact republishes nothing and needs no manual selection of packages. The same rule resolves the tension between one vendor release carrying several tags and a workflow that can only run from one ref: the workflow never infers which packages to publish from the tag it ran from.
+
+### Workspace-internal references use the `workspace:` protocol
+
+Every reference to a workspace member uses `workspace:^`, so `pnpm pack` substitutes a range matching the target version: sibling `peerDependencies` follow the family version, and a reference to a vendored package follows that package's own line. The Landlock platform packages keep `workspace:*`, which publishes the exact version, because a platform package and its entry must agree exactly.
+
+`scripts/check-workspace-constraints.ts` requires the protocol, so a new package cannot reintroduce a hand-written range; the invariant-companion rule requires `workspace:^` for `@deepseek-ai/dsh-invariants` for the same reason.
+
+### Release family objects
+
+The entity in this domain is a **release family**: a set of packages sharing one version baseline and tag naming that publishes as a unit. Adding a family means adding a subclass and a workflow lane, not changing the core.
+
+| Object | Responsibility |
+|---|---|
+| `ReleaseFamily` | a family's identity: member discovery, version baseline, tag prefix, packed-payload rule, installed entry |
+| `ReleaseMember` | one publishable package: directory, name, version, manifest |
+| `publishOrder` | topological order over runtime dependencies, ties broken by package name; a cycle is reported rather than resolved arbitrarily |
+| `pack` | packs a whole family into one directory and records the upload order |
+| `verify` | the family's version baseline, and — when publishing — that the run comes from that family's tag and its members are publishable |
+| `verify-packed-install` | installs the tarballs of one or more pack directories into a throwaway consumer and drives the installed executable |
+| `publish` | the three registry states above |
+| `process` / `tarball` | the one home for spawning commands and for reading a packed tarball, including the entry guard that keeps every script importable |
+
+The dsh family applies the repository's publication payload policy, which rejects sources and declaration maps. The vendored family keeps upstream's payload, because those manifests export `./src/*` and dropping `src` would publish an export map pointing at absent files.
+
+### Workflow shape: pack everything at once, then publish as one set
+
+The `pack` job walks the whole release set once, packing each member into one directory, writes the upload order, and uploads that directory as one artifact; the `publish` job downloads that artifact and publishes each entry in order. The release set is one unit — half the packages can never reach the registry while the other half is still building.
+
+`pack` carries no credentials and runs on every pull request and master push, so a pull request proves the release set still packs. `publish` is a manual dispatch, sits behind the `npm-publish` environment for human approval, and neither builds nor rebuilds — it uploads the bytes pack produced. Pack runs are grouped per ref so concurrent pull requests do not displace each other; the publish job carries the global group, because dist-tags are shared registry state.
+
+A dsh verification installs the vendored family's pack output too. The harness packages declare the vendored framework as a peer, those packages live in another sequence, and the credential-free job cannot fetch them from a private registry — so `release.yml` packs the vendored family for verification while publishing only its own set.
+
+The verification also packs the Landlock entry, which `dsh-sandbox-local` declares as a plain dependency, and omits optional dependencies. The platform packages behind those optional entries need a musl toolchain and one build per architecture, so a job on one runner cannot produce them; a consumer that cannot install them must still start, which is what optional means here. The verification therefore reads a directory by its contents rather than a pack order, because a directory can hold tarballs packed only to satisfy a cross-sequence dependency.
+
+### Repository changes this carried
+
+| Item | Content |
+|---|---|
+| release-set manifests | `private: true` removed; `publishConfig.access: restricted` and `repository` with each package's `directory` added |
+| release-set boundary | every member of `packages/*/*`, `apps/*`, and `vendor/*` |
+| dependency protocol | workspace-internal references are `workspace:^`, with `check-workspace-constraints.ts` and the invariant-companion rule requiring it |
+| root `AGENTS.md` | the convention that vendored packages are `private: true` no longer holds |
+| `vendor/README.md` | records `src` joining `cordis`'s `files` as a local modification |
+| the three native packages | `publishConfig.access: restricted`, and their workflow no longer passes `--access` |
+
+### Relationship to the earlier proposal
+
+This Agent Note replaces the version scheme and the release-set boundary in [artifact-first npm baseline publication](../../proposed/process/2026-08-04-artifact-first-npm-baseline-publication.md): its `<base>-<timestamp>-<short SHA>` prerelease versions and `dev-<base>` dist-tag are not adopted, and vendor is not excluded from the release set. What both agree on stands: pack and publish are separate, publish consumes only verified tarballs, and the payload and installed-artifact probes are release gates.
+
+## Alternatives considered
+
+**A `<base>-<timestamp>-<short SHA>` version.** Planned for continuous dev publication. It conflicts with keeping the published version in the repository: the version embeds a commit SHA, and writing the version back produces a new commit, so the SHA can only name the parent commit that was published and the link needs a convention to explain it. With numbered versions, a prerelease such as `0.0.1-rc.1` already covers "verify first, then release".
+
+**A `vendor/published.json` ledger recording each package's published version and commit.** This preceded the tag design. It adds a state file that must not drift from the registry. A per-package tag gives the same commit pointer, and the tag has to exist anyway, so it introduces no second copy of the state.
+
+**Event-level tags (`vendor-r1`, `vendor-r2`).** Prepared for one release event carrying several package versions. Once the registry decides what publishes, the workflow no longer infers the set from the tag, so per-package tags suffice — and each one names its own package's real version.
+
+**Putting the nine vendored packages on one `4.0.x` line.** It removes change detection, but cosmokit would jump from `1.8.1` to `4.0.1` and lose its upstream lineage; the upstream ranges inside the nine (`^1.8.1` and friends) would stop matching immediately, forcing a rewrite of the vendored manifests.
+
+**Incrementing every vendored package on every vendor release, with no change detection.** The least machinery, at the cost of new version numbers for packages whose content is byte-identical to the previous release. Tags reduce change detection to reading one tag and running one diff, which is not worth trading for inflated version numbers.
+
+**Deciding "already published" from the version alone, without comparing content.** The reference flow queries no registry: publish uploads each tarball and npm rejects a duplicate version. Skipping on the version alone misses code that changed without a bump, which is the only failure that quietly leaves stale bytes on the registry. The cost is a registry query and a dependency on reproducible builds.
+
+**Verifying only the packed install, with no local registry.** The reference flow unpacks tarballs into a tree and drives it with plain Node, which bypasses version-range resolution. Running a local registry in CI to cover that layer was rejected: artifact correctness is covered by existing tests, the publication path is exercised by the master rehearsal, and a pull request only needs to prove the release set packs. Installing from `file:` specifiers still exercises range resolution for every internal dependency.
+
+**Selecting a subset by entry closure.** Crawling `dependencies` from `@deepseek-ai/dsh` and `@deepseek-ai/dsh-frontend` yields 156 packages, 61 fewer than the whole set. But this repository's plugins are mounted by name from `cordis.yml` rather than imported: `vendor/cordis-plugin-group` and `vendor/cordis-plugin-logger-console` fall outside the dependency closure while being required at runtime. Selecting by code dependency fails as "the consumer installs it and it will not start", and it would need a standing proof that no mounted package was missed. Under a private scope the extra packages are invisible outside the organization. `python/`, the root `examples/`, `docs/`, and `website/` are not members.
+
+**Extending `scripts/publish-npm-baseline.ts`.** It is a local publication script that packs and publishes in one process, the opposite of separating credential-free packing from protected publication. Its verified parts — payload validation and installed-artifact probes — are reused so `pnpm run duplication` does not report clones.
+
+**One workflow with a `family` input.** Two version models in one file forks the concurrency group, the tag prefix, and the rehearsal triggers into conditional expressions. One file per family is both shorter and easier to read.
+
+**Rewriting dependency ranges at publication time.** Compared with the protocol, the rewrite runs only in CI, a local `pnpm install` cannot show whether it is correct, and it repeats on every release.
+
+**Running bump in CI and pushing the version back.** It needs repository write permission for the workflow, and a version commit on the release branch races human commits. Bump and commit stay local; CI checks and uploads.
+
+## Consequences
+
+The release scripts are importable modules behind a guarded entry point, and their judgements carry unit tests: tag naming, publish order and cycle reporting, version-baseline arithmetic, the payload change judgement, and each family's payload policy. Two defects the first draft carried — a publish command that ran the pack command on import, and a change judgement blind to `vendor/cordis` source edits — are exactly what a test at that seam catches.
+
+A pull request runs the full pack for both sequences without credentials and installs the packed dsh tarballs into a throwaway consumer, where plain Node drives `dsh --version`. That probe is deliberately one command: it proves `files` selected a complete payload and that the published ranges resolve, and says nothing about interactive behavior.
+
+What this costs:
+
+- **Tags can drift from the registry.** A tag pushed for a publication that then failed is caught by bump's registry check, but only where credentials exist; an unauthenticated machine reports the gap and continues.
+- **The change judgement depends on visible tags.** A shallow clone, or a checkout without tags, degrades the vendored judgement to "publish everything for the first time". `fetch-depth: 0` is a precondition, not an optimization.
+- **The protocol rewrite touched 1504 dependency declarations.** It does not change local resolution — pnpm already resolves from the workspace — but it changes the ranges that go out.
+- **Private packages need credentials to install.** Every consumer — CI, sandbox e2e, outside users — needs scope credentials, including for the Landlock packages, which have never been published and so cut off no existing anonymous path.
+- **`repository` names a different organization than the one running the workflows.** Token-based publication is unaffected; npm provenance (OIDC) requires the two to agree, so adopting it means either repointing `repository` or publishing from the organization it names.
+- **Byte reproducibility is assumed, not measured.** The skip-on-identical-integrity state rests on packing the same commit twice producing the same bytes. Nothing measures that yet: if the build embeds absolute paths or timestamps, a re-run reports a false failure. Measure it before the first publication a re-run might follow, and fall back to comparing per-file content hashes if it does not hold.
+- **Re-running publish over an older artifact can move `latest` backwards.** Publication is decided per version, so an older set republished after a newer one takes the stable dist-tag again. The rehearsals run from a prerelease version, which never takes `latest`.
+- **The first publication is one large step.** Nine vendored packages and the whole dsh set publish at once, so any payload defect surfaces in a single release, which is why a prerelease version drives the complete path first.

.agents/notes/implemented/process/2026-08-10-npm-release-sequences.zh.md

@@ -0,0 +1,162 @@
+# Agent Note: 三条独立序列的私有 NPM 发布
+
+Status: implemented
+
+[English](2026-08-10-npm-release-sequences.md) | 中文
+
+## 问题
+
+这个仓库有三组互不相干的可发布包，却没有任何发布通道把它们送上 registry。
+
+`packages/*/*` 与 `apps/*` 组成 `@deepseek-ai/dsh` 的运行面；`vendor/*` 是九个 rescope 过的 Cordis 框架包，各自带着上游的版本号；`native/landlock-run/packages/*` 是 Linux 平台包，有自己的 workflow。三组的版本基线、变更节奏和构建要求都不同：dsh 随产品迭代，vendor 只在同步上游或改动本地修改时才动，native 需要 musl 工具链和逐架构构建。把它们塞进一条发布流水线，等于每次产品发版都要重发框架和原生二进制。
+
+挡路的还有两处硬门。全部 217 个 workspace manifest 都是 `private: true`，`npm publish` 直接拒绝。更隐蔽的是 933 条 dsh 兄弟包之间硬写的 `peerDependencies: "^0.0.1"`：`pnpm pack` 只替换 `workspace:` 协议，不动语义范围，而 `^0.0.1` 等于 `>=0.0.1 <0.0.2`——发 `0.0.2` 落不进去，发 `0.0.1-rc.1` 也落不进去（semver 规定不带预发布段的范围排除预发布版本）。这些条目至今没出事，只因为版本一直停在 `0.0.1`。
+
+`scripts/publish-npm-baseline.ts` 是本机发布脚本：它把 pack 与 publish 放进同一个进程，需要人工在本机完成认证与重试，且把 vendor 排除在发布集之外。它不能作为 CI 发布的基础，但其中的 tarball payload 校验与已安装产物探针是验证过的零件。
+
+## 决策
+
+### 三条独立序列
+
+`packages/`、`vendor/`、`native/` 各自一条 bump 序列、各自一次发布，不共享版本号、不共享触发、不互相等待。发 dsh 不重发 vendor，发 vendor 不重发 native。
+
+| 序列 | 成员 | 版本基线 | tag | workflow |
+|---|---|---|---|---|
+| dsh | `packages/*/*` + `apps/*`（`@deepseek-ai/dsh` 与 `@deepseek-ai/dsh-frontend`） | 全族与 workspace 根共用一个 `0.0.x` | `dsh-v<版本>` | `release.yml` |
+| vendored framework | `vendor/*` 九个包 | 每包各自一条版本线 | `vendor-<包名>-v<版本>`（每包一个） | `release-vendor.yml` |
+| native | `native/landlock-run/packages/*` | 自己的 `0.0.x` | `landlock-run-v<版本>` | `landlock-run-release.yml` |
+
+三组一律发到 npmjs.com 的 `@deepseek-ai` scope 下的私有包。每个 manifest 的 `publishConfig.access` 都是 `restricted`，且没有任何 workflow 传 `--access`——命令行选项会覆盖 manifest。
+
+### 版本由本地命令写进仓库，CI 只核对与上传
+
+每条序列有一条 bump-and-commit 命令：算出目标版本，写进相关 manifest，跑 `pnpm install --lockfile-only`，再把 manifest 连 lockfile 一起 commit。发布版本因此在仓库里查得到。tag 由人工在 commit 合入 master 后打；CI 不写仓库，也不需要写权限。
+
+`release:dsh` 接受 `major`、`minor`、`patch` 或显式版本号，把同一个版本写进全族**以及 workspace 根**——workspace 约束要求每个成员的版本等于根版本，所以根承载族版本，而根的检查接受预发布段。像 `0.0.1-rc.1` 这样的预发布号先把 pack、已安装产物探针和一次真实私有发布跑通，数字版本随后。dist-tag 沿用 `landlock-run-release.yml` 已有的判定：版本带预发布段就 `--tag next`，否则进 `latest`。
+
+### vendor：谁改了谁发版，tag 就是账本
+
+vendor 九包加了 scope 之后与上游脱钩，但保留各自的版本线。发布版本取「manifest 版本」与「上次发布版本」中较高的那个，再递增 patch——这一步同时去掉上游的预发布段。首发版本：
+
+| 包 | 上游版本 | 首发版本 |
+|---|---|---|
+| `@deepseek-ai/cordis` | 4.0.0-rc.7 | 4.0.1 |
+| `@deepseek-ai/cordis-plugin-loader` | 1.0.0-rc.5 | 1.0.1 |
+| `@deepseek-ai/cosmokit` | 1.8.1 | 1.8.2 |
+| `@deepseek-ai/schemastery` | 3.18.0 | 3.18.1 |
+| `@deepseek-ai/cordis-plugin-hmr` | 1.0.15 | 1.0.16 |
+| `@deepseek-ai/cordis-plugin-include` | 1.0.4 | 1.0.5 |
+| `@deepseek-ai/cordis-plugin-timer` | 1.1.2 | 1.1.3 |
+| `@deepseek-ai/cordis-plugin-group` | 1.0.0 | 1.0.1 |
+| `@deepseek-ai/cordis-plugin-logger-console` | 1.0.0 | 1.0.1 |
+
+以「上次发布版本」为基线才扛得住重同步：本仓发过 `4.0.1` 之后上游把版本恢复成 `4.0.0-rc.8`，只看 manifest 会再算出 `4.0.1` 并撞上已发版本。加 `--prerelease rc.1` 则发一次排练版：它进 `--tag next`，而且不占用那组数字——预发布的优先级低于它所先行的正式版，所以 `4.0.1` 仍然接在 `4.0.1-rc.1` 之后。这个次序由脚本自己算，不读 `git tag --sort=v:refname`——git 会把预发布排在正式版之前。
+
+只发改动过的包，而变更判据不引入新的状态文件：**每包一个 tag，tag 就是「上次发布到哪个 commit」的记录**。bump 对每个包取最新的 `vendor-<包名>-v*` tag，拿包目录与它做 diff。一条路径算命中的条件是：manifest 的 `files` 选中它，或 npm 无论如何都会发布它（`package.json`、`README*`、`LICENSE*`），或者——当该包的 `files` 选中 `lib/` 时——它是构建输入（`src/**`、`tsconfig*.json`、构建配置）。最后那条规则的存在理由是构建产物不在 git 里：没有它，真实的源码改动会读成「没变化」，而下一次发布会在一个字节已变的版本上失败。
+
+tag 只是 commit 指针，不是发布成功的证明。bump 会向 registry 核对「最新 tag 指向的版本是否真的存在」，不存在就明确失败交人处理——否则一个为失败发布而推的 tag 会被读成「已发布」，从此永远跳过该包。查询私有包需要凭据，因此未鉴权的机器只报告这道核对被跳过，不失败。
+
+`vendor/cordis` 现在也发布 `src`。它的 exports 声明了 `"./src/*"`，tarball 里没有这些文件就等于把消费方指向不存在的路径；而 `files` 只选构建产物，也让变更判据没有任何受 git 跟踪的路径可匹配。
+
+### 发布只在 GitHub 执行，由 registry 状态决定发什么
+
+发布只从 GitHub Actions 执行，没有本机发布路径。publish 不读 tag、不读任何「本次发布包含什么」的清单，而是对每个打包好的 tarball 拿版本与 registry 比对，分三态：
+
+| 状态 | 处置 |
+|---|---|
+| registry 上没有该版本 | 发布 |
+| 已有该版本，且 tarball 的 sha512 等于记录的 `dist.integrity` | 跳过：这是同一批产物的重跑 |
+| 已有该版本，但 integrity 不同 | 失败退出，报「内容已变但版本未 bump」 |
+
+第三态拦住「改了代码却没 bump 版本」。前两态给出幂等——同一个 artifact 重跑 publish 不会重复发布，也不需要人工挑拣包。同一条规则还解决了「一次 vendor 发布携带多个 tag，而 workflow 只能从一个 ref 触发」的矛盾：workflow 从不从触发它的 tag 去推断该发哪些包。
+
+### workspace 内部引用走 `workspace:` 协议
+
+所有指向 workspace 成员的引用都用 `workspace:^`，由 `pnpm pack` 替换成匹配目标版本的范围：兄弟包的 `peerDependencies` 跟随族版本，指向 vendored 包的引用跟随那个包自己的版本线。Landlock 平台包保留 `workspace:*`（发布成精确版本），因为平台包与它的入口必须版本完全一致。
+
+`scripts/check-workspace-constraints.ts` 要求这个协议，所以新包无法再引入硬写的范围；同理，invariant companion 规则要求 `@deepseek-ai/dsh-invariants` 用 `workspace:^`。
+
+### 发布族对象
+
+这个领域里的实体是**发布族**：一组共享版本基线与 tag 命名、可整体发布的包。新增一族等于加一个子类和一条 workflow lane，不改核心。
+
+| 对象 | 职责 |
+|---|---|
+| `ReleaseFamily` | 一族的身份：成员发现、版本基线、tag 前缀、打包 payload 规则、已安装入口 |
+| `ReleaseMember` | 一个可发布包：目录、包名、版本、manifest |
+| `publishOrder` | 按运行时依赖的拓扑序，同层按包名排；遇到环是报错而不是随意定序 |
+| `pack` | 把整族打进一个目录并记录上传顺序 |
+| `verify` | 族的版本基线；发布时还要求本次运行来自该族的 tag、且成员可发布 |
+| `verify-packed-install` | 把一个或多个 pack 目录的 tarball 装进一次性 consumer，并驱动已安装的可执行入口 |
+| `publish` | 上面那三态 |
+| `process` / `tarball` | 启动命令、读取打包 tarball 的唯一正家，其中的入口守卫让每个脚本都可被 import |
+
+dsh 族套用仓库的发布 payload 策略（拒绝源码与声明映射）。vendored 族保留上游 payload，因为那些 manifest 导出 `./src/*`，去掉 `src` 会发出一个导出映射指向不存在文件的包。
+
+### workflow 形状：一次性 pack 全部，再统一 publish
+
+`pack` job 一趟遍历整个发布集，把每个成员打进同一个目录，写出上传顺序，整个目录作为一份 artifact 上传；`publish` job 下载那一份 artifact，按顺序逐个发布。发布集是一个整体——绝不会出现一半的包已经上了 registry、另一半还在构建。
+
+`pack` 无凭据，在每个 pull request 和每次 master push 上跑，所以一个 pull request 就能证明发布集仍能完整打出来。`publish` 是手动 dispatch，挂在 `npm-publish` environment 后面等人工审批，且既不构建也不重建——它上传的就是 pack 产出的字节。pack 的 run 按 ref 分组，并发的 pull request 不会互相顶掉；全局分组落在 publish job 上，因为 dist-tag 是共享的 registry 状态。
+
+dsh 的验证会一并安装 vendored 族的 pack 产物。harness 的包把 vendored 框架声明成 peer，而那些包属于另一条序列，无凭据的 job 无法从私有 registry 取到——所以 `release.yml` 为验证而打包 vendored 族，发布的仍只有自己那一份。
+
+验证还会打一份 Landlock entry 的 tarball——`dsh-sandbox-local` 把它声明为普通 `dependencies`——同时略去可选依赖。那些可选项背后的平台包需要 musl 工具链且每个架构各构建一次，单台 runner 产不出来；而装不到它们的消费方也必须能起，这正是「可选」在这里的含义。因此验证按目录内容读取 tarball，而不是读发布顺序：一个目录可能只装着为满足跨序列依赖而打出来的包，任何发布顺序都不描述它。
+
+### 本次带出的仓库改动
+
+| 项 | 内容 |
+|---|---|
+| 发布集 manifest | 去掉 `private: true`；补 `publishConfig.access: restricted` 与带各自 `directory` 的 `repository` |
+| 发布集边界 | `packages/*/*`、`apps/*`、`vendor/*` 的全部成员 |
+| 依赖协议 | workspace 内部引用为 `workspace:^`，由 `check-workspace-constraints.ts` 与 invariant companion 规则强制 |
+| 根 `AGENTS.md` | 「vendored 包是 `private: true`」这条约定不再成立 |
+| `vendor/README.md` | 记录「`src` 加入 `cordis` 的 `files`」这条本地修改 |
+| native 三包 | `publishConfig.access: restricted`，且其 workflow 不再传 `--access` |
+
+### 与先前提案的关系
+
+本 Note 取代 [以产物为先的 NPM 基线发布](../../proposed/process/2026-08-04-artifact-first-npm-baseline-publication.md) 中的版本方案与发布集边界：那篇的 `<base>-<时间戳>-<短 SHA>` 预发布版本与 `dev-<base>` dist-tag 不再采用，vendor 也不排除在发布集之外。两篇一致的部分保留：pack 与 publish 分离、publish 只消费已验证的 tarball、payload 与安装后探针作为发布门。
+
+## 曾考虑的替代方案
+
+**`<base>-<时间戳>-<短 SHA>` 版本号。** 曾计划用于持续 dev 发布。它与「把发布版本留在仓库里」冲突：版本内嵌 commit SHA，而把版本写回会产生新的 commit，于是 SHA 只能指向被发布的父 commit，这条链要靠约定解释。改用数字版本后，`0.0.1-rc.1` 这类预发布号已经覆盖「先验证再正式发」。
+
+**用 `vendor/published.json` 账本记录每包的已发版本与 commit。** 这是 tag 方案之前的设计。它新增一份必须与 registry 不漂移的状态文件；per-package tag 提供同样的 commit 指针，而 tag 本来就要打，不引入第二处状态。
+
+**事件级 tag（`vendor-r1`、`vendor-r2`）。** 为「一次发布事件携带多个包版本」准备。既然由 registry 决定发什么，workflow 就不再从 tag 推断集合，per-package tag 够用，而且每个 tag 携带的是它自己那个包的真实版本。
+
+**把九个 vendored 包统一到一条 `4.0.x` 版本线。** 省掉变更检测，但 cosmokit 会从 `1.8.1` 跳到 `4.0.1`、丢失上游血缘；九包内部的上游范围（`^1.8.1` 之类）会立刻失配，必须改写 vendored manifest。
+
+**每次 vendor 发布把九包全部 patch+1，不做变更检测。** 机制最少，代价是内容与上一版逐字节相同的包也拿到新版本号。tag 把变更检测的成本压到「读一个 tag、跑一次 diff」，不值得为省这点让版本号虚涨。
+
+**只按版本号判断「是否已发布」，不比对内容。** 参照流程根本不查 registry：publish 逐个上传，重复版本由 npm 拒绝。只按版本号跳过会漏掉「改了代码没 bump」，而这是唯一会安静地把旧字节留在 registry 上的错误。代价是引入一次 registry 查询和对构建可复现性的依赖。
+
+**只做打包后安装验证，不起本地 registry。** 参照流程是把 tarball 解包成一棵树、用普通 Node 驱动，这绕过了版本范围解析。曾提议在 CI 里起本地 registry 补这一层，被否：产物正确性已由既有测试覆盖，发布路径由 master 的排练覆盖，而 pull request 只需证明发布集能打出来。用 `file:` 说明符安装依然会对每个内部依赖走一遍范围解析。
+
+**按入口闭包挑一部分包发。** 从 `@deepseek-ai/dsh` 与 `@deepseek-ai/dsh-frontend` 沿 `dependencies` 爬得到 156 个包，比全量少 61 个。但本仓的插件是 `cordis.yml` 按名字挂载的、不是被 import 的：`vendor/cordis-plugin-group` 与 `vendor/cordis-plugin-logger-console` 落在依赖闭包之外，却是运行时必需。照代码依赖挑的失败形态是「消费方装完起不来」，而且要额外持续证明「没漏任何挂载项」。私有 scope 下多出来的包对组织外不可见。`python/`、根 `examples/`、`docs/` 与 `website/` 不是成员。
+
+**在 `scripts/publish-npm-baseline.ts` 上扩展。** 它是本机发布脚本，把 pack 与 publish 放在同一进程，与「无凭据 pack、受保护 publish」的分离相反。它验证过的零件——payload 校验与已安装产物探针——被搬运复用，以免 `pnpm run duplication` 判重复。
+
+**一个 workflow 用 `family` 输入选择序列。** 两套版本模型塞进一个文件，会让 concurrency 组、tag 前缀、排练触发条件全部分叉成条件表达式。一族一个文件更短也更好读。
+
+**在发布期改写依赖范围。** 与协议相比，改写逻辑只在 CI 执行过，本机 `pnpm install` 看不出它是否正确，而且每次发布都要重来一遍。
+
+**在 CI 里执行 bump 并把版本推回仓库。** 需要给 workflow 仓库写权限，且发布分支上的版本 commit 会与人的 commit 竞争。bump 与 commit 留在本地，CI 只核对与上传。
+
+## 后果
+
+发布脚本是带入口守卫的可 import 模块，其判断都有单测覆盖：tag 命名、发布顺序与环报告、版本基线运算、payload 变更判据，以及各族的 payload 策略。第一版带过的两个缺陷——publish 命令在 import 时执行了 pack 命令、变更判据对 `vendor/cordis` 的源码改动失明——正是这类测试在对应接缝上能抓住的。
+
+一个 pull request 会为两条序列跑完整的 pack（无凭据），并把打包好的 dsh tarball 装进一次性 consumer，用普通 Node 驱动 `dsh --version`。这个探针刻意只有一条命令：它证明 `files` 选出了完整 payload、发布出去的范围可解析，不涉及任何交互行为。
+
+代价：
+
+- **tag 可能与 registry 漂移。** 为失败发布而推的 tag 由 bump 的 registry 核对拦下，但只在有凭据的地方；未鉴权的机器只报告这道核对被跳过。
+- **变更判据依赖 tag 可见。** shallow clone 或未拉 tag 会把 vendored 族的判据退化成「全部首发」。`fetch-depth: 0` 是前提，不是优化。
+- **协议改写触及 1504 处依赖声明。** 它不改变本机解析（pnpm 本来就从 workspace 解析），但改变了发布出去的范围写法。
+- **私有包需要凭据才能安装。** 任何消费方——CI、沙箱 e2e、外部使用者——都要持有 scope 凭据，Landlock 三包也在其中；它们从未发布过，所以没有切断既有的匿名安装路径。
+- **`repository` 指向的组织与运行 workflow 的组织不同。** 用 token 发布不受影响；npm provenance（OIDC）要求二者一致，届时要么把 `repository` 改指过去，要么从它指向的组织发布。
+- **字节可复现性是假定的，没有实测。** 「integrity 相同则跳过」这一态建立在「同一 commit 两次 pack 得到相同字节」之上。目前没有任何东西测量过它：若构建嵌入了绝对路径或时间，重跑会误报失败。在第一次可能被重跑的发布之前实测，若不成立就退到比对 tarball 内逐文件内容哈希。
+- **用较旧的 artifact 重跑 publish 会把 `latest` 拉回旧版。** 发布是按版本决定的，所以在较新版本之后重发较旧的一批，会让稳定 dist-tag 再次指向旧版。排练用的是预发布版本，它永远不占 `latest`。
+- **首发是一次大步。** 九个 vendored 包与整个 dsh 集一次发出，任何 payload 缺陷都会集中在同一次发布里暴露——这正是先用预发布版本把完整链路走一遍的理由。

.agents/notes/implemented/testing/2026-07-24-web-gui-browser-e2e-lane.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write .agents/notes/implemented/testing/2026-07-24-web-gui-browser-e2e-lane.md
-2026-07-24-web-gui-browser-e2e-lane.md: e572929ae6762da6adc2e77e1dba19361beaf670
-2026-07-24-web-gui-browser-e2e-lane.zh.md: 99f86f40ba006c4024f367b73ce52f8679b8d2fd
+2026-07-24-web-gui-browser-e2e-lane.md: 6e52d96a8adb5486e8666d65a3425bf5a0aad4a9
+2026-07-24-web-gui-browser-e2e-lane.zh.md: 7598a8edc530a34261799e57ce953edafe44e70e

.agents/notes/implemented/testing/2026-07-24-web-gui-browser-e2e-lane.md

@@ -88,7 +88,7 @@ Surveyed AI-chat/agent web UIs and mocking layers (LibreChat, vercel/ai-chatbot
 - **Follow-up-prompt-after-resume scenario**: the history/live stitch path over the real wire; add as its own scenario when that code changes or regresses.
 - **Composer steering gesture**: the input locks while running (stop-or-wait), so the steering scenario steers over the wire from the page; `TODO(web-steer-composer)` upgrades the drive step to a real composer gesture when the product grows one.
 - **Drag session reorder**: `workspace.insertSessionBefore` has no browser scenario; it needs two sessions materialized in one workspace plus synthesized HTML5 drag events. Add it when that surface changes or regresses. The inert session Rename/Fork/Delete and workspace Delete menu rows get scenarios when they gain behavior.
-- **Long-history Chat-to-Trajectory Inspect**: the independent inspection source exhausts history after the view opens, while the selected record is addressed by a derived table index that can move as older pages prepend. Short-history Inspect remains covered; the long-history interaction contract excludes this handoff until selection has a stable semantic identity.
+- **Long-history Chat-to-Trajectory Inspect**: both views share Session paging, while the selected Trajectory record is addressed by a derived table index that can move as older pages prepend. Short-history Inspect remains covered; the long-history interaction contract excludes this handoff until selection has a stable semantic identity.
 
 ## Consequences
 

.agents/notes/implemented/testing/2026-07-24-web-gui-browser-e2e-lane.zh.md

@@ -88,7 +88,7 @@ Web GUI 以一条真实组装链交付——chromium 页面 → client 插件 bu
 - **恢复后追问场景**：真实 wire 上的历史/实时缝合路径；当该代码变更或回归时作为独立场景补充。
 - **输入框 steering 手势**：输入在运行期间锁定（只能停止或等待），因此 steering 场景从页面走 wire 做 steer；`TODO(web-steer-composer)` 待产品长出真实的输入框手势后，把驱动步骤升级为该手势。
 - **拖拽会话重排**：`workspace.insertSessionBefore` 尚无浏览器场景；它需要在同一个工作区里物化两个会话，并合成 HTML5 拖拽事件。当该表面变更或回归时再补充。无行为的会话 Rename/Fork/Delete 和工作区 Delete 菜单行待获得行为后再补充场景。
-- **长历史 Chat 到 Trajectory 的 Inspect**：独立的检查数据源会在视图打开后穷尽历史，而所选记录由一个派生的表格索引定位；随着较早页面前插，该索引可能移动。短历史 Inspect 仍有覆盖；在选中项具有稳定的语义身份之前，长历史交互约定不包含这项交接。
+- **长历史 Chat 到 Trajectory 的 Inspect**：两个视图共用 Session 分页，而所选 Trajectory 记录由一个派生的表格索引定位；随着较早页面前插，该索引可能移动。短历史 Inspect 仍有覆盖；在选中项具有稳定的语义身份之前，长历史交互约定不包含这项交接。
 
 ## 后果
 

.github/workflows/landlock-run-release.yml

@@ -172,5 +172,7 @@ jobs:
           tag_args=()
           case "$version" in *-*) tag_args=(--tag next);; esac
           while IFS= read -r tarball; do
-            npm publish "dist/npm/${tarball}" --access public "${tag_args[@]}"
+            # No --access: publishConfig.access in each manifest decides, and a
+            # command-line flag would override it.
+            npm publish "dist/npm/${tarball}" "${tag_args[@]}"
           done < dist/npm/publish-order.txt

.github/workflows/release-vendor.yml

@@ -0,0 +1,132 @@
+# Pack and publish the vendored framework sequence: the nine rescoped Cordis
+# packages under vendor/, each on its own version line. This sequence releases
+# independently of dsh and of the native packages.
+#
+# Pack runs without credentials on every pull request and master push.
+# Publication is a manual dispatch from a vendor-* tag; a vendor release can
+# carry several versions, so each package has its own tag.
+name: Release (vendor)
+
+on:
+  pull_request:
+  push:
+    branches: [master]
+  workflow_dispatch:
+    inputs:
+      publish:
+        description: Publish the packed tarballs to npm. Must run from a vendor-* tag.
+        required: true
+        type: boolean
+        default: false
+
+permissions:
+  contents: read
+
+concurrency:
+  # Pack runs per ref so concurrent pull requests never displace each
+  # other; the publish job below serializes the shared dist-tag state.
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: false
+
+env:
+  PRIMARY_NODE_VERSION: '24'
+  DSH_TELEMETRY_DISABLED: '1'
+
+jobs:
+  pack:
+    name: Pack npm tarballs
+    runs-on: ubuntu-24.04
+    steps:
+      # Complete history: the release scripts read tags.
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+
+      - uses: pnpm/action-setup@v4
+        with:
+          dest: ${{ runner.temp }}/setup-pnpm
+
+      - uses: actions/setup-node@v6
+        with:
+          node-version: ${{ env.PRIMARY_NODE_VERSION }}
+
+      - name: Configure pnpm store path
+        id: pnpm-store
+        run: |
+          store_root="$HOME/.local/share/pnpm/store"
+          echo "PNPM_CONFIG_STORE_DIR=$store_root" >> "$GITHUB_ENV"
+          store_path=$(PNPM_CONFIG_STORE_DIR="$store_root" pnpm store path --silent)
+          echo "path=$store_path" >> "$GITHUB_OUTPUT"
+
+      - uses: actions/cache/restore@v4
+        with:
+          path: ${{ steps.pnpm-store.outputs.path }}
+          key: ${{ runner.os }}-node-${{ env.PRIMARY_NODE_VERSION }}-pnpm-${{ hashFiles('pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-node-${{ env.PRIMARY_NODE_VERSION }}-pnpm-
+
+      - name: Install (immutable)
+        run: pnpm install --frozen-lockfile
+
+      - name: Verify release version
+        env:
+          RELEASE_PUBLISH: ${{ inputs.publish }}
+        run: pnpm run release:verify --family vendor
+
+      # The vendored packages publish their own sources and build outputs; the
+      # host build produces what their manifests select.
+      - name: Build
+        run: pnpm run build:lib:host
+
+      - name: Pack release tarballs
+        run: pnpm run release:pack --family vendor --out dist/npm-vendor
+
+      - name: Verify packed install
+        run: pnpm run release:verify-packed-install --family vendor --from dist/npm-vendor
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: vendor-npm-tarballs
+          path: dist/npm-vendor/*
+          if-no-files-found: error
+          retention-days: 7
+
+  publish:
+    name: Publish to npm
+    if: inputs.publish
+    needs: pack
+    runs-on: ubuntu-24.04
+    environment: npm-publish
+    concurrency:
+      group: Release-publish
+      cancel-in-progress: false
+    permissions:
+      contents: read
+    steps:
+      # Checkout and install carry the release scripts only; no build step.
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+
+      - uses: pnpm/action-setup@v4
+        with:
+          dest: ${{ runner.temp }}/setup-pnpm
+
+      - uses: actions/setup-node@v6
+        with:
+          node-version: ${{ env.PRIMARY_NODE_VERSION }}
+          registry-url: https://registry.npmjs.org
+
+      - name: Install (immutable, no package scripts)
+        run: pnpm install --frozen-lockfile --ignore-scripts
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: vendor-npm-tarballs
+          path: dist/npm-vendor
+
+      - name: Publish tarballs
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: pnpm run release:publish --family vendor --from dist/npm-vendor

.github/workflows/release.yml

@@ -0,0 +1,147 @@
+# Pack and publish the dsh release sequence: every package under packages/ plus
+# the apps/ entries, all on one version. The vendored framework and the native
+# packages are separate sequences with their own workflows and version lines.
+#
+# Pack runs without credentials on every pull request and master push, so a
+# pull request proves the whole publish set still packs. Publication is a
+# manual dispatch from a dsh-v* tag and consumes exactly the packed bytes.
+name: Release (dsh)
+
+on:
+  pull_request:
+  push:
+    branches: [master]
+  workflow_dispatch:
+    inputs:
+      publish:
+        description: Publish the packed tarballs to npm. Must run from a dsh-v* tag.
+        required: true
+        type: boolean
+        default: false
+
+permissions:
+  contents: read
+
+concurrency:
+  # Pack runs per ref so concurrent pull requests never displace each
+  # other; the publish job below serializes the shared dist-tag state.
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: false
+
+env:
+  PRIMARY_NODE_VERSION: '24'
+  DSH_TELEMETRY_DISABLED: '1'
+
+jobs:
+  pack:
+    name: Pack npm tarballs
+    runs-on: ubuntu-24.04
+    steps:
+      # Complete history: the release scripts read tags.
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+
+      - uses: pnpm/action-setup@v4
+        with:
+          dest: ${{ runner.temp }}/setup-pnpm
+
+      - uses: actions/setup-node@v6
+        with:
+          node-version: ${{ env.PRIMARY_NODE_VERSION }}
+
+      - name: Configure pnpm store path
+        id: pnpm-store
+        run: |
+          store_root="$HOME/.local/share/pnpm/store"
+          echo "PNPM_CONFIG_STORE_DIR=$store_root" >> "$GITHUB_ENV"
+          store_path=$(PNPM_CONFIG_STORE_DIR="$store_root" pnpm store path --silent)
+          echo "path=$store_path" >> "$GITHUB_OUTPUT"
+
+      - uses: actions/cache/restore@v4
+        with:
+          path: ${{ steps.pnpm-store.outputs.path }}
+          key: ${{ runner.os }}-node-${{ env.PRIMARY_NODE_VERSION }}-pnpm-${{ hashFiles('pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-node-${{ env.PRIMARY_NODE_VERSION }}-pnpm-
+
+      - name: Install (immutable)
+        run: pnpm install --frozen-lockfile
+
+      - name: Verify release version
+        env:
+          RELEASE_PUBLISH: ${{ inputs.publish }}
+        run: pnpm run release:verify --family dsh
+
+      - name: Build
+        run: pnpm run build
+
+      - name: Pack release tarballs
+        run: pnpm run release:pack --family dsh --out dist/npm
+
+      # The harness packages declare the vendored framework as a peer, and this
+      # job has no credentials for the private registry, so the verification
+      # installs that family's pack output too. Only dist/npm is published.
+      - name: Pack the vendored framework for verification
+        run: pnpm run release:pack --family vendor --out dist/npm-vendor
+
+      # dsh-sandbox-local declares the Landlock entry as a runtime dependency, so
+      # the verification needs its tarball. Its platform packages stay out: they
+      # are optional, and building them needs a musl toolchain per architecture.
+      - name: Pack the Landlock entry for verification
+        run: |
+          pnpm --dir native/landlock-run run build:ts
+          pnpm --dir native/landlock-run/packages/entry pack --pack-destination "$PWD/dist/npm-landlock"
+
+      - name: Verify packed install
+        run: pnpm run release:verify-packed-install --family dsh --from dist/npm --from dist/npm-vendor --from dist/npm-landlock
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dsh-npm-tarballs
+          path: dist/npm/*
+          if-no-files-found: error
+          retention-days: 7
+
+  publish:
+    name: Publish to npm
+    if: inputs.publish
+    needs: pack
+    runs-on: ubuntu-24.04
+    # Required reviewers and the allowed tags live on the environment; this is
+    # the only step in the sequence that can write to the registry.
+    environment: npm-publish
+    concurrency:
+      group: Release-publish
+      cancel-in-progress: false
+    permissions:
+      contents: read
+    steps:
+      # Checkout and install carry the release scripts only. There is no build
+      # step: publication uploads the bytes the pack job produced.
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+
+      - uses: pnpm/action-setup@v4
+        with:
+          dest: ${{ runner.temp }}/setup-pnpm
+
+      - uses: actions/setup-node@v6
+        with:
+          node-version: ${{ env.PRIMARY_NODE_VERSION }}
+          registry-url: https://registry.npmjs.org
+
+      - name: Install (immutable, no package scripts)
+        run: pnpm install --frozen-lockfile --ignore-scripts
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: dsh-npm-tarballs
+          path: dist/npm
+
+      - name: Publish tarballs
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: pnpm run release:publish --family dsh --from dist/npm

apps/cli/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh",
   "description": "dsh CLI: profile boot, plugin management, and the browser UI alias",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "apps/cli"
+  },
   "type": "module",
   "bin": {
     "dsh": "lib/bin.js"
@@ -13,10 +20,10 @@
   ],
   "license": "BSD-3-Clause",
   "dependencies": {
-    "@deepseek-ai/cordis-plugin-hmr": "workspace:*",
-    "@deepseek-ai/cordis-plugin-include": "workspace:*",
-    "@deepseek-ai/cordis-plugin-loader": "workspace:*",
-    "@deepseek-ai/cordis-plugin-timer": "workspace:*",
+    "@deepseek-ai/cordis-plugin-hmr": "workspace:^",
+    "@deepseek-ai/cordis-plugin-include": "workspace:^",
+    "@deepseek-ai/cordis-plugin-loader": "workspace:^",
+    "@deepseek-ai/cordis-plugin-timer": "workspace:^",
     "@deepseek-ai/dsh-agent-tool-mode": "workspace:^",
     "@deepseek-ai/dsh-app-boot": "workspace:^",
     "@deepseek-ai/dsh-base": "workspace:^",
@@ -65,7 +72,7 @@
     "@deepseek-ai/dsh-workflow-workerthread": "workspace:^",
     "@deepseek-ai/dsh-workspace-context": "workspace:^",
     "commander": "^15.0.0",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7",
+    "@deepseek-ai/cordis": "workspace:^",
     "js-yaml": "^4.2.0",
     "node-addon-require-builtin": "^0.1.4"
   },

apps/cli/tests/built-bin.e2e.ts

@@ -8,6 +8,9 @@ import { afterEach, beforeEach, describe, expect, it } from 'vitest'
 
 /** Published-entry acceptance for argument errors, profile lifecycle, and boot-free config dumps. */
 const repoRoot = fileURLToPath(new URL('../../../', import.meta.url))
+// The release version, including a prerelease such as 0.0.1-rc.1: `--version`
+// prints what this manifest carries, so no test may pin it to a literal.
+const cliVersion = (JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')) as { version: string }).version
 const dshBin = join(repoRoot, 'apps/cli/lib/bin.js')
 const invalidProvider = fileURLToPath(new URL('./fixtures/invalid-provider.cordis.yml', import.meta.url))
 
@@ -387,7 +390,7 @@ describe.skipIf(!existsSync(dshBin))('dsh BUILT bin (node lib/bin.js, no tsx)',
     writeFileSync(join(project, '.env'), 'PATH=/project-only-path\n')
     try {
       const result = await runBuiltBin(['--version'], {}, project)
-      expect(result).toEqual({ code: 0, stdout: '0.0.1', stderr: '' })
+      expect(result).toEqual({ code: 0, stdout: cliVersion, stderr: '' })
     } finally {
       rmSync(project, { recursive: true, force: true })
     }

apps/web/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-frontend",
   "description": "Web application entry: vite build over the @deepseek-ai/dsh-client-web shell library; dist/ served by apps/cli's dsh web",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "apps/web"
+  },
   "type": "module",
   "exports": {
     "./dist/*": "./dist/*",

docs/cookbook/adding-a-conversation-node.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write docs/cookbook/adding-a-conversation-node.md
-adding-a-conversation-node.md: ea4ec73eb109af6b0e4c7cf50fc8692942c75dd4
-adding-a-conversation-node.zh.md: 4b9a8049e2f1d060ec4bc3334036559b989ea562
+adding-a-conversation-node.md: c1965dc8a3081eebb8c1026ac53d2f7b8964edb7
+adding-a-conversation-node.zh.md: 92445e1432369a4e42cc372b5d5869c3cdeada4a

docs/cookbook/adding-a-conversation-node.md

@@ -120,6 +120,7 @@ function viewData(state: ReviewState): ReviewChatData {
 
 const reviewDefinition: ConversationNodeDefinition<ReviewState> = {
   kind: 'review-job',
+  target: 'chat',
   match: (event) => {
     if (event.type === 'review/start') {
       return { id: String(event.data.reviewId), role: 'start' }
@@ -161,8 +162,8 @@ const reviewDefinition: ConversationNodeDefinition<ReviewState> = {
       value: viewData(context.state),
     }
   },
-  buildViewNode: (context, target) => {
-    if (target !== 'chat' || context.state === undefined) return null
+  buildViewNode: (context) => {
+    if (context.state === undefined) return null
     return {
       key: context.key,
       kind: 'review-job',
@@ -196,7 +197,7 @@ export function apply(ctx: ClientContext): void {
 
 `buildLocationData(context, scope)` optionally publishes Definition-owned data onto an engine-owned Turn or Step. Use declaration merging to give each key a precise value type. Another Node in the same Location can consume that value through its constrained slot hook, such as `useTurnData(key)`, without receiving the Session or scanning `snapshot.chat.nodes`.
 
-`buildViewNode(context, target)` materializes the final target-specific Node. Preserve `context.key` as the React-facing identity, choose `anchorSeq` from durable ordering evidence, and return only renderer-ready data. Once a target Node has been published, keep returning the same key; use `visibility: 'hidden'` when it must temporarily leave the visible flow rather than withdrawing it with `null`.
+`target` and `buildViewNode(context)` declare one target-owned rendering contribution and must appear together. Preserve `context.key` as the React-facing identity, choose `anchorSeq` from durable ordering evidence, and return only renderer-ready data. Once a target Node has been published, keep returning the same key; use `visibility: 'hidden'` when it must temporarily leave the visible flow rather than withdrawing it with `null`.
 
 ## 3. Query an earlier business Context only at start
 

docs/cookbook/adding-a-conversation-node.zh.md

@@ -120,6 +120,7 @@ function viewData(state: ReviewState): ReviewChatData {
 
 const reviewDefinition: ConversationNodeDefinition<ReviewState> = {
   kind: 'review-job',
+  target: 'chat',
   match: (event) => {
     if (event.type === 'review/start') {
       return { id: String(event.data.reviewId), role: 'start' }
@@ -161,8 +162,8 @@ const reviewDefinition: ConversationNodeDefinition<ReviewState> = {
       value: viewData(context.state),
     }
   },
-  buildViewNode: (context, target) => {
-    if (target !== 'chat' || context.state === undefined) return null
+  buildViewNode: (context) => {
+    if (context.state === undefined) return null
     return {
       key: context.key,
       kind: 'review-job',
@@ -196,7 +197,7 @@ export function apply(ctx: ClientContext): void {
 
 `buildLocationData(context, scope)` 可以把 Definition 拥有的数据发布到引擎拥有的 Turn 或 Step 上。通过 declaration merging 为每个 key 指定精确 value 类型。同一 Location 内的另一个 Node 可以使用受限 slot hook（例如 `useTurnData(key)`）读取该值，无须取得 Session，也无须扫描 `snapshot.chat.nodes`。
 
-`buildViewNode(context, target)` 物化最终的目标专用 Node。把 `context.key` 保留为 React 侧身份，根据持久排序证据选择 `anchorSeq`，并且只返回 renderer 可以直接使用的数据。某个 target Node 一旦发布，就要继续返回同一个 key；需要暂时离开可见流时使用 `visibility: 'hidden'`，不要改为返回 `null` 撤回它。
+`target` 与 `buildViewNode(context)` 必须同时声明一项由 target 拥有的渲染贡献。把 `context.key` 保留为 React 侧身份，根据持久排序证据选择 `anchorSeq`，并且只返回 renderer 可以直接使用的数据。某个 target Node 一旦发布，就要继续返回同一个 key；需要暂时离开可见流时使用 `visibility: 'hidden'`，不要改为返回 `null` 撤回它。
 
 ## 3. 只在 start 时查询更早的业务 Context
 

docs/module-graph.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write docs/module-graph.md
-module-graph.md: 8a57d745df400dbd2df985490c5ec815ee2d8f98
-module-graph.zh.md: 08bd86d650400a55823e519a91448ad1c109060e
+module-graph.md: e88839f6372ecdd1e9c0e4ac00839a036f24bc40
+module-graph.zh.md: efd5ee1fe4430c6371121bf752004b65cefad28e

docs/module-graph.md

@@ -400,9 +400,6 @@ flowchart TD
   pkg_client_ui_settings --> pkg_client_ui_primitives
   pkg_client_ui_settings --> pkg_client_ui_slots
   pkg_client_ui_settings --> pkg_invariants
-  pkg_client_ui_trajectory --> pkg_client_runtime
-  pkg_client_ui_trajectory --> pkg_client_ui_primitives
-  pkg_client_ui_trajectory --> pkg_invariants
   pkg_credentials_local --> pkg_atomic_write
   pkg_credentials_local --> pkg_credentials
   pkg_credentials_local --> pkg_environment
@@ -907,6 +904,12 @@ flowchart TD
   pkg_llm_replay --> pkg_invariants
   pkg_llm_replay --> pkg_llm
   pkg_llm_replay --> pkg_session
+  pkg_client_ui_trajectory --> pkg_agent
+  pkg_client_ui_trajectory --> pkg_client_runtime
+  pkg_client_ui_trajectory --> pkg_client_ui_primitives
+  pkg_client_ui_trajectory --> pkg_compact
+  pkg_client_ui_trajectory --> pkg_invariants
+  pkg_client_ui_trajectory --> pkg_tools
   pkg_session_reference --> pkg_agent
   pkg_session_reference --> pkg_compact
   pkg_session_reference --> pkg_invariants
@@ -1309,7 +1312,6 @@ flowchart TD
 | [`client-locale`](../packages/client/locale) | `client` | [`client-connection`](../packages/client/connection), [`client-runtime`](../packages/client/runtime), [`client-ui-primitives`](../packages/client/ui-primitives), [`client-ui-slots`](../packages/client/ui-slots), [`invariants`](../packages/support/invariants) |
 | [`client-ui-models`](../packages/client/ui-models) | `client` | [`client-connection`](../packages/client/connection), [`client-runtime`](../packages/client/runtime), [`client-schema-form`](../packages/client/schema-form), [`client-ui-primitives`](../packages/client/ui-primitives), [`client-ui-slots`](../packages/client/ui-slots), [`client-web-react`](../packages/client/web-react), [`invariants`](../packages/support/invariants) |
 | [`client-ui-settings`](../packages/client/ui-settings) | `client` | [`client-runtime`](../packages/client/runtime), [`client-ui-primitives`](../packages/client/ui-primitives), [`client-ui-slots`](../packages/client/ui-slots), [`invariants`](../packages/support/invariants) |
-| [`client-ui-trajectory`](../packages/client/ui-trajectory) | `client` | [`client-runtime`](../packages/client/runtime), [`client-ui-primitives`](../packages/client/ui-primitives), [`invariants`](../packages/support/invariants) |
 | [`credentials-local`](../packages/credentials/credentials-local) | `credentials` | [`atomic-write`](../packages/util/atomic-write), [`credentials`](../packages/credentials/credentials), [`environment`](../packages/util/environment), [`invariants`](../packages/support/invariants), [`paths`](../packages/util/paths) |
 | [`settings-local`](../packages/settings/settings-local) | `settings` | [`atomic-write`](../packages/util/atomic-write), [`invariants`](../packages/support/invariants), [`paths`](../packages/util/paths), [`settings`](../packages/settings/settings) |
 | [`llm-deepseek`](../packages/llm/llm-deepseek) | `llm` | [`credentials`](../packages/credentials/credentials), [`environment`](../packages/util/environment), [`invariants`](../packages/support/invariants), [`llm`](../packages/llm/llm), [`settings`](../packages/settings/settings), [`timeout`](../packages/util/timeout) |
@@ -1415,6 +1417,7 @@ flowchart TD
 | [`tool-session-query`](../packages/session-query/tool-session-query) | `session-query` | [`invariants`](../packages/support/invariants), [`llm`](../packages/llm/llm), [`session`](../packages/core/session), [`session-query`](../packages/session-query/session-query), [`system-prompt`](../packages/core/system-prompt), [`timeout`](../packages/util/timeout), [`tools`](../packages/core/tools) |
 | [`agent-loop-testkit`](../packages/support/agent-loop-testkit) | `support` | [`agent`](../packages/core/agent), [`invariants`](../packages/support/invariants), [`llm`](../packages/llm/llm), [`session`](../packages/core/session), [`system-prompt`](../packages/core/system-prompt), [`tools`](../packages/core/tools) |
 | [`llm-replay`](../packages/support/llm-replay) | `support` | [`compact`](../packages/compact/compact), [`invariants`](../packages/support/invariants), [`llm`](../packages/llm/llm), [`session`](../packages/core/session) |
+| [`client-ui-trajectory`](../packages/client/ui-trajectory) | `client` | [`agent`](../packages/core/agent), [`client-runtime`](../packages/client/runtime), [`client-ui-primitives`](../packages/client/ui-primitives), [`compact`](../packages/compact/compact), [`invariants`](../packages/support/invariants), [`tools`](../packages/core/tools) |
 | [`session-reference`](../packages/context/session-reference) | `context` | [`agent`](../packages/core/agent), [`compact`](../packages/compact/compact), [`invariants`](../packages/support/invariants), [`llm`](../packages/llm/llm), [`retention`](../packages/util/retention), [`session`](../packages/core/session), [`session-query`](../packages/session-query/session-query) |
 | [`workspace-context`](../packages/context/workspace-context) | `context` | [`agent`](../packages/core/agent), [`fs`](../packages/fs/fs), [`invariants`](../packages/support/invariants), [`llm`](../packages/llm/llm), [`paths`](../packages/util/paths), [`session`](../packages/core/session), [`tools`](../packages/core/tools) |
 | [`repeat-tool-guard`](../packages/guard/repeat-tool-guard) | `guard` | [`agent`](../packages/core/agent), [`invariants`](../packages/support/invariants), [`tools`](../packages/core/tools) |

docs/module-graph.zh.md

@@ -402,9 +402,6 @@ flowchart TD
   pkg_client_ui_settings --> pkg_client_ui_primitives
   pkg_client_ui_settings --> pkg_client_ui_slots
   pkg_client_ui_settings --> pkg_invariants
-  pkg_client_ui_trajectory --> pkg_client_runtime
-  pkg_client_ui_trajectory --> pkg_client_ui_primitives
-  pkg_client_ui_trajectory --> pkg_invariants
   pkg_credentials_local --> pkg_atomic_write
   pkg_credentials_local --> pkg_credentials
   pkg_credentials_local --> pkg_environment
@@ -909,6 +906,12 @@ flowchart TD
   pkg_llm_replay --> pkg_invariants
   pkg_llm_replay --> pkg_llm
   pkg_llm_replay --> pkg_session
+  pkg_client_ui_trajectory --> pkg_agent
+  pkg_client_ui_trajectory --> pkg_client_runtime
+  pkg_client_ui_trajectory --> pkg_client_ui_primitives
+  pkg_client_ui_trajectory --> pkg_compact
+  pkg_client_ui_trajectory --> pkg_invariants
+  pkg_client_ui_trajectory --> pkg_tools
   pkg_session_reference --> pkg_agent
   pkg_session_reference --> pkg_compact
   pkg_session_reference --> pkg_invariants
@@ -1311,7 +1314,6 @@ flowchart TD
 | [`client-locale`](../packages/client/locale) | `client` | [`client-connection`](../packages/client/connection), [`client-runtime`](../packages/client/runtime), [`client-ui-primitives`](../packages/client/ui-primitives), [`client-ui-slots`](../packages/client/ui-slots), [`invariants`](../packages/support/invariants) |
 | [`client-ui-models`](../packages/client/ui-models) | `client` | [`client-connection`](../packages/client/connection), [`client-runtime`](../packages/client/runtime), [`client-schema-form`](../packages/client/schema-form), [`client-ui-primitives`](../packages/client/ui-primitives), [`client-ui-slots`](../packages/client/ui-slots), [`client-web-react`](../packages/client/web-react), [`invariants`](../packages/support/invariants) |
 | [`client-ui-settings`](../packages/client/ui-settings) | `client` | [`client-runtime`](../packages/client/runtime), [`client-ui-primitives`](../packages/client/ui-primitives), [`client-ui-slots`](../packages/client/ui-slots), [`invariants`](../packages/support/invariants) |
-| [`client-ui-trajectory`](../packages/client/ui-trajectory) | `client` | [`client-runtime`](../packages/client/runtime), [`client-ui-primitives`](../packages/client/ui-primitives), [`invariants`](../packages/support/invariants) |
 | [`credentials-local`](../packages/credentials/credentials-local) | `credentials` | [`atomic-write`](../packages/util/atomic-write), [`credentials`](../packages/credentials/credentials), [`environment`](../packages/util/environment), [`invariants`](../packages/support/invariants), [`paths`](../packages/util/paths) |
 | [`settings-local`](../packages/settings/settings-local) | `settings` | [`atomic-write`](../packages/util/atomic-write), [`invariants`](../packages/support/invariants), [`paths`](../packages/util/paths), [`settings`](../packages/settings/settings) |
 | [`llm-deepseek`](../packages/llm/llm-deepseek) | `llm` | [`credentials`](../packages/credentials/credentials), [`environment`](../packages/util/environment), [`invariants`](../packages/support/invariants), [`llm`](../packages/llm/llm), [`settings`](../packages/settings/settings), [`timeout`](../packages/util/timeout) |
@@ -1417,6 +1419,7 @@ flowchart TD
 | [`tool-session-query`](../packages/session-query/tool-session-query) | `session-query` | [`invariants`](../packages/support/invariants), [`llm`](../packages/llm/llm), [`session`](../packages/core/session), [`session-query`](../packages/session-query/session-query), [`system-prompt`](../packages/core/system-prompt), [`timeout`](../packages/util/timeout), [`tools`](../packages/core/tools) |
 | [`agent-loop-testkit`](../packages/support/agent-loop-testkit) | `support` | [`agent`](../packages/core/agent), [`invariants`](../packages/support/invariants), [`llm`](../packages/llm/llm), [`session`](../packages/core/session), [`system-prompt`](../packages/core/system-prompt), [`tools`](../packages/core/tools) |
 | [`llm-replay`](../packages/support/llm-replay) | `support` | [`compact`](../packages/compact/compact), [`invariants`](../packages/support/invariants), [`llm`](../packages/llm/llm), [`session`](../packages/core/session) |
+| [`client-ui-trajectory`](../packages/client/ui-trajectory) | `client` | [`agent`](../packages/core/agent), [`client-runtime`](../packages/client/runtime), [`client-ui-primitives`](../packages/client/ui-primitives), [`compact`](../packages/compact/compact), [`invariants`](../packages/support/invariants), [`tools`](../packages/core/tools) |
 | [`session-reference`](../packages/context/session-reference) | `context` | [`agent`](../packages/core/agent), [`compact`](../packages/compact/compact), [`invariants`](../packages/support/invariants), [`llm`](../packages/llm/llm), [`retention`](../packages/util/retention), [`session`](../packages/core/session), [`session-query`](../packages/session-query/session-query) |
 | [`workspace-context`](../packages/context/workspace-context) | `context` | [`agent`](../packages/core/agent), [`fs`](../packages/fs/fs), [`invariants`](../packages/support/invariants), [`llm`](../packages/llm/llm), [`paths`](../packages/util/paths), [`session`](../packages/core/session), [`tools`](../packages/core/tools) |
 | [`repeat-tool-guard`](../packages/guard/repeat-tool-guard) | `guard` | [`agent`](../packages/core/agent), [`invariants`](../packages/support/invariants), [`tools`](../packages/core/tools) |

native/landlock-run/packages/entry/package.json

@@ -32,7 +32,7 @@
   },
   "license": "BSD-3-Clause",
   "publishConfig": {
-    "access": "public"
+    "access": "restricted"
   },
   "optionalDependencies": {
     "@deepseek-ai/node-addon-landlock-run-linux-arm64": "workspace:*",

native/landlock-run/packages/linux-arm64/package.json

@@ -26,6 +26,6 @@
   },
   "license": "BSD-3-Clause",
   "publishConfig": {
-    "access": "public"
+    "access": "restricted"
   }
 }

native/landlock-run/packages/linux-x64/package.json

@@ -26,6 +26,6 @@
   },
   "license": "BSD-3-Clause",
   "publishConfig": {
-    "access": "public"
+    "access": "restricted"
   }
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepseek-ai/dsh-root",
-  "version": "0.0.1",
+  "version": "0.0.1-rc.1",
   "private": true,
   "type": "module",
   "packageManager": "pnpm@11.7.0",
@@ -121,6 +121,12 @@
     "doc-sync": "tsx scripts/run-gates.ts doc-sync",
     "hygiene": "pnpm run rescope-vendor:check && pnpm run knip && pnpm run publint && pnpm run constraints && pnpm run verify-package-invariants && pnpm run verify-built-package-invariants && pnpm run verify-cordis-config && pnpm run verify-node-next-types && pnpm run verify-runtime-closure && pnpm run verify-vendored-links",
     "publish:npm-baseline": "tsx scripts/publish-npm-baseline.ts",
+    "release:dsh": "tsx scripts/release/bump.ts --family dsh",
+    "release:vendor": "tsx scripts/release/bump.ts --family vendor",
+    "release:verify": "tsx scripts/release/verify.ts",
+    "release:pack": "tsx scripts/release/pack.ts",
+    "release:verify-packed-install": "tsx scripts/release/verify-packed-install.ts",
+    "release:publish": "tsx scripts/release/publish.ts",
     "dsh": "node --import tsx/esm apps/cli/src/bin.ts",
     "demo:headless": "node --import tsx/esm apps/cli/src/bin.ts --profile headless",
     "demo:code-mode": "node scripts/demo-code-mode.mjs",

packages/acp/acp/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-acp",
   "description": "Automation-only Agent Client Protocol server for driving DeepSeek Harness agents over JSON-RPC stdio",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/acp/acp"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -26,14 +33,14 @@
   "license": "BSD-3-Clause",
   "dependencies": {
     "@agentclientprotocol/sdk": "0.25.1",
-    "@deepseek-ai/schemastery": "^3.17.0"
+    "@deepseek-ai/schemastery": "workspace:^"
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh-agent": "^0.0.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/dsh-session": "^0.0.1",
-    "@deepseek-ai/dsh-user-approval": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/dsh-agent": "workspace:^",
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/dsh-session": "workspace:^",
+    "@deepseek-ai/dsh-user-approval": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-agent": "workspace:^",
@@ -44,6 +51,6 @@
     "@deepseek-ai/dsh-session": "workspace:^",
     "@deepseek-ai/dsh-tools": "workspace:^",
     "@deepseek-ai/dsh-user-approval": "workspace:^",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/cordis": "workspace:^"
   }
 }

packages/api/gateway/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-api-gateway",
   "description": "TypeRT Remote Host dispatcher and Client API endpoint",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/api/gateway"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -52,17 +59,17 @@
     "@deepseek-ai/dsh-type-meta": "workspace:^"
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh-client-connection": "^0.0.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/dsh-typert-registry": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/dsh-client-connection": "workspace:^",
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/dsh-typert-registry": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-client-connection": "workspace:^",
     "@deepseek-ai/dsh-host-webserver": "workspace:^",
     "@deepseek-ai/dsh-invariants": "workspace:^",
     "@deepseek-ai/dsh-typert-registry": "workspace:^",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7",
+    "@deepseek-ai/cordis": "workspace:^",
     "zod": "^4.4.3"
   }
 }

packages/api/remotes/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-api-remotes",
   "description": "Remote BFF assembly and Host Agent/Session lookup policy",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/api/remotes"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -46,13 +53,13 @@
     "@deepseek-ai/dsh-type-meta": "workspace:^"
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh-agent": "^0.0.1",
-    "@deepseek-ai/dsh-goal": "^0.0.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/dsh-session": "^0.0.1",
-    "@deepseek-ai/dsh-session-persistence": "^0.0.1",
-    "@deepseek-ai/dsh-typert-registry": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/dsh-agent": "workspace:^",
+    "@deepseek-ai/dsh-goal": "workspace:^",
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/dsh-session": "workspace:^",
+    "@deepseek-ai/dsh-session-persistence": "workspace:^",
+    "@deepseek-ai/dsh-typert-registry": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-agent": "workspace:^",
@@ -61,6 +68,6 @@
     "@deepseek-ai/dsh-session": "workspace:^",
     "@deepseek-ai/dsh-session-persistence": "workspace:^",
     "@deepseek-ai/dsh-typert-registry": "workspace:^",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/cordis": "workspace:^"
   }
 }

packages/attachment/attachment-local/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-attachment-local",
   "description": "Private content-addressed DSH_HOME attachment storage",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/attachment/attachment-local"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -15,19 +22,19 @@
   "files": ["lib/index.js", "lib/invariant.js", "lib/types/**/*.d.ts"],
   "license": "BSD-3-Clause",
   "peerDependencies": {
-    "@deepseek-ai/dsh-attachment": "^0.0.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/dsh-paths": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/dsh-attachment": "workspace:^",
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/dsh-paths": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^"
   },
   "dependencies": {
-    "@deepseek-ai/schemastery": "^3.18.0",
+    "@deepseek-ai/schemastery": "workspace:^",
     "sharp": "^0.35.3"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-attachment": "workspace:^",
     "@deepseek-ai/dsh-invariants": "workspace:^",
     "@deepseek-ai/dsh-paths": "workspace:^",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/cordis": "workspace:^"
   }
 }

packages/attachment/attachment/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-attachment",
   "description": "Durable immutable attachment storage seam for the DeepSeek Harness",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/attachment/attachment"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -15,13 +22,13 @@
   "files": ["lib/index.js", "lib/invariant.js", "lib/types/**/*.d.ts"],
   "license": "BSD-3-Clause",
   "peerDependencies": {
-    "@deepseek-ai/dsh-brand": "^0.0.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/dsh-brand": "workspace:^",
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-brand": "workspace:^",
     "@deepseek-ai/dsh-invariants": "workspace:^",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/cordis": "workspace:^"
   }
 }

packages/bash/bash-env/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-bash-env",
   "description": "Tool-independent managed DSH_* shell environment registry",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/bash/bash-env"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -25,15 +32,15 @@
   ],
   "license": "BSD-3-Clause",
   "peerDependencies": {
-    "@deepseek-ai/dsh-bash": "^0.0.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/dsh-paths": "^0.0.1",
-    "@deepseek-ai/dsh-session-persistence": "^0.0.1",
-    "@deepseek-ai/dsh-tools": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/dsh-bash": "workspace:^",
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/dsh-paths": "workspace:^",
+    "@deepseek-ai/dsh-session-persistence": "workspace:^",
+    "@deepseek-ai/dsh-tools": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^"
   },
   "dependencies": {
-    "@deepseek-ai/schemastery": "^3.18.0"
+    "@deepseek-ai/schemastery": "workspace:^"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-agent": "workspace:^",
@@ -43,6 +50,6 @@
     "@deepseek-ai/dsh-paths": "workspace:^",
     "@deepseek-ai/dsh-session-persistence": "workspace:^",
     "@deepseek-ai/dsh-tools": "workspace:^",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/cordis": "workspace:^"
   }
 }

packages/bash/bash-local/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-bash-local",
   "description": "Local-subprocess implementation of the DeepSeek Harness bash executor seam",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/bash/bash-local"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -25,23 +32,23 @@
   ],
   "license": "BSD-3-Clause",
   "peerDependencies": {
-    "@deepseek-ai/dsh-bash": "^0.0.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/dsh-settings": "^0.0.1",
-    "@deepseek-ai/dsh-subprocess": "^0.0.1",
-    "@deepseek-ai/dsh-timeout": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/dsh-bash": "workspace:^",
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/dsh-subprocess": "workspace:^",
+    "@deepseek-ai/dsh-timeout": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^",
+    "@deepseek-ai/dsh-settings": "workspace:^"
   },
   "dependencies": {
-    "@deepseek-ai/schemastery": "^3.18.0"
+    "@deepseek-ai/schemastery": "workspace:^"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-bash": "workspace:^",
     "@deepseek-ai/dsh-invariants": "workspace:^",
-    "@deepseek-ai/dsh-settings": "workspace:^",
     "@deepseek-ai/dsh-subprocess": "workspace:^",
     "@deepseek-ai/dsh-subprocess-local": "workspace:^",
     "@deepseek-ai/dsh-timeout": "workspace:^",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/cordis": "workspace:^",
+    "@deepseek-ai/dsh-settings": "workspace:^"
   }
 }

packages/bash/bash-sandbox/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-bash-sandbox",
   "description": "Sandbox-consuming implementation of the DeepSeek Harness bash executor seam (confines every command via ctx.sandbox, reports denial/enforcement result facts)",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/bash/bash-sandbox"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -25,12 +32,12 @@
   ],
   "license": "BSD-3-Clause",
   "peerDependencies": {
-    "@deepseek-ai/dsh-bash": "^0.0.1",
-    "@deepseek-ai/dsh-bash-local": "^0.0.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/dsh-sandbox": "^0.0.1",
-    "@deepseek-ai/dsh-sandbox-policy": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/dsh-bash": "workspace:^",
+    "@deepseek-ai/dsh-bash-local": "workspace:^",
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/dsh-sandbox": "workspace:^",
+    "@deepseek-ai/dsh-sandbox-policy": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-bash": "workspace:^",
@@ -40,7 +47,7 @@
     "@deepseek-ai/dsh-sandbox": "workspace:^",
     "@deepseek-ai/dsh-sandbox-local": "workspace:^",
     "@deepseek-ai/dsh-sandbox-policy": "workspace:^",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7",
+    "@deepseek-ai/cordis": "workspace:^",
     "@deepseek-ai/node-addon-landlock-run": "workspace:*"
   }
 }

packages/bash/bash/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-bash",
   "description": "Abstract bash executor seam (ctx.bash) for the DeepSeek Harness",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/bash/bash"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -25,17 +32,17 @@
   ],
   "license": "BSD-3-Clause",
   "peerDependencies": {
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/dsh-sandbox": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7",
-    "@deepseek-ai/dsh-settings": "^0.0.1",
-    "@deepseek-ai/dsh-subprocess": "^0.0.1"
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/dsh-subprocess": "workspace:^",
+    "@deepseek-ai/dsh-sandbox": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^",
+    "@deepseek-ai/dsh-settings": "workspace:^"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/dsh-subprocess": "workspace:^",
     "@deepseek-ai/dsh-sandbox": "workspace:^",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7",
-    "@deepseek-ai/dsh-settings": "workspace:^",
-    "@deepseek-ai/dsh-subprocess": "workspace:^"
+    "@deepseek-ai/cordis": "workspace:^",
+    "@deepseek-ai/dsh-settings": "workspace:^"
   }
 }

packages/bash/pwsh-local/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-pwsh-local",
   "description": "Local PowerShell implementation of the DeepSeek Harness bash executor seam",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/bash/pwsh-local"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -25,23 +32,23 @@
   ],
   "license": "BSD-3-Clause",
   "peerDependencies": {
-    "@deepseek-ai/dsh-bash": "^0.0.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/dsh-settings": "^0.0.1",
-    "@deepseek-ai/dsh-subprocess": "^0.0.1",
-    "@deepseek-ai/dsh-timeout": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/dsh-bash": "workspace:^",
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/dsh-subprocess": "workspace:^",
+    "@deepseek-ai/dsh-timeout": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^",
+    "@deepseek-ai/dsh-settings": "workspace:^"
   },
   "dependencies": {
-    "@deepseek-ai/schemastery": "^3.18.0"
+    "@deepseek-ai/schemastery": "workspace:^"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-bash": "workspace:^",
     "@deepseek-ai/dsh-invariants": "workspace:^",
-    "@deepseek-ai/dsh-settings": "workspace:^",
     "@deepseek-ai/dsh-subprocess": "workspace:^",
     "@deepseek-ai/dsh-subprocess-local": "workspace:^",
     "@deepseek-ai/dsh-timeout": "workspace:^",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/cordis": "workspace:^",
+    "@deepseek-ai/dsh-settings": "workspace:^"
   }
 }

packages/bash/pwsh-sandbox/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-pwsh-sandbox",
   "description": "Sandbox-consuming implementation of the DeepSeek Harness PowerShell executor seam (confines every command via ctx.sandbox, reports denial/enforcement result facts)",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/bash/pwsh-sandbox"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -25,12 +32,12 @@
   ],
   "license": "BSD-3-Clause",
   "peerDependencies": {
-    "@deepseek-ai/dsh-bash": "^0.0.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/dsh-pwsh-local": "^0.0.1",
-    "@deepseek-ai/dsh-sandbox": "^0.0.1",
-    "@deepseek-ai/dsh-sandbox-policy": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/dsh-bash": "workspace:^",
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/dsh-pwsh-local": "workspace:^",
+    "@deepseek-ai/dsh-sandbox": "workspace:^",
+    "@deepseek-ai/dsh-sandbox-policy": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-bash": "workspace:^",
@@ -40,6 +47,6 @@
     "@deepseek-ai/dsh-sandbox-local": "workspace:^",
     "@deepseek-ai/dsh-sandbox-policy": "workspace:^",
     "@deepseek-ai/dsh-subprocess-local": "workspace:^",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/cordis": "workspace:^"
   }
 }

packages/bash/tool-bash/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-tool-bash",
   "description": "Model-facing bash tool with optional generic background-task and sandbox-escalation support",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/bash/tool-bash"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -25,21 +32,21 @@
   ],
   "license": "BSD-3-Clause",
   "peerDependencies": {
-    "@deepseek-ai/dsh-agent": "^0.0.1",
-    "@deepseek-ai/dsh-bash": "^0.0.1",
-    "@deepseek-ai/dsh-bash-env": "^0.0.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/dsh-llm": "^0.0.1",
-    "@deepseek-ai/dsh-sandbox": "^0.0.1",
-    "@deepseek-ai/dsh-sandbox-policy": "^0.0.1",
-    "@deepseek-ai/dsh-system-prompt": "^0.0.1",
-    "@deepseek-ai/dsh-tasks": "^0.0.1",
-    "@deepseek-ai/dsh-tools": "^0.0.1",
-    "@deepseek-ai/dsh-user-approval": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/dsh-agent": "workspace:^",
+    "@deepseek-ai/dsh-bash": "workspace:^",
+    "@deepseek-ai/dsh-bash-env": "workspace:^",
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/dsh-llm": "workspace:^",
+    "@deepseek-ai/dsh-sandbox": "workspace:^",
+    "@deepseek-ai/dsh-sandbox-policy": "workspace:^",
+    "@deepseek-ai/dsh-system-prompt": "workspace:^",
+    "@deepseek-ai/dsh-tasks": "workspace:^",
+    "@deepseek-ai/dsh-tools": "workspace:^",
+    "@deepseek-ai/dsh-user-approval": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^"
   },
   "dependencies": {
-    "@deepseek-ai/schemastery": "^3.18.0"
+    "@deepseek-ai/schemastery": "workspace:^"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-agent": "workspace:^",
@@ -61,6 +68,6 @@
     "@deepseek-ai/dsh-tool-tasks": "workspace:^",
     "@deepseek-ai/dsh-tools": "workspace:^",
     "@deepseek-ai/dsh-user-approval": "workspace:^",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/cordis": "workspace:^"
   }
 }

packages/bash/tool-pwsh/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-tool-pwsh",
   "description": "Model-facing pwsh tool over the bash executor seam",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/bash/tool-pwsh"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -25,21 +32,21 @@
   ],
   "license": "BSD-3-Clause",
   "peerDependencies": {
-    "@deepseek-ai/dsh-agent": "^0.0.1",
-    "@deepseek-ai/dsh-bash": "^0.0.1",
-    "@deepseek-ai/dsh-bash-env": "^0.0.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/dsh-llm": "^0.0.1",
-    "@deepseek-ai/dsh-sandbox": "^0.0.1",
-    "@deepseek-ai/dsh-sandbox-policy": "^0.0.1",
-    "@deepseek-ai/dsh-system-prompt": "^0.0.1",
-    "@deepseek-ai/dsh-tasks": "^0.0.1",
-    "@deepseek-ai/dsh-tools": "^0.0.1",
-    "@deepseek-ai/dsh-user-approval": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/dsh-agent": "workspace:^",
+    "@deepseek-ai/dsh-bash": "workspace:^",
+    "@deepseek-ai/dsh-bash-env": "workspace:^",
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/dsh-llm": "workspace:^",
+    "@deepseek-ai/dsh-sandbox": "workspace:^",
+    "@deepseek-ai/dsh-sandbox-policy": "workspace:^",
+    "@deepseek-ai/dsh-system-prompt": "workspace:^",
+    "@deepseek-ai/dsh-tasks": "workspace:^",
+    "@deepseek-ai/dsh-tools": "workspace:^",
+    "@deepseek-ai/dsh-user-approval": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^"
   },
   "dependencies": {
-    "@deepseek-ai/schemastery": "^3.18.0"
+    "@deepseek-ai/schemastery": "workspace:^"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-agent": "workspace:^",
@@ -58,6 +65,6 @@
     "@deepseek-ai/dsh-tool-tasks": "workspace:^",
     "@deepseek-ai/dsh-tools": "workspace:^",
     "@deepseek-ai/dsh-user-approval": "workspace:^",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/cordis": "workspace:^"
   }
 }

packages/boot/app-boot/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-app-boot",
   "description": "Shared boot glue for the app bins: .env loading, fail-loud Loader guards, snapshot-aware config resolution, and the Loader boot sequence",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/boot/app-boot"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -28,15 +35,15 @@
     "js-yaml": "^4.2.0"
   },
   "peerDependencies": {
-    "@deepseek-ai/cordis-plugin-group": "^1.0.0",
-    "@deepseek-ai/cordis-plugin-hmr": "^1.0.15",
-    "@deepseek-ai/cordis-plugin-include": "^1.0.4",
-    "@deepseek-ai/cordis-plugin-loader": "^1.0.0-rc.5",
-    "@deepseek-ai/dsh-environment": "^0.0.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/dsh-paths": "^0.0.1",
-    "@deepseek-ai/dsh-system-prompt": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/cordis-plugin-group": "workspace:^",
+    "@deepseek-ai/cordis-plugin-hmr": "workspace:^",
+    "@deepseek-ai/cordis-plugin-include": "workspace:^",
+    "@deepseek-ai/cordis-plugin-loader": "workspace:^",
+    "@deepseek-ai/dsh-environment": "workspace:^",
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/dsh-paths": "workspace:^",
+    "@deepseek-ai/dsh-system-prompt": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^"
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/cordis-plugin-hmr": {
@@ -54,6 +61,6 @@
     "@deepseek-ai/dsh-paths": "workspace:^",
     "@deepseek-ai/dsh-system-prompt": "workspace:^",
     "@types/js-yaml": "^4.0.9",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/cordis": "workspace:^"
   }
 }

packages/boot/cmdline/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-cmdline",
   "description": "Immutable command-line handoff from a dsh launcher to any app plugin that injects cmdlineArgs",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/boot/cmdline"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -25,15 +32,15 @@
   ],
   "license": "BSD-3-Clause",
   "peerDependencies": {
-    "@deepseek-ai/cordis-plugin-loader": "^1.0.0-rc.5",
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/cordis-plugin-loader": "workspace:^",
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^"
   },
   "devDependencies": {
     "@deepseek-ai/cordis-plugin-include": "workspace:^",
     "@deepseek-ai/cordis-plugin-loader": "workspace:^",
     "commander": "^15.0.0",
     "@deepseek-ai/dsh-invariants": "workspace:^",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/cordis": "workspace:^"
   }
 }

packages/bundle/base/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-base",
   "description": "The shared dsh core as a profile bundle: every profile's first patch layer, inserting the base plugin rows over the empty profile root",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/bundle/base"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -34,8 +41,8 @@
     }
   },
   "dependencies": {
-    "@deepseek-ai/cordis-plugin-hmr": "workspace:*",
-    "@deepseek-ai/cordis-plugin-timer": "workspace:*",
+    "@deepseek-ai/cordis-plugin-hmr": "workspace:^",
+    "@deepseek-ai/cordis-plugin-timer": "workspace:^",
     "@deepseek-ai/dsh-agent": "workspace:^",
     "@deepseek-ai/dsh-agent-default-model": "workspace:^",
     "@deepseek-ai/dsh-agent-loop": "workspace:^",
@@ -115,11 +122,11 @@
     "@deepseek-ai/dsh-workspace-context": "workspace:^"
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-invariants": "workspace:^",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/cordis": "workspace:^"
   }
 }

packages/bundle/headless/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-headless",
   "description": "The dsh one-shot bundle: a direct core Agent/Session runner over dsh-base with no Host, HTTP, or browser layer",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/bundle/headless"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -39,17 +46,17 @@
   "dependencies": {
     "@deepseek-ai/dsh-cmdline": "workspace:^",
     "@deepseek-ai/dsh-code-runtime-worker": "workspace:^",
-    "@deepseek-ai/schemastery": "^3.18.0",
+    "@deepseek-ai/schemastery": "workspace:^",
     "commander": "^15.0.0"
   },
   "peerDependencies": {
-    "@deepseek-ai/cordis-plugin-loader": "^1.0.0-rc.5",
-    "@deepseek-ai/dsh-agent": "^0.0.1",
-    "@deepseek-ai/dsh-agent-default-model": "^0.0.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/dsh-llm": "^0.0.1",
-    "@deepseek-ai/dsh-session": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/cordis-plugin-loader": "workspace:^",
+    "@deepseek-ai/dsh-agent": "workspace:^",
+    "@deepseek-ai/dsh-agent-default-model": "workspace:^",
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/dsh-llm": "workspace:^",
+    "@deepseek-ai/dsh-session": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^"
   },
   "devDependencies": {
     "@deepseek-ai/cordis-plugin-loader": "workspace:^",
@@ -58,6 +65,6 @@
     "@deepseek-ai/dsh-invariants": "workspace:^",
     "@deepseek-ai/dsh-llm": "workspace:^",
     "@deepseek-ai/dsh-session": "workspace:^",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/cordis": "workspace:^"
   }
 }

packages/bundle/web-app/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-web-app",
   "description": "The dsh browser-surface bundle: the web patch layer over dsh-base plus the runtime glue plugin (frontend dist serving, web-surface prompt, bash runtime variables, URL line)",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/bundle/web-app"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -81,21 +88,21 @@
     "@deepseek-ai/dsh-storage-domain": "workspace:^",
     "@deepseek-ai/dsh-storage-json": "workspace:^",
     "@deepseek-ai/dsh-workspace": "workspace:^",
-    "@deepseek-ai/schemastery": "^3.18.0",
+    "@deepseek-ai/schemastery": "workspace:^",
     "commander": "^15.0.0"
   },
   "peerDependencies": {
-    "@deepseek-ai/cordis-plugin-loader": "^1.0.0-rc.5",
-    "@deepseek-ai/dsh-bash-env": "^0.0.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/dsh-system-prompt": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/cordis-plugin-loader": "workspace:^",
+    "@deepseek-ai/dsh-bash-env": "workspace:^",
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/dsh-system-prompt": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^"
   },
   "devDependencies": {
     "@deepseek-ai/cordis-plugin-loader": "workspace:^",
     "@deepseek-ai/dsh-bash-env": "workspace:^",
     "@deepseek-ai/dsh-invariants": "workspace:^",
     "@deepseek-ai/dsh-system-prompt": "workspace:^",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/cordis": "workspace:^"
   }
 }

packages/client/connection/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-client-connection",
   "description": "Wire consumer layer: HTTP-up/WebSocket-down client, ConnectionController dual streams with reconnect, and fixture api",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/client/connection"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -37,7 +44,7 @@
     "@deepseek-ai/dsh-llm": "workspace:^",
     "@deepseek-ai/dsh-session": "workspace:^",
     "@deepseek-ai/dsh-tools": "workspace:^",
-    "@deepseek-ai/schemastery": "^3.18.0",
+    "@deepseek-ai/schemastery": "workspace:^",
     "ws": "^8.21.0"
   },
   "files": [
@@ -47,14 +54,14 @@
     "lib/types/**/*.d.ts"
   ],
   "peerDependencies": {
-    "@deepseek-ai/dsh-host-webserver": "^0.0.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/dsh-host-webserver": "workspace:^",
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-host-webserver": "workspace:^",
     "@deepseek-ai/dsh-invariants": "workspace:^",
     "@types/ws": "^8.18.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/cordis": "workspace:^"
   }
 }

packages/client/hmr/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-client-hmr",
   "description": "Dev-only hot-reload driver for script-loaded client entries: SSE rebuilt frames → invalidate/prefetch → fiber swap through the vendored Loader entry",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/client/hmr"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -31,21 +38,21 @@
   },
   "license": "BSD-3-Clause",
   "dependencies": {
-    "@deepseek-ai/schemastery": "^3.18.0"
+    "@deepseek-ai/schemastery": "workspace:^"
   },
   "peerDependencies": {
-    "@deepseek-ai/cordis-plugin-loader": "^1.0.0-rc.5",
-    "@deepseek-ai/dsh-client-modules": "^0.0.1",
-    "@deepseek-ai/dsh-host-webserver": "^0.0.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/cordis-plugin-loader": "workspace:^",
+    "@deepseek-ai/dsh-client-modules": "workspace:^",
+    "@deepseek-ai/dsh-host-webserver": "workspace:^",
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^"
   },
   "devDependencies": {
     "@deepseek-ai/cordis-plugin-loader": "workspace:^",
     "@deepseek-ai/dsh-client-modules": "workspace:^",
     "@deepseek-ai/dsh-host-webserver": "workspace:^",
     "@deepseek-ai/dsh-invariants": "workspace:^",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/cordis": "workspace:^"
   },
   "files": [
     "lib/index.js",

packages/client/locale/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-client-locale",
   "description": "Locale plugin: Host-backed zh/en preference, browser-derived fallback, locale snapshots, and typed namespace dictionaries",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/client/locale"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -34,12 +41,12 @@
   },
   "license": "BSD-3-Clause",
   "peerDependencies": {
-    "@deepseek-ai/dsh-client-connection": "^0.0.1",
-    "@deepseek-ai/dsh-client-runtime": "^0.0.1",
-    "@deepseek-ai/dsh-client-ui-primitives": "^0.0.1",
-    "@deepseek-ai/dsh-client-ui-slots": "^0.0.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7",
+    "@deepseek-ai/dsh-client-connection": "workspace:^",
+    "@deepseek-ai/dsh-client-runtime": "workspace:^",
+    "@deepseek-ai/dsh-client-ui-primitives": "workspace:^",
+    "@deepseek-ai/dsh-client-ui-slots": "workspace:^",
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^",
     "react": "^18.2.0"
   },
   "devDependencies": {
@@ -48,12 +55,12 @@
     "@deepseek-ai/dsh-client-ui-slots": "workspace:^",
     "@deepseek-ai/dsh-invariants": "workspace:^",
     "@types/react": "~18.3.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7",
+    "@deepseek-ai/cordis": "workspace:^",
     "react": "^18.2.0"
   },
   "dependencies": {
     "@deepseek-ai/dsh-settings": "workspace:^",
-    "@deepseek-ai/schemastery": "^3.18.0"
+    "@deepseek-ai/schemastery": "workspace:^"
   },
   "files": [
     "lib/index.js",

packages/client/modules/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-client-modules",
   "description": "Client module system, dual-face: node half composes the __DSH_BOOT__ entry graph (incremental dsh.client scan, bundle route, index tap, webPlugins service); browser half is the lazy-CJS module table the vendored cordis Loader consumes as its internal seam",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/client/modules"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -38,7 +45,7 @@
     "@deepseek-ai/cordis-plugin-loader": "workspace:^",
     "@deepseek-ai/dsh-host-webserver": "workspace:^",
     "@deepseek-ai/dsh-invariants": "workspace:^",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/cordis": "workspace:^"
   },
   "files": [
     "lib/index.js",
@@ -47,7 +54,7 @@
     "lib/types/**/*.d.ts"
   ],
   "peerDependencies": {
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^"
   }
 }

packages/client/runtime/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/client/runtime/README.md
-README.md: b605fd2adc13ab6a1a4b727d116fc4e8b9973b10
-README.zh.md: efd86b9d5deb21bdec298d305c1fef0e687ce6f4
+README.md: b1893dc7c55353eb29e6cccfd84b11d9873060b8
+README.zh.md: f5cc65742cf165e61e6a691d616c1cc7984cc9f4

packages/client/runtime/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-client-runtime",
   "description": "Client core services: SlotsService, SessionsService (scope tree + object layer)",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/client/runtime"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -39,7 +46,6 @@
     "@deepseek-ai/dsh-client-connection": "workspace:^",
     "@deepseek-ai/dsh-client-schema-form": "workspace:^",
     "@deepseek-ai/dsh-commands": "workspace:^",
-    "@deepseek-ai/dsh-compact": "workspace:^",
     "@deepseek-ai/dsh-client-ui-slots": "workspace:^",
     "@deepseek-ai/dsh-host-apiproxy": "workspace:^",
     "@deepseek-ai/dsh-llm": "workspace:^",
@@ -53,10 +59,10 @@
     "zustand": "~4.4.7"
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/dsh-type-meta": "^0.0.1",
-    "@deepseek-ai/dsh-typert-registry": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/dsh-type-meta": "workspace:^",
+    "@deepseek-ai/dsh-typert-registry": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-invariants": "workspace:^",
@@ -64,8 +70,8 @@
     "@deepseek-ai/dsh-type-meta": "workspace:^",
     "@deepseek-ai/dsh-typert-registry": "workspace:^",
     "@types/react": "~18.3.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7",
-    "@deepseek-ai/schemastery": "^3.18.0"
+    "@deepseek-ai/cordis": "workspace:^",
+    "@deepseek-ai/schemastery": "workspace:^"
   },
   "files": [
     "lib/index.js",

packages/client/runtime/src/client/contract/conversation.ts

@@ -110,6 +110,17 @@ export interface ConversationViewNode {
   readonly data: unknown
 }
 
+/** Merge-extensible immutable snapshots published by registered view targets. */
+export interface ConversationViewSnapshotMap {}
+
+/** Stable reader over the latest snapshot of every registered view target. */
+export interface ConversationViewSnapshotStore {
+  /** @param target - registered view target. @returns its current snapshot. */
+  get<Target extends Extract<keyof ConversationViewSnapshotMap, string>>(
+    target: Target,
+  ): ConversationViewSnapshotMap[Target] | undefined
+}
+
 /** Final Chat render unit produced directly by a business Definition. */
 export interface ChatConversationViewNode extends ConversationViewNode {
   readonly target: 'chat'
@@ -159,6 +170,8 @@ export type ConversationLocationDataScope = 'step' | 'turn'
 /** One independently registered business Event-to-Node state machine. */
 export interface ConversationNodeDefinition<State = unknown> {
   readonly kind: string
+  /** Sole view target owned by this Definition; omitted for state-only Contexts. */
+  readonly target?: string
   /**
    * Extract this Definition's stable business identity from one event.
    * @param event - raw Session event; no Context or history access is available.
@@ -207,15 +220,11 @@ export interface ConversationNodeDefinition<State = unknown> {
     scope: ConversationLocationDataScope,
   ): ConversationLocationData | null
   /**
-   * Materialize one final Node for a registered view target.
+   * Materialize one final Node for this Definition's declared view target.
    * @param context - latest complete Context.
-   * @param target - registered view target such as `chat`.
    * @returns final Node, or null when this Context is not currently visible.
    */
-  buildViewNode(
-    context: ConversationNodeContext<State>,
-    target: string,
-  ): ConversationViewNode | null
+  buildViewNode?(context: ConversationNodeContext<State>): ConversationViewNode | null
 }
 
 /** Reference-stable Turn/Step facts published beside view Nodes. */

packages/client/runtime/src/client/contract/session-history.ts

@@ -1,43 +0,0 @@
-import type {
-  RpcError, SessionId,
-} from '@deepseek-ai/dsh-client-connection/client'
-import type { SessionHistoryInspection } from '../sessions/history.ts'
-import type { ObservableSnapshot } from './store.ts'
-
-/** Observable state of one independently loaded session history ledger. */
-export interface SessionHistorySnapshot {
-  state: 'cold' | 'loading' | 'ready' | 'error'
-  error: RpcError | null
-  hasMore: boolean
-  /** Absolute sequence of the first loaded raw event, or zero for an empty window. */
-  baseSeq: number
-  inspection: SessionHistoryInspection
-}
-
-/** Read-only history source addressed by session id. */
-export interface SessionHistoryFace
-  extends ObservableSnapshot<SessionHistorySnapshot> {
-  readonly sessionId: SessionId
-  /**
-   * Load the current tail without reading older pages.
-   * @param signal - Consumer lifetime.
-   * @returns When the tail is ready or loading fails.
-   */
-  loadTail(signal?: AbortSignal): Promise<void>
-  /**
-   * Prepend one older page when the current window has a predecessor.
-   * @param signal - Consumer lifetime.
-   * @returns Whether the loaded window advanced.
-   */
-  loadOlder(signal?: AbortSignal): Promise<boolean>
-}
-
-/** Runtime service resolving independent history sources. */
-export interface ISessionHistory {
-  /**
-   * Resolve the identity-stable source for a session.
-   * @param sessionId - Host session identity.
-   * @returns The source owned outside Session and SessionManager.
-   */
-  source(sessionId: SessionId): SessionHistoryFace
-}

packages/client/runtime/src/client/conversation/event-registry.ts

@@ -17,6 +17,7 @@ export class ConversationEventRegistry extends ConversationDefinitionRegistry<Co
    * @returns idempotent disposer.
    */
   register(definition: ConversationNodeDefinition): () => void {
+    assertDefinitionTarget(definition)
     return this.registerDefinition(
       definition.kind,
       definition,
@@ -31,6 +32,9 @@ export class ConversationEventRegistry extends ConversationDefinitionRegistry<Co
    * @returns idempotent disposer.
    */
   registerFallback(definition: ConversationNodeDefinition): () => void {
+    assertDefinitionTarget(definition)
+    const target = definition.target
+    if (target === undefined) throw new Error('conversation fallback Definition must declare a target')
     if (this.fallback !== undefined) throw new Error('conversation fallback Definition is already registered')
     const owner = this.ctx
     const dispose = owner.effect(() => {
@@ -52,5 +56,12 @@ export class ConversationEventRegistry extends ConversationDefinitionRegistry<Co
   fallbackEntry(): ConversationNodeDefinition | undefined {
     return this.fallback
   }
+}
 
+function assertDefinitionTarget(definition: ConversationNodeDefinition): void {
+  if ((definition.target === undefined) !== (definition.buildViewNode === undefined)) {
+    throw new Error(
+      `conversation Definition "${definition.kind}" must declare target and buildViewNode together`,
+    )
+  }
 }

packages/client/runtime/src/client/index.ts

@@ -6,7 +6,6 @@ import type { MaybeSnapshotSelectorHook, SnapshotSelectorHook } from '@deepseek-
 import { SlotsService } from './slots.ts'
 import { SessionsService } from './sessions/service.ts'
 import type { SessionListState } from './sessions/service.ts'
-import { SessionHistoryService } from './session-history/service.ts'
 import { WorkspacesService } from './workspaces/service.ts'
 import type { ConversationSnapshot } from './sessions/conversation.ts'
 import type { UseProjection } from './sessions/projection-store.ts'
@@ -28,12 +27,12 @@ export type {
   ConversationLocation, ConversationMatch, ConversationMatchResult,
   ConversationNodeContext, ConversationNodeDefinition, ConversationPreviousContext,
   ConversationPublication, ConversationTimelineSnapshot, ConversationTurnDataMap, ConversationViewBuilder,
-  ConversationViewDefinition, ConversationViewNode, StepLocation, TurnLocation,
+  ConversationViewDefinition, ConversationViewNode, ConversationViewSnapshotMap,
+  ConversationViewSnapshotStore, StepLocation, TurnLocation,
 } from './contract/conversation.ts'
 export type { ConversationRuntime } from './sessions/conversation-assembler.ts'
 export type { RootOwnerProps } from './slots.ts'
 export { SessionCreateError, SessionsService, scopeOf, workspaceTitleOf } from './sessions/service.ts'
-export { SessionHistoryService } from './session-history/service.ts'
 export { indexSubagentDescendants } from './sessions/subagent-lineage.ts'
 export type { SubagentDescendantSummary } from './sessions/subagent-lineage.ts'
 // The provide channel is shared with the client test runtime (one
@@ -48,9 +47,6 @@ export type { SettingsScope, SettingsScopeSnapshot, SettingsScopeSpec } from './
 export { resolveWorkspacePath } from './workspaces/path.ts'
 export type { Session } from './sessions/session.ts'
 export type { ISession, ProjectionsFace, SessionFace } from './contract/session.ts'
-export type {
-  ISessionHistory, SessionHistoryFace, SessionHistorySnapshot,
-} from './contract/session-history.ts'
 export type { AgentContext, ISessions } from './contract/sessions.ts'
 export type { IWorkspaces } from './contract/workspaces.ts'
 export type {
@@ -76,7 +72,9 @@ export type {
   LegacyConversationSlice, PartialAssistant, RunningToolCall,
   SteeringMessageNode, TodoItem, ToolCallBlock, ToolResultNode, TurnErrorNode, UnknownSurfaceNode, UserMessageNode,
 } from './sessions/conversation.ts'
-export { EMPTY_CHAT_SNAPSHOT, toAssistantBlock, toAssistantBlocks } from './sessions/conversation.ts'
+export {
+  EMPTY_CHAT_SNAPSHOT, EMPTY_CONVERSATION_VIEWS, toAssistantBlock, toAssistantBlocks,
+} from './sessions/conversation.ts'
 export { emptyAssistantBlock } from './sessions/partial.ts'
 export { isTokenDelta } from './sessions/assistant-timing.ts'
 export { contextForm, contextProvenance } from './sessions/context-provenance.ts'
@@ -90,8 +88,6 @@ export type {
 export type {
   ConversationPromptSnapshot, RequestInspectionSnapshot, RequestPromptChange, RequestView,
 } from './sessions/request-inspection.ts'
-export type { ConversationHistoryProjection } from './session-history/history-fold.ts'
-export type { SessionHistoryInspection } from './sessions/history.ts'
 export { PendingWait } from './sessions/pending.ts'
 export type {
   PendingInteraction, PendingInteractionStatus, PendingKind, PendingPayloads,
@@ -211,8 +207,6 @@ declare module '@deepseek-ai/cordis' {
     conversationViews: import('./conversation/view-registry.ts').ConversationViewRegistry
     /** The outward face only; the concrete service stays inside the runtime. */
     sessions: import('./contract/sessions.ts').ISessions
-    /** Read-only history sources isolated from Chat sessions and workspace state. */
-    sessionHistory: import('./contract/session-history.ts').ISessionHistory
     /** The outward face only; the concrete service stays inside the runtime. */
     workspaces: import('./contract/workspaces.ts').IWorkspaces
   }
@@ -235,7 +229,6 @@ export function apply(ctx: Context): void {
   ctx.typert.contexts.registerClient('agent', {
     identity: candidate => sessions.scopeOf(candidate),
   })
-  const sessionHistory = new SessionHistoryService(ctx, connection.api)
   const workspaces = new WorkspacesService(ctx, connection.api, sessions)
   ctx.effect(
     () => workspaces.startInitialSelection(),
@@ -244,11 +237,6 @@ export function apply(ctx: Context): void {
   const loop = connection.start({
     onMuxEnvelope: (envelope) => {
       sessions.handleMuxEnvelope(envelope)
-      try {
-        sessionHistory.handleMuxEnvelope(envelope)
-      } catch (error) {
-        console.error('[web-runtime] history frame routing failed:', error)
-      }
     },
     onHostEnvelope: (envelope) => {
       sessions.handleHostEnvelope(envelope)
@@ -264,21 +252,11 @@ export function apply(ctx: Context): void {
       else if (frame.type === 'host/settings-changed') ctx.emit('settings/changed', frame.ns)
       else if (frame.type === 'host/credentials-changed') ctx.emit('credentials/changed', frame.ref)
       else if (frame.type === 'host/models-changed') ctx.emit('models/changed')
-      try {
-        sessionHistory.handleHostEnvelope(envelope)
-      } catch (error) {
-        console.error('[web-runtime] history host-frame routing failed:', error)
-      }
     },
     onConnected: () => {
       sessions.handleConnected()
       workspaces.handleConnected()
       ctx.emit('connection/reset')
-      try {
-        sessionHistory.handleConnected()
-      } catch (error) {
-        console.error('[web-runtime] history reconnect failed:', error)
-      }
     },
     onStateChange: (state) => {
       // Generation death fires before any next-generation frame can arrive
@@ -286,11 +264,6 @@ export function apply(ctx: Context): void {
       // the only safe moment to drop generation-scoped interaction state.
       if (state === 'reconnecting') {
         sessions.handleDisconnected()
-        try {
-          sessionHistory.handleDisconnected()
-        } catch (error) {
-          console.error('[web-runtime] history disconnect failed:', error)
-        }
       }
     },
   })

packages/client/runtime/src/client/session-history/history-fold.ts

@@ -1,428 +0,0 @@
-import type { SessionEvent } from '@deepseek-ai/dsh-session/types'
-import {
-  SurfaceManager, isSurfaceEligibleType, isSurfaceEvent,
-} from '@deepseek-ai/dsh-session/surface'
-import type {
-  HistoryEntry, ToolCallView, ToolResultView,
-} from '@deepseek-ai/dsh-client-connection/client'
-import type {
-  AssistantRequestConfig, AssistantTiming, ConversationNode,
-  PartialAssistant, RunningToolCall,
-} from '../sessions/conversation.ts'
-import { toAssistantBlocks } from '../sessions/conversation.ts'
-import { contextForm, contextProvenance } from '../sessions/context-provenance.ts'
-import { SteeringHistory } from '../sessions/steering-history.ts'
-import type {
-  ConversationContext, ConversationContextOriginKind,
-} from '../sessions/conversation-context.ts'
-import type { ConversationPromptSnapshot } from '../sessions/request-inspection.ts'
-import { PartialAccumulator } from '../sessions/partial.ts'
-import type { AssistantStepMetadata } from '../sessions/assistant-timing.ts'
-import { indexAssistantStepTiming, settledAssistantTiming } from '../sessions/assistant-timing.ts'
-import { ToolCallTree } from '../sessions/tool-call-tree.ts'
-
-interface CallIndexEntry {
-  name: string
-  argsRaw: string
-  time: number
-  callView: ToolCallView | null
-}
-
-interface FoldedContext {
-  generation: number
-  nodes: readonly number[]
-  originSeq?: number
-}
-
-/** Immutable conversation projections derived only from the history source. */
-export interface ConversationHistoryProjection {
-  eventNodes: readonly ConversationNode[]
-  contexts: readonly ConversationContext[]
-  interruptedNodes: readonly ConversationNode[]
-  partial: PartialAssistant | null
-  runningCalls: readonly RunningToolCall[]
-}
-
-function replacementCrossesWindowHead(event: SessionEvent, baseSeq: number): boolean {
-  if (!isSurfaceEvent(event) || event.surfaceOp === 'append') return false
-  return event.surfaceOp.start < baseSeq || event.surfaceOp.end < baseSeq
-}
-
-function contextOriginKind(event: SessionEvent | undefined): ConversationContextOriginKind {
-  if (event?.type !== 'user/message') return 'rewrite'
-  const source = event.data.source
-  if (typeof source === 'object' && 'kind' in source && 'plugin' in source) {
-    if (source.plugin === 'compact') return 'compaction'
-    if (source.plugin === 'rewind') return 'rewind'
-  }
-  return 'rewrite'
-}
-
-function foldContexts(events: readonly SessionEvent[]): readonly FoldedContext[] {
-  const replay: SessionEvent[] = []
-  const originalSeqs: number[] = []
-  const rebasedSeqByOriginal = new Map<number, number>()
-  const surface = new SurfaceManager(replay)
-  const contexts: FoldedContext[] = []
-  let generation = 0
-  let originSeq: number | undefined
-  const originalNodes = () => surface.nodes.map((seq) => {
-    const original = originalSeqs[seq]
-    if (original === undefined) throw new Error(`rebased surface seq ${seq} has no origin`)
-    return original
-  })
-  for (const event of events) {
-    if (!isSurfaceEvent(event)) continue
-    if (event.surfaceOp !== 'append') {
-      contexts.push({
-        generation,
-        nodes: originalNodes(),
-        ...(originSeq === undefined ? {} : { originSeq }),
-      })
-      generation++
-      originSeq = event.seq
-    }
-    const rebasedSeq = replay.length
-    const {
-      sourceEventSeqs: rawSources,
-      ...eventWithoutSources
-    } = event as SessionEvent & { sourceEventSeqs?: readonly number[] }
-    const mappedSourceEventSeqs = rawSources?.flatMap((seq) => {
-      const rebased = rebasedSeqByOriginal.get(seq)
-      return rebased === undefined ? [] : [rebased]
-    })
-    const sourceEventSeqs = mappedSourceEventSeqs?.length === 0
-      ? undefined
-      : mappedSourceEventSeqs
-    const surfaceOp = event.surfaceOp === 'append'
-      ? event.surfaceOp
-      : {
-        ...event.surfaceOp,
-        start: rebasedSeqByOriginal.get(event.surfaceOp.start) ?? event.surfaceOp.start,
-        end: rebasedSeqByOriginal.get(event.surfaceOp.end) ?? event.surfaceOp.end,
-      }
-    originalSeqs.push(event.seq)
-    rebasedSeqByOriginal.set(event.seq, rebasedSeq)
-    replay.push({
-      ...eventWithoutSources,
-      seq: rebasedSeq,
-      surfaceOp,
-      ...(sourceEventSeqs === undefined ? {} : { sourceEventSeqs }),
-    } as SessionEvent)
-  }
-  contexts.push({
-    generation,
-    nodes: originalNodes(),
-    ...(originSeq === undefined ? {} : { originSeq }),
-  })
-  return contexts
-}
-
-// History projection owns its node mapping so Chat's live adapter remains free
-// of inspection metadata and lifecycle coupling.
-/* jscpd:ignore-start */
-function materializeNode(
-  event: SessionEvent,
-  callIndex: ReadonlyMap<string, CallIndexEntry>,
-  resultView: ToolResultView | null,
-  assistantTiming: AssistantTiming | undefined,
-  requestConfig: AssistantRequestConfig | undefined,
-  steering: boolean,
-): ConversationNode {
-  switch (event.type) {
-    case 'user/message':
-      if (event.data.source.kind !== 'user') {
-        return {
-          kind: 'context', seq: event.seq, time: event.time,
-          content: event.data.content, source: event.data.source,
-          provenance: contextProvenance(event.data.source),
-          form: contextForm(event.data.source),
-        }
-      }
-      if (steering) {
-        return {
-          kind: 'steering', messageId: event.data.id,
-          seq: event.seq, time: event.time,
-          content: event.data.content, source: event.data.source,
-        }
-      }
-      return {
-        kind: 'user', seq: event.seq, time: event.time,
-        content: event.data.content, source: event.data.source,
-      }
-    case 'assistant/message':
-      return {
-        kind: 'assistant', seq: event.seq, time: event.time,
-        turn: event.data.turn, step: event.data.step,
-        blocks: toAssistantBlocks(event.data.message.content), usage: event.data.usage,
-        provenance: {
-          provider: event.data.message.source.provider,
-          model: event.data.message.source.model,
-        },
-        ...(requestConfig === undefined ? {} : { requestConfig }),
-        ...(assistantTiming === undefined ? {} : { timing: assistantTiming }),
-      }
-    case 'tool/result': {
-      const result = event.data.message.content[0]
-      const callId = String(event.data.message.source.callId)
-      const call = callIndex.get(callId)
-      return {
-        kind: 'tool-result', seq: event.seq, time: event.time,
-        callId,
-        call: call === undefined ? null : { name: call.name, argsRaw: call.argsRaw },
-        callTime: call?.time ?? null,
-        content: result.content, isError: result.isError === true,
-        ...(event.data.error === undefined ? {} : { error: event.data.error }),
-        meta: event.data.meta,
-        callView: call?.callView ?? null,
-        resultView,
-        subCalls: [],
-      }
-    }
-    default:
-      return {
-        kind: 'unknown', seq: event.seq, time: event.time,
-        type: event.type, data: (event as { data?: unknown }).data,
-      }
-  }
-}
-/* jscpd:ignore-end */
-
-interface TransientProjection extends Pick<
-  ConversationHistoryProjection,
-  'interruptedNodes' | 'partial' | 'runningCalls'
-> {
-  toolCallTree: ToolCallTree
-}
-
-function projectTransient(entries: readonly HistoryEntry[]): TransientProjection {
-  let partial: PartialAccumulator | null = null
-  const openCalls = new Map<string, RunningToolCall>()
-  const interruptedNodes: ConversationNode[] = []
-  const toolCallTree = new ToolCallTree()
-
-  for (const entry of entries) {
-    const { event } = entry
-    if (toolCallTree.apply(event)) continue
-    switch (event.type) {
-      case 'assistant/chunk': {
-        const { turn, step, chunk } = event.data
-        if (partial === null || partial.turn !== turn || partial.step !== step) {
-          partial = new PartialAccumulator(turn, step)
-        }
-        partial.push(chunk)
-        break
-      }
-      case 'assistant/message':
-        if (partial?.turn === event.data.turn && partial.step === event.data.step) partial = null
-        break
-      case 'tool/call':
-        // History reconstructs its own in-flight index; this intentionally
-        // mirrors the published Chat node shape, not Chat's mutable state.
-        /* jscpd:ignore-start */
-        openCalls.set(String(event.data.callId), {
-          callId: String(event.data.callId),
-          name: event.data.name,
-          argsRaw: event.data.arguments,
-          turn: event.data.turn,
-          step: event.data.step,
-          time: event.time,
-          callView: entry.view?.for === 'call' ? entry.view.view : null,
-          subCalls: [],
-        })
-        /* jscpd:ignore-end */
-        break
-      case 'tool/result':
-        openCalls.delete(String(event.data.message.source.callId))
-        break
-      case 'turn/end': {
-        if (partial !== null && partial.turn === event.data.turn) {
-          const { blocks } = partial.toPartial()
-          const visible = blocks.some(block =>
-            block.kind === 'text' || block.kind === 'reasoning' ? block.text !== '' : true)
-          if (visible) {
-            interruptedNodes.push({
-              kind: 'assistant', seq: event.seq - 0.9, time: event.time,
-              turn: partial.turn, step: partial.step, blocks, interrupted: true,
-            })
-          }
-          partial = null
-        }
-        let callOffset = 0
-        for (const [callId, call] of openCalls) {
-          if (call.turn !== event.data.turn) continue
-          openCalls.delete(callId)
-          // Interrupted terminal nodes are reconstructed independently so a
-          // Trajectory replay cannot observe Session's frozen-node lifecycle.
-          /* jscpd:ignore-start */
-          interruptedNodes.push({
-            kind: 'tool-result', seq: event.seq - 0.8 + callOffset++ * 0.01,
-            time: event.time,
-            callId,
-            call: { name: call.name, argsRaw: call.argsRaw },
-            callTime: call.time,
-            content: [],
-            isError: true,
-            error: { name: 'Interrupted', code: 'interrupted' },
-            callView: call.callView,
-            resultView: null,
-            subCalls: [],
-          })
-          /* jscpd:ignore-end */
-        }
-        break
-      }
-      default:
-        break
-    }
-  }
-
-  return {
-    interruptedNodes,
-    partial: partial?.toPartial() ?? null,
-    runningCalls: [...openCalls.values()],
-    toolCallTree,
-  }
-}
-
-/**
- * Project one immutable history ledger without reading or mutating Chat state.
- * @param entries - Contiguous history entries in sequence order.
- * @returns Event order, context lineage, and transient tail state.
- */
-export function projectConversationHistory(
-  entries: readonly HistoryEntry[],
-): ConversationHistoryProjection {
-  const events = entries.map(entry => entry.event)
-  const steeringHistory = new SteeringHistory()
-  const steeringSeqs = new Set<number>()
-  for (const event of events) {
-    if (steeringHistory.apply(event)) steeringSeqs.add(event.seq)
-  }
-  const baseSeq = events[0]?.seq ?? 0
-  const eventsBySeq = new Map(events.map(event => [event.seq, event]))
-  const callIndex = new Map<string, CallIndexEntry>()
-  const resultViews = new Map<number, ToolResultView>()
-  const assistantSteps = new Map<string, AssistantStepMetadata>()
-  const assistantTimings = new Map<number, AssistantTiming>()
-  const assistantRequestConfigs = new Map<number, AssistantRequestConfig>()
-  const promptsByContext = new Map<number, ConversationPromptSnapshot>()
-  let activeRequestConfig: AssistantRequestConfig | undefined
-  let activePrompt: ConversationPromptSnapshot | undefined
-  let contextGeneration = 0
-
-  for (const [index, event] of events.entries()) {
-    const view = entries[index]?.view
-    if (event.type === 'tool/call') {
-      callIndex.set(String(event.data.callId), {
-        name: event.data.name,
-        argsRaw: event.data.arguments,
-        time: event.time,
-        callView: view?.for === 'call' ? view.view : null,
-      })
-    } else if (event.type === 'tool/result' && view?.for === 'result') {
-      resultViews.set(event.seq, view.view)
-    }
-    if (isSurfaceEvent(event) && event.surfaceOp !== 'append') {
-      contextGeneration++
-      if (activePrompt !== undefined) promptsByContext.set(contextGeneration, activePrompt)
-    }
-    indexAssistantStepTiming(assistantSteps, event)
-    if (event.type === 'request/header') {
-      activeRequestConfig = event.data.header.config
-      activePrompt = {
-        config: event.data.header.config,
-        system: event.data.header.system ?? '',
-        tools: event.data.header.tools ?? [],
-      }
-      promptsByContext.set(contextGeneration, activePrompt)
-    } else if (event.type === 'assistant/message') {
-      assistantTimings.set(
-        event.seq,
-        settledAssistantTiming(assistantSteps, event.data.turn, event.data.step, event.time),
-      )
-      if (activeRequestConfig !== undefined) {
-        assistantRequestConfigs.set(event.seq, activeRequestConfig)
-      }
-    }
-  }
-
-  const nodeCache = new Map<number, ConversationNode>()
-  const materialize = (seq: number): ConversationNode | undefined => {
-    const cached = nodeCache.get(seq)
-    if (cached !== undefined) return cached
-    const event = eventsBySeq.get(seq)
-    if (event === undefined || !isSurfaceEligibleType(event.type)) return
-    const node = materializeNode(
-      event,
-      callIndex,
-      resultViews.get(seq) ?? null,
-      assistantTimings.get(seq),
-      assistantRequestConfigs.get(seq),
-      steeringSeqs.has(seq),
-    )
-    nodeCache.set(seq, node)
-    return node
-  }
-  const eventNodes = events.flatMap((event) => {
-    const node = materialize(event.seq)
-    return node === undefined ? [] : [node]
-  })
-
-  let contexts: readonly ConversationContext[]
-  if (events.some(event => replacementCrossesWindowHead(event, baseSeq))) {
-    contexts = [{
-      id: 0,
-      ...(activePrompt === undefined ? {} : { prompt: activePrompt }),
-      nodes: eventNodes,
-    }]
-  } else {
-    try {
-      contexts = foldContexts(events).map((context): ConversationContext => {
-        const nodes = context.nodes.flatMap((seq) => {
-          const node = materialize(seq)
-          return node === undefined ? [] : [node]
-        })
-        const prompt = promptsByContext.get(context.generation)
-        if (context.originSeq === undefined) {
-          return {
-            id: context.generation,
-            ...(prompt === undefined ? {} : { prompt }),
-            nodes,
-          }
-        }
-        const originEvent = eventsBySeq.get(context.originSeq)
-        return {
-          id: context.generation,
-          parentId: context.generation - 1,
-          origin: contextOriginKind(originEvent),
-          originSeq: context.originSeq,
-          ...(originEvent === undefined ? {} : { createdAt: originEvent.time }),
-          ...(prompt === undefined ? {} : { prompt }),
-          nodes,
-        }
-      })
-    } catch (error) {
-      console.error('[web-runtime] history surface fold failed, using event order:', error)
-      contexts = [{
-        id: 0,
-        ...(activePrompt === undefined ? {} : { prompt: activePrompt }),
-        nodes: eventNodes,
-      }]
-    }
-  }
-
-  const transient = projectTransient(entries)
-  const projectedEventNodes = transient.toolCallTree.projectNodes(eventNodes)
-  const projectedContexts = contexts.map((context): ConversationContext => {
-    const nodes = transient.toolCallTree.projectNodes(context.nodes)
-    return nodes === context.nodes ? context : { ...context, nodes }
-  })
-  return {
-    eventNodes: projectedEventNodes,
-    contexts: projectedContexts,
-    interruptedNodes: transient.toolCallTree.projectNodes(transient.interruptedNodes),
-    partial: transient.partial,
-    runningCalls: transient.toolCallTree.projectRunningCalls(transient.runningCalls),
-  }
-}

packages/client/runtime/src/client/session-history/service.ts

@@ -1,66 +0,0 @@
-import type { Context } from '@deepseek-ai/cordis'
-import type {
-  HostFrame, IApiClient, MuxFrame, RpcRequest, SessionId,
-} from '@deepseek-ai/dsh-client-connection/client'
-import type {
-  ISessionHistory, SessionHistoryFace,
-} from '../contract/session-history.ts'
-import { SessionHistorySource } from './source.ts'
-
-/** Root registry and frame router for independent inspection histories. */
-export class SessionHistoryService implements ISessionHistory {
-  private readonly sources = new Map<SessionId, SessionHistorySource>()
-
-  /**
-   * @param ctx - Client root context.
-   * @param api - Shared wire client.
-   */
-  constructor(ctx: Context, private readonly api: IApiClient) {
-    ctx.reflect.provide('sessionHistory', this, undefined)
-  }
-
-  /**
-   * Resolve one identity-stable history source.
-   * @param sessionId - Host session identity.
-   * @returns Source independent from SessionManager.
-   */
-  source(sessionId: SessionId): SessionHistoryFace {
-    let source = this.sources.get(sessionId)
-    if (source === undefined) {
-      source = new SessionHistorySource(sessionId, this.api)
-      this.sources.set(sessionId, source)
-    }
-    return source
-  }
-
-  /**
-   * Route history-relevant mux frames only to an existing source.
-   * @param envelope - Validated mux envelope.
-   */
-  handleMuxEnvelope(envelope: RpcRequest<MuxFrame>): void {
-    const frame = envelope.payload
-    if (frame.type === 'stream/error') return
-    this.sources.get(frame.sessionId)?.handleMuxFrame(frame)
-  }
-
-  /**
-   * Drop a removed session's independent history source.
-   * @param envelope - Validated host envelope.
-   */
-  handleHostEnvelope(envelope: RpcRequest<HostFrame>): void {
-    const frame = envelope.payload
-    if (frame.type !== 'host/session-removed') return
-    this.sources.get(frame.sessionId)?.dispose()
-    this.sources.delete(frame.sessionId)
-  }
-
-  /** Invalidate requests from the dead connection generation. */
-  handleDisconnected(): void {
-    for (const source of this.sources.values()) source.handleDisconnected()
-  }
-
-  /** Rebuild every previously activated source from the new generation. */
-  handleConnected(): void {
-    for (const source of this.sources.values()) source.resync()
-  }
-}

packages/client/runtime/src/client/session-history/source.ts

@@ -1,432 +0,0 @@
-import type {
-  HistoryEntry, IApiClient, MuxFrame, RpcError, SessionId,
-} from '@deepseek-ai/dsh-client-connection/client'
-import type { SessionEvent } from '@deepseek-ai/dsh-session/types'
-import { transportError } from '@deepseek-ai/dsh-host-apiproxy/api'
-import type {
-  SessionHistoryFace, SessionHistorySnapshot,
-} from '../contract/session-history.ts'
-import {
-  compactHistoryInspectionEntries, createHistoryInspection,
-} from '../sessions/history.ts'
-import { Notifier } from '../sessions/notifier.ts'
-import { isVisibleAssistantChunk, PartialAccumulator } from '../sessions/partial.ts'
-
-const HISTORY_PAGE_MESSAGES = 50
-
-function isAborted(signal: AbortSignal | undefined): boolean {
-  return signal?.aborted === true
-}
-
-/** Independent raw-history owner used only by inspection consumers. */
-export class SessionHistorySource implements SessionHistoryFace {
-  private entries: HistoryEntry[] = []
-  private inspectionEntries: readonly HistoryEntry[] = []
-  private baseSeq = 0
-  private hasMore = false
-  private state: SessionHistorySnapshot['state'] = 'cold'
-  private error: RpcError | null = null
-  private generation = 0
-  private persistentConsumer = false
-  private readonly consumerSignals = new Set<AbortSignal>()
-  private openPromise: Promise<void> | null = null
-  private olderPromise: Promise<void> | null = null
-  private stitching = false
-  private liveBuffer: HistoryEntry[] = []
-  private subscribedLastSeq: number | null = null
-  private inspectionCache: {
-    entries: readonly HistoryEntry[]
-    value: SessionHistorySnapshot['inspection']
-  } | null = null
-  private streamPublishToken: object | null = null
-  private streamPartial: PartialAccumulator | null = null
-  private snapshotCache: SessionHistorySnapshot
-  private readonly notifier = new Notifier(() => {
-    this.snapshotCache = this.buildSnapshot()
-  })
-
-  /**
-   * @param sessionId - Host session identity.
-   * @param api - Shared wire client.
-   */
-  constructor(
-    readonly sessionId: SessionId,
-    private readonly api: IApiClient,
-  ) {
-    this.snapshotCache = this.buildSnapshot()
-  }
-
-  /**
-   * Subscribe to ledger changes.
-   * @param listener - Change callback.
-   * @returns Unsubscribe function.
-   */
-  subscribe(listener: () => void): () => void {
-    return this.notifier.subscribe(listener)
-  }
-
-  /**
-   * Read the cached ledger snapshot.
-   * @returns Stable snapshot until the source changes.
-   */
-  getSnapshot(): SessionHistorySnapshot {
-    this.notifier.ensureFresh()
-    return this.snapshotCache
-  }
-
-  /**
-   * Load the current tail without reading older pages.
-   * @param signal - Consumer lifetime.
-   * @returns When the tail is ready or loading fails.
-   */
-  async loadTail(signal?: AbortSignal): Promise<void> {
-    if (isAborted(signal)) return
-    this.trackConsumer(signal)
-    await this.open()
-  }
-
-  /**
-   * Prepend one older page when the current window has a predecessor.
-   * @param signal - Consumer lifetime.
-   * @returns Whether the loaded window advanced.
-   */
-  async loadOlder(signal?: AbortSignal): Promise<boolean> {
-    if (isAborted(signal)) return false
-    this.trackConsumer(signal)
-    await this.open()
-    if (isAborted(signal)) return false
-    const previousBaseSeq = this.baseSeq
-    await this.loadOlderPage()
-    return this.baseSeq !== previousBaseSeq
-  }
-
-  /**
-   * Route a relevant mux frame without involving the Chat session.
-   * @param frame - Session-addressed frame.
-   */
-  handleMuxFrame(frame: MuxFrame): void {
-    if (frame.type === 'session/subscribed') {
-      this.subscribedLastSeq = frame.lastSeq
-      return
-    }
-    if (frame.type !== 'session/event') return
-    this.acceptLive({ event: frame.event, ...(frame.view === undefined ? {} : { view: frame.view }) })
-  }
-
-  /** Invalidate dead-generation requests while retaining the last readable snapshot. */
-  handleDisconnected(): void {
-    this.generation++
-    this.openPromise = null
-    this.olderPromise = null
-    this.stitching = false
-    this.liveBuffer = []
-    this.subscribedLastSeq = null
-    if (this.state !== 'cold') {
-      this.state = 'cold'
-      this.error = null
-      this.publishDirtyNow()
-    }
-  }
-
-  /** Rebuild an activated ledger from the new connection generation. */
-  resync(): void {
-    if (!this.hasConsumer()) return
-    this.generation++
-    this.openPromise = null
-    this.olderPromise = null
-    this.stitching = false
-    this.liveBuffer = []
-    this.subscribedLastSeq = null
-    this.entries = []
-    this.inspectionEntries = []
-    this.baseSeq = 0
-    this.hasMore = false
-    this.state = 'cold'
-    this.error = null
-    this.publishDirtyNow()
-    void this.open()
-  }
-
-  /** Stop future refresh work after the host removes the session. */
-  dispose(): void {
-    this.persistentConsumer = false
-    this.consumerSignals.clear()
-    this.generation++
-    this.openPromise = null
-    this.olderPromise = null
-    this.liveBuffer = []
-    this.streamPublishToken = null
-    this.streamPartial = null
-  }
-
-  private open(): Promise<void> {
-    if (this.state === 'ready') return Promise.resolve()
-    if (this.openPromise !== null) return this.openPromise
-    const generation = this.generation
-    const operation = this.doOpen(generation)
-    const settled = operation.finally(() => {
-      if (this.openPromise === settled) this.openPromise = null
-    })
-    this.openPromise = settled
-    return settled
-  }
-
-  private trackConsumer(signal: AbortSignal | undefined): void {
-    if (signal === undefined) {
-      this.persistentConsumer = true
-      return
-    }
-    if (this.consumerSignals.has(signal)) return
-    this.consumerSignals.add(signal)
-    signal.addEventListener('abort', () => {
-      this.consumerSignals.delete(signal)
-    }, { once: true })
-  }
-
-  private hasConsumer(): boolean {
-    return this.persistentConsumer || this.consumerSignals.size > 0
-  }
-
-  private async doOpen(generation: number): Promise<void> {
-    this.state = 'loading'
-    this.error = null
-    this.publishDirtyNow()
-    try {
-      let { result } = await this.api.sessions.history({
-        sessionId: this.sessionId,
-        maxMessages: HISTORY_PAGE_MESSAGES,
-      })
-      if (generation !== this.generation) return
-      if (!result.ok) {
-        this.state = 'error'
-        this.error = result.error
-        return
-      }
-      this.installTail(result.value.events, result.value.hasMore, true)
-      const tailSeq = this.tailSeq()
-      if (
-        this.subscribedLastSeq !== null
-        && tailSeq !== null
-        && this.subscribedLastSeq > tailSeq
-      ) {
-        result = (await this.api.sessions.history({
-          sessionId: this.sessionId,
-          maxMessages: HISTORY_PAGE_MESSAGES,
-        })).result
-        if (generation !== this.generation) return
-        if (result.ok) this.installTail(result.value.events, result.value.hasMore, true)
-      }
-      this.state = 'ready'
-    } catch (error) {
-      if (generation !== this.generation) return
-      this.state = 'error'
-      const folded = transportError<never>(error)
-      /* v8 ignore next -- transportError always returns the error branch. */
-      this.error = folded.ok ? null : folded.error
-    } finally {
-      if (generation === this.generation) this.publishDirtyNow()
-    }
-  }
-
-  private loadOlderPage(): Promise<void> {
-    if (this.olderPromise !== null) return this.olderPromise
-    if (this.state !== 'ready' || !this.hasMore) return Promise.resolve()
-    const generation = this.generation
-    const operation = (async () => {
-      try {
-        const { result } = await this.api.sessions.history({
-          sessionId: this.sessionId,
-          beforeSeq: this.baseSeq,
-          maxMessages: HISTORY_PAGE_MESSAGES,
-        })
-        if (generation !== this.generation || this.state !== 'ready' || !result.ok) return
-        const older = result.value.events
-        if (older.length === 0) {
-          this.hasMore = result.value.hasMore
-          return
-        }
-        const tail = older.at(-1)
-        if (tail === undefined || tail.event.seq + 1 !== this.baseSeq) {
-          console.error(
-            `[web-runtime] inspection history page discontinuous: tail seq ${tail?.event.seq} vs baseSeq ${this.baseSeq}`,
-          )
-          this.hasMore = false
-          return
-        }
-        this.entries = [...older, ...this.entries]
-        this.inspectionEntries = compactHistoryInspectionEntries([...this.entries])
-        this.baseSeq = older[0]?.event.seq ?? this.baseSeq
-        this.hasMore = result.value.hasMore
-      } catch (error) {
-        console.error('[web-runtime] inspection history paging failed:', error)
-      }
-    })()
-    const settled = operation.finally(() => {
-      if (this.olderPromise !== settled) return
-      this.olderPromise = null
-      this.publishDirtyNow()
-    })
-    this.olderPromise = settled
-    return settled
-  }
-
-  private installTail(
-    tail: readonly HistoryEntry[],
-    hasMore: boolean,
-    replace: boolean,
-  ): void {
-    if (replace) {
-      this.entries = [...tail]
-      this.hasMore = hasMore
-    } else {
-      const firstSeq = tail[0]?.event.seq
-      const prefix = firstSeq === undefined
-        ? this.entries
-        : this.entries.filter(entry => entry.event.seq < firstSeq)
-      this.entries = [...prefix, ...tail]
-    }
-    this.baseSeq = this.entries[0]?.event.seq ?? 0
-    this.inspectionEntries = compactHistoryInspectionEntries([...this.entries])
-    const buffered = this.liveBuffer
-    this.liveBuffer = []
-    for (const entry of buffered) this.appendLive(entry)
-    this.publishDirtyNow()
-  }
-
-  private acceptLive(entry: HistoryEntry): void {
-    if (this.state === 'loading' || this.stitching) {
-      this.liveBuffer.push(entry)
-      return
-    }
-    if (this.state !== 'ready') return
-    const tailSeq = this.tailSeq()
-    if (tailSeq !== null && entry.event.seq > tailSeq + 1) {
-      this.liveBuffer.push(entry)
-      void this.repairGap()
-      return
-    }
-    if (
-      entry.event.type === 'assistant/chunk'
-      && entry.event.data.chunk.type !== 'usage'
-    ) {
-      if (!this.appendIncrementalChunk(entry, entry.event)) return
-      this.publishStreamDirty()
-      return
-    }
-    this.appendLive(entry)
-    this.publishDirtyNow()
-  }
-
-  private appendLive(entry: HistoryEntry): void {
-    const tailSeq = this.tailSeq()
-    if (tailSeq !== null && entry.event.seq <= tailSeq) return
-    this.entries.push(entry)
-    this.inspectionEntries = [...this.inspectionEntries, entry]
-    if (entry.event.type === 'assistant/message') {
-      this.inspectionEntries = compactHistoryInspectionEntries(this.inspectionEntries)
-    }
-  }
-
-  /** Append a chunk against the cached finalized projection; false means no visible publish. */
-  private appendIncrementalChunk(
-    entry: HistoryEntry,
-    event: SessionEvent<'assistant/chunk'>,
-  ): boolean {
-    const { turn, step, chunk } = event.data
-    if (!isVisibleAssistantChunk(chunk.type)) {
-      const inspection = this.currentInspection()
-      this.appendLive(entry)
-      this.inspectionCache = { entries: this.inspectionEntries, value: inspection }
-      return false
-    }
-    const base = this.currentInspection()
-    if (
-      this.streamPartial === null
-      || this.streamPartial.turn !== turn
-      || this.streamPartial.step !== step
-    ) {
-      const current = base.partial
-      this.streamPartial = new PartialAccumulator(
-        turn,
-        step,
-        current?.turn === turn && current.step === step ? current.blocks : [],
-      )
-    }
-    this.streamPartial.push(chunk)
-    this.appendLive(entry)
-    this.inspectionCache = {
-      entries: this.inspectionEntries,
-      value: { ...base, partial: this.streamPartial.toPartial() },
-    }
-    return true
-  }
-
-  /** Coalesce token-stream projection and rendering work to one publish per browser frame. */
-  private publishStreamDirty(): void {
-    if (this.streamPublishToken !== null) return
-    const token = {}
-    this.streamPublishToken = token
-    const publish = () => {
-      if (this.streamPublishToken !== token) return
-      this.streamPublishToken = null
-      this.notifier.markDirty()
-    }
-    if (typeof globalThis.requestAnimationFrame === 'function') {
-      globalThis.requestAnimationFrame(publish)
-    } else {
-      queueMicrotask(publish)
-    }
-  }
-
-  /** Publish structural changes immediately and invalidate an older scheduled stream publish. */
-  private publishDirtyNow(): void {
-    this.streamPublishToken = null
-    this.streamPartial = null
-    this.notifier.markDirty()
-  }
-
-  private async repairGap(): Promise<void> {
-    if (this.stitching) return
-    this.stitching = true
-    const generation = this.generation
-    try {
-      const { result } = await this.api.sessions.history({
-        sessionId: this.sessionId,
-        maxMessages: HISTORY_PAGE_MESSAGES,
-      })
-      if (result.ok && generation === this.generation && this.state === 'ready') {
-        this.installTail(result.value.events, result.value.hasMore, false)
-      }
-    } catch (error) {
-      console.error('[web-runtime] inspection history gap repair failed:', error)
-    } finally {
-      if (generation === this.generation) this.stitching = false
-    }
-  }
-
-  private tailSeq(): number | null {
-    return this.entries.at(-1)?.event.seq ?? null
-  }
-
-  private buildSnapshot(): SessionHistorySnapshot {
-    return {
-      state: this.state,
-      error: this.error,
-      hasMore: this.hasMore,
-      baseSeq: this.baseSeq,
-      inspection: this.currentInspection(),
-    }
-  }
-
-  /** Inspection pinned to the source's current immutable entry array. */
-  private currentInspection(): SessionHistorySnapshot['inspection'] {
-    if (this.inspectionCache?.entries !== this.inspectionEntries) {
-      const entries = this.inspectionEntries
-      this.inspectionCache = {
-        entries,
-        value: createHistoryInspection(() => entries),
-      }
-    }
-    return this.inspectionCache.value
-  }
-}

packages/client/runtime/src/client/sessions/conversation-assembler.ts

@@ -2,7 +2,8 @@ import type {
   ConversationContextReader, ConversationEventInput, ConversationLocationData, ConversationMatch,
   ConversationNodeContext, ConversationNodeDefinition, ConversationPreviousContext,
   ConversationLocationDataScope, ConversationPublication, ConversationViewBuilder,
-  ConversationViewDefinition, ConversationViewNode,
+  ConversationViewDefinition, ConversationViewNode, ConversationViewSnapshotMap,
+  ConversationViewSnapshotStore,
 } from '../contract/conversation.ts'
 import { conversationContextKey } from '../contract/conversation.ts'
 import {
@@ -133,7 +134,7 @@ export interface ConversationViewDefinitions {
  * Session-owned incremental engine that assembles business Contexts from a
  * contiguous Event window and materializes registered view snapshots.
  */
-export class ConversationNodeAssembler {
+export class ConversationNodeAssembler implements ConversationViewSnapshotStore {
   private readonly contexts = new Map<string, InternalContext>()
   private readonly contextsByKind = new Map<string, InternalContext[]>()
   private readonly contextsBySeq = new Map<number, Set<InternalContext>>()
@@ -266,11 +267,11 @@ export class ConversationNodeAssembler {
       const allByTarget = new Map<string, ConversationViewNode[]>()
       for (const target of this.views.keys()) allByTarget.set(target, [])
       for (const context of this.contexts.values()) {
-        for (const target of this.views.keys()) {
-          const node = this.buildNode(context, target)
-          context.current.set(target, node)
-          if (node !== null) allByTarget.get(target)?.push(node)
-        }
+        const target = context.definition.target
+        if (target === undefined || !this.views.has(target)) continue
+        const node = this.buildNode(context, target)
+        context.current.set(target, node)
+        if (node !== null) allByTarget.get(target)?.push(node)
       }
       for (const view of this.views.values()) {
         view.snapshot = view.builder.replace({
@@ -288,17 +289,17 @@ export class ConversationNodeAssembler {
     for (const target of this.views.keys()) upsertsByTarget.set(target, [])
     if (this.applyDirtyLocationData()) this.timelineDirty = true
     for (const context of this.dirty) {
-      for (const target of this.views.keys()) {
-        const previous = context.current.get(target) ?? null
-        const node = this.buildNode(context, target)
-        if (node === null && previous !== null) {
-          throw new Error(
-            `conversation Definition "${context.kind}" withdrew materialized target "${target}"; return the same key with hidden visibility instead`,
-          )
-        }
-        context.current.set(target, node)
-        if (node !== null) upsertsByTarget.get(target)?.push(node)
+      const target = context.definition.target
+      if (target === undefined || !this.views.has(target)) continue
+      const previous = context.current.get(target) ?? null
+      const node = this.buildNode(context, target)
+      if (node === null && previous !== null) {
+        throw new Error(
+          `conversation Definition "${context.kind}" withdrew materialized target "${target}"; return the same key with hidden visibility instead`,
+        )
       }
+      context.current.set(target, node)
+      if (node !== null) upsertsByTarget.get(target)?.push(node)
     }
     this.dirty.clear()
     const timelineDirty = this.timelineDirty
@@ -323,6 +324,12 @@ export class ConversationNodeAssembler {
     return this.views.get(target)?.snapshot
   }
 
+  get<Target extends Extract<keyof ConversationViewSnapshotMap, string>>(
+    target: Target,
+  ): ConversationViewSnapshotMap[Target] | undefined {
+    return this.snapshot(target) as ConversationViewSnapshotMap[Target] | undefined
+  }
+
   private sortedInputs(): ConversationEventInput[] {
     return [...this.inputs.values()].sort((left, right) => left.event.seq - right.event.seq)
   }
@@ -358,18 +365,19 @@ export class ConversationNodeAssembler {
       role: ConversationMatch['role'],
     ) => ConversationPublication,
   ): ConversationPublication {
-    let matched = false
+    const matchedTargets = new Set<string>()
     let publication: ConversationPublication = 'none'
     for (const definition of this.eventDefinitions.entries()) {
       const result = definition.match(input.event)
       if (result === null) continue
-      matched = true
+      if (definition.target !== undefined) matchedTargets.add(definition.target)
       publication = maximumPublication(publication, accept(definition, result.id, result.role))
     }
-    if (!matched) {
-      const fallback = this.eventDefinitions.fallbackEntry()
-      const result = fallback?.match(input.event) ?? null
-      if (fallback !== undefined && result !== null) {
+    const fallback = this.eventDefinitions.fallbackEntry()
+    const target = fallback?.target
+    if (fallback !== undefined && target !== undefined && !matchedTargets.has(target)) {
+      const result = fallback.match(input.event)
+      if (result !== null) {
         publication = maximumPublication(publication, accept(fallback, result.id, result.role))
       }
     }
@@ -697,7 +705,8 @@ export class ConversationNodeAssembler {
   }
 
   private buildNode(context: InternalContext, target: string): ConversationViewNode | null {
-    const node = context.definition.buildViewNode(contextSnapshot(context), target)
+    if (context.definition.target !== target || context.definition.buildViewNode === undefined) return null
+    const node = context.definition.buildViewNode(contextSnapshot(context))
     if (node === null) return null
     if (node.key !== context.key) {
       throw new Error(`conversation Definition "${context.kind}" returned unstable key "${node.key}"; expected "${context.key}"`)

packages/client/runtime/src/client/sessions/conversation.ts

@@ -17,7 +17,7 @@ import type {
 import type { PendingInteraction } from './pending.ts'
 import type { ContextProvenanceView, KnownContextForm } from './context-provenance.ts'
 import type {
-  ChatConversationViewNode, ConversationTimelineSnapshot,
+  ChatConversationViewNode, ConversationTimelineSnapshot, ConversationViewSnapshotStore,
 } from '../contract/conversation.ts'
 export type { TodoItem }
 
@@ -384,6 +384,11 @@ export interface ChatSnapshot {
 const EMPTY_LIST: readonly never[] = []
 const EMPTY_TIMELINE: ConversationTimelineSnapshot = { turnOrder: EMPTY_LIST, turns: new Map() }
 
+/** Empty target store used by fixtures and Sessions without registered views. */
+export const EMPTY_CONVERSATION_VIEWS: ConversationViewSnapshotStore = {
+  get: () => undefined,
+}
+
 /** Empty Chat target used before a view builder is registered. */
 export const EMPTY_CHAT_SNAPSHOT: ChatSnapshot = {
   order: EMPTY_LIST,
@@ -408,6 +413,8 @@ export const EMPTY_CHAT_SNAPSHOT: ChatSnapshot = {
 /** The immutable snapshot contract Session hands to uSES (see the web client architecture RFC). */
 export interface ConversationSnapshot {
   sessionId: SessionId
+  /** Registered target snapshots assembled from Session events. */
+  views: ConversationViewSnapshotStore
   /** Final Chat target assembled from independently registered business Definitions. */
   chat: ChatSnapshot
   /** Legacy top-level compatibility field mirrored from the registered Chat Definitions. */

packages/client/runtime/src/client/sessions/history.ts

@@ -1,121 +0,0 @@
-import type { ToolSchema } from '@deepseek-ai/dsh-llm/types'
-import type { HistoryEntry } from '@deepseek-ai/dsh-client-connection/client'
-import type {
-  ConversationNode, PartialAssistant, RunningToolCall,
-} from './conversation.ts'
-import type { ConversationContext } from './conversation-context.ts'
-import { projectConversationHistory } from '../session-history/history-fold.ts'
-import { inspectRequests, type RequestView } from './request-inspection.ts'
-
-function assistantStepKey(turn: number, step: number): string {
-  return `${turn}\u0000${step}`
-}
-
-function isFirstTokenCandidate(entry: HistoryEntry): boolean {
-  const event = entry.event
-  if (event.type !== 'assistant/chunk') return false
-  switch (event.data.chunk.type) {
-    case 'text-delta':
-    case 'reasoning-delta':
-      return event.data.chunk.text !== ''
-    case 'tool-call-delta':
-      return event.data.chunk.argumentsDelta !== '' || event.data.chunk.name !== undefined
-    default:
-      return false
-  }
-}
-
-/** Lazily derived inspection data for one immutable session-history window. */
-export interface SessionHistoryInspection {
-  eventNodes: readonly ConversationNode[]
-  contexts: readonly ConversationContext[]
-  requests: readonly RequestView[]
-  callSchemas: ReadonlyMap<string, ToolSchema>
-  interruptedNodes: readonly ConversationNode[]
-  partial: PartialAssistant | null
-  runningCalls: readonly RunningToolCall[]
-}
-
-/**
- * Remove completed-step token payloads that no inspection projection reads.
- * The first visible token preserves timing, usage chunks preserve accounting,
- * and unfinished steps retain every chunk for live or interrupted content.
- * @param entries - Contiguous raw history entries in sequence order.
- * @returns A projection-equivalent, usually much smaller entry ledger.
- */
-export function compactHistoryInspectionEntries(
-  entries: readonly HistoryEntry[],
-): readonly HistoryEntry[] {
-  const completedSteps = new Set<string>()
-  for (const { event } of entries) {
-    if (event.type === 'assistant/message') {
-      completedSteps.add(assistantStepKey(event.data.turn, event.data.step))
-    }
-  }
-
-  const firstTokenSteps = new Set<string>()
-  const compacted: HistoryEntry[] = []
-  let changed = false
-  for (const entry of entries) {
-    const event = entry.event
-    if (event.type !== 'assistant/chunk') {
-      compacted.push(entry)
-      continue
-    }
-    const key = assistantStepKey(event.data.turn, event.data.step)
-    if (!completedSteps.has(key) || event.data.chunk.type === 'usage') {
-      compacted.push(entry)
-      continue
-    }
-    if (isFirstTokenCandidate(entry) && !firstTokenSteps.has(key)) {
-      firstTokenSteps.add(key)
-      compacted.push(entry)
-    } else {
-      changed = true
-    }
-  }
-  return changed ? compacted : entries
-}
-
-/**
- * Create a lazy inspection projection over an immutable history window.
- * Conversation consumers retain the cheap wrapper; only Trajectory snapshots
- * the entries and replays event order and request lifecycle state.
- * @param loadEntries - Lazily snapshots contiguous raw entries in sequence order.
- * @returns Lazy, memoized inspection fields for that exact window.
- */
-export function createHistoryInspection(
-  loadEntries: () => readonly HistoryEntry[],
-): SessionHistoryInspection {
-  let entries: readonly HistoryEntry[] | undefined
-  let conversation: ReturnType<typeof projectConversationHistory> | undefined
-  let requests: ReturnType<typeof inspectRequests> | undefined
-  const historyEntries = () => entries ??= loadEntries()
-  const conversationProjection = () =>
-    conversation ??= projectConversationHistory(historyEntries())
-  const requestProjection = () =>
-    requests ??= inspectRequests(historyEntries())
-  return {
-    get eventNodes() {
-      return conversationProjection().eventNodes
-    },
-    get contexts() {
-      return conversationProjection().contexts
-    },
-    get interruptedNodes() {
-      return conversationProjection().interruptedNodes
-    },
-    get partial() {
-      return conversationProjection().partial
-    },
-    get runningCalls() {
-      return conversationProjection().runningCalls
-    },
-    get requests() {
-      return requestProjection().requests
-    },
-    get callSchemas() {
-      return requestProjection().callSchemas
-    },
-  }
-}

packages/client/runtime/src/client/sessions/request-inspection.ts

@@ -1,17 +1,7 @@
-// Request-centric inspection read model. Ordinary generation and compaction
-// calls share one chronological projection; presentation-specific grouping
-// remains in the trajectory consumer.
-
-import type { ContentBlock, TokenUsage, ToolSchema } from '@deepseek-ai/dsh-llm/types'
-import type { HistoryEntry } from '@deepseek-ai/dsh-client-connection/client'
-import type { SessionEvent } from '@deepseek-ai/dsh-session/types'
-import type {} from '@deepseek-ai/dsh-compact/types'
-import type {} from '@deepseek-ai/dsh-llm-retry/types'
-import type {} from '@deepseek-ai/dsh-tools/types'
+import type { ContentBlock, ToolSchema } from '@deepseek-ai/dsh-llm/types'
 import type {
   AssistantProvenanceView, AssistantRequestConfig,
 } from './conversation.ts'
-import { displayFailureMessage } from './failure-display.ts'
 
 export type {
   AssistantProvenanceView, AssistantRequestConfig,
@@ -54,7 +44,7 @@ interface RequestViewBase {
   resultSeq?: number
 }
 
-/** One ordinary assistant generation reconstructed from durable request events. */
+/** One ordinary assistant generation assembled from durable request events. */
 interface AssistantRequestView extends RequestViewBase {
   purpose: 'assistant'
   turn: number
@@ -85,321 +75,11 @@ interface CompactionRequestView extends RequestViewBase {
   rawOutput?: readonly ContentBlock[]
 }
 
-/** One provider request reconstructed from durable request lifecycle events. */
+/** One provider request assembled from durable request lifecycle events. */
 export type RequestView = AssistantRequestView | CompactionRequestView
 
-/** Immutable request-centric projection derived from one history window. */
+/** Request data consumed by the stage-oriented Trajectory layout. */
 export interface RequestInspectionSnapshot {
   requests: readonly RequestView[]
   callSchemas: ReadonlyMap<string, ToolSchema>
 }
-
-/**
- * Derive the request-centric read model from one immutable history window.
- * Compaction participates as a request purpose rather than a parallel
- * top-level collection. A leading resume/change header exposes its prompt but
- * cannot project a change until the preceding header enters the window.
- * @param entries - Contiguous raw session history.
- * @returns Requests and call-time schemas derived from that history.
- */
-export function inspectRequests(
-  entries: readonly HistoryEntry[],
-): RequestInspectionSnapshot {
-  const events = entries.map(entry => entry.event)
-  return {
-    requests: deriveRequests(events),
-    callSchemas: deriveCallSchemas(events),
-  }
-}
-
-function requestKey(turn: number, step: number): string {
-  return `${turn}\u0000${step}`
-}
-
-function addTokenUsage(current: unknown, next: TokenUsage): TokenUsage {
-  const previous = current as TokenUsage | undefined
-  return {
-    inputTokens: (previous?.inputTokens ?? 0) + next.inputTokens,
-    outputTokens: (previous?.outputTokens ?? 0) + next.outputTokens,
-    ...(previous?.cacheReadTokens === undefined && next.cacheReadTokens === undefined
-      ? {}
-      : {
-        cacheReadTokens:
-          (previous?.cacheReadTokens ?? 0) + (next.cacheReadTokens ?? 0),
-      }),
-    ...(previous?.cacheWriteTokens === undefined && next.cacheWriteTokens === undefined
-      ? {}
-      : {
-        cacheWriteTokens:
-          (previous?.cacheWriteTokens ?? 0) + (next.cacheWriteTokens ?? 0),
-      }),
-    ...(previous?.reasoningTokens === undefined && next.reasoningTokens === undefined
-      ? {}
-      : {
-        reasoningTokens:
-          (previous?.reasoningTokens ?? 0) + (next.reasoningTokens ?? 0),
-      }),
-  }
-}
-
-function deriveCallSchemas(
-  events: readonly SessionEvent[],
-): ReadonlyMap<string, ToolSchema> {
-  let active = new Map<string, ToolSchema>()
-  const calls = new Map<string, ToolSchema>()
-  const capture = (callId: string, name: string): void => {
-    if (calls.has(callId)) return
-    const schema = active.get(name)
-    if (schema !== undefined) calls.set(callId, schema)
-  }
-  for (const event of events) {
-    if (event.type === 'request/header') {
-      const tools: unknown = event.data.header.tools
-      active = new Map(
-        Array.isArray(tools)
-          ? (tools as ToolSchema[]).map(schema => [schema.name, schema])
-          : [],
-      )
-      continue
-    }
-    if (event.type === 'tool/call') {
-      capture(String(event.data.callId), event.data.name)
-      continue
-    }
-    if (event.type === 'tool/code-dispatch-start' || event.type === 'tool/code-dispatch') {
-      capture(String(event.data.subCallId), event.data.name)
-    }
-  }
-  return calls
-}
-
-function promptChange(
-  previous: ConversationPromptSnapshot | undefined,
-  prompt: ConversationPromptSnapshot,
-  event: SessionEvent<'request/header'>,
-): RequestPromptChange | undefined {
-  if (previous === undefined && event.data.reason !== 'initial') return
-  const systemChanged = previous !== undefined && previous.system !== prompt.system
-  const toolsChanged = previous !== undefined
-    && JSON.stringify(previous.tools) !== JSON.stringify(prompt.tools)
-  if (previous !== undefined && !systemChanged && !toolsChanged) return
-  return {
-    seq: event.seq,
-    time: event.time,
-    kind: previous === undefined
-      ? 'initial'
-      : systemChanged && toolsChanged
-        ? 'system-and-tools'
-        : systemChanged
-          ? 'system'
-          : 'tools',
-    ...(previous === undefined ? {} : { previous }),
-  }
-}
-
-/** Project ordinary and compaction provider calls into one chronological request stream. */
-function deriveRequests(events: readonly SessionEvent[]): readonly RequestView[] {
-  const requests: RequestView[] = []
-  const ordinaryByStep = new Map<string, number>()
-  const lastStepByTurn = new Map<number, string>()
-  let activeStep: string | undefined
-  let activePrompt: ConversationPromptSnapshot | undefined
-  let activeCompaction: number | undefined
-
-  const updateAssistant = (
-    index: number | undefined,
-    change: Partial<Omit<AssistantRequestView, 'purpose'>>,
-  ): void => {
-    if (index === undefined) return
-    const request = requests[index]
-    if (request?.purpose === 'assistant') requests[index] = { ...request, ...change }
-  }
-  const updateCompaction = (
-    index: number | undefined,
-    change: Partial<Omit<CompactionRequestView, 'purpose'>>,
-  ): void => {
-    if (index === undefined) return
-    const request = requests[index]
-    if (request?.purpose === 'compaction') requests[index] = { ...request, ...change }
-  }
-
-  for (const sourceEvent of events) {
-    if (sourceEvent.type === 'step/start') {
-      const { turn, step } = sourceEvent.data
-      const key = requestKey(turn, step)
-      ordinaryByStep.set(key, requests.length)
-      lastStepByTurn.set(turn, key)
-      requests.push({
-        purpose: 'assistant',
-        startSeq: sourceEvent.seq,
-        turn,
-        step,
-        startedAt: sourceEvent.time,
-        completedAt: null,
-        status: 'running',
-        ...(activePrompt === undefined
-          ? {}
-          : { prompt: activePrompt, requestConfig: activePrompt.config }),
-      })
-      activeStep = key
-      continue
-    }
-    if (sourceEvent.type === 'request/header') {
-      const tools: unknown = sourceEvent.data.header.tools
-      const prompt: ConversationPromptSnapshot = {
-        config: sourceEvent.data.header.config,
-        system: sourceEvent.data.header.system ?? '',
-        tools: Array.isArray(tools) ? tools as ToolSchema[] : [],
-      }
-      const change = promptChange(activePrompt, prompt, sourceEvent)
-      activePrompt = prompt
-      updateAssistant(activeStep === undefined ? undefined : ordinaryByStep.get(activeStep), {
-        prompt,
-        requestConfig: prompt.config,
-        ...(change === undefined ? {} : { promptChange: change }),
-      })
-      continue
-    }
-    if (
-      sourceEvent.type === 'assistant/chunk'
-      && sourceEvent.data.chunk.type === 'usage'
-    ) {
-      const index = ordinaryByStep.get(
-        requestKey(sourceEvent.data.turn, sourceEvent.data.step),
-      )
-      const request = index === undefined ? undefined : requests[index]
-      updateAssistant(index, {
-        usage: addTokenUsage(
-          request?.purpose === 'assistant' ? request.usage : undefined,
-          sourceEvent.data.chunk.usage,
-        ),
-      })
-      continue
-    }
-    if (sourceEvent.type === 'assistant/message') {
-      const index = ordinaryByStep.get(
-        requestKey(sourceEvent.data.turn, sourceEvent.data.step),
-      )
-      const request = index === undefined ? undefined : requests[index]
-      updateAssistant(index, {
-        completedAt: sourceEvent.time,
-        status: 'complete',
-        resultSeq: sourceEvent.seq,
-        provenance: {
-          provider: sourceEvent.data.message.source.provider,
-          model: sourceEvent.data.message.source.model,
-        },
-        ...(request?.purpose === 'assistant'
-          && request.usage !== undefined
-          || sourceEvent.data.usage === undefined
-          ? {}
-          : { usage: sourceEvent.data.usage }),
-      })
-      continue
-    }
-    if (sourceEvent.type === 'step/end') {
-      const key = requestKey(sourceEvent.data.turn, sourceEvent.data.step)
-      const index = ordinaryByStep.get(key)
-      const request = index === undefined ? undefined : requests[index]
-      if (request?.purpose === 'assistant' && request.status === 'running') {
-        updateAssistant(index, {
-          completedAt: sourceEvent.time,
-          status: 'error',
-        })
-      }
-      if (activeStep === key) activeStep = undefined
-      continue
-    }
-    if (sourceEvent.type === 'llm/retry') {
-      const data = sourceEvent.data
-      updateAssistant(ordinaryByStep.get(requestKey(data.turn, data.step)), {
-        status: 'error',
-        error: displayFailureMessage(data.failure),
-        retry: data.retry,
-        ...data.mode === 'normal' ? { maxRetries: data.maxRetries } : {},
-        retryDelayMs: data.delayMs,
-      })
-      continue
-    }
-    if (sourceEvent.type === 'turn/end') {
-      const lastStep = lastStepByTurn.get(sourceEvent.data.turn)
-      if (sourceEvent.data.reason.kind === 'error') {
-        updateAssistant(lastStep === undefined ? undefined : ordinaryByStep.get(lastStep), {
-          status: 'error',
-          error: displayFailureMessage(sourceEvent.data.reason.error),
-        })
-      }
-      lastStepByTurn.delete(sourceEvent.data.turn)
-      continue
-    }
-
-    if (sourceEvent.type === 'session/end-seed' && activeCompaction !== undefined) {
-      updateCompaction(activeCompaction, {
-        completedAt: sourceEvent.time,
-        status: 'error',
-        error: 'Compaction was interrupted before completion.',
-      })
-      activeCompaction = undefined
-      continue
-    }
-    if (sourceEvent.type === 'compact/start') {
-      activeCompaction = requests.length
-      requests.push({
-        purpose: 'compaction',
-        startSeq: sourceEvent.seq,
-        turn: sourceEvent.data.turn,
-        step: 0,
-        startedAt: sourceEvent.time,
-        completedAt: null,
-        status: 'running',
-      })
-      continue
-    }
-    if (sourceEvent.type === 'compact/summary' && activeCompaction !== undefined) {
-      const data = sourceEvent.data
-      updateCompaction(activeCompaction, {
-        resultSeq: sourceEvent.seq,
-        summary: data.summary,
-        ...(data.rawOutput === undefined ? {} : { rawOutput: data.rawOutput }),
-        provenance: {
-          provider: data.provider,
-          model: data.model,
-        },
-        requestConfig: {
-          provider: data.provider,
-          model: data.model,
-          purpose: 'compaction',
-          ...(data.maxTokens === undefined ? {} : { maxTokens: data.maxTokens }),
-        },
-        ...(data.usage === undefined ? {} : { usage: data.usage }),
-      })
-      continue
-    }
-    if (
-      sourceEvent.type === 'user/message'
-      && activeCompaction !== undefined
-      && isCompactionSource(sourceEvent.data.source)
-    ) {
-      updateCompaction(activeCompaction, { replacementSeq: sourceEvent.seq })
-      continue
-    }
-    if (sourceEvent.type !== 'compact/end' || activeCompaction === undefined) continue
-    updateCompaction(activeCompaction, {
-      completedAt: sourceEvent.time,
-      status: sourceEvent.data.error === undefined ? 'complete' : 'error',
-      ...(sourceEvent.data.error === undefined ? {} : { error: sourceEvent.data.error }),
-    })
-    activeCompaction = undefined
-  }
-
-  return requests.sort((left, right) => left.startSeq - right.startSeq)
-}
-
-function isCompactionSource(source: unknown): boolean {
-  return typeof source === 'object'
-    && source !== null
-    && 'kind' in source
-    && source.kind === 'plugin'
-    && 'plugin' in source
-    && source.plugin === 'compact'
-}

packages/client/runtime/src/client/sessions/session.ts

@@ -727,6 +727,7 @@ export class Session implements SessionFace {
     const legacy = chat.legacy
     return {
       sessionId: this.sessionId,
+      views: this.conversation,
       chat,
       nodes: legacy.nodes,
       turnTimings: legacy.turnTimings,

packages/client/runtime/tests/client-apply.spec.ts

@@ -126,6 +126,7 @@ describe('runtime client apply', () => {
     const rebuild = vi.spyOn(Session.prototype, 'rebuildConversationRegistry')
     const definition: ConversationNodeDefinition<null> = {
       kind: 'registry-probe',
+      target: 'chat',
       match: () => null,
       start: () => null,
       update: context => context.state,

packages/client/runtime/tests/conversation-assembler.spec.ts

@@ -30,10 +30,16 @@ interface TestSnapshot {
 }
 
 class TestEventDefinitions {
+  readonly definitions: readonly ConversationNodeDefinition[]
+  readonly fallback: ConversationNodeDefinition | undefined
+
   constructor(
-    readonly definitions: readonly ConversationNodeDefinition[],
-    readonly fallback?: ConversationNodeDefinition,
-  ) {}
+    definitions: readonly ConversationNodeDefinition[],
+    fallback?: ConversationNodeDefinition,
+  ) {
+    this.definitions = definitions
+    this.fallback = fallback
+  }
 
   entries(): readonly ConversationNodeDefinition[] {
     return this.definitions
@@ -93,7 +99,10 @@ function chatSnapshot(assembler: ConversationNodeAssembler): TestSnapshot | unde
   return assembler.snapshot('chat') as TestSnapshot | undefined
 }
 
-function node(context: Parameters<ConversationNodeDefinition['buildViewNode']>[0], data: unknown): ConversationViewNode {
+function node(
+  context: Parameters<NonNullable<ConversationNodeDefinition['buildViewNode']>>[0],
+  data: unknown,
+): ConversationViewNode {
   return {
     key: context.key,
     kind: context.kind,
@@ -103,6 +112,17 @@ function node(context: Parameters<ConversationNodeDefinition['buildViewNode']>[0
   }
 }
 
+function fallbackDefinition(start: () => string): ConversationNodeDefinition<string> {
+  return {
+    kind: 'fallback',
+    target: 'chat',
+    match: event => ({ id: String(event.seq), role: 'start' }),
+    start,
+    update: context => context.state,
+    buildViewNode: context => node(context, context.state),
+  }
+}
+
 describe('ConversationNodeAssembler', () => {
   it('appends through an exact business-id Context without replaying unrelated Contexts', () => {
     const starts = vi.fn((
@@ -122,6 +142,7 @@ describe('ConversationNodeAssembler', () => {
       },
       start: starts,
       update: updates,
+      target: 'chat',
       buildViewNode: context => node(context, context.state),
     }
     const assembler = new ConversationNodeAssembler(
@@ -173,6 +194,7 @@ describe('ConversationNodeAssembler', () => {
         matchCollections.add(context.matches)
         return updates(context)
       },
+      target: 'chat',
       buildViewNode: context => node(context, context.state),
     }
     const assembler = new ConversationNodeAssembler(
@@ -208,6 +230,7 @@ describe('ConversationNodeAssembler', () => {
       },
       start: starts,
       update: updates,
+      target: 'chat',
       buildViewNode: context => node(context, context.state),
     }
     const assembler = new ConversationNodeAssembler(
@@ -247,6 +270,7 @@ describe('ConversationNodeAssembler', () => {
       },
       start: () => ({ settled: false }),
       update: updates,
+      target: 'chat',
       buildViewNode: context => node(context, context.state ?? { pendingStart: true }),
     }
     const assembler = new ConversationNodeAssembler(
@@ -280,6 +304,7 @@ describe('ConversationNodeAssembler', () => {
         : event.type === 'turn/start' ? { id: 'one', role: 'update' } : null,
       start: () => null,
       update: context => context.state,
+      target: 'chat',
       buildViewNode: () => null,
     }
     const assembler = new ConversationNodeAssembler(
@@ -301,6 +326,7 @@ describe('ConversationNodeAssembler', () => {
         : null,
       start: (_context, match) => Number((match.event.data as { value?: unknown }).value ?? 0),
       update: context => context.state,
+      target: 'chat',
       buildViewNode: () => null,
     }
     const consumerStart = vi.fn((
@@ -315,6 +341,7 @@ describe('ConversationNodeAssembler', () => {
         : null,
       start: consumerStart,
       update: context => context.state,
+      target: 'chat',
       buildViewNode: context => node(context, context.state),
     }
     const assembler = new ConversationNodeAssembler(
@@ -344,6 +371,7 @@ describe('ConversationNodeAssembler', () => {
         : null,
       start: (_context, match) => match.event.seq,
       update: context => context.state,
+      target: 'chat',
       buildViewNode: () => null,
     }
     const consumer: ConversationNodeDefinition<number> = {
@@ -353,6 +381,7 @@ describe('ConversationNodeAssembler', () => {
         : null,
       start: (_context, _match, reader) => reader.previous<number>('source')?.state ?? -1,
       update: context => context.state,
+      target: 'chat',
       buildViewNode: context => node(context, context.state),
     }
     const assembler = new ConversationNodeAssembler(
@@ -397,6 +426,7 @@ describe('ConversationNodeAssembler', () => {
         : null,
       start: consumerStart,
       update: context => context.state,
+      target: 'chat',
       buildViewNode: context => node(context, context.state),
     }
     const assembler = new ConversationNodeAssembler(
@@ -425,6 +455,7 @@ describe('ConversationNodeAssembler', () => {
       },
       start: () => 1,
       update: (_context, match) => (match.event.data as unknown as { value: number }).value,
+      target: 'chat',
       buildViewNode: () => null,
     }
     const consumerStart = vi.fn((
@@ -439,6 +470,7 @@ describe('ConversationNodeAssembler', () => {
         : null,
       start: consumerStart,
       update: context => context.state,
+      target: 'chat',
       buildViewNode: context => node(context, context.state),
     }
     const assembler = new ConversationNodeAssembler(
@@ -468,6 +500,7 @@ describe('ConversationNodeAssembler', () => {
       },
       start: () => 1,
       update: (_context, match) => (match.event.data as unknown as { value: number }).value,
+      target: 'chat',
       buildViewNode: () => null,
     }
     const sourceX: ConversationNodeDefinition<number> = {
@@ -479,6 +512,7 @@ describe('ConversationNodeAssembler', () => {
       },
       start: () => 10,
       update: (_context, match) => (match.event.data as unknown as { value: number }).value,
+      target: 'chat',
       buildViewNode: () => null,
     }
     const middle: ConversationNodeDefinition<number> = {
@@ -491,6 +525,7 @@ describe('ConversationNodeAssembler', () => {
         + (reader.previous<number>('diamond-x')?.state ?? 0)
       ),
       update: context => context.state,
+      target: 'chat',
       buildViewNode: context => node(context, context.state),
     }
     const consumer: ConversationNodeDefinition<number> = {
@@ -503,6 +538,7 @@ describe('ConversationNodeAssembler', () => {
         + (reader.previous<number>('diamond-b')?.state ?? 0)
       ),
       update: context => context.state,
+      target: 'chat',
       buildViewNode: context => node(context, context.state),
     }
     const assembler = new ConversationNodeAssembler(
@@ -538,6 +574,7 @@ describe('ConversationNodeAssembler', () => {
         : null,
       start: starts,
       update: context => context.state,
+      target: 'chat',
       buildViewNode: context => node(context, context.state),
     }
     const assembler = new ConversationNodeAssembler(
@@ -609,6 +646,7 @@ describe('ConversationNodeAssembler', () => {
           value: { valueSeenFromStep: stepValue ?? -1 },
         }
       },
+      target: 'chat',
       buildViewNode: (context) => {
         const location = context.start?.location
         if (location?.kind !== 'step') return null
@@ -646,6 +684,7 @@ describe('ConversationNodeAssembler', () => {
         : null,
       start: () => null,
       update: context => context.state,
+      target: 'chat',
       buildViewNode: context => node(context, context.start?.location.kind === 'turn'
         ? context.start.location.turn.steps.length
         : -1),
@@ -701,6 +740,7 @@ describe('ConversationNodeAssembler', () => {
       },
       start: () => null,
       update: context => context.state,
+      target: 'chat',
       buildViewNode: (context) => {
         const location = context.start?.location
         const data = location?.kind === 'step'
@@ -734,6 +774,7 @@ describe('ConversationNodeAssembler', () => {
         : null,
       start: () => null,
       update: context => context.state,
+      target: 'chat',
       buildViewNode: context => node(context, context.start?.location.kind),
     }
     const assembler = new ConversationNodeAssembler(
@@ -760,6 +801,7 @@ describe('ConversationNodeAssembler', () => {
         : null,
       start: () => null,
       update: context => context.state,
+      target: 'chat',
       buildViewNode: (context) => {
         const location = context.start?.location
         return node(context, location?.kind === 'step'
@@ -792,6 +834,7 @@ describe('ConversationNodeAssembler', () => {
         : null,
       start: () => null,
       update: context => context.state,
+      target: 'chat',
       buildViewNode: (context) => {
         const location = context.start?.location
         return node(context, location?.kind === 'step'
@@ -826,6 +869,7 @@ describe('ConversationNodeAssembler', () => {
         : null,
       start: seen,
       update: context => context.state,
+      target: 'chat',
       buildViewNode: context => node(context, context.state),
     }
     const assembler = new ConversationNodeAssembler(
@@ -841,24 +885,64 @@ describe('ConversationNodeAssembler', () => {
     expect(seen).toHaveBeenCalledTimes(2)
   })
 
-  it('does not invoke the fallback when an ordinary non-rendering Definition claims an event', () => {
+  it('invokes the fallback when only a State-only Definition claims an event', () => {
     const fallbackStart = vi.fn(() => 'fallback')
     const claimed: ConversationNodeDefinition<null> = {
-      kind: 'claimed',
-      match: event => (event.type as string) === 'command/run' ? { id: 'claimed', role: 'start' } : null,
+      kind: 'claimed-state',
+      match: event => (event.type as string) === 'command/run'
+        ? { id: 'claimed', role: 'start' }
+        : null,
+      start: () => null,
+      update: context => context.state,
+    }
+    const assembler = new ConversationNodeAssembler(
+      new TestEventDefinitions([claimed], fallbackDefinition(fallbackStart)),
+      new TestViewDefinitions([testView()]),
+    )
+
+    assembler.replaceWindow([input(at(1, 'command/run', { commandId: 'one', name: 'x' }))], false)
+    assembler.flush()
+
+    expect(fallbackStart).toHaveBeenCalledOnce()
+    expect(chatSnapshot(assembler)?.order).toHaveLength(1)
+  })
+
+  it('invokes the fallback when only another target claims an event', () => {
+    const fallbackStart = vi.fn(() => 'fallback')
+    const claimed: ConversationNodeDefinition<null> = {
+      kind: 'claimed-trajectory',
+      target: 'trajectory',
+      match: event => (event.type as string) === 'command/run'
+        ? { id: 'claimed', role: 'start' }
+        : null,
       start: () => null,
       update: context => context.state,
       buildViewNode: () => null,
     }
-    const fallback: ConversationNodeDefinition<string> = {
-      kind: 'fallback',
-      match: event => ({ id: String(event.seq), role: 'start' }),
-      start: fallbackStart,
+    const assembler = new ConversationNodeAssembler(
+      new TestEventDefinitions([claimed], fallbackDefinition(fallbackStart)),
+      new TestViewDefinitions([testView()]),
+    )
+
+    assembler.replaceWindow([input(at(1, 'command/run', { commandId: 'one', name: 'x' }))], false)
+    assembler.flush()
+
+    expect(fallbackStart).toHaveBeenCalledOnce()
+    expect(chatSnapshot(assembler)?.order).toHaveLength(1)
+  })
+
+  it('suppresses the fallback when the same target claims an event', () => {
+    const fallbackStart = vi.fn(() => 'fallback')
+    const claimed: ConversationNodeDefinition<null> = {
+      kind: 'claimed',
+      target: 'chat',
+      match: event => (event.type as string) === 'command/run' ? { id: 'claimed', role: 'start' } : null,
+      start: () => null,
       update: context => context.state,
-      buildViewNode: context => node(context, context.state),
+      buildViewNode: () => null,
     }
     const assembler = new ConversationNodeAssembler(
-      new TestEventDefinitions([claimed], fallback),
+      new TestEventDefinitions([claimed], fallbackDefinition(fallbackStart)),
       new TestViewDefinitions([testView()]),
     )
     assembler.replaceWindow([input(at(1, 'command/run', { commandId: 'one', name: 'x' }))], false)
@@ -878,6 +962,7 @@ describe('ConversationNodeAssembler', () => {
       },
       start: () => true,
       update: () => false,
+      target: 'chat',
       buildViewNode: context => context.state === true ? node(context, true) : null,
     }
     const assembler = new ConversationNodeAssembler(
@@ -900,6 +985,7 @@ describe('ConversationNodeAssembler', () => {
       match: event => (event.type as string) === 'command/run' ? { id: 'one', role: 'start' } : null,
       start: () => undefined,
       update: context => context.state,
+      target: 'chat',
       buildViewNode: () => null,
     }
     const startAssembler = new ConversationNodeAssembler(
@@ -919,6 +1005,7 @@ describe('ConversationNodeAssembler', () => {
       },
       start: () => true,
       update: () => undefined as never,
+      target: 'chat',
       buildViewNode: context => node(context, context.state),
     }
     const updateAssembler = new ConversationNodeAssembler(
@@ -939,6 +1026,7 @@ describe('ConversationNodeAssembler', () => {
       match: event => (event.type as string) === 'command/run' ? { id: 'one', role: 'start' } : null,
       start: (_context, match) => match.event.seq,
       update: context => context.state,
+      target: 'chat',
       buildViewNode: context => node(context, context.state),
     }
     const assembler = new ConversationNodeAssembler(

packages/client/runtime/tests/conversation-registry.spec.ts

@@ -13,6 +13,7 @@ import { FakeApiClient, ok } from './fake-api.ts'
 function eventDefinition(kind: string): ConversationNodeDefinition<null> {
   return {
     kind,
+    target: 'chat',
     match: () => null,
     start: () => null,
     update: context => context.state,
@@ -71,6 +72,40 @@ describe('Conversation registries', () => {
     expect(events.fallbackEntry()).toBeUndefined()
   })
 
+  it('rejects rendering Definitions that omit either target or builder', async () => {
+    const { events } = await bootRegistries()
+    const targetOnly: ConversationNodeDefinition<null> = {
+      kind: 'target-only',
+      target: 'chat',
+      match: () => null,
+      start: () => null,
+      update: context => context.state,
+    }
+    const builderOnly: ConversationNodeDefinition<null> = {
+      kind: 'builder-only',
+      match: () => null,
+      start: () => null,
+      update: context => context.state,
+      buildViewNode: () => null,
+    }
+
+    expect(() => events.register(targetOnly)).toThrow(/target and buildViewNode together/)
+    expect(() => events.register(builderOnly)).toThrow(/target and buildViewNode together/)
+  })
+
+  it('rejects a State-only Definition as the unmatched-event fallback', async () => {
+    const { events } = await bootRegistries()
+    const fallback: ConversationNodeDefinition<null> = {
+      kind: 'state-only-fallback',
+      match: () => null,
+      start: () => null,
+      update: context => context.state,
+    }
+
+    expect(() => events.registerFallback(fallback))
+      .toThrow('conversation fallback Definition must declare a target')
+  })
+
   it('rejects duplicate view targets and disposes a view registration once', async () => {
     const { views } = await bootRegistries()
     const definition = viewDefinition('chat')

packages/client/runtime/tests/history-fold.spec.ts

@@ -1,232 +0,0 @@
-import { createMessage, createUserMessage } from '@deepseek-ai/dsh-llm'
-import type { SessionEvent } from '@deepseek-ai/dsh-session/types'
-import { describe, expect, it } from 'vitest'
-import { projectConversationHistory } from '../src/client/session-history/history-fold.ts'
-import { compactHistoryInspectionEntries } from '../src/client/sessions/history.ts'
-import { inspectRequests } from '../src/client/sessions/request-inspection.ts'
-import { ev } from './event-script.ts'
-
-const at = (seq: number, event: Record<string, unknown>): SessionEvent =>
-  ({ seq, time: 1_700_000_000_000 + seq, ...event }) as unknown as SessionEvent
-
-describe('projectConversationHistory', () => {
-  it('names an injected context node from its durable source, like the live adapter', () => {
-    // The fold declares its own node mapping (jscpd:ignore in the source), so
-    // the source projection is pinned on both sides independently.
-    const injected = at(0, {
-      type: 'user/message',
-      surfaceOp: 'append',
-      data: createUserMessage({
-        content: [{ type: 'text', text: '<available_skills>…</available_skills>' }],
-        // A plugin source, because the client program does not see the host
-        // packages that merge richer source kinds; those arms are pinned in
-        // context-provenance.spec.ts.
-        source: { kind: 'plugin', plugin: 'dsh-tool-skill', form: 'catalog' },
-      }),
-    })
-    const { contexts } = projectConversationHistory([{ event: injected }])
-    expect(contexts[contexts.length - 1]?.nodes).toMatchObject([{
-      kind: 'context',
-      seq: 0,
-      provenance: { role: 'inject', label: 'dsh-tool-skill' },
-      form: 'catalog',
-    }])
-  })
-
-  it('projects next-step human input as durable steering', () => {
-    const steering = createUserMessage({
-      content: [{ type: 'text', text: 'change course' }],
-      source: { kind: 'user' },
-    })
-    const events = [
-      at(0, { type: 'agent/inbox/spliced', data: {
-        target: 'next-step', start: 0, inserted: [steering],
-      } }),
-      at(1, { type: 'agent/inbox/spliced', data: {
-        target: 'next-step', start: 0, removedCount: 1, inserted: [],
-      } }),
-      at(2, { type: 'user/message', surfaceOp: 'append', data: steering }),
-    ]
-    const projection = projectConversationHistory(events.map(event => ({ event })))
-    expect(projection.eventNodes).toMatchObject([{
-      kind: 'steering', messageId: steering.id, seq: 2,
-    }])
-  })
-
-  it('projects a high-sequence history window without synthesizing its unloaded prefix', () => {
-    const baseSeq = 400_000
-    const events = [
-      ev.user(baseSeq, 'loaded tail'),
-      at(baseSeq + 1, {
-        type: 'assistant/message',
-        surfaceOp: { op: 'replace', start: baseSeq, end: baseSeq },
-        sourceEventSeqs: [baseSeq],
-        data: {
-          turn: 80,
-          step: 1,
-          message: createMessage({
-            role: 'assistant',
-            content: [{ type: 'text', text: 'tail summary' }],
-            source: { kind: 'model', provider: 'fake', model: 'fake' },
-          }),
-        },
-      }),
-    ]
-
-    const projection = projectConversationHistory(events.map(event => ({ event })))
-    expect(projection.eventNodes.map(node => node.seq)).toEqual([baseSeq, baseSeq + 1])
-    expect(projection.contexts.map(context => ({
-      originSeq: context.originSeq,
-      nodes: context.nodes.map(node => node.seq),
-    }))).toEqual([
-      { originSeq: undefined, nodes: [baseSeq] },
-      { originSeq: baseSeq + 1, nodes: [baseSeq + 1] },
-    ])
-  })
-
-  it('projects frozen surface generations without widening the core live surface', () => {
-    const events = [
-      ev.user(0, 'a'),
-      ev.user(1, 'b'),
-      at(2, {
-        type: 'assistant/message',
-        surfaceOp: { op: 'replace', start: 0, end: 0 },
-        sourceEventSeqs: [0],
-        data: {
-          turn: 1,
-          step: 1,
-          message: createMessage({
-            role: 'assistant',
-            content: [{ type: 'text', text: 'summary' }],
-            source: { kind: 'model', provider: 'fake', model: 'fake' },
-          }),
-        },
-      }),
-      at(3, {
-        type: 'assistant/message',
-        surfaceOp: { op: 'replace', start: 2, end: 1 },
-        sourceEventSeqs: [2, 1],
-        data: {
-          turn: 1,
-          step: 2,
-          message: createMessage({
-            role: 'assistant',
-            content: [{ type: 'text', text: 'summary 2' }],
-            source: { kind: 'model', provider: 'fake', model: 'fake' },
-          }),
-        },
-      }),
-    ]
-
-    expect(projectConversationHistory(events.map(event => ({ event }))).contexts.map(context => ({
-      id: context.id,
-      parentId: context.parentId,
-      originSeq: context.originSeq,
-      nodes: context.nodes.map(node => node.seq),
-    }))).toEqual([
-      { id: 0, parentId: undefined, originSeq: undefined, nodes: [0, 1] },
-      { id: 1, parentId: 0, originSeq: 2, nodes: [2, 1] },
-      { id: 2, parentId: 1, originSeq: 3, nodes: [3] },
-    ])
-  })
-
-  it('projects assistant timing and the active request header from history', () => {
-    const projection = projectConversationHistory([
-      ev.stepStart(0, 1, 2),
-      at(1, { type: 'request/header', data: {
-        reason: 'initial',
-        header: {
-          config: { provider: 'fake', model: 'first' },
-          tools: [],
-        },
-      } }),
-      ev.chunkStart(2, 1, 2),
-      ev.chunkText(3, 1, 'token', 2),
-      ev.assistant(4, 1, 'done', 2),
-      ev.stepStart(5, 2, 1),
-      ev.chunkText(6, 2, 'next', 1),
-      ev.assistant(7, 2, 'next done', 1),
-    ].map(event => ({ event })))
-
-    expect(projection.eventNodes[0]).toMatchObject({
-      kind: 'assistant',
-      timing: {
-        stepStartTime: 1_700_000_000_000,
-        firstTokenTime: 1_700_000_000_003,
-        completedTime: 1_700_000_000_004,
-      },
-      requestConfig: { provider: 'fake', model: 'first' },
-    })
-
-    expect(projection.eventNodes.at(-1)).toMatchObject({
-      timing: {
-        stepStartTime: 1_700_000_000_005,
-        firstTokenTime: 1_700_000_000_006,
-        completedTime: 1_700_000_000_007,
-      },
-      requestConfig: { provider: 'fake', model: 'first' },
-    })
-  })
-
-  it('projects nested dispatches onto settled and interrupted history calls', () => {
-    const projection = projectConversationHistory([
-      ev.turnStart(0, 1),
-      ev.toolCall(1, 1, 'settled', 'run_code', '{}'),
-      ev.codeDispatchStart(2, 'settled', 1, 'run_code', { code: 'nested' }),
-      ev.codeDispatchStart(3, 'settled:code:1', 1, 'read', { path: 'a.txt' }),
-      ev.codeDispatch(4, 'settled:code:1', 1, 'read', { path: 'a.txt' }, 'alpha'),
-      ev.codeDispatch(5, 'settled', 1, 'run_code', { code: 'nested' }, 'alpha'),
-      ev.toolResult(6, 1, 'settled', 'done'),
-      ev.turnEnd(7, 1),
-      ev.turnStart(8, 2),
-      ev.toolCall(9, 2, 'interrupted', 'run_code', '{}'),
-      ev.codeDispatchStart(10, 'interrupted', 1, 'bash', { command: 'sleep 1' }),
-      ev.turnEnd(11, 2, 'aborted'),
-    ].map(event => ({ event })))
-
-    const settled = {
-      callId: 'settled',
-      subCalls: [{
-        callId: 'settled:code:1',
-        subCalls: [{ callId: 'settled:code:1:code:1', call: { name: 'read' } }],
-      }],
-    }
-    expect(projection.eventNodes).toMatchObject([settled])
-    expect(projection.contexts[0]?.nodes).toMatchObject([settled])
-    expect(projection.interruptedNodes).toMatchObject([{
-      callId: 'interrupted',
-      subCalls: [{ callId: 'interrupted:code:1', name: 'bash' }],
-    }])
-  })
-
-  it('drops completed token payloads without changing inspection projections', () => {
-    const events = [
-      ev.user(0, 'before'),
-      ev.stepStart(1, 1, 0),
-      ev.chunkStart(2, 1),
-      ev.chunkText(3, 1, ''),
-      ev.chunkText(4, 1, 'first'),
-      ev.chunkText(5, 1, ' discarded'),
-      at(6, { type: 'assistant/chunk', data: {
-        turn: 1,
-        step: 0,
-        chunk: { type: 'usage', usage: { inputTokens: 4, outputTokens: 2 } },
-      } }),
-      ev.assistant(7, 1, 'first discarded'),
-      ev.compactSummary(8, 'summary', 0, 7),
-      ev.compactCheckpoint(9, 8, 0, 7),
-      ev.stepStart(10, 2, 0),
-      ev.chunkStart(11, 2),
-      ev.chunkText(12, 2, 'interrupted'),
-      ev.turnEnd(13, 2, 'aborted'),
-    ]
-    const raw = events.map(event => ({ event }))
-    const compacted = compactHistoryInspectionEntries(raw)
-
-    expect(compacted.map(entry => entry.event.seq)).toEqual([
-      0, 1, 4, 6, 7, 8, 9, 10, 11, 12, 13,
-    ])
-    expect(projectConversationHistory(compacted)).toEqual(projectConversationHistory(raw))
-    expect(inspectRequests(compacted)).toEqual(inspectRequests(raw))
-  })
-})

packages/client/runtime/tests/request-inspection.spec.ts

@@ -1,319 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import type { HistoryEntry } from '@deepseek-ai/dsh-client-connection/client'
-import { createAssistantMessage, createUserMessage } from '@deepseek-ai/dsh-llm'
-import type { SessionEvent } from '@deepseek-ai/dsh-session/types'
-import { inspectRequests } from '../src/client/sessions/request-inspection.ts'
-
-const at = (seq: number, type: string, data: unknown): SessionEvent =>
-  ({ seq, time: 1_700_000_000_000 + seq, type, data }) as SessionEvent
-
-const entriesOf = (events: readonly SessionEvent[]): HistoryEntry[] =>
-  events.map(event => ({ event }))
-
-describe('inspectRequests', () => {
-  it('projects ordinary and compaction calls into one chronological request stream', () => {
-    const events = [
-      at(0, 'step/start', { turn: 1, step: 1 }),
-      at(1, 'request/header', {
-        reason: 'initial',
-        header: {
-          config: { provider: 'fake', model: 'model' },
-          system: 'system',
-          tools: [{
-            name: 'read',
-            description: 'Read a file.',
-            parameters: { type: 'object' },
-          }],
-        },
-      }),
-      at(2, 'tool/call', {
-        turn: 1,
-        step: 1,
-        callId: 'call-1',
-        name: 'read',
-        arguments: '{}',
-      }),
-      at(3, 'assistant/message', {
-        turn: 1,
-        step: 1,
-        message: createAssistantMessage({
-          content: [{ type: 'text', text: 'done' }],
-          source: { provider: 'fake', model: 'model' },
-        }),
-        usage: { inputTokens: 5, outputTokens: 2 },
-      }),
-      at(4, 'step/end', { turn: 1, step: 1 }),
-      at(5, 'compact/start', { turn: 1 }),
-      at(6, 'compact/summary', {
-        summary: [{ type: 'text', text: 'summary' }],
-        rawOutput: [
-          { type: 'reasoning', text: 'thought' },
-          { type: 'text', text: 'summary' },
-        ],
-        provider: 'fake',
-        model: 'compact-model',
-        usage: { inputTokens: 8, outputTokens: 3 },
-      }),
-      at(7, 'user/message', createUserMessage({
-        content: [{ type: 'text', text: 'checkpoint' }],
-        source: { kind: 'plugin', plugin: 'compact' },
-      })),
-      at(8, 'compact/end', { turn: 1 }),
-    ]
-    const snapshot = inspectRequests(entriesOf(events))
-    expect(snapshot.requests).toMatchObject([
-      {
-        purpose: 'assistant',
-        startSeq: 0,
-        resultSeq: 3,
-        status: 'complete',
-        prompt: {
-          config: { provider: 'fake', model: 'model' },
-          system: 'system',
-        },
-        promptChange: { seq: 1, kind: 'initial' },
-      },
-      {
-        purpose: 'compaction',
-        startSeq: 5,
-        resultSeq: 6,
-        replacementSeq: 7,
-        status: 'complete',
-        summary: [{ type: 'text', text: 'summary' }],
-      },
-    ])
-    expect(snapshot.callSchemas.get('call-1')?.name).toBe('read')
-  })
-
-  it('does not promote a truncated resume or change header to the initial prompt', () => {
-    for (const reason of ['resume', 'change'] as const) {
-      const snapshot = inspectRequests(entriesOf([
-        at(10, 'step/start', { turn: 3, step: 1 }),
-        at(11, 'request/header', {
-          reason,
-          header: {
-            config: { provider: 'fake', model: 'model' },
-            system: 'tail-window prompt',
-          },
-        }),
-      ]))
-
-      expect(snapshot.requests[0]).toMatchObject({
-        purpose: 'assistant',
-        prompt: { system: 'tail-window prompt' },
-      })
-      expect(snapshot.requests[0]).not.toHaveProperty('promptChange')
-    }
-  })
-
-  it('classifies a prompt change once the preceding header is loaded', () => {
-    const snapshot = inspectRequests(entriesOf([
-      at(0, 'step/start', { turn: 1, step: 1 }),
-      at(1, 'request/header', {
-        reason: 'initial',
-        header: {
-          config: { provider: 'fake', model: 'model' },
-          system: 'before',
-        },
-      }),
-      at(2, 'step/start', { turn: 1, step: 2 }),
-      at(3, 'request/header', {
-        reason: 'change',
-        header: {
-          config: { provider: 'fake', model: 'model' },
-          system: 'after',
-        },
-      }),
-    ]))
-
-    expect(snapshot.requests[1]).toMatchObject({
-      promptChange: {
-        seq: 3,
-        kind: 'system',
-        previous: { system: 'before' },
-      },
-    })
-  })
-
-  it('preserves a standalone compaction owner without widening assistant turns', () => {
-    const snapshot = inspectRequests(entriesOf([
-      at(0, 'compact/start', { turn: null }),
-      at(1, 'compact/summary', {
-        summary: [{ type: 'text', text: 'standalone summary' }],
-        provider: 'fake',
-        model: 'compact-model',
-      }),
-      at(2, 'compact/end', { turn: null }),
-      at(3, 'step/start', { turn: 2, step: 1 }),
-    ]))
-
-    const [compaction, assistant] = snapshot.requests
-    expect(compaction).toMatchObject({
-      purpose: 'compaction',
-      turn: null,
-      step: 0,
-      status: 'complete',
-    })
-    expect(assistant).toMatchObject({
-      purpose: 'assistant',
-      turn: 2,
-      step: 1,
-      status: 'running',
-    })
-    if (assistant?.purpose === 'assistant') {
-      const turn: number = assistant.turn
-      expect(turn).toBe(2)
-    }
-  })
-
-  it('interrupts an orphaned compaction at end-seed before projecting a new attempt', () => {
-    const snapshot = inspectRequests(entriesOf([
-      at(0, 'compact/start', { turn: null }),
-      at(1, 'session/end-seed', {}),
-      at(2, 'compact/start', { turn: null }),
-      at(3, 'compact/summary', {
-        summary: [{ type: 'text', text: 'replacement summary' }],
-        provider: 'fake',
-        model: 'compact-model',
-      }),
-      at(4, 'compact/end', { turn: null }),
-    ]))
-
-    expect(snapshot.requests).toMatchObject([
-      {
-        purpose: 'compaction',
-        startSeq: 0,
-        status: 'error',
-        completedAt: 1_700_000_000_001,
-        error: 'Compaction was interrupted before completion.',
-      },
-      {
-        purpose: 'compaction',
-        startSeq: 2,
-        status: 'complete',
-        completedAt: 1_700_000_000_004,
-        summary: [{ type: 'text', text: 'replacement summary' }],
-      },
-    ])
-  })
-
-  it('captures schemas for nested tool dispatches from the active request header', () => {
-    const snapshot = inspectRequests(entriesOf([
-      at(0, 'request/header', {
-        reason: 'initial',
-        header: {
-          config: { provider: 'fake', model: 'model' },
-          tools: [{
-            name: 'read',
-            description: 'Read a file.',
-            parameters: { type: 'object' },
-          }],
-        },
-      }),
-      at(1, 'tool/code-dispatch-start', {
-        parentCallId: 'parent',
-        subCallId: 'nested',
-        name: 'read',
-        arguments: {},
-      }),
-    ]))
-
-    expect(snapshot.callSchemas.get('nested')?.name).toBe('read')
-  })
-
-  it('keeps chunk-reported usage through request failure and prefers it to message fallback', () => {
-    const chunkUsage = { inputTokens: 21, outputTokens: 3 }
-    const retryUsage = {
-      inputTokens: 5,
-      outputTokens: 2,
-      cacheReadTokens: 8,
-      reasoningTokens: 1,
-    }
-    const snapshot = inspectRequests(entriesOf([
-      at(0, 'step/start', { turn: 1, step: 1 }),
-      at(1, 'assistant/chunk', {
-        turn: 1,
-        step: 1,
-        chunk: { type: 'usage', usage: chunkUsage },
-      }),
-      at(2, 'llm/retry', {
-        turn: 1,
-        step: 1,
-        retry: 1,
-        maxRetries: 2,
-        delayMs: 100,
-        failure: { message: 'rate limited' },
-      }),
-      at(3, 'assistant/chunk', {
-        turn: 1,
-        step: 1,
-        chunk: { type: 'usage', usage: retryUsage },
-      }),
-      at(4, 'assistant/message', {
-        turn: 1,
-        step: 1,
-        message: createAssistantMessage({
-          content: [{ type: 'text', text: 'recovered' }],
-          source: { provider: 'fake', model: 'model' },
-        }),
-        usage: { inputTokens: 1, outputTokens: 1 },
-      }),
-    ]))
-
-    expect(snapshot.requests[0]).toMatchObject({
-      status: 'complete',
-      usage: {
-        inputTokens: 26,
-        outputTokens: 5,
-        cacheReadTokens: 8,
-        reasoningTokens: 1,
-      },
-    })
-  })
-
-  it('keeps provider credential fragments out of projected request errors', () => {
-    const snapshot = inspectRequests(entriesOf([
-      at(0, 'step/start', { turn: 1, step: 1 }),
-      at(1, 'turn/end', {
-        turn: 1, reason: { kind: 'error', error: {
-          code: 'AUTH',
-          message: 'Authentication Fails, Your api key: sk-preview-secret is invalid',
-        },
-        },
-      }),
-      at(2, 'step/start', { turn: 2, step: 1 }),
-      at(3, 'turn/end', {
-        turn: 2, reason: { kind: 'error', error: { message: 'plugin exploded', code: 'UNKNOWN' } },
-      }),
-    ]))
-
-    expect(snapshot.requests).toMatchObject([
-      { status: 'error', error: 'API key is invalid' },
-      { status: 'error', error: 'plugin exploded' },
-    ])
-  })
-
-  it('treats a scrubbed durable-fixture tool catalog as unavailable', () => {
-    const snapshot = inspectRequests(entriesOf([
-      at(0, 'step/start', { turn: 1, step: 1 }),
-      at(1, 'request/header', {
-        reason: 'initial',
-        header: {
-          config: { provider: 'fake', model: 'model' },
-          tools: '{{tools}}',
-        },
-      }),
-      at(2, 'tool/call', {
-        turn: 1,
-        step: 1,
-        callId: 'call-1',
-        name: 'read',
-        arguments: '{}',
-      }),
-    ]))
-
-    expect(snapshot.callSchemas).toEqual(new Map())
-    const [request] = snapshot.requests
-    expect(request?.purpose === 'assistant' ? request.prompt?.tools : undefined).toEqual([])
-  })
-})

packages/client/runtime/tests/session-history-source.spec.ts

@@ -1,180 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest'
-import type { SessionEvent } from '@deepseek-ai/dsh-session/types'
-import type { SessionId } from '@deepseek-ai/dsh-client-connection/client'
-import { SessionHistorySource } from '../src/client/session-history/source.ts'
-import { FakeApiClient, deferred, err, ok } from './fake-api.ts'
-import { entries, ev, plainTurn } from './event-script.ts'
-
-const SID = 'history-s1' as SessionId
-
-afterEach(() => {
-  vi.unstubAllGlobals()
-})
-
-function histResponse(events: SessionEvent[], hasMore = false) {
-  return Promise.resolve(ok({ events: entries(events) as never[], hasMore }))
-}
-
-describe('SessionHistorySource', () => {
-  it('loads the tail first and prepends older pages on demand', async () => {
-    const pages = [
-      plainTurn(0, 0, '最早问', '最早答'),
-      plainTurn(6, 1, '中间问', '中间答'),
-      plainTurn(12, 2, '最新问', '最新答'),
-    ]
-    const api = new FakeApiClient()
-    api.onHistory = (payload) => {
-      if (payload.beforeSeq === undefined) return histResponse(pages[2]!, true)
-      if (payload.beforeSeq === 12) return histResponse(pages[1]!, true)
-      return histResponse(pages[0]!, false)
-    }
-    const source = new SessionHistorySource(SID, api)
-
-    await source.loadTail()
-
-    expect(api.callsOf('session.history')).toHaveLength(1)
-    expect(source.getSnapshot().hasMore).toBe(true)
-    expect(source.getSnapshot().baseSeq).toBe(12)
-    expect(source.getSnapshot().inspection.eventNodes.map(node => node.seq))
-      .toEqual([13, 15])
-
-    expect(await source.loadOlder()).toBe(true)
-    expect(await source.loadOlder()).toBe(true)
-    expect(await source.loadOlder()).toBe(false)
-
-    expect(api.callsOf('session.history')).toHaveLength(3)
-    expect(source.getSnapshot().hasMore).toBe(false)
-    expect(source.getSnapshot().baseSeq).toBe(0)
-    expect(source.getSnapshot().inspection.eventNodes.map(node => node.seq))
-      .toEqual([1, 3, 7, 9, 13, 15])
-  })
-
-  it('pins a lazy inspection to the entries in its source snapshot', async () => {
-    const api = new FakeApiClient()
-    api.onHistory = () => histResponse(plainTurn(0, 0, '问', '答'))
-    const source = new SessionHistorySource(SID, api)
-    await source.loadTail()
-    const before = source.getSnapshot()
-
-    source.handleMuxFrame({
-      type: 'session/event',
-      sessionId: SID,
-      event: ev.user(6, 'later'),
-    })
-
-    expect(before.inspection.eventNodes.map(node => node.seq)).toEqual([1, 3])
-    expect(source.getSnapshot().inspection.eventNodes.map(node => node.seq))
-      .toEqual([1, 3, 6])
-  })
-
-  it('publishes multiple assistant chunks once per browser frame', async () => {
-    const api = new FakeApiClient()
-    api.onHistory = () => histResponse(plainTurn(0, 0, '问', '答'))
-    const source = new SessionHistorySource(SID, api)
-    await source.loadTail()
-    const frames: FrameRequestCallback[] = []
-    vi.stubGlobal('requestAnimationFrame', (callback: FrameRequestCallback) => {
-      frames.push(callback)
-      return frames.length
-    })
-    let notifications = 0
-    const unsubscribe = source.subscribe(() => { notifications++ })
-    const before = source.getSnapshot().inspection
-    const finalizedNodes = before.eventNodes
-    const requests = before.requests
-    const contexts = before.contexts
-
-    for (const event of [
-      ev.chunkStart(6, 1),
-      ev.chunkText(7, 1, 'stream '),
-      ev.chunkText(8, 1, 'content'),
-    ]) {
-      source.handleMuxFrame({
-        type: 'session/event',
-        sessionId: SID,
-        event,
-      })
-    }
-
-    expect(frames).toHaveLength(1)
-    expect(notifications).toBe(0)
-    frames[0]?.(0)
-    await Promise.resolve()
-
-    expect(notifications).toBe(1)
-    const streamed = source.getSnapshot().inspection
-    expect(streamed.eventNodes).toBe(finalizedNodes)
-    expect(streamed.requests).toBe(requests)
-    expect(streamed.contexts).toBe(contexts)
-    expect(streamed.partial?.blocks).toEqual([
-      { kind: 'text', text: 'stream content' },
-    ])
-
-    source.handleMuxFrame({
-      type: 'session/event',
-      sessionId: SID,
-      event: ev.chunkText(9, 1, ' then final'),
-    })
-    source.handleMuxFrame({
-      type: 'session/event',
-      sessionId: SID,
-      event: ev.assistant(10, 1, 'stream content then final'),
-    })
-    await Promise.resolve()
-
-    expect(notifications).toBe(2)
-    const finalized = source.getSnapshot().inspection
-    expect(finalized.eventNodes).not.toBe(finalizedNodes)
-    expect(finalized.partial).toBeNull()
-    frames[1]?.(0)
-    await Promise.resolve()
-    expect(notifications).toBe(2)
-    unsubscribe()
-  })
-
-  it('stops loading when an older page fails to advance', async () => {
-    const api = new FakeApiClient()
-    api.onHistory = payload => payload.beforeSeq === undefined
-      ? histResponse(plainTurn(6, 1, '新问', '新答'), true)
-      : Promise.resolve(err({
-        code: 'internal',
-        message: 'page unavailable',
-        details: {},
-      }))
-    const source = new SessionHistorySource(SID, api)
-
-    await source.loadTail()
-    expect(await source.loadOlder()).toBe(false)
-
-    expect(api.callsOf('session.history')).toHaveLength(2)
-    expect(source.getSnapshot().hasMore).toBe(true)
-  })
-
-  it('finishes an already started older page after consumer cancellation', async () => {
-    const middle = deferred<Awaited<ReturnType<FakeApiClient['onHistory']>>>()
-    const olderStarted = deferred<undefined>()
-    const api = new FakeApiClient()
-    api.onHistory = (payload) => {
-      if (payload.beforeSeq === undefined) {
-        return histResponse(plainTurn(12, 2, '最新问', '最新答'), true)
-      }
-      olderStarted.resolve(undefined)
-      return middle.promise
-    }
-    const source = new SessionHistorySource(SID, api)
-    const controller = new AbortController()
-    await source.loadTail(controller.signal)
-    const complete = source.loadOlder(controller.signal)
-    await olderStarted.promise
-    controller.abort()
-    middle.resolve(ok({
-      events: entries(plainTurn(6, 1, '中间问', '中间答')) as never[],
-      hasMore: true,
-    }))
-
-    expect(await complete).toBe(true)
-
-    expect(api.callsOf('session.history')).toHaveLength(2)
-    expect(source.getSnapshot().hasMore).toBe(true)
-  })
-})

packages/client/runtime/tests/session.spec.ts

@@ -123,12 +123,13 @@ function testViewDefinition(): ConversationViewDefinition<ChatConversationViewNo
 
 const TEST_EVENT_DEFINITION: ConversationNodeDefinition<TestEventState> = {
   kind: 'runtime-test-event',
+  target: 'chat',
   match: event => ({ id: String(event.seq), role: 'start' }),
   start: (_context, match) => ({ event: match.event, view: match.view }),
   update: context => context.state,
   publication: match => match.event.type === 'assistant/chunk' ? 'animation-frame' : 'immediate',
-  buildViewNode: (context, target) => {
-    if (target !== 'chat' || context.state === undefined || context.start === undefined) return null
+  buildViewNode: (context) => {
+    if (context.state === undefined || context.start === undefined) return null
     return {
       key: context.key,
       kind: 'runtime-test-event',

packages/client/schema-form/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-client-schema-form",
   "description": "Schema/draft model layer for settings editors: rehydrates a serialized schemastery schema, validates drafts, and edits them immutably by path",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/client/schema-form"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -20,15 +27,15 @@
   },
   "license": "BSD-3-Clause",
   "dependencies": {
-    "@deepseek-ai/schemastery": "^3.18.0"
+    "@deepseek-ai/schemastery": "workspace:^"
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-invariants": "workspace:^",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7"
+    "@deepseek-ai/cordis": "workspace:^"
   },
   "files": [
     "lib/index.js",

packages/client/test-runtime/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-client-test-runtime",
   "description": "jsdom slot test runtime: real Cordis Context + SlotsService + web-react renderer with test-owned session/workspace doubles for feature specs",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/client/test-runtime"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -25,12 +32,12 @@
     "vitest": "^4.1.8"
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh-client-runtime": "^0.0.1",
-    "@deepseek-ai/dsh-client-ui-slots": "^0.0.1",
-    "@deepseek-ai/dsh-client-web-react": "^0.0.1",
-    "@deepseek-ai/dsh-host-apiproxy": "^0.0.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7",
+    "@deepseek-ai/dsh-client-runtime": "workspace:^",
+    "@deepseek-ai/dsh-client-ui-slots": "workspace:^",
+    "@deepseek-ai/dsh-client-web-react": "workspace:^",
+    "@deepseek-ai/dsh-host-apiproxy": "workspace:^",
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^",
     "react": "^18.2.0",
     "react-dom": "^18.2.0"
   },
@@ -42,7 +49,7 @@
     "@deepseek-ai/dsh-invariants": "workspace:^",
     "@types/react": "~18.3.1",
     "@types/react-dom": "~18.3.0",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7",
+    "@deepseek-ai/cordis": "workspace:^",
     "react": "^18.2.0",
     "react-dom": "^18.2.0"
   },

packages/client/test-runtime/src/fixtures.ts

@@ -2,7 +2,9 @@
 import type {
   ConversationSnapshot, ISession, SessionId, SessionSummary, WorkspaceListState,
 } from '@deepseek-ai/dsh-client-runtime/client'
-import { EMPTY_CHAT_SNAPSHOT } from '@deepseek-ai/dsh-client-runtime/client'
+import {
+  EMPTY_CHAT_SNAPSHOT, EMPTY_CONVERSATION_VIEWS,
+} from '@deepseek-ai/dsh-client-runtime/client'
 
 /**
  * Fixture overrides for the session behavior face: any subset of the
@@ -46,6 +48,7 @@ export interface SessionFixture {
 export function conversationSnapshot(sessionId: SessionId): ConversationSnapshot {
   return {
     sessionId,
+    views: EMPTY_CONVERSATION_VIEWS,
     chat: EMPTY_CHAT_SNAPSHOT,
     nodes: [],
     turnTimings: new Map(),

packages/client/ui-agent-preset/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-client-ui-agent-preset",
   "description": "Agent-preset surfaces: the default for later sessions, this session's seat, and the composition editor",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/client/ui-agent-preset"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -40,16 +47,16 @@
   },
   "license": "BSD-3-Clause",
   "peerDependencies": {
-    "@deepseek-ai/dsh-client-connection": "^0.0.1",
-    "@deepseek-ai/dsh-client-locale": "^0.0.1",
-    "@deepseek-ai/dsh-client-runtime": "^0.0.1",
-    "@deepseek-ai/dsh-client-ui-conversation": "^0.0.1",
-    "@deepseek-ai/dsh-client-ui-primitives": "^0.0.1",
-    "@deepseek-ai/dsh-client-ui-settings": "^0.0.1",
-    "@deepseek-ai/dsh-client-ui-slots": "^0.0.1",
-    "@deepseek-ai/dsh-client-web-react": "^0.0.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7",
+    "@deepseek-ai/dsh-client-connection": "workspace:^",
+    "@deepseek-ai/dsh-client-locale": "workspace:^",
+    "@deepseek-ai/dsh-client-runtime": "workspace:^",
+    "@deepseek-ai/dsh-client-ui-conversation": "workspace:^",
+    "@deepseek-ai/dsh-client-ui-primitives": "workspace:^",
+    "@deepseek-ai/dsh-client-ui-settings": "workspace:^",
+    "@deepseek-ai/dsh-client-ui-slots": "workspace:^",
+    "@deepseek-ai/dsh-client-web-react": "workspace:^",
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^",
     "react": "^18.2.0"
   },
   "devDependencies": {
@@ -64,7 +71,7 @@
     "@deepseek-ai/dsh-client-web-react": "workspace:^",
     "@deepseek-ai/dsh-invariants": "workspace:^",
     "@types/react": "~18.3.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7",
+    "@deepseek-ai/cordis": "workspace:^",
     "react": "^18.2.0"
   },
   "files": [

packages/client/ui-command/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-client-ui-command",
   "description": "Client command surface: global directory cache, '/' source, three command UI kinds, popupSelect registry",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/client/ui-command"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -42,15 +49,15 @@
     "clsx": "^2.0.0"
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh-client-connection": "^0.0.1",
-    "@deepseek-ai/dsh-client-locale": "^0.0.1",
-    "@deepseek-ai/dsh-client-runtime": "^0.0.1",
-    "@deepseek-ai/dsh-client-ui-conversation": "^0.0.1",
-    "@deepseek-ai/dsh-client-ui-primitives": "^0.0.1",
-    "@deepseek-ai/dsh-client-ui-slash": "^0.0.1",
-    "@deepseek-ai/dsh-client-ui-slots": "^0.0.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7",
+    "@deepseek-ai/dsh-client-connection": "workspace:^",
+    "@deepseek-ai/dsh-client-locale": "workspace:^",
+    "@deepseek-ai/dsh-client-runtime": "workspace:^",
+    "@deepseek-ai/dsh-client-ui-conversation": "workspace:^",
+    "@deepseek-ai/dsh-client-ui-primitives": "workspace:^",
+    "@deepseek-ai/dsh-client-ui-slash": "workspace:^",
+    "@deepseek-ai/dsh-client-ui-slots": "workspace:^",
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^",
     "react": "^18.2.0"
   },
   "devDependencies": {
@@ -64,7 +71,7 @@
     "@deepseek-ai/dsh-client-ui-slots": "workspace:^",
     "@deepseek-ai/dsh-invariants": "workspace:^",
     "@types/react": "~18.3.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7",
+    "@deepseek-ai/cordis": "workspace:^",
     "react": "^18.2.0"
   },
   "files": [

packages/client/ui-conversation/package.json

@@ -1,8 +1,15 @@
 {
   "name": "@deepseek-ai/dsh-client-ui-conversation",
   "description": "Conversation domain: skeleton, ordered chat flow, composer with the Host-backed busy-Enter preference, and details host",
-  "version": "0.0.1",
-  "private": true,
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/client/ui-conversation"
+  },
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -41,25 +48,25 @@
   "dependencies": {
     "@deepseek-ai/dsh-settings": "workspace:^",
     "clsx": "^2.0.0",
-    "@deepseek-ai/schemastery": "^3.18.0"
+    "@deepseek-ai/schemastery": "workspace:^"
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh-agent": "^0.0.1",
-    "@deepseek-ai/dsh-attachment": "^0.0.1",
-    "@deepseek-ai/dsh-brand": "^0.0.1",
-    "@deepseek-ai/dsh-client-connection": "^0.0.1",
-    "@deepseek-ai/dsh-client-locale": "^0.0.1",
-    "@deepseek-ai/dsh-client-runtime": "^0.0.1",
-    "@deepseek-ai/dsh-client-ui-primitives": "^0.0.1",
-    "@deepseek-ai/dsh-client-ui-slash": "^0.0.1",
-    "@deepseek-ai/dsh-client-ui-slots": "^0.0.1",
-    "@deepseek-ai/dsh-compact": "^0.0.1",
-    "@deepseek-ai/dsh-commands": "^0.0.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1",
-    "@deepseek-ai/dsh-llm-retry": "^0.0.1",
-    "@deepseek-ai/dsh-token-meter": "^0.0.1",
-    "@deepseek-ai/dsh-tools": "^0.0.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7",
+    "@deepseek-ai/dsh-agent": "workspace:^",
+    "@deepseek-ai/dsh-attachment": "workspace:^",
+    "@deepseek-ai/dsh-brand": "workspace:^",
+    "@deepseek-ai/dsh-client-connection": "workspace:^",
+    "@deepseek-ai/dsh-client-locale": "workspace:^",
+    "@deepseek-ai/dsh-client-runtime": "workspace:^",
+    "@deepseek-ai/dsh-client-ui-primitives": "workspace:^",
+    "@deepseek-ai/dsh-client-ui-slash": "workspace:^",
+    "@deepseek-ai/dsh-client-ui-slots": "workspace:^",
+    "@deepseek-ai/dsh-compact": "workspace:^",
+    "@deepseek-ai/dsh-commands": "workspace:^",
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@deepseek-ai/dsh-llm-retry": "workspace:^",
+    "@deepseek-ai/dsh-token-meter": "workspace:^",
+    "@deepseek-ai/dsh-tools": "workspace:^",
+    "@deepseek-ai/cordis": "workspace:^",
     "react": "^18.2.0"
   },
   "devDependencies": {
@@ -86,7 +93,7 @@
     "@deepseek-ai/dsh-tools": "workspace:^",
     "@deepseek-ai/dsh-tool-todo": "workspace:^",
     "@types/react": "~18.3.1",
-    "@deepseek-ai/cordis": "^4.0.0-rc.7",
+    "@deepseek-ai/cordis": "workspace:^",
     "react": "^18.2.0"
   },
   "files": [

packages/client/ui-conversation/src/client/conversation-nodes/assistant.ts

@@ -242,6 +242,7 @@ function projectAssistant(context: ConversationNodeContext<AssistantState>): Ass
 /** Per-step Assistant streaming/final/interruption Definition. */
 export const assistantDefinition: ConversationNodeDefinition<AssistantState> = {
   kind: 'assistant-step',
+  target: 'chat',
   match: (event) => {
     if (event.type === 'step/start') return { id: `${event.data.turn}:${event.data.step}`, role: 'start' }
     if (event.type === 'assistant/chunk'
@@ -291,8 +292,7 @@ export const assistantDefinition: ConversationNodeDefinition<AssistantState> = {
       value: projected.data,
     }
   },
-  buildViewNode: (context, target) => {
-    if (target !== 'chat') return null
+  buildViewNode: (context) => {
     const projected = projectAssistant(context)
     if (projected === undefined) return null
     if (projected.settled === undefined && !projected.visible) {

packages/client/ui-conversation/src/client/conversation-nodes/command.ts

@@ -175,6 +175,7 @@ export function updateCompactionState<State extends CompactionEvidence>(
 /** Slash-command lifecycle, including integrated manual compaction, Definition. */
 export const commandDefinition: ConversationNodeDefinition<CommandState> = {
   kind: 'command',
+  target: 'chat',
   match: (event) => {
     if (event.type === 'command/run') {
       return { id: String(event.data.commandId), role: 'start' }
@@ -202,8 +203,7 @@ export const commandDefinition: ConversationNodeDefinition<CommandState> = {
     }
     return updateCompactionState(context.state, match)
   },
-  buildViewNode: (context, target) => {
-    if (target !== 'chat') return null
+  buildViewNode: (context) => {
     const state = context.state ?? fallbackState(context)
     if (state === undefined) return null
     if (state.command.name !== 'compact') {

packages/client/ui-conversation/src/client/conversation-nodes/compaction.ts

@@ -30,6 +30,7 @@ function fallbackState(context: ConversationNodeContext<CompactionState>): Compa
 /** Automatic compaction lifecycle and landed checkpoint Definition. */
 export const compactionDefinition: ConversationNodeDefinition<CompactionState> = {
   kind: 'compaction',
+  target: 'chat',
   match: (event) => {
     const checkpoint = compactSource(event)
     if (checkpoint !== undefined && checkpoint.sourceCommandId === undefined) {
@@ -47,8 +48,7 @@ export const compactionDefinition: ConversationNodeDefinition<CompactionState> =
   },
   start: () => ({}),
   update: (context, match) => updateCompactionState(context.state, match),
-  buildViewNode: (context, target) => {
-    if (target !== 'chat') return null
+  buildViewNode: (context) => {
     const state = context.state ?? fallbackState(context)
     if (state.checkpoint === undefined) return null
     const marker = compactSummary(state.summary, state.checkpoint)

packages/client/ui-conversation/src/client/conversation-nodes/fallback.ts

@@ -15,6 +15,7 @@ declare module '@deepseek-ai/dsh-client-ui-conversation/client' {
 /** Unclaimed append-surface fallback Definition. */
 export const unknownFallbackDefinition: ConversationNodeDefinition<UnknownSurfaceNode> = {
   kind: 'unknown-surface',
+  target: 'chat',
   match: event => isAppendSurfaceEvent(event)
     ? { id: String(event.seq), role: 'start' }
     : null,
@@ -26,7 +27,7 @@ export const unknownFallbackDefinition: ConversationNodeDefinition<UnknownSurfac
     data: match.event.data,
   }),
   update: context => context.state,
-  buildViewNode: (context, target) => target !== 'chat' || context.state === undefined
+  buildViewNode: context => context.state === undefined
     ? null
     : chatNode(context, 'unknown', context.state.seq, context.state),
 }

packages/client/ui-conversation/src/client/conversation-nodes/inbox.ts

@@ -50,7 +50,6 @@ function inboxDefinition(target: InboxTarget): ConversationNodeDefinition<InboxS
     },
     update: context => context.state,
     publication: () => 'none',
-    buildViewNode: () => null,
   }
 }
 

packages/client/ui-conversation/src/client/conversation-nodes/message.ts

@@ -30,6 +30,7 @@ function isCompactionCheckpoint(event: Parameters<ConversationNodeDefinition['ma
 /** User, steering, and injected-context message classification Definition. */
 export const messageDefinition: ConversationNodeDefinition<MessageNode> = {
   kind: 'input-message',
+  target: 'chat',
   match: event => event.type === 'user/message'
     && isAppendSurfaceEvent(event)
     && !isCompactionCheckpoint(event)
@@ -68,8 +69,8 @@ export const messageDefinition: ConversationNodeDefinition<MessageNode> = {
       }
   },
   update: context => context.state,
-  buildViewNode: (context, target) => {
-    if (target !== 'chat' || context.state === undefined) return null
+  buildViewNode: (context) => {
+    if (context.state === undefined) return null
     return chatNode(context, context.state.kind, context.state.seq, context.state)
   },
 }

packages/client/ui-conversation/src/client/conversation-nodes/retry.ts

@@ -40,6 +40,7 @@ function isClosed(location: ConversationLocation): boolean {
 /** Producer-correlated model retry chain Definition. */
 export const retryDefinition: ConversationNodeDefinition<RetryState> = {
   kind: 'model-retry',
+  target: 'chat',
   match: (event) => {
     if (event.type === 'llm/retry') {
       const retryId: unknown = event.data.retryId
@@ -70,8 +71,8 @@ export const retryDefinition: ConversationNodeDefinition<RetryState> = {
         attempt.retry === retry ? { ...attempt, retryState: 'started' } : attempt),
     }
   },
-  buildViewNode: (context, target) => {
-    if (target !== 'chat' || context.state === undefined || context.state.attempts.length === 0) return null
+  buildViewNode: (context) => {
+    if (context.state === undefined || context.state.attempts.length === 0) return null
     const location = context.start?.location ?? context.matches[0]?.location ?? { kind: 'unresolved' as const }
     const stateAttempts = context.state.attempts
     const attempts = stateAttempts.map((attempt, index) =>

packages/client/ui-conversation/src/client/conversation-nodes/tool.ts

@@ -235,6 +235,7 @@ function fallbackState(context: ConversationNodeContext<ToolState>): ToolState |
 /** Root Tool lifecycle and nested Code Dispatch Definition. */
 export const toolDefinition: ConversationNodeDefinition<ToolState> = {
   kind: 'tool-call',
+  target: 'chat',
   match: (event) => {
     if (event.type === 'tool/call') return { id: String(event.data.callId), role: 'start' }
     if (event.type === 'tool/result' && isAppendSurfaceEvent(event)) {
@@ -257,8 +258,7 @@ export const toolDefinition: ConversationNodeDefinition<ToolState> = {
     }
     return updateDispatch(context.state, match)
   },
-  buildViewNode: (context, target) => {
-    if (target !== 'chat') return null
+  buildViewNode: (context) => {
     const state = context.state ?? fallbackState(context)
     if (state === undefined) return null
     const projected = projectBlock(state.root, state, interruption(context))

packages/client/ui-conversation/src/client/conversation-nodes/turn-error.ts

@@ -63,6 +63,7 @@ function fallbackState(context: ConversationNodeContext<TurnErrorState>): TurnEr
 /** Terminal turn failure Definition, suppressed when the turn owns a retry chain. */
 export const turnErrorDefinition: ConversationNodeDefinition<TurnErrorState> = {
   kind: 'turn-error',
+  target: 'chat',
   match: (event) => {
     if (event.type === 'turn/start') return { id: String(event.data.turn), role: 'start' }
     if (event.type === 'turn/end' && event.data.reason.kind === 'error') {
@@ -82,8 +83,7 @@ export const turnErrorDefinition: ConversationNodeDefinition<TurnErrorState> = {
       ? { ...context.state, hidden: true }
       : context.state
   },
-  buildViewNode: (context, target) => {
-    if (target !== 'chat') return null
+  buildViewNode: (context) => {
     const state = context.state ?? fallbackState(context)
     if (state?.failure === undefined) return null
     const failure = state.failure

packages/client/ui-conversation/src/client/conversation-nodes/turn-tail.ts

@@ -151,6 +151,7 @@ function tailData(context: ConversationNodeContext<TurnTailState>): TurnTailChat
 /** Completed-turn footer Definition independent of any Assistant row. */
 export const turnTailDefinition: ConversationNodeDefinition<TurnTailState> = {
   kind: 'turn-tail',
+  target: 'chat',
   match: (event) => {
     if (event.type === 'turn/start') return { id: String(event.data.turn), role: 'start' }
     if (event.type === 'turn/end') return { id: String(event.data.turn), role: 'update' }
@@ -179,8 +180,7 @@ export const turnTailDefinition: ConversationNodeDefinition<TurnTailState> = {
       value,
     }
   },
-  buildViewNode: (context, target) => {
-    if (target !== 'chat') return null
+  buildViewNode: (context) => {
     const turn = turnLocation(context)
     const data = turn?.data.get('turn-tail')
     return data === undefined ? null : chatNode(context, 'turn-tail', closingAnchor(context), data)

packages/client/ui-conversation/tests/chat-stats.spec.tsx

@@ -7,6 +7,7 @@ import { act, cleanup, fireEvent, render } from '@testing-library/react'
 import type {
   AssistantMessageNode, ConversationSnapshot, SessionId, ToolResultNode,
 } from '@deepseek-ai/dsh-client-runtime/client'
+import { EMPTY_CONVERSATION_VIEWS } from '@deepseek-ai/dsh-client-runtime/client'
 import { bindSnapshotSelector } from '@deepseek-ai/dsh-client-web-react'
 import { makeTranslate } from '@deepseek-ai/dsh-client-test-runtime'
 import { en as commonEn } from '@deepseek-ai/dsh-client-locale/src/locales/en.ts'
@@ -43,7 +44,7 @@ const assistant = (seq: number, turn: number, usage?: unknown): AssistantMessage
 
 function snapshotBase(): ConversationSnapshot {
   return {
-    sessionId: SID, chat: chatSnapshotFixture(),
+    sessionId: SID, views: EMPTY_CONVERSATION_VIEWS, chat: chatSnapshotFixture(),
     nodes: [], turnTimings: new Map(), turnEnds: new Map(), partial: null, runningCalls: [],
     pending: [], queue: [], running: false, composerPhase: 'active', removed: false, openState: 'open', openError: null,
     hasMore: false, loadingOlder: false, promptError: null, blank: false, subagent: null, lastAgentError: null,

packages/client/ui-conversation/tests/chat-view.spec.tsx

@@ -12,7 +12,9 @@ import type {
   UserMessageNode, WorkspaceListState,
 } from '@deepseek-ai/dsh-client-runtime/client'
 import { bindSnapshotSelector } from '@deepseek-ai/dsh-client-web-react'
-import { createSnapshotStore, PendingWait } from '@deepseek-ai/dsh-client-runtime/client'
+import {
+  createSnapshotStore, EMPTY_CONVERSATION_VIEWS, PendingWait,
+} from '@deepseek-ai/dsh-client-runtime/client'
 import { RpcId } from '@deepseek-ai/dsh-client-connection/client'
 import type {
   ChatNode, ChatNodeOwnerProps, ChatNodeViewProps, ChatViewSlotProps, SelectionTarget, UseChatNodeTurnData,
@@ -47,7 +49,8 @@ type RoutedChatNodeOwner = ChatNodeOwnerProps & { readonly node: ChatNode }
 
 function snapshotBase(): ConversationSnapshot {
   return {
-    sessionId: SID, chat: chatSnapshotFixture(), nodes: [], turnTimings: new Map(), turnEnds: new Map(), partial: null, runningCalls: [],
+    sessionId: SID, views: EMPTY_CONVERSATION_VIEWS, chat: chatSnapshotFixture(), nodes: [],
+    turnTimings: new Map(), turnEnds: new Map(), partial: null, runningCalls: [],
     pending: [], queue: [], running: false, composerPhase: 'active', removed: false, openState: 'open', openError: null,
     hasMore: false, loadingOlder: false, promptError: null, blank: false, subagent: null, lastAgentError: null,
   }

packages/client/ui-conversation/tests/gate-branch-tails.spec.tsx

@@ -3,7 +3,9 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { cleanup, render } from '@testing-library/react'
 import { bindSnapshotSelector } from '@deepseek-ai/dsh-client-web-react'
-import { createSnapshotStore, EMPTY_CHAT_SNAPSHOT } from '@deepseek-ai/dsh-client-runtime/client'
+import {
+  createSnapshotStore, EMPTY_CHAT_SNAPSHOT, EMPTY_CONVERSATION_VIEWS,
+} from '@deepseek-ai/dsh-client-runtime/client'
 import type { UseSession } from '@deepseek-ai/dsh-client-web-react'
 import type { ConversationSnapshot, SessionId, SessionListState, WorkspaceListState } from '@deepseek-ai/dsh-client-runtime/client'
 import type { SessionProviderComponent } from '@deepseek-ai/dsh-client-ui-slots'
@@ -48,7 +50,7 @@ function renderToolDetailsProbe(owners?: DetailsToolOwnerProps[]): DetailsSlotPr
 
 function snapshotBase(): ConversationSnapshot {
   return {
-    sessionId: SID, chat: EMPTY_CHAT_SNAPSHOT,
+    sessionId: SID, views: EMPTY_CONVERSATION_VIEWS, chat: EMPTY_CHAT_SNAPSHOT,
     nodes: [], turnTimings: new Map(), turnEnds: new Map(), partial: null, runningCalls: [],
     pending: [], queue: [], running: false, composerPhase: 'active', removed: false, openState: 'open', openError: null,
     hasMore: false, loadingOlder: false, promptError: null, blank: false, subagent: null, lastAgentError: null,

packages/client/ui-conversation/tests/input-bar.spec.tsx

@@ -7,7 +7,9 @@
 import { afterEach, describe, expect, it, onTestFinished, vi } from 'vitest'
 import { act, cleanup, fireEvent, render } from '@testing-library/react'
 import { bindSnapshotSelector } from '@deepseek-ai/dsh-client-web-react'
-import { createSnapshotStore, EMPTY_CHAT_SNAPSHOT } from '@deepseek-ai/dsh-client-runtime/client'
+import {
+  createSnapshotStore, EMPTY_CHAT_SNAPSHOT, EMPTY_CONVERSATION_VIEWS,
+} from '@deepseek-ai/dsh-client-runtime/client'
 import { makeTranslate } from '@deepseek-ai/dsh-client-test-runtime'
 import { zh as commonZh } from '@deepseek-ai/dsh-client-locale/src/locales/zh.ts'
 import type { ClientContext, ConversationSnapshot, SessionId } from '@deepseek-ai/dsh-client-runtime/client'
@@ -37,7 +39,7 @@ const SID = 's1' as SessionId
 
 function snapshotOf(overrides: Partial<ConversationSnapshot> = {}): ConversationSnapshot {
   return {
-    sessionId: SID, chat: EMPTY_CHAT_SNAPSHOT,
+    sessionId: SID, views: EMPTY_CONVERSATION_VIEWS, chat: EMPTY_CHAT_SNAPSHOT,
     nodes: [], turnTimings: new Map(), turnEnds: new Map(), partial: null, runningCalls: [],
     pending: [], queue: [], running: false, composerPhase: 'active', removed: false,
     openState: 'open', openError: null, hasMore: false, loadingOlder: false,

packages/client/ui-conversation/tests/input-matrix.spec.tsx

@@ -8,7 +8,9 @@
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { act, cleanup, fireEvent, render } from '@testing-library/react'
 import { bindSnapshotSelector } from '@deepseek-ai/dsh-client-web-react'
-import { createSnapshotStore, EMPTY_CHAT_SNAPSHOT } from '@deepseek-ai/dsh-client-runtime/client'
+import {
+  createSnapshotStore, EMPTY_CHAT_SNAPSHOT, EMPTY_CONVERSATION_VIEWS,
+} from '@deepseek-ai/dsh-client-runtime/client'
 import type { ClientContext, ConversationSnapshot, SessionId } from '@deepseek-ai/dsh-client-runtime/client'
 import type { SubmitOutcome } from '@deepseek-ai/dsh-client-ui-slash/client'
 import { makeTranslate } from '@deepseek-ai/dsh-client-test-runtime'
@@ -26,7 +28,7 @@ const SID = 's1' as SessionId
 /** Standard-props InputBar mount over a real shell (the composer-bar entry shape). */
 function mountBar(shell: SessionInputShell, over?: { running?: boolean; disabled?: boolean }) {
   const session = createSnapshotStore<ConversationSnapshot>({
-    sessionId: SID, chat: EMPTY_CHAT_SNAPSHOT,
+    sessionId: SID, views: EMPTY_CONVERSATION_VIEWS, chat: EMPTY_CHAT_SNAPSHOT,
     nodes: [], turnTimings: new Map(), turnEnds: new Map(), partial: null, runningCalls: [],
     pending: [], queue: [], running: over?.running ?? false, composerPhase: 'active',
     removed: over?.disabled ?? false, openState: 'open', openError: null, hasMore: false,