@deepseek-ai/dsh-session-title 0.1.1-rc.1 → 0.1.2-alpha.2

package/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/session/session-title/README.md
-README.md: e923bd9700180214f235c4971d4b020565bfee43
-README.zh.md: 6b1eef269dea65c66c1e9a70ce9469c66d192e84
+README.md: debc737e3f572f15856f7f78a58abe8532ae15dc
+README.zh.md: cf8079cd5566023f3dc1da8480eeec5327eebb5a

package/README.md

@@ -1,38 +1,117 @@
+---
+description: "Log-backed session titles for users and maintainers choosing a title source, configuring the service, or debugging title state."
+kind: "package-reference"
+---
+
 # @deepseek-ai/dsh-session-title
 
 English | [中文](README.zh.md)
 
-Log-backed session titles with an immediate deterministic fallback and one optional asynchronous provider. Every accepted revision is a log-only `session/title` event; `foldSessionTitle()` and `ctx.sessionTitle.get()` select the latest event and return its event seq and timestamp.
+## Summary
+
+`dsh-session-title` gives every session a title clients can display: a deterministic fallback from the first eligible human message, an optional asynchronous provider (such as a model-backed one), or an explicit user rename. Every accepted revision is a log-only `session/title` event, so titles survive replay, resume, and paging exactly like any other session event and never enter the model surface. The service owns scheduling and acceptance; the optional provider owns generation. Automatic work never delays the main agent response, and a newer revision supersedes older work. Configuration and title sources come first; the implementation internals live in a collapsible developer section below.
+
+## Table of Contents
+
+- [Use this package](#use-this-package)
+- [Understand the implementation](#understand-the-implementation)
+- [Further Exploration](#further-exploration)
+- [Model Experience](#model-experience)
+- [Known Limitations and Deferred Work](#known-limitations-and-deferred-work)
+- [Dev Note](#dev-note)
+
+-----
+
+<a id="use-this-package"></a>
+## Use this package
+
+Mount the service to give sessions titles that clients can display and that never reach the model. The common path is explicit: load the session store, mount the service with its required limits, and optionally mount one provider plugin.
+
+### Choosing a title source
+
+Titles come from three sources, newest wins. The built-in fallback derives from the first eligible human message's leading words within the configured caps; a registered provider generates a title over eligible messages; an explicit `rename()` accepts a user-supplied title. Only text blocks from human `user/message` events are eligible, and empty or non-text prompts wait for later eligible input. A user-sourced latest title pins the session — later user messages schedule no automatic revision, and an explicit `refresh()` remains the deliberate unpin.
+
+### Minimal configuration
+
+All limits are required; the library supplies no defaults. Mount the service with the three bounds:
+
+```yaml
+- name: '@deepseek-ai/dsh-session'
+- name: '@deepseek-ai/dsh-session-title'
+  config:
+    fallbackMaxWords: 8
+    fallbackMaxBytes: 96
+    maxTitleBytes: 120
+```
+
+| Field | Default | Meaning |
+|---|---|---|
+| `fallbackMaxWords` | required | Maximum whitespace-delimited words in the deterministic fallback |
+| `fallbackMaxBytes` | required | Maximum UTF-8 bytes in the fallback; must not exceed `maxTitleBytes` |
+| `maxTitleBytes` | required | Maximum UTF-8 bytes accepted from any source |
+
+The generated [configuration catalog](../../../docs/config-catalog.md#deepseek-aidsh-session-title) is the exhaustive source for every accepted field and its JSDoc.
+
+### Adding a provider
+
+One optional asynchronous provider may be registered through `ctx.sessionTitle.register(provider)`; a second registration throws. The shipped model-backed providers are [first-prompt](../session-title-first-prompt-llm/README.md) and [all-prompts](../session-title-all-prompts-llm/README.md), both using the shared [LLM generation policy](../session-title-llm/README.md). A provider starts only after a marked loop-built request's exact route matches the logged `request/header`, and a newer revision supersedes and aborts older work.
+
+### Reading titles
 
-Only text blocks from human `user/message` events are eligible. The first eligible prompt schedules a fallback from its first words within the configured UTF-8 byte limit. Whitespace is normalized, terminal control sequences are removed, and truncation never splits a code point. Empty and non-text prompts wait for later eligible input.
+`get(session)` reads the latest folded title from one live or replayed session, and `foldSessionTitle(events)` is the pure fold over a log. The service requires `ctx.sessionProjections` and registers two units: the client-visible `title` unit (the accepted title string for client list rows) and the host-only `titleInput` unit, which folds the first and latest eligible messages plus their count so scheduling and fallback reads are O(1) through `stateOf()`; the full eligible prefix for one provider generation is scanned from the session log at execution time. An explicit `refresh(session)` materializes the fallback when needed, then explicitly runs the registered provider over the current eligible messages.
 
-## Service: `SessionTitleService` (ctx key: `sessionTitle`)
+### Failures and recovery
 
-- `get(session)` folds the latest accepted title from a live or replayed log.
-- `refresh(session, signal?)` materializes the fallback when needed, then explicitly runs the registered provider over the current eligible messages. Provider errors and caller cancellation reject; cancellation does not roll back an already accepted fallback event.
-- `rename(session, title)` accepts an explicit user title synchronously: it normalizes the text, supersedes in-flight automatic work, and appends a `session/title` event with the `user` source. A user-sourced latest title pins the session — later user messages schedule no automatic revision; an explicit `refresh` remains the deliberate unpin.
-- `register(provider)` installs the sole optional provider and returns its awaitable Cordis effect disposer. A second registration throws immediately; disposal aborts pending and active calls, waits for their settlement, and only then permits another provider to register.
+Automatic failures warn and retain the latest title; explicit `refresh()` rejects on provider error or caller cancellation, and cancellation does not roll back an already accepted fallback event. Automatic work never delays the main agent response, its late completion appends a standalone log-only event without opening a turn, and a stale completion cannot append. Forks inherit title events in their seed unchanged.
 
-Automatic work never delays the main agent response. A provider starts only after a marked loop-built request's exact route matches the current logged `request/header`, including when the unchanged header needs no new snapshot. Its late completion appends a standalone log-only event directly through `Session` without opening a turn. Persistence observes that event eagerly and drains on ordinary lifecycle checkpoints; title publication itself does not force a flush. Automatic failures warn and retain the latest title. New all-message revisions, provider disposal, session disposal, and explicit refresh abort older work, and a stale completion cannot append. Concurrent explicit refreshes reserve their revision before provider work, while overlapping automatic and explicit fallback requests share one session-local in-flight append. The service and bundled model provider each append their own literal event type, so no generic title-write marker, cast, or settlement queue is needed. Service teardown cancels queued work and drains calls that ignore cancellation before unloading completes.
+-----
 
-Forks inherit title events in their seed unchanged. The first-prompt cadence does not automatically retitle a child; the all-messages cadence may append a new revision after the child receives a later human prompt.
+<a id="understand-the-implementation"></a>
+## Understand the implementation
 
-## Configuration
+<details>
+<summary>Implementation internals — click to expand</summary>
 
-All limits are required; the library supplies no defaults.
+This section explains the title design; the observable behavior is fully covered in [Use this package](#use-this-package).
 
-| Key | Contract |
+### Design concept
+
+Titles are durable, log-only state: every accepted revision is a `session/title` event, and `foldSessionTitle()` selects the latest, so a title survives replay, resume, and paging exactly like any other session event. The service owns scheduling, supersession, and acceptance; providers own generation.
+
+### Source map
+
+| File | Role |
 |---|---|
-| `fallbackMaxWords` | Positive maximum whitespace-delimited words in the deterministic fallback. |
-| `fallbackMaxBytes` | Positive maximum UTF-8 bytes in the fallback; must not exceed `maxTitleBytes`. |
-| `maxTitleBytes` | Positive maximum UTF-8 bytes accepted from any source. |
+| [`src/index.ts`](src/index.ts) | Service: config, fold, fallback scheduling, provider registry, concurrency, `title` projection unit |
+| [`src/normalize.ts`](src/normalize.ts) | Title-text cleaning, UTF-8-safe truncation, and the deterministic fallback |
+| [`src/types.ts`](src/types.ts) | One home of the `title` projection-key declaration |
+
+### Lifecycle and concurrency
+
+Per-session work state tracks a revision counter, an in-flight fallback, and pending and active provider work. A newer user message, provider disposal, session disposal, or explicit refresh aborts older work through an `AbortController`; a completion whose provider, revision, session, or signal is stale cannot append. Explicit refreshes reserve their revision before provider work; overlapping automatic and explicit fallback requests share one session-local in-flight append. Service teardown cancels queued work and drains calls that ignore cancellation before unloading completes.
+
+### Normalization
+
+Accepted titles are cleaned of terminal control sequences, directional and invisible controls, and non-whitespace C0/C1 controls; whitespace is normalized, and truncation to the byte caps never splits a Unicode code point. The deterministic fallback takes the first eligible message's leading words within `fallbackMaxWords` and `fallbackMaxBytes`.
+
+</details>
+
+-----
 
-## Provider contract
+<a id="further-exploration"></a>
+## Further Exploration
 
-A provider supplies a branded stable id, automatic mode (`first-prompt` or `all-prompts`), and `generate(request)`. The request carries the live session, all eligible messages through one fixed revision, the current logged main-request route when available, and cancellation. The result identifies a non-empty title, unique ordered source-message seqs from that request, and the optional provider/model route used to generate it. The service normalizes and validates the result before it becomes durable.
+Read these pages when the service contract is not enough. They move from the subsystem reference to the model-backed providers that plug in here.
 
-See the [session-title data structures](../../../docs/subsystems/session-title.md) and [implemented decision](../../../.agents/notes/implemented/feature/2026-07-21-log-backed-session-titles.md).
+- [Session title subsystem](../../../docs/subsystems/session-title.md) — durable title state and the provider vocabulary types.
+- [Shared LLM title policy](../session-title-llm/README.md) — the model-backed generation helper both shipped providers use.
+- [First-message title provider](../session-title-first-prompt-llm/README.md) — titles from the first eligible human message.
+- [All-messages title provider](../session-title-all-prompts-llm/README.md) — titles from every eligible human message.
+- [Session package map](../README.md) — adjacent persistence, projection, title, and telemetry packages.
 
+-----
+
+<a id="model-experience"></a>
 ## Model Experience
 
 ### Session title state
@@ -51,5 +130,20 @@ None for the main request; title events do not change its reconstructed content
 
 ## Known Limitations and Deferred Work
 
-- Title deletion (unpinning back to automatic titles without an explicit `refresh`), search, and list indexing are outside this service.
-- The provider registry deliberately accepts at most one implementation, so a deployment cannot compose competing title strategies without writing one provider that owns their precedence.
+<a id="known-limitations-and-deferred-work"></a>
+
+
+These limits define what the title service does not provide. They are current package constraints.
+
+- **No title deletion, search, or list indexing** — unpinning back to automatic titles without an explicit `refresh`, search, and list indexing are outside this service.
+- **At most one provider** — the registry deliberately accepts a single implementation, so a deployment cannot compose competing title strategies without writing one provider that owns their precedence.
+
+<a id="dev-note"></a>
+### Dev Note
+
+<details>
+<summary>Working context for maintainers — click to expand</summary>
+
+None.
+
+</details>

package/README.zh.md

@@ -1,43 +1,122 @@
+---
+description: "面向用户与维护者的日志会话标题说明，用于选择标题来源、配置服务或排查标题状态。"
+kind: "package-reference"
+---
+
 # @deepseek-ai/dsh-session-title
 
 [English](README.md) | 中文
 
-由日志支持的会话标题，提供即时确定性回退与一个可选异步提供方。每次已接受的修订都是仅写入日志的 `session/title` 事件；`foldSessionTitle()` 与 `ctx.sessionTitle.get()` 会选择最新事件，并返回其事件 seq 和时间戳。
+## 概述
+
+`dsh-session-title` 为每个会话提供客户端可以显示的标题：来自第一条符合条件用户消息的确定性回退、一个可选异步提供方（例如模型支持的提供方），或显式用户重命名。每个已接受的修订都是仅写入日志的 `session/title` 事件，因此标题像任何其他会话事件一样在回放、恢复与分页中存活，且绝不进入模型可见面。服务拥有调度与接受；可选提供方负责生成。自动工作绝不会延迟主 agent 响应，较新的修订会取代旧工作。配置与标题来源在前；实现内部细节放在下方可折叠的开发者章节中。
+
+## 目录
+
+- [使用本包](#use-this-package)
+- [理解实现](#understand-the-implementation)
+- [进一步探索](#further-exploration)
+- [模型体验](#model-experience)
+- [已知限制与延期工作](#known-limitations-and-deferred-work)
+- [开发备注](#dev-note)
+
+-----
+
+<a id="use-this-package"></a>
+## 使用本包
+
+挂载服务，让会话获得客户端可以显示、且绝不触及模型的标题。常用路径是显式的：加载会话存储、以必填上限挂载服务，并可选挂载一个提供方插件。
+
+### 选择标题来源
+
+标题来自三个来源，最新者胜出。内置回退在配置上限内从第一条符合条件用户消息的开头若干词派生；已注册提供方对符合条件的消息生成标题；显式 `rename()` 接受用户提供的标题。只有人类 `user/message` 事件中的文本块符合条件，空提示词或非文本提示词会等待后续符合条件的输入。用户来源的最新标题会钉住会话——后续用户消息不再安排自动修订，显式 `refresh()` 仍是有意的解钉手段。
+
+### 最小配置
+
+所有上限都是必填项；该库不提供默认值。以三个上限挂载服务：
+
+```yaml
+- name: '@deepseek-ai/dsh-session'
+- name: '@deepseek-ai/dsh-session-title'
+  config:
+    fallbackMaxWords: 8
+    fallbackMaxBytes: 96
+    maxTitleBytes: 120
+```
+
+| 字段 | 默认值 | 含义 |
+|---|---|---|
+| `fallbackMaxWords` | 必填 | 确定性回退中以空白分隔的最大词数 |
+| `fallbackMaxBytes` | 必填 | 回退允许的最大 UTF-8 字节数；不得超过 `maxTitleBytes` |
+| `maxTitleBytes` | 必填 | 接受任何来源标题的最大 UTF-8 字节数 |
+
+生成的[配置目录](../../../docs/config-catalog.zh.md#deepseek-aidsh-session-title)是每个受支持字段及其 JSDoc 的穷尽式真源。
+
+### 添加提供方
+
+可选异步提供方可通过 `ctx.sessionTitle.register(provider)` 注册一个；第二次注册会立即抛出。随附的模型支持提供方是[首消息](../session-title-first-prompt-llm/README.zh.md)与[全消息](../session-title-all-prompts-llm/README.zh.md)，两者都使用共享的 [LLM 生成策略](../session-title-llm/README.zh.md)。提供方只有在带标记、由循环构建的请求的确切路由与已记录 `request/header` 匹配时才启动，较新的修订会取代并中止旧工作。
+
+### 读取标题
 
-只有用户 `user/message` 事件中的文本块符合条件。第一条符合条件的提示词会安排回退，从其开头若干词生成标题，并受所配置 UTF-8 字节上限约束。系统会规范化空白、移除终端控制序列，且截断绝不会切断码点。空提示词和非文本提示词会等待后续符合条件的输入。
+`get(session)` 从活跃或回放会话读取折叠出的最新标题，`foldSessionTitle(events)` 是对日志的纯折叠。服务要求 `ctx.sessionProjections` 并注册两个单元：客户端可见的 `title` 单元（供客户端列表行使用的已接受标题字符串）和仅供 host 使用的 `titleInput` 单元——后者折叠第一条与最新一条合格消息及其计数，使调度与回退读取通过 `stateOf()` 达到 O(1)；某次提供方生成所需的完整合格前缀，则会在执行时从会话日志中扫描取得。显式 `refresh(session)` 在需要时物化回退，然后对当前符合条件的消息显式运行已注册提供方。
 
-## 服务：`SessionTitleService`（ctx 键：`sessionTitle`）
+### 失败与恢复
 
-- `get(session)` 从活跃或回放日志折叠最新已接受标题。
-- `refresh(session, signal?)` 在需要时物化回退，然后显式运行已注册提供方，处理当前符合条件的消息。提供方错误或调用方取消都会导致返回的 Promise 被拒绝；取消不会回滚已接受的回退事件。
-- `rename(session, title)` 同步接受用户显式标题：规范化文本、取代在途自动工作，并追加一条 `user` 来源的 `session/title` 事件。用户来源的最新标题会钉住该会话——后续用户消息不再安排自动修订；显式 `refresh` 仍是有意的解钉手段。
-- `register(provider)` 安装唯一可选提供方，并返回可等待的 Cordis effect disposer。第二次注册会立即抛出；对提供方执行 dispose（资源释放）会中止待处理和活跃调用，等待其结算，之后才允许注册另一个提供方。
+自动失败会发出警告并保留最新标题；显式 `refresh()` 在提供方错误或调用方取消时拒绝，取消不会回滚已接受的回退事件。自动工作绝不会延迟主 agent 响应，其延迟完成会追加一个独立纯日志事件而不打开轮次，陈旧的完成结果无法追加。fork 出的会话会原样继承种子中的标题事件。
 
-自动工作绝不会延迟主 agent（智能体）响应。只有当带标记、由循环构建的请求，其确切路由与当前已记录的 `request/header` 匹配时，提供方才会启动；即使请求头未变而无需新快照，也适用此规则。延迟完成会直接通过 `Session` 追加一个独立的纯日志事件，而不打开轮次。持久化会立即观察到该事件，并在常规生命周期检查点完成刷写；标题发布本身不会强制刷写。自动失败会发出警告并保留最新标题。新的全消息修订、提供方 dispose、会话 dispose 和显式刷新都会中止旧工作，陈旧的完成结果无法追加。并发显式刷新会在提供方工作之前预留修订号；重叠的自动／显式回退请求共享一个会话本地正在进行的追加操作。服务与内置模型提供方各自追加自己的字面事件类型，因此不需要通用标题写入标记、类型断言或结算队列。服务拆卸会取消排队工作，并在卸载完成前等待不响应取消的调用结算完成。
+-----
 
-fork 出的会话会原样继承种子中的标题事件。首消息节奏不会自动为子会话重新生成标题；全消息节奏可以在子会话收到后续用户提示词后追加新修订。
+<a id="understand-the-implementation"></a>
+## 理解实现
 
-## 配置
+<details>
+<summary>实现细节——点击展开</summary>
 
-所有上限都是必填项；该库不提供默认值。
+本节解释标题设计；可观察行为已在[使用本包](#use-this-package)中完整说明。
 
-| 键 | 约定 |
+### 设计理念
+
+标题是持久的、仅写入日志的状态：每个已接受的修订都是 `session/title` 事件，`foldSessionTitle()` 选择最新事件，因此标题像任何其他会话事件一样在回放、恢复与分页中存活。服务拥有调度、取代与接受；提供方负责生成。
+
+### 源码地图
+
+| 文件 | 职责 |
 |---|---|
-| `fallbackMaxWords` | 确定性回退中以空白分隔的最大正整数词数。 |
-| `fallbackMaxBytes` | 回退允许的最大正整数 UTF-8 字节数；不得超过 `maxTitleBytes`。 |
-| `maxTitleBytes` | 接受任何来源标题的最大正整数 UTF-8 字节数。 |
+| [`src/index.ts`](src/index.ts) | 服务：配置、折叠、回退调度、提供方注册表、并发、`title` 投影单元 |
+| [`src/normalize.ts`](src/normalize.ts) | 标题文本清洗、UTF-8 安全截断与确定性回退 |
+| [`src/types.ts`](src/types.ts) | `title` 投影键声明的唯一归属 |
+
+### 生命周期与并发
+
+每个会话的工作状态维护一个修订计数器、一个进行中的回退，以及待处理与活跃的提供方工作。较新的用户消息、提供方 dispose（资源释放）、会话 dispose 或显式刷新都会通过 `AbortController` 中止旧工作；提供方、修订、会话或信号已陈旧的完成结果无法追加。显式刷新会在提供方工作之前预留修订号；重叠的自动／显式回退请求共享一个会话本地正在进行的追加操作。服务拆卸会取消排队工作，并在卸载完成前等待不响应取消的调用结算。
+
+### 规范化
+
+已接受标题会清除终端控制序列、方向性与不可见控制符以及非空白的 C0/C1 控制符；空白被规范化，按字节上限截断时绝不切断 Unicode 码点。确定性回退在 `fallbackMaxWords` 与 `fallbackMaxBytes` 内取第一条符合条件消息的开头若干词。
+
+</details>
+
+-----
 
-## 提供方约定
+<a id="further-exploration"></a>
+## 进一步探索
 
-提供方会提供带品牌类型的稳定 id、自动模式（`first-prompt` 或 `all-prompts`）和 `generate(request)`。请求携带活跃会话、截至一次固定修订的所有符合条件消息、可用时当前已记录的主请求路由，以及取消信号。结果包含非空标题、该请求中互不重复且有序的来源消息 seq，以及生成该标题时使用的可选提供方／模型路由。服务会在结果持久保存前进行规范化和验证。
+当服务约定不够用时阅读以下页面。它们从子系统参考逐步进入在此插拔的模型支持提供方。
 
-参见[会话标题数据结构](../../../docs/subsystems/session-title.zh.md)与[已实现决策](../../../.agents/notes/implemented/feature/2026-07-21-log-backed-session-titles.zh.md)。
+- [会话标题子系统](../../../docs/subsystems/session-title.zh.md)——持久标题状态与提供方词汇类型。
+- [共享 LLM 标题策略](../session-title-llm/README.zh.md)——两个随附提供方共用的模型生成辅助模块。
+- [首消息标题提供方](../session-title-first-prompt-llm/README.zh.md)——根据第一条符合条件的用户消息生成标题。
+- [全消息标题提供方](../session-title-all-prompts-llm/README.zh.md)——根据所有符合条件的用户消息生成标题。
+- [会话包映射](../README.zh.md)——相邻的持久化、投影、标题与遥测包。
 
+-----
+
+<a id="model-experience"></a>
 ## 模型体验
 
 ### 会话标题状态
 
-#### 模型看到的内容
+#### 模型看到什么
 
 无。`session/title` 只写入日志，绝不会进入会话接口、`deriveMessages()`、系统提示词、工具 schema 或请求前缀。
 
@@ -47,9 +126,24 @@ fork 出的会话会原样继承种子中的标题事件。首消息节奏不会
 
 #### KV Cache 影响
 
-不影响主请求；标题事件不会改变重建内容或缓存键。
+不影响主请求；标题事件不会改变其重建内容或缓存键。
+
+## 已知限制与延期工作
+
+<a id="known-limitations-and-deferred-work"></a>
+
+
+这些限制说明标题服务不提供什么。它们是当前包约束。
+
+- **没有标题删除、搜索或列表索引**——不经显式 `refresh` 就解钉回自动标题、搜索与列表索引不属于此服务。
+- **至多一个提供方**——注册表有意只接受一个实现，因此部署若要组合相互竞争的标题策略，必须编写一个自行负责优先级的提供方。
+
+<a id="dev-note"></a>
+### 开发备注
+
+<details>
+<summary>维护者的工作上下文——点击展开</summary>
 
-## 已知限制与暂缓事项
+无。
 
-- 删除标题（不经显式 `refresh` 就解钉回自动标题）、搜索和列表索引不属于此服务。
-- 提供方注册表有意最多接受一个实现，因此部署若要组合相互竞争的标题策略，必须编写一个自行负责优先级的提供方。
+</details>

package/lib/index.js

@@ -1,7 +1,8 @@
 import { Service } from "@deepseek-ai/cordis";
 import z from "@deepseek-ai/schemastery";
 import { z as z$1 } from "zod";
-import { assertNever, deepFreeze, isAgentLoopRequest } from "@deepseek-ai/dsh-llm";
+import { isAgentLoopRequest } from "@deepseek-ai/dsh-llm";
+import { assertNever, deepFreeze } from "@deepseek-ai/dsh-util-values";
 //#region lib/types/normalize.js
 /** Title text normalization and UTF-8-safe truncation. */
 /** Operating-system-command escape sequences, including unterminated tails. */
@@ -84,26 +85,100 @@ function SessionTitleProviderId(id) {
 var SessionTitleInvalidError = class extends Error {
 	name = "SessionTitleInvalidError";
 };
+/** Extract one eligible human text message from a session event. */
+function sessionTitleUserMessageOf(event) {
+	if (event.type !== "user/message" || event.data.source.kind !== "user") return void 0;
+	const text = event.data.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+	if (normalizeSessionTitle(text, Number.MAX_SAFE_INTEGER).length === 0) return void 0;
+	return {
+		seq: event.seq,
+		text
+	};
+}
+/** Defensive copy of a logged title source (the snapshot must not alias log-owned objects). */
+function copySessionTitleSource(source) {
+	switch (source.kind) {
+		case "fallback": return { kind: "fallback" };
+		case "provider": return {
+			kind: "provider",
+			provider: source.provider,
+			...source.model === void 0 ? {} : { model: { ...source.model } }
+		};
+		case "user": return { kind: "user" };
+		/* v8 ignore next -- closed-union exhaustiveness guard */
+		default: return assertNever(source, "SessionTitleSource");
+	}
+}
+/** Validate one positive integer configuration field. */
+function assertPositiveInteger(name, value) {
+	if (!Number.isInteger(value) || value <= 0) throw new Error(`session-title: ${name} must be a positive integer`);
+}
+/**
+* Convert title projection state into an immutable snapshot.
+* @param state - the title unit's folded state.
+* @returns the immutable snapshot.
+*/
+function titleSnapshotFromState(state) {
+	return deepFreeze({
+		title: state.title,
+		messageSeqs: [...state.messageSeqs],
+		source: copySessionTitleSource(state.source),
+		eventSeq: state.eventSeq,
+		updatedAt: state.updatedAt
+	});
+}
+const EMPTY_TITLE_INPUT = {
+	first: null,
+	count: 0,
+	lastSeq: null
+};
+const sessionTitleUserMessageSchema = z$1.object({
+	seq: z$1.number().int().nonnegative(),
+	text: z$1.string()
+}).strict();
+const titleInputStateSchema = z$1.object({
+	first: sessionTitleUserMessageSchema.nullable(),
+	count: z$1.number().int().nonnegative(),
+	lastSeq: z$1.number().int().nonnegative().nullable()
+}).strict().superRefine((state, context) => {
+	const empty = state.first === null && state.lastSeq === null && state.count === 0;
+	const populated = state.first !== null && state.lastSeq !== null && state.count > 0 && state.first.seq <= state.lastSeq;
+	if (!empty && !populated) context.addIssue({
+		code: "custom",
+		message: "title input state must pair its count with first and last message seqs"
+	});
+});
 /**
-* Collect human text-bearing user messages in log order.
-* @param events - session log or persisted replay.
-* @param throughSeq - optional inclusive event boundary.
+* Collect eligible human text messages from a session log, in seq order.
+* The full eligible prefix is only materialized for one provider generation,
+* so it is scanned from the log at execution time rather than retained by
+* the O(1) `titleInput` projection.
+* @param events - the session event log.
+* @param throughSeq - optional inclusive upper seq bound.
 * @returns eligible messages with exact source seqs.
 */
 function collectSessionTitleMessages(events, throughSeq) {
 	const messages = [];
 	for (const event of events) {
 		if (throughSeq !== void 0 && event.seq > throughSeq) break;
-		if (event.type !== "user/message" || event.data.source.kind !== "user") continue;
-		const text = event.data.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
-		if (normalizeSessionTitle(text, Number.MAX_SAFE_INTEGER).length === 0) continue;
-		messages.push({
-			seq: event.seq,
-			text
-		});
+		const message = sessionTitleUserMessageOf(event);
+		if (message !== void 0) messages.push(message);
 	}
 	return messages;
 }
+const titleViewSchema = z$1.string().min(1).nullable();
+/** Latest logged title text and its client view. */
+const titleProjectionDefinition = {
+	key: "title",
+	stateVersion: 1,
+	stateSchema: titleViewSchema,
+	init: () => null,
+	apply: (state, event) => event.type === "session/title" ? event.data.title : state,
+	wire: {
+		viewSchema: titleViewSchema,
+		view: (state) => state
+	}
+};
 /**
 * Fold the latest logged title without consulting mutable metadata.
 * @param events - live or persisted session log.
@@ -112,35 +187,17 @@ function collectSessionTitleMessages(events, throughSeq) {
 function foldSessionTitle(events) {
 	const event = events.findLast((item) => item.type === "session/title");
 	if (event === void 0) return void 0;
-	return deepFreeze({
+	return titleSnapshotFromState({
 		title: event.data.title,
-		messageSeqs: [...event.data.messageSeqs],
-		source: copySessionTitleSource(event.data.source),
+		messageSeqs: event.data.messageSeqs,
+		source: event.data.source,
 		eventSeq: event.seq,
 		updatedAt: event.time
 	});
 }
-/** Defensive copy of a logged title source (the snapshot must not alias log-owned objects). */
-function copySessionTitleSource(source) {
-	switch (source.kind) {
-		case "fallback": return { kind: "fallback" };
-		case "provider": return {
-			kind: "provider",
-			provider: source.provider,
-			...source.model === void 0 ? {} : { model: { ...source.model } }
-		};
-		case "user": return { kind: "user" };
-		/* v8 ignore next -- closed-union exhaustiveness guard */
-		default: return assertNever(source, "SessionTitleSource");
-	}
-}
-/** Validate one positive integer configuration field. */
-function assertPositiveInteger(name, value) {
-	if (!Number.isInteger(value) || value <= 0) throw new Error(`session-title: ${name} must be a positive integer`);
-}
 /** Log-backed title fold plus asynchronous fallback generation. */
 var SessionTitleService = class extends Service {
-	static inject = ["sessions"];
+	static inject = ["sessions", "sessionProjections"];
 	static Config = z.object({
 		fallbackMaxWords: z.number().step(1).min(1).required(),
 		fallbackMaxBytes: z.number().step(1).min(1).required(),
@@ -174,19 +231,21 @@ var SessionTitleService = class extends Service {
 			await this.drain(this.inFlight);
 			this.work.clear();
 		}, "sessionTitle lifecycle");
-		ctx.inject(["sessionProjections"], (projectionCtx) => {
-			const titleSchema = z$1.union([z$1.string().min(1), z$1.null()]);
-			projectionCtx.sessionProjections.register({
-				key: "title",
-				stateSchema: titleSchema,
-				init: () => null,
-				apply: (state, event) => event.type === "session/title" ? event.data.title : state,
-				wire: {
-					viewSchema: titleSchema,
-					view: (state) => state
-				},
-				stateVersion: 1
-			});
+		ctx.sessionProjections.register(titleProjectionDefinition);
+		ctx.sessionProjections.register({
+			key: "titleInput",
+			stateVersion: 3,
+			stateSchema: titleInputStateSchema,
+			init: () => EMPTY_TITLE_INPUT,
+			apply: (state, event) => {
+				const message = sessionTitleUserMessageOf(event);
+				if (message === void 0) return state;
+				return {
+					first: state.first ?? message,
+					count: state.count + 1,
+					lastSeq: message.seq
+				};
+			}
 		});
 		ctx.on("session/event", (session, event) => {
 			switch (event.type) {
@@ -261,12 +320,11 @@ var SessionTitleService = class extends Service {
 		this.assertServiceActive();
 		if (this.ctx.sessions.get(session.id) !== session) throw new Error(`session "${session.id}" is not live in this store`);
 		const registration = this.registration;
-		const messages = collectSessionTitleMessages(session.events);
-		const latest = messages.at(-1);
-		if (registration === void 0 || registration.closing || latest === void 0) {
+		const input = this.titleInputOf(session);
+		if (registration === void 0 || registration.closing || input.lastSeq === null) {
 			const current = this.get(session);
-			const [first] = messages;
-			if (current?.source.kind === "user" && first !== void 0) {
+			const first = input.first;
+			if (current?.source.kind === "user" && first !== null) {
 				this.appendFallback(session, first);
 				signal?.throwIfAborted();
 				return this.get(session);
@@ -280,7 +338,7 @@ var SessionTitleService = class extends Service {
 		const work = this.activate({
 			registration,
 			revision,
-			throughSeq: latest.seq
+			throughSeq: input.lastSeq
 		}, state, signal);
 		const config = session.requestHeader()?.config;
 		const route = config === void 0 ? void 0 : {
@@ -319,12 +377,12 @@ var SessionTitleService = class extends Service {
 	/** Schedule fallback creation and any provider cadence for one eligible event. */
 	onUserMessage(session, event) {
 		if (!this.serviceActive()) return;
-		if (event.data.source.kind !== "user" || collectSessionTitleMessages([event]).length === 0) return;
+		if (event.data.source.kind !== "user" || sessionTitleUserMessageOf(event) === void 0) return;
 		if (this.get(session)?.source.kind === "user") return;
 		const registration = this.registration;
 		if (registration !== void 0 && !registration.closing) {
-			const messages = collectSessionTitleMessages(session.events, event.seq);
-			if (registration.provider.automatic === "all-prompts" || session.header.parentSession === void 0 && messages.length === 1 && this.get(session) === void 0) {
+			const count = this.titleInputOf(session).count;
+			if (registration.provider.automatic === "all-prompts" || session.header.parentSession === void 0 && count === 1 && this.get(session) === void 0) {
 				const state = this.stateFor(session);
 				state.pending = {
 					registration,
@@ -361,9 +419,9 @@ var SessionTitleService = class extends Service {
 		const state = session === void 0 ? void 0 : this.work.get(session);
 		const pending = state?.pending;
 		if (session === void 0 || state === void 0 || pending === void 0) return;
-		const boundary = session.events.findLast((event) => event.type === "step/start" || event.type === "step/end");
+		const boundary = this.ctx.sessionProjections.stateOf(session, "turnBoundary")?.lastStepBoundary;
 		const route = session.requestHeader()?.config;
-		if (boundary?.type !== "step/start" || boundary.seq <= pending.throughSeq || route?.provider !== options.provider || route.model !== options.model) return;
+		if (boundary?.kind !== "start" || boundary.seq <= pending.throughSeq || route?.provider !== options.provider || route.model !== options.model) return;
 		this.startPending(session, state, pending, {
 			provider: options.provider,
 			model: options.model
@@ -494,6 +552,9 @@ var SessionTitleService = class extends Service {
 		}
 		return state;
 	}
+	titleInputOf(session) {
+		return this.ctx.sessionProjections.stateOf(session, "titleInput");
+	}
 	/** Queue detached service work and retain it through service disposal. */
 	defer(task) {
 		const run = Promise.resolve().then(async () => {
@@ -554,8 +615,8 @@ var SessionTitleService = class extends Service {
 		this.assertServiceActive();
 		const current = this.get(session);
 		if (current !== void 0) return current;
-		const [first] = collectSessionTitleMessages(session.events);
-		if (first === void 0) return void 0;
+		const first = this.titleInputOf(session).first;
+		if (first === null) return void 0;
 		const title = fallbackSessionTitle(first.text, this.config.fallbackMaxWords, this.config.fallbackMaxBytes);
 		if (title.length === 0) return void 0;
 		const state = this.stateFor(session);
@@ -581,4 +642,4 @@ var SessionTitleService = class extends Service {
 	}
 };
 //#endregion
-export { SessionTitleInvalidError, SessionTitleProviderId, SessionTitleService, SessionTitleService as default, collectSessionTitleMessages, fallbackSessionTitle, foldSessionTitle, normalizeSessionTitle, truncateTitleUtf8 };
+export { SessionTitleInvalidError, SessionTitleProviderId, SessionTitleService, SessionTitleService as default, fallbackSessionTitle, foldSessionTitle, normalizeSessionTitle, titleProjectionDefinition, truncateTitleUtf8 };

package/lib/types/index.d.ts

@@ -4,10 +4,11 @@
  */
 import { Context, Service } from '@deepseek-ai/cordis';
 import z from '@deepseek-ai/schemastery';
+import { z as zod } from 'zod';
 import type { Branded } from '@deepseek-ai/dsh-brand';
 import type { Session, SessionEvent } from '@deepseek-ai/dsh-session';
-export type * from './types.ts';
-export { fallbackSessionTitle, normalizeSessionTitle, truncateTitleUtf8 } from './normalize.ts';
+export type { SessionTitleEventData, SessionTitleModelProvenance, SessionTitleSnapshot, SessionTitleSource, SessionTitleUserMessage, TitleProjection, } from './types.ts';
+import type { SessionTitleEventData, SessionTitleModelProvenance, SessionTitleSnapshot, SessionTitleUserMessage } from './types.ts';
 /** Identifies one session-title provider registration. */
 export type SessionTitleProviderId = Branded<'SessionTitleProviderId'>;
 /**
@@ -16,40 +17,7 @@ export type SessionTitleProviderId = Branded<'SessionTitleProviderId'>;
  * @returns the same string with the session-title provider brand.
  */
 export declare function SessionTitleProviderId(id: string): SessionTitleProviderId;
-/** Exact auxiliary model route that produced a title. */
-export interface SessionTitleModelProvenance {
-    /** Registered LLM provider route. */
-    readonly provider: string;
-    /** Provider model id. */
-    readonly model: string;
-}
-/** Durable ownership record for an accepted session title. */
-export type SessionTitleSource = {
-    readonly kind: 'fallback';
-} | {
-    readonly kind: 'provider';
-    readonly provider: SessionTitleProviderId;
-    readonly model?: SessionTitleModelProvenance;
-} | {
-    /** Explicit user rename: pins the title — automatic generation stops scheduling. */
-    readonly kind: 'user';
-};
-/** Payload of the log-only `session/title` event. */
-export interface SessionTitleEventData {
-    /** Normalized non-empty title text. */
-    readonly title: string;
-    /** Exact human `user/message` seqs used to derive this title; empty for an explicit user rename. */
-    readonly messageSeqs: number[];
-    /** Whether the built-in fallback, a registered provider, or the user supplied the title. */
-    readonly source: SessionTitleSource;
-}
-/** Latest folded title plus the title event's durable envelope facts. */
-export interface SessionTitleSnapshot extends SessionTitleEventData {
-    /** Seq of the latest `session/title` event. */
-    readonly eventSeq: number;
-    /** Timestamp of the latest `session/title` event. */
-    readonly updatedAt: number;
-}
+export { fallbackSessionTitle, normalizeSessionTitle, truncateTitleUtf8 } from './normalize.ts';
 /** Required deterministic fallback and accepted-title limits. */
 export interface Config {
     /** Maximum whitespace-delimited words in the built-in fallback. */
@@ -82,13 +50,6 @@ declare module '@deepseek-ai/dsh-session/types' {
 export declare class SessionTitleInvalidError extends Error {
     readonly name = "SessionTitleInvalidError";
 }
-/** One eligible human text message exposed to title providers. */
-export interface SessionTitleUserMessage {
-    /** Source `user/message` event seq. */
-    readonly seq: number;
-    /** Exact concatenated text-block content. */
-    readonly text: string;
-}
 /** Automatic generation cadence owned by a registered provider. */
 export type SessionTitleAutomaticMode = 'first-prompt' | 'all-prompts';
 /** Immutable input supplied to one title-provider call. */
@@ -124,13 +85,18 @@ export interface SessionTitleProvider {
      */
     generate(request: SessionTitleProviderRequest): Promise<SessionTitleProviderResult>;
 }
-/**
- * Collect human text-bearing user messages in log order.
- * @param events - session log or persisted replay.
- * @param throughSeq - optional inclusive event boundary.
- * @returns eligible messages with exact source seqs.
- */
-export declare function collectSessionTitleMessages(events: readonly SessionEvent[], throughSeq?: number): SessionTitleUserMessage[];
+/** Latest logged title text and its client view. */
+export declare const titleProjectionDefinition: {
+    key: "title";
+    stateVersion: number;
+    stateSchema: zod.ZodType<string | null, unknown, zod.core.$ZodTypeInternals<string | null, unknown>>;
+    init: () => null;
+    apply: (state: string | null, event: SessionEvent) => string | null;
+    wire: {
+        viewSchema: zod.ZodType<string | null, unknown, zod.core.$ZodTypeInternals<string | null, unknown>>;
+        view: (state: string | null) => string | null;
+    };
+};
 /**
  * Fold the latest logged title without consulting mutable metadata.
  * @param events - live or persisted session log.
@@ -203,6 +169,7 @@ export declare class SessionTitleService extends Service {
     private supersede;
     /** Return mutable work state for one session. */
     private stateFor;
+    private titleInputOf;
     /** Queue detached service work and retain it through service disposal. */
     private defer;
     /** Retain one promise until settlement for service and optional provider teardown. */

package/lib/types/index.js

@@ -5,9 +5,9 @@
 import { Service } from '@deepseek-ai/cordis';
 import z from '@deepseek-ai/schemastery';
 import { z as zod } from 'zod';
-import { assertNever, deepFreeze, isAgentLoopRequest } from '@deepseek-ai/dsh-llm';
+import { isAgentLoopRequest } from '@deepseek-ai/dsh-llm';
+import { assertNever, deepFreeze } from '@deepseek-ai/dsh-util-values';
 import { fallbackSessionTitle, normalizeSessionTitle } from "./normalize.js";
-export { fallbackSessionTitle, normalizeSessionTitle, truncateTitleUtf8 } from "./normalize.js";
 /**
  * Brand a raw provider id.
  * @param id - stable non-empty provider identifier supplied by a plugin.
@@ -16,6 +16,7 @@ export { fallbackSessionTitle, normalizeSessionTitle, truncateTitleUtf8 } from "
 export function SessionTitleProviderId(id) {
     return id;
 }
+export { fallbackSessionTitle, normalizeSessionTitle, truncateTitleUtf8 } from "./normalize.js";
 /**
  * Rejection of an explicit user title whose text normalizes to empty — the
  * one {@link SessionTitleService.rename} failure that blames the input.
@@ -25,30 +26,110 @@ export function SessionTitleProviderId(id) {
 export class SessionTitleInvalidError extends Error {
     name = 'SessionTitleInvalidError';
 }
+/** Extract one eligible human text message from a session event. */
+function sessionTitleUserMessageOf(event) {
+    if (event.type !== 'user/message' || event.data.source.kind !== 'user')
+        return undefined;
+    const content = event.data.content;
+    const text = content
+        .filter((block) => block.type === 'text')
+        .map(block => block.text)
+        .join('\n');
+    if (normalizeSessionTitle(text, Number.MAX_SAFE_INTEGER).length === 0)
+        return undefined;
+    return { seq: event.seq, text };
+}
+/** Defensive copy of a logged title source (the snapshot must not alias log-owned objects). */
+function copySessionTitleSource(source) {
+    switch (source.kind) {
+        case 'fallback': return { kind: 'fallback' };
+        case 'provider': return {
+            kind: 'provider',
+            provider: source.provider,
+            ...(source.model === undefined ? {} : { model: { ...source.model } }),
+        };
+        case 'user': return { kind: 'user' };
+        /* v8 ignore next -- closed-union exhaustiveness guard */
+        default: return assertNever(source, 'SessionTitleSource');
+    }
+}
+/** Validate one positive integer configuration field. */
+function assertPositiveInteger(name, value) {
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new Error(`session-title: ${name} must be a positive integer`);
+    }
+}
 /**
- * Collect human text-bearing user messages in log order.
- * @param events - session log or persisted replay.
- * @param throughSeq - optional inclusive event boundary.
+ * Convert title projection state into an immutable snapshot.
+ * @param state - the title unit's folded state.
+ * @returns the immutable snapshot.
+ */
+function titleSnapshotFromState(state) {
+    return deepFreeze({
+        title: state.title,
+        messageSeqs: [...state.messageSeqs],
+        source: copySessionTitleSource(state.source),
+        eventSeq: state.eventSeq,
+        updatedAt: state.updatedAt,
+    });
+}
+const EMPTY_TITLE_INPUT = { first: null, count: 0, lastSeq: null };
+const sessionTitleUserMessageSchema = zod.object({
+    seq: zod.number().int().nonnegative(),
+    text: zod.string(),
+}).strict();
+const titleInputStateSchema = zod.object({
+    first: sessionTitleUserMessageSchema.nullable(),
+    count: zod.number().int().nonnegative(),
+    lastSeq: zod.number().int().nonnegative().nullable(),
+}).strict().superRefine((state, context) => {
+    const empty = state.first === null && state.lastSeq === null && state.count === 0;
+    const populated = state.first !== null
+        && state.lastSeq !== null
+        && state.count > 0
+        && state.first.seq <= state.lastSeq;
+    if (!empty && !populated) {
+        context.addIssue({
+            code: 'custom',
+            message: 'title input state must pair its count with first and last message seqs',
+        });
+    }
+});
+/**
+ * Collect eligible human text messages from a session log, in seq order.
+ * The full eligible prefix is only materialized for one provider generation,
+ * so it is scanned from the log at execution time rather than retained by
+ * the O(1) `titleInput` projection.
+ * @param events - the session event log.
+ * @param throughSeq - optional inclusive upper seq bound.
  * @returns eligible messages with exact source seqs.
  */
-export function collectSessionTitleMessages(events, throughSeq) {
+function collectSessionTitleMessages(events, throughSeq) {
     const messages = [];
     for (const event of events) {
         if (throughSeq !== undefined && event.seq > throughSeq)
             break;
-        if (event.type !== 'user/message' || event.data.source.kind !== 'user')
-            continue;
-        const content = event.data.content;
-        const text = content
-            .filter((block) => block.type === 'text')
-            .map(block => block.text)
-            .join('\n');
-        if (normalizeSessionTitle(text, Number.MAX_SAFE_INTEGER).length === 0)
-            continue;
-        messages.push({ seq: event.seq, text });
+        const message = sessionTitleUserMessageOf(event);
+        if (message !== undefined)
+            messages.push(message);
     }
     return messages;
 }
+const titleViewSchema = zod.string().min(1).nullable();
+/** Latest logged title text and its client view. */
+export const titleProjectionDefinition = {
+    key: 'title',
+    stateVersion: 1,
+    stateSchema: titleViewSchema,
+    init: () => null,
+    apply: (state, event) => (event.type === 'session/title'
+        ? event.data.title
+        : state),
+    wire: {
+        viewSchema: titleViewSchema,
+        view: state => state,
+    },
+};
 /**
  * Fold the latest logged title without consulting mutable metadata.
  * @param events - live or persisted session log.
@@ -58,37 +139,17 @@ export function foldSessionTitle(events) {
     const event = events.findLast(item => item.type === 'session/title');
     if (event === undefined)
         return undefined;
-    return deepFreeze({
+    return titleSnapshotFromState({
         title: event.data.title,
-        messageSeqs: [...event.data.messageSeqs],
-        source: copySessionTitleSource(event.data.source),
+        messageSeqs: event.data.messageSeqs,
+        source: event.data.source,
         eventSeq: event.seq,
         updatedAt: event.time,
     });
 }
-/** Defensive copy of a logged title source (the snapshot must not alias log-owned objects). */
-function copySessionTitleSource(source) {
-    switch (source.kind) {
-        case 'fallback': return { kind: 'fallback' };
-        case 'provider': return {
-            kind: 'provider',
-            provider: source.provider,
-            ...(source.model === undefined ? {} : { model: { ...source.model } }),
-        };
-        case 'user': return { kind: 'user' };
-        /* v8 ignore next -- closed-union exhaustiveness guard */
-        default: return assertNever(source, 'SessionTitleSource');
-    }
-}
-/** Validate one positive integer configuration field. */
-function assertPositiveInteger(name, value) {
-    if (!Number.isInteger(value) || value <= 0) {
-        throw new Error(`session-title: ${name} must be a positive integer`);
-    }
-}
 /** Log-backed title fold plus asynchronous fallback generation. */
 export class SessionTitleService extends Service {
-    static inject = ['sessions'];
+    static inject = ['sessions', 'sessionProjections'];
     static Config = z.object({
         fallbackMaxWords: z.number().step(1).min(1).required(),
         fallbackMaxBytes: z.number().step(1).min(1).required(),
@@ -127,20 +188,22 @@ export class SessionTitleService extends Service {
             await this.drain(this.inFlight);
             this.work.clear();
         }, 'sessionTitle lifecycle');
-        // The title projection unit: pure last-wins fold of session/title events
-        // (the same events foldSessionTitle consumes), serving the plain title
-        // string clients list rows read. The unit child activates only when a
-        // projection registry is composed (headless assemblies stay unaffected).
-        ctx.inject(['sessionProjections'], (projectionCtx) => {
-            const titleSchema = zod.union([zod.string().min(1), zod.null()]);
-            projectionCtx.sessionProjections.register({
-                key: 'title',
-                stateSchema: titleSchema,
-                init: () => null,
-                apply: (state, event) => (event.type === 'session/title' ? event.data.title : state),
-                wire: { viewSchema: titleSchema, view: state => state },
-                stateVersion: 1,
-            });
+        ctx.sessionProjections.register(titleProjectionDefinition);
+        ctx.sessionProjections.register({
+            key: 'titleInput',
+            stateVersion: 3,
+            stateSchema: titleInputStateSchema,
+            init: () => EMPTY_TITLE_INPUT,
+            apply: (state, event) => {
+                const message = sessionTitleUserMessageOf(event);
+                if (message === undefined)
+                    return state;
+                return {
+                    first: state.first ?? message,
+                    count: state.count + 1,
+                    lastSeq: message.seq,
+                };
+            },
         });
         ctx.on('session/event', (session, event) => {
             switch (event.type) {
@@ -221,15 +284,14 @@ export class SessionTitleService extends Service {
             throw new Error(`session "${session.id}" is not live in this store`);
         }
         const registration = this.registration;
-        const messages = collectSessionTitleMessages(session.events);
-        const latest = messages.at(-1);
-        if (registration === undefined || registration.closing || latest === undefined) {
+        const input = this.titleInputOf(session);
+        if (registration === undefined || registration.closing || input.lastSeq === null) {
             // Explicit refresh is the unpin even without a provider: a standing
             // user title must not short-circuit ensureFallback into a no-op, so
             // re-derive and append the fallback over it when one is derivable.
             const current = this.get(session);
-            const [first] = messages;
-            if (current?.source.kind === 'user' && first !== undefined) {
+            const first = input.first;
+            if (current?.source.kind === 'user' && first !== null) {
                 this.appendFallback(session, first);
                 signal?.throwIfAborted();
                 return this.get(session);
@@ -243,7 +305,7 @@ export class SessionTitleService extends Service {
         const work = this.activate({
             registration,
             revision,
-            throughSeq: latest.seq,
+            throughSeq: input.lastSeq,
         }, state, signal);
         const config = session.requestHeader()?.config;
         const route = config === undefined ? undefined : { provider: config.provider, model: config.model };
@@ -287,16 +349,16 @@ export class SessionTitleService extends Service {
     onUserMessage(session, event) {
         if (!this.serviceActive())
             return;
-        if (event.data.source.kind !== 'user' || collectSessionTitleMessages([event]).length === 0)
+        if (event.data.source.kind !== 'user' || sessionTitleUserMessageOf(event) === undefined)
             return;
         // A user rename pins the title: no automatic revision may override it.
         if (this.get(session)?.source.kind === 'user')
             return;
         const registration = this.registration;
         if (registration !== undefined && !registration.closing) {
-            const messages = collectSessionTitleMessages(session.events, event.seq);
+            const count = this.titleInputOf(session).count;
             const shouldSchedule = registration.provider.automatic === 'all-prompts'
-                || (session.header.parentSession === undefined && messages.length === 1 && this.get(session) === undefined);
+                || (session.header.parentSession === undefined && count === 1 && this.get(session) === undefined);
             if (shouldSchedule) {
                 const state = this.stateFor(session);
                 const revision = this.supersede(state, 'newer user message superseded title generation');
@@ -337,9 +399,9 @@ export class SessionTitleService extends Service {
         const pending = state?.pending;
         if (session === undefined || state === undefined || pending === undefined)
             return;
-        const boundary = session.events.findLast(event => event.type === 'step/start' || event.type === 'step/end');
+        const boundary = this.ctx.sessionProjections.stateOf(session, 'turnBoundary')?.lastStepBoundary;
         const route = session.requestHeader()?.config;
-        if (boundary?.type !== 'step/start'
+        if (boundary?.kind !== 'start'
             || boundary.seq <= pending.throughSeq
             || route?.provider !== options.provider
             || route.model !== options.model)
@@ -490,6 +552,9 @@ export class SessionTitleService extends Service {
         }
         return state;
     }
+    titleInputOf(session) {
+        return this.ctx.sessionProjections.stateOf(session, 'titleInput');
+    }
     /** Queue detached service work and retain it through service disposal. */
     defer(task) {
         const run = Promise.resolve().then(async () => {
@@ -565,8 +630,8 @@ export class SessionTitleService extends Service {
         const current = this.get(session);
         if (current !== undefined)
             return current;
-        const [first] = collectSessionTitleMessages(session.events);
-        if (first === undefined)
+        const first = this.titleInputOf(session).first;
+        if (first === null)
             return undefined;
         const title = fallbackSessionTitle(first.text, this.config.fallbackMaxWords, this.config.fallbackMaxBytes);
         if (title.length === 0)

package/lib/types/types.d.ts

@@ -2,15 +2,73 @@
  * Pure types of the title domain: the ONE home of the `title` projection-key
  * declaration, free of this package's host-side value imports (cordis
  * service, schemastery, the llm seam). Two namespace projections serve it —
- * `./types` for host consumers, `./client/types` (the browser half-entry's
- * re-export) for client aggregates — with zero content duplication.
+ * `./types` for host consumers and `./client/types` for client aggregates —
+ * with zero content duplication.
  *
  * @module @deepseek-ai/dsh-session-title/types
  */
 export {};
+import type { Branded } from '@deepseek-ai/dsh-brand';
+/** Identifies one session-title provider registration. */
+export type SessionTitleProviderId = Branded<'SessionTitleProviderId'>;
+/** Exact auxiliary model route that produced a title. */
+export interface SessionTitleModelProvenance {
+    /** Registered LLM provider route. */
+    readonly provider: string;
+    /** Provider model id. */
+    readonly model: string;
+}
+/** Durable ownership record for an accepted session title. */
+export type SessionTitleSource = {
+    readonly kind: 'fallback';
+} | {
+    readonly kind: 'provider';
+    readonly provider: SessionTitleProviderId;
+    readonly model?: SessionTitleModelProvenance;
+} | {
+    /** Explicit user rename: pins the title — automatic generation stops scheduling. */
+    readonly kind: 'user';
+};
+/** Payload of the log-only `session/title` event. */
+export interface SessionTitleEventData {
+    /** Normalized non-empty title text. */
+    readonly title: string;
+    /** Exact human `user/message` seqs used to derive this title; empty for an explicit user rename. */
+    readonly messageSeqs: number[];
+    /** Whether the built-in fallback, a registered provider, or the user supplied the title. */
+    readonly source: SessionTitleSource;
+}
+/** Latest folded title plus the title event's durable envelope facts. */
+export interface SessionTitleSnapshot extends SessionTitleEventData {
+    /** Seq of the latest `session/title` event. */
+    readonly eventSeq: number;
+    /** Timestamp of the latest `session/title` event. */
+    readonly updatedAt: number;
+}
+/** Host title projection value. */
+export type TitleProjection = SessionTitleSnapshot;
+/** One eligible human text message exposed to title providers. */
+export interface SessionTitleUserMessage {
+    /** Source `user/message` event seq. */
+    readonly seq: number;
+    /** Exact concatenated text-block content. */
+    readonly text: string;
+}
+/** Eligible title input stored as a bounded aggregate. */
+export interface TitleInputState {
+    /** The oldest eligible message, or null before any. */
+    readonly first: SessionTitleUserMessage | null;
+    /** Total eligible messages folded so far. */
+    readonly count: number;
+    /** Seq of the newest eligible message, or null before any. */
+    readonly lastSeq: number | null;
+}
 declare module '@deepseek-ai/dsh-session-projection/types' {
     interface SessionProjectionStateMap {
+        /** Latest logged title text, or null. */
         title: string | null;
+        /** Eligible human title input. */
+        titleInput: TitleInputState;
     }
     interface SessionProjectionMap {
         /**

package/lib/types/types.js

@@ -2,8 +2,8 @@
  * Pure types of the title domain: the ONE home of the `title` projection-key
  * declaration, free of this package's host-side value imports (cordis
  * service, schemastery, the llm seam). Two namespace projections serve it —
- * `./types` for host consumers, `./client/types` (the browser half-entry's
- * re-export) for client aggregates — with zero content duplication.
+ * `./types` for host consumers and `./client/types` for client aggregates —
+ * with zero content duplication.
  *
  * @module @deepseek-ai/dsh-session-title/types
  */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-session-title",
   "description": "Log-backed session title service and provider registry for the DeepSeek Harness",
-  "version": "0.1.1-rc.1",
+  "version": "0.1.2-alpha.2",
   "publishConfig": {
     "access": "public"
   },
@@ -41,25 +41,29 @@
   ],
   "license": "MIT",
   "peerDependencies": {
-    "@deepseek-ai/dsh-invariants": "^0.1.1-rc.1",
-    "@deepseek-ai/dsh-llm": "^0.1.1-rc.1",
-    "@deepseek-ai/dsh-brand": "^0.1.1-rc.1",
-    "@deepseek-ai/dsh-session": "^0.1.1-rc.1",
-    "@deepseek-ai/dsh-session-projection": "^0.1.1-rc.1",
-    "@deepseek-ai/cordis": "^4.0.1"
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-agent": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-brand": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-invariants": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-llm": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-session": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-session-projection": "^0.1.2-alpha.2"
   },
   "dependencies": {
     "zod": "^4.4.3",
-    "@deepseek-ai/schemastery": "^3.18.1"
+    "@deepseek-ai/dsh-util-values": "^0.1.2-alpha.2",
+    "@deepseek-ai/schemastery": "^3.18.2"
   },
   "devDependencies": {
-    "@deepseek-ai/dsh-brand": "^0.1.1-rc.1",
-    "@deepseek-ai/dsh-invariants": "^0.1.1-rc.1",
-    "@deepseek-ai/dsh-llm": "^0.1.1-rc.1",
-    "@deepseek-ai/dsh-session": "^0.1.1-rc.1",
-    "@deepseek-ai/dsh-session-persistence-sqlite": "^0.1.1-rc.1",
-    "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-session-persistence-jsonl": "^0.1.1-rc.1",
-    "@deepseek-ai/dsh-session-projection": "^0.1.1-rc.1"
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-agent": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-agent-loop": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-brand": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-session-persistence-jsonl": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-invariants": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-session": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-llm": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-session-projection": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-session-persistence-sqlite": "^0.1.2-alpha.2"
   }
 }