@deepseek-ai/dsh-time-context 0.0.1-rc.1 → 0.0.1-rc.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/context/time-context/README.md
-README.md: 9956918c63b49de8ec5e739bc3d9887e269930a8
-README.zh.md: 3a9bb1012fc0639d9c3f6b104cea5a64d4b187d6
+README.md: 0bdb0d463362427d6a7050c2d7d6d55f96779f9c
+README.zh.md: 92eb0b3f43162279ac7e0f728e685863d75a28b6

package/README.md

@@ -2,7 +2,7 @@
 
 English | [中文](README.zh.md)
 
-Opt-in durable context with the current zoned time and elapsed time sampled during model-request preparation. `dsh-agent-spine-demo` and shipped examples do not mount it. Decision record: [the durable time-context Agent Note](../../../.agents/notes/implemented/feature/2026-07-16-durable-per-step-time-context.md).
+Opt-in durable context with the current zoned time, the browser zone attached to the open request, and elapsed time sampled during model-request preparation. Default compositions leave it disabled; the Schedule Web overlay mounts it so the model can interpret otherwise-unqualified dates and times in the user's browser zone. Decision record: [the durable time-context Agent Note](../../../.agents/notes/implemented/feature/2026-07-16-durable-per-step-time-context.md).
 
 ## Config
 
@@ -10,27 +10,31 @@ Opt-in durable context with the current zoned time and elapsed time sampled duri
 - id: time-context
   name: '@deepseek-ai/dsh-time-context'
   config:
-    timeZone: Asia/Shanghai  # optional IANA override; omit for the process zone
+    timeZone: Asia/Shanghai  # optional fallback when the request has no unique browser zone
     refreshIntervalMs: 60000 # optional; omit or set to 0 for every eligible attempt
 ```
 
-When `timeZone` is omitted, the plugin resolves the Node process's system zone once at plugin load. Node honors `TZ`; without that override, the host or container supplies the zone. An explicit `timeZone` must be an IANA identifier and is validated at plugin load.
+When the open turn contains one Host-validated browser zone, that request-local zone formats the timestamp. With missing or mixed browser provenance, `timeZone` supplies the display fallback; omitting it resolves the Node process zone once at plugin load. Node honors `TZ`, and every explicit fallback is validated through `Intl.DateTimeFormat`.
 
-`refreshIntervalMs` must be a non-negative safe integer. Omission or `0` adds context to every eligible entering pre-step whose signal is not already aborted. A positive value adds it only when the session has no earlier time-context injection, wall time moved backward, or at least that many milliseconds have elapsed since the latest injection.
+`refreshIntervalMs` must be a non-negative safe integer. Omission or `0` adds context to every eligible entering pre-step whose signal is not already aborted. A positive value adds it only when the Session has no earlier time-context injection, wall time moved backward, or at least that many milliseconds elapsed since the latest injection.
 
-## Timing semantics
+## Request-zone ownership
+
+The browser samples `Intl.DateTimeFormat().resolvedOptions().timeZone` for each prompt. The Host validates and canonicalizes that value before binding it to the exact durable `user-rpc` message source. Time-context examines only those sources in the open turn: one unique zone resolves the request, multiple zones are `mixed`, and none are `unavailable`. It does not read or mutate Session headers, connection state, or Schedule records.
 
-The plugin prepends an `agent/pre-step` listener. When an injection is due and the downstream decision enters the proposed step, it adds one sourced `UserMessage` to the returned batch. AgentLoop records that context after `step/start` and before ordinary automatic compaction with source `{ kind: 'plugin', plugin: 'time-context' }`. A suppressed, rejected, or failed pre-step records nothing.
+The resolved instruction tells the model to interpret otherwise-unqualified dates and times in that browser zone. Mixed or unavailable provenance tells the model to ask the user to clarify. This is natural-language context, not an input default at another package boundary: a tool that accepts local calendar fields still owns its explicit zone requirement.
+
+## Timing semantics
 
-Positive-interval scheduling scans the raw durable session events for the latest `user/message` with that source, including a reading shadowed by compaction. The schedule therefore applies across turns and resumed processes without process-local cache state. It reduces append frequency and history growth but never removes an existing reading, and sessions schedule independently.
+The plugin prepends an `agent/pre-step` listener and delegates first. When an injection is due and the downstream decision enters, it appends one sourced `UserMessage` to the returned batch. AgentLoop records the final batch after `step/start` and before request derivation. Rejection, listener failure, or an already-aborted signal records nothing.
 
-Step 1 measures from the latest preceding model-visible message, including the prompt that opened the turn. Later steps measure from the preceding time-context event in the same turn. Both baselines use durable session-event timestamps; backward wall-clock movement clamps elapsed time to zero. A missing first-step baseline, or a later step with no earlier same-turn reading because interval suppression skipped it, reports `unavailable`.
+Each reading uses the exact snapshot source `{ kind: 'plugin', plugin: 'time-context', form: 'snapshot', sections: [{ name: 'time-context', text: <same text> }] }`. The `./invariant` companion validates that shape, re-derives the current-turn browser policy from the original `user-rpc` messages, and checks the timestamp zone and elapsed baseline.
 
-A time reading records an entered pre-step batch, not a completed step or transmitted request. A later request-preparation failure can therefore leave the reading in history, but a downstream pre-step listener that rejects or fails prevents it from being recorded.
+Positive-interval scheduling scans raw durable Session events for the latest plugin-attributed message, including a reading shadowed by compaction. It therefore survives resume without a process-local cache. A positive interval can intentionally let a later request reuse existing history without a fresh reading; the Schedule Web overlay omits the interval.
 
-The separately published `./invariant` companion checks each plugin-attributed reading against the open turn, next pre-step position, elapsed baseline, and durable event time. Its rendered timestamp must parse and cannot postdate the event; process suspension between sampling and append does not invalidate the reading.
+Step 1 measures from the latest preceding durable user, assistant, or tool-result message. The prompt proposed for that step has not been appended yet. Later steps measure from the preceding time-context event in the same turn. Missing baselines report `unavailable`, and backward wall-clock movement clamps elapsed time to zero.
 
-The time reading stays in derived conversation history until a later compaction shadows it. Request headers contain no time-context state. Request reconstruction uses the complete durable surface prefix after each `step/start`, so transmitted requests need not map one-to-one to readings: request preparation can fail after step entry, while interval suppression can let a request reuse existing history without adding one.
+A reading records an entered step, not a completed or transmitted request. A later preparation failure can leave it in history. The message remains in derived conversation history until compaction shadows it; `request/header` contains no time-context state, and request reconstruction uses the complete durable surface prefix after each `step/start`.
 
 ## Model Experience
 
@@ -38,12 +42,13 @@ The time reading stays in derived conversation history until a later compaction
 
 #### What the model sees
 
-On each preparation attempt that injects, one source-tagged context message containing the two lines below. `<timestamp>` is an ISO-shaped local timestamp with numeric offset and IANA zone; durations use compact whole-second units. Positive intervals can leave an attempted step without a new reading.
+Each injected message contains three lines. `<timestamp>` is an ISO-shaped timestamp with numeric offset and IANA zone; durations use compact whole-second units.
 
 ##### First step
 
 ```markdown
 Time sampled while preparing turn <turn>, step 1: <timestamp>
+Browser time zone for this request: <iana-zone-or-mixed-or-unavailable-policy>.
 Elapsed since the preceding model-visible message: <duration-or-unavailable>.
 ```
 
@@ -51,12 +56,13 @@ Elapsed since the preceding model-visible message: <duration-or-unavailable>.
 
 ```markdown
 Time sampled while preparing turn <turn>, step <step>: <timestamp>
+Browser time zone for this request: <iana-zone-or-mixed-or-unavailable-policy>.
 Elapsed since the preceding step context: <duration-or-unavailable>.
 ```
 
 #### Token effect
 
-Each injected two-line message accumulates until compaction shadows it. A positive interval reduces additions; omission or `0` adds one for every eligible preparation attempt.
+Each reading accumulates until compaction shadows it. A positive interval reduces additions; omission or `0` adds one at every eligible preparation attempt.
 
 #### KV Cache effect
 
@@ -64,7 +70,8 @@ Append-only; newly visible content follows the reusable request prefix and does
 
 ## Known Limitations and Deferred Work
 
+- **Prompt provenance only** — browser-zone context guides natural-language interpretation but does not silently supply another tool's required zone field.
+- **Mixed turns ask** — if one open turn contains prompts from different browser zones, the model is told to clarify rather than guess which one owns an unqualified time.
+- **Fallback is not user authority** — the configured or process zone formats the clock when browser provenance is missing or mixed, but the model-facing policy still says to clarify.
 - **Whole-second display** — timestamps and durations omit sub-second precision even though durable event times retain milliseconds.
-- **Session-event baseline** — elapsed time starts from durable append timestamps, not a client transport's original send timestamp.
-- **Process-local default zone** — omission uses the Node process's `TZ`, host, or container zone captured at plugin load, not a remote user's zone; configure an explicit IANA zone when those differ.
-- **History cost between compactions** — omission or `0` retains one reading for every eligible preparation attempt, including attempts later cancelled or failed; a positive interval reduces but does not eliminate this cost.
+- **History cost between compactions** — omission or `0` retains one reading for every eligible attempt; a positive interval reduces but does not eliminate this cost and may leave a later request without fresh browser-zone guidance.

package/README.zh.md

@@ -2,7 +2,7 @@
 
 [English](README.md) | 中文
 
-可选的持久上下文，包含模型请求准备期间采样的带时区的当前时间与经过时长。`dsh-agent-spine-demo` 与随附示例不挂载该插件。决策记录：[持久 time-context Agent Note](../../../.agents/notes/implemented/feature/2026-07-16-durable-per-step-time-context.md)。
+可选的持久上下文，包含当前带时区时间、附加到当前开放请求的浏览器时区，以及在模型请求准备期间采样的经过时长。默认组合不启用它；Schedule Web overlay 会挂载它，使模型可以按用户的浏览器时区解释未明确限定时区的日期和时间。决策记录：[持久 time-context Agent Note](../../../.agents/notes/implemented/feature/2026-07-16-durable-per-step-time-context.md)。
 
 ## 配置
 
@@ -10,27 +10,31 @@
 - id: time-context
   name: '@deepseek-ai/dsh-time-context'
   config:
-    timeZone: Asia/Shanghai  # optional IANA override; omit for the process zone
+    timeZone: Asia/Shanghai  # optional fallback when the request has no unique browser zone
     refreshIntervalMs: 60000 # optional; omit or set to 0 for every eligible attempt
 ```
 
-省略 `timeZone` 时，插件会在加载时解析一次 Node 进程的系统时区。Node 遵循 `TZ`；如果没有该覆盖，时区由宿主或容器提供。显式 `timeZone` 必须是 IANA 标识符，并在插件加载时验证。
+当当前开放轮次只包含一个经 Host 校验的浏览器时区时，使用该请求本地时区格式化时间戳。浏览器来源信息缺失或混杂时，`timeZone` 提供显示回退；省略它则会在插件加载时解析一次 Node 进程时区。Node 遵循 `TZ`，每个显式回退值都经 `Intl.DateTimeFormat` 校验。
 
-`refreshIntervalMs` 必须是非负安全整数。省略或设为 `0` 时，会为每次信号尚未中止且会进入步骤的合格步骤前处理添加上下文。正数值只会在会话没有早先 time-context 注入、挂钟时间倒退，或自最新注入起已经过至少相应毫秒数时添加上下文。
+`refreshIntervalMs` 必须是非负安全整数。省略或设为 `0` 时，会为每个信号尚未中止且将进入步骤的合格 pre-step 添加上下文。正数值只会在会话没有更早的 time-context 注入、挂钟时间倒退，或自最新注入起已经过至少相应毫秒数时添加上下文。
 
-## 时序语义
+## 请求时区归属
+
+浏览器会为每条提示词采样 `Intl.DateTimeFormat().resolvedOptions().timeZone`。Host 校验并规范化该值，再将其绑定到确切的持久 `user-rpc` 消息来源。Time-context 只检查当前开放轮次中的这些来源：唯一一个时区可解析请求，多个时区记为 `mixed`，没有时区则记为 `unavailable`。它不会读取或修改会话标头、连接状态或 Schedule 记录。
 
-该插件会前置一个 `agent/pre-step` 监听器。需要注入且下游决策进入拟议步骤时，它会在返回批次中添加一条带来源的 `UserMessage`。AgentLoop 会在 `step/start` 之后、普通自动压缩（compaction）之前记录该上下文，其来源为 `{ kind: 'plugin', plugin: 'time-context' }`。被抑制、拒绝或失败的步骤前处理不会记录任何内容。
+解析后的指令告诉模型，把未明确限定时区的日期和时间解释为该浏览器时区。来源信息为 mixed 或 unavailable 时，模型会收到要求用户澄清的指令。这是自然语言上下文，并非另一个包边界上的输入默认值：接受本地日历字段的工具仍自行负责其显式时区要求。
+
+## 时序语义
 
-正间隔调度会扫描原始持久会话事件，查找最新的上述源 `user/message`，包括已被压缩遮蔽的时间读数。因此，调度可以跨轮次以及进程恢复持续生效，不需要进程本地缓存状态。它会降低追加频率与历史增长，但绝不移除现有时间读数，且每个会话独立调度。
+该插件会前置一个 `agent/pre-step` 监听器，并先行委托下游。需要注入且下游决策进入步骤时，它会向返回批次追加一条带来源的 `UserMessage`。AgentLoop 在 `step/start` 之后、请求派生之前记录最终批次。决策被拒绝、监听器失败或信号已经中止时，不会记录任何内容。
 
-第 1 步从前一条模型可见消息起测量，包括开启轮次的提示词。后续步骤从同一轮次中前一个 time-context 事件起测量。两种基线都使用持久会话事件时间戳；挂钟时间倒退时，经过时长限制为零。如果第一步缺少基线，或者后续步骤因间隔抑制而没有较早的同轮次时间读数，则报告 `unavailable`。
+每个读数都使用确切的快照来源 `{ kind: 'plugin', plugin: 'time-context', form: 'snapshot', sections: [{ name: 'time-context', text: <same text> }] }`。`./invariant` 配套模块会校验该形状，根据原始 `user-rpc` 消息重新派生当前轮次的浏览器策略，并检查时间戳时区与经过时长基线。
 
-时间读数记录的是一个已进入步骤的步骤前批次，不是已完成步骤或已传输请求。后续请求准备失败时，该读数可能已留在历史中；但下游步骤前监听器拒绝或失败时，该读数不会被记录。
+正数间隔调度会扫描原始持久会话事件，查找最新一条归因于插件的消息，其中包括已被压缩（compaction）遮蔽的读数。因此，它无需进程本地缓存也能在恢复后继续生效。正数间隔可以有意让后续请求复用现有历史，而不添加新读数；Schedule Web overlay 会省略该间隔。
 
-单独发布的 `./invariant` 配套模块会根据当前未结束的轮次、下一个步骤前位置、经过时长基线与持久事件时间检查每个归因于插件的时间读数。其渲染时间戳必须可解析，且不能晚于该事件；采样与追加之间的进程挂起不会使时间读数失效。
+第 1 步从最新一条在其之前持久化的用户、助手或工具结果消息起测量。为该步骤拟议的提示词尚未追加。后续步骤从同一轮次中前一个 time-context 事件起测量。缺少基线时报告 `unavailable`，挂钟时间倒退时将经过时长限制为零。
 
-时间读数会保留在派生会话历史中，直到后续压缩遮蔽它。请求标头不含 time-context 状态。请求重建会在每个 `step/start` 之后使用完整持久表层前缀，因此已传输请求无需与时间读数一一对应：请求准备可能在进入步骤后失败，而间隔抑制可让请求复用现有历史，无需添加时间读数。
+读数记录的是已进入的步骤，不是已完成或已传输的请求。后续准备失败时，该读数可能留在历史中。消息会保留在派生会话历史中，直到压缩将其遮蔽；`request/header` 不含 time-context 状态，请求重建会使用每个 `step/start` 之后的完整持久表层前缀。
 
 ## 模型体验
 
@@ -38,12 +42,13 @@
 
 #### 模型看到的内容
 
-每次执行注入的准备尝试都会生成一条带源标记的上下文消息，包含下方两行。`<timestamp>` 是带数字偏移与 IANA 时区、形如 ISO 的本地时间戳；持续时间使用紧凑的整秒单位。正间隔可能使某次步骤尝试没有新时间读数。
+每条注入消息包含三行。`<timestamp>` 是带数字偏移和 IANA 时区、形如 ISO 的时间戳；持续时间使用紧凑的整秒单位。
 
 ##### 第一步
 
 ```markdown
 Time sampled while preparing turn <turn>, step 1: <timestamp>
+Browser time zone for this request: <iana-zone-or-mixed-or-unavailable-policy>.
 Elapsed since the preceding model-visible message: <duration-or-unavailable>.
 ```
 
@@ -51,12 +56,13 @@ Elapsed since the preceding model-visible message: <duration-or-unavailable>.
 
 ```markdown
 Time sampled while preparing turn <turn>, step <step>: <timestamp>
+Browser time zone for this request: <iana-zone-or-mixed-or-unavailable-policy>.
 Elapsed since the preceding step context: <duration-or-unavailable>.
 ```
 
 #### Token 影响
 
-每条注入的两行消息都会累积，直到压缩遮蔽它。正间隔会减少添加；省略或设为 `0` 则会为每次合格准备尝试添加一条。
+每个读数都会累积，直到压缩将其遮蔽。正数间隔会减少新增读数；省略或设为 `0` 时，每次合格的准备尝试都会添加一条。
 
 #### KV Cache 影响
 
@@ -64,7 +70,8 @@ Elapsed since the preceding step context: <duration-or-unavailable>.
 
 ## 已知限制与暂缓事项
 
+- **仅限提示词来源信息**：浏览器时区上下文用于指导自然语言解释，但不会悄然填入另一工具所要求的时区字段。
+- **混合轮次会询问**：如果同一个开放轮次包含来自不同浏览器时区的提示词，模型会收到要求澄清的指令，而不会猜测哪个时区拥有未限定的时间。
+- **回退值不代表用户权威**：浏览器来源信息缺失或混杂时，配置或进程时区用于格式化时钟，但面向模型的策略仍要求澄清。
 - **整秒显示**：时间戳与持续时间省略亚秒精度，尽管持久事件时间保留毫秒。
-- **会话事件基线**：经过时长从持久追加时间戳起计算，而非客户端传输的原始发送时间戳。
-- **进程本地默认时区**：省略设置时，使用插件加载时捕获的 Node 进程 `TZ`、宿主或容器时区，而非远程用户的时区；两者不同时，请配置显式 IANA 时区。
-- **压缩之间的历史成本**：省略设置或设为 `0` 会为每次合格准备尝试保留一条时间读数，包括后续取消或失败的尝试；正间隔可以降低但无法消除该成本。
+- **压缩之间的历史成本**：省略或设为 `0` 时，每次合格尝试都会保留一条读数；正数间隔可以降低但无法消除该成本，也可能使后续请求缺少新鲜的浏览器时区指导。

package/lib/index.js

@@ -158,6 +158,114 @@ z.union([normalPolicySchema, alwaysPolicySchema]);
 */
 const { version } = createRequire(import.meta.url)("../package.json");
 //#endregion
+//#region ../../llm/llm/src/never.ts
+/**
+* Exhaustiveness helper for closed core unions. Use {@link assertNever} at the default branch so a
+* new variant fails compilation at every required handler. Do not use it for declaration-merged
+* unions such as session events or content blocks: handle known variants and explicitly fall
+* through because plugins may add valid unknown cases.
+* @module @deepseek-ai/dsh-llm/never
+*/
+/**
+* Mark an unreachable closed-union branch. A newly unhandled typed variant fails at the call site;
+* a value that escaped its type throws with diagnostics at runtime.
+* @param value - the impossible value; typed `never` so an unhandled variant fails compilation at the call site.
+* @param context - optional label (e.g. the switch site) prefixed into the throw message.
+* @returns never — it always throws, with the offending value JSON-rendered in the message.
+*/
+function assertNever(value, context) {
+	const rendered = JSON.stringify(value) ?? String(value);
+	throw new Error(`unreachable variant${context ? ` in ${context}` : ""}: ${rendered}`);
+}
+//#endregion
+//#region lib/types/request-zone.js
+/** Browser-zone derivation and model-facing policy text for one open request turn. */
+const IANA_TIME_ZONE = /^[A-Za-z][A-Za-z0-9_+.-]*(?:\/[A-Za-z0-9_+.-]+)+$/;
+/** Read and validate a Host-canonicalized browser zone from one ordinary user-rpc message. */
+function browserTimeZone(message) {
+	const source = message.source;
+	const value = source.kind === "user" && "rpcId" in source && typeof source.rpcId === "string" && "clientTimeZone" in source && typeof source.clientTimeZone === "string" ? source.clientTimeZone : void 0;
+	if (value === void 0) return void 0;
+	if (value !== "UTC" && !IANA_TIME_ZONE.test(value)) throw new TypeError(`browser time zone must be canonical UTC or IANA Area/Location: ${JSON.stringify(value)}`);
+	let canonical;
+	try {
+		canonical = new Intl.DateTimeFormat("en-US", { timeZone: value }).resolvedOptions().timeZone;
+	} catch (error) {
+		throw new TypeError(`browser time zone is unsupported: ${JSON.stringify(value)}`, { cause: error });
+	}
+	if (canonical !== value) throw new TypeError(`browser time zone must be canonical: ${JSON.stringify(value)}`);
+	return value;
+}
+/**
+* Derive the unique, mixed, or missing browser zone for one open turn.
+* @param messages - Entered and proposed user messages belonging to the turn.
+* @returns Sorted, duplicate-free browser-zone facts.
+* @throws TypeError when a user-rpc source carries an invalid or noncanonical zone.
+*/
+function deriveBrowserTimeZoneContext(messages) {
+	const timeZones = [...new Set(messages.flatMap((message) => {
+		const timeZone = browserTimeZone(message);
+		return timeZone === void 0 ? [] : [timeZone];
+	}))].sort();
+	const [timeZone, ...remaining] = timeZones;
+	if (timeZone === void 0) return { kind: "missing" };
+	if (remaining.length === 0) return {
+		kind: "resolved",
+		timeZone
+	};
+	return {
+		kind: "mixed",
+		timeZones
+	};
+}
+/**
+* Render the model instruction for one browser-zone context.
+* @param context - Browser-zone facts for the open turn.
+* @returns One durable policy line.
+*/
+function renderBrowserTimeZoneContext(context) {
+	switch (context.kind) {
+		case "resolved": return `Browser time zone for this request: ${context.timeZone}. Interpret otherwise-unqualified dates and times in this zone.`;
+		case "mixed": return `Browser time zone for this request: mixed ${JSON.stringify(context.timeZones)}. Ask the user to clarify otherwise-unqualified dates and times.`;
+		case "missing": return "Browser time zone for this request: unavailable. Ask the user to clarify otherwise-unqualified dates and times.";
+		/* v8 ignore next 2 -- the closed BrowserTimeZoneContext union is exhausted above. */
+		default: return assertNever(context, "BrowserTimeZoneContext");
+	}
+}
+//#endregion
+//#region lib/types/timestamp.js
+/** ISO-shaped time-context timestamp formatting shared by production and replay validation. */
+/**
+* Create the exact formatter used by durable time-context readings.
+* @param timeZone - Explicit display zone, or `undefined` for the process fallback.
+* @returns A formatter with stable numeric local fields and long numeric offset.
+*/
+function createTimestampFormatter(timeZone) {
+	return new Intl.DateTimeFormat("en-US", {
+		...timeZone === void 0 ? {} : { timeZone },
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit",
+		hourCycle: "h23",
+		timeZoneName: "longOffset"
+	});
+}
+/**
+* Format an epoch millisecond value as an ISO-shaped timestamp with offset and IANA zone.
+* @param now - Epoch milliseconds to display.
+* @param formatter - Formatter created for `timeZone`.
+* @param timeZone - Canonical zone label carried in brackets.
+* @returns The durable timestamp text.
+*/
+function formatTimestamp(now, formatter, timeZone) {
+	const parts = Object.fromEntries(formatter.formatToParts(now).map((part) => [part.type, part.value]));
+	const offset = parts.timeZoneName.replace(/^GMT$/, "GMT+00:00").slice(3);
+	return `${parts["year"]}-${parts["month"]}-${parts["day"]}T${parts["hour"]}:${parts["minute"]}:${parts["second"]}${offset}[${timeZone}]`;
+}
+//#endregion
 //#region lib/types/index.js
 /**
 * Opt-in request clock context. Eligible steps add durable,
@@ -174,12 +282,6 @@ const Config = z.object({
 	timeZone: z.string(),
 	refreshIntervalMs: z.number()
 });
-/** Format an epoch millisecond value as an ISO-shaped timestamp with offset and IANA zone. */
-function formatTimestamp(now, formatter, timeZone) {
-	const parts = Object.fromEntries(formatter.formatToParts(now).map((part) => [part.type, part.value]));
-	const offset = parts.timeZoneName.replace(/^GMT$/, "GMT+00:00").slice(3);
-	return `${parts["year"]}-${parts["month"]}-${parts["day"]}T${parts["hour"]}:${parts["minute"]}:${parts["second"]}${offset}[${timeZone}]`;
-}
 /** Format a non-negative elapsed millisecond count as compact whole-second units. */
 function formatDuration(elapsedMs) {
 	let seconds = Math.floor(Math.max(0, elapsedMs) / 1e3);
@@ -216,10 +318,16 @@ function precedingStepContextTime(agent, turn) {
 function latestInjectionTime(agent) {
 	for (const event of [...agent.session.events].reverse()) if (event.type === "user/message" && event.data.source.kind === "plugin" && event.data.source.plugin === "time-context") return event.time;
 }
-function renderText(now, turn, step, previous, formatter, timeZone) {
+/** Collect already-entered and proposed user messages belonging to one open turn. */
+function requestMessages(agent, turn, proposed) {
+	const start = agent.session.events.findLastIndex((event) => event.type === "turn/start" && event.data.turn === turn);
+	return [...start < 0 ? [] : agent.session.events.slice(start + 1).flatMap((event) => event.type === "user/message" ? [event.data] : []), ...proposed];
+}
+function renderText(now, turn, step, previous, formatter, timeZone, browserContext) {
 	const elapsed = previous === void 0 ? "unavailable" : formatDuration(now - previous);
 	const baseline = step === 1 ? "model-visible message" : "step context";
-	return `Time sampled while preparing turn ${turn}, step ${step}: ${formatTimestamp(now, formatter, timeZone)}\nElapsed since the preceding ${baseline}: ${elapsed}.`;
+	const browserText = renderBrowserTimeZoneContext(browserContext);
+	return `Time sampled while preparing turn ${turn}, step ${step}: ${formatTimestamp(now, formatter, timeZone)}\n${browserText}\nElapsed since the preceding ${baseline}: ${elapsed}.`;
 }
 /** Reject refresh intervals that cannot represent an exact elapsed-millisecond threshold. */
 function validateRefreshInterval(refreshIntervalMs) {
@@ -235,24 +343,23 @@ function apply(ctx, config) {
 	const timeZone = config.timeZone;
 	const refreshIntervalMs = config.refreshIntervalMs;
 	validateRefreshInterval(refreshIntervalMs);
-	let formatter;
+	let fallbackFormatter;
 	try {
-		formatter = new Intl.DateTimeFormat("en-US", {
-			...timeZone === void 0 ? {} : { timeZone },
-			year: "numeric",
-			month: "2-digit",
-			day: "2-digit",
-			hour: "2-digit",
-			minute: "2-digit",
-			second: "2-digit",
-			hourCycle: "h23",
-			timeZoneName: "longOffset"
-		});
+		fallbackFormatter = createTimestampFormatter(timeZone);
 	} catch (error) {
 		const message = timeZone === void 0 ? "time-context: failed to resolve the system time zone" : `time-context: invalid IANA timeZone ${JSON.stringify(timeZone)}`;
 		throw new Error(message, { cause: error });
 	}
-	const resolvedTimeZone = formatter.resolvedOptions().timeZone;
+	const fallbackTimeZone = fallbackFormatter.resolvedOptions().timeZone;
+	const formatters = new Map([[fallbackTimeZone, fallbackFormatter]]);
+	/** Resolve and cache one request-local timestamp formatter. */
+	const formatterFor = (selectedTimeZone) => {
+		const existing = formatters.get(selectedTimeZone);
+		if (existing !== void 0) return existing;
+		const created = createTimestampFormatter(selectedTimeZone);
+		formatters.set(selectedTimeZone, created);
+		return created;
+	};
 	ctx.on("agent/pre-step", async ({ agent, turn, step, signal }, next) => {
 		const decision = await next();
 		if (decision.kind === "reject" || signal.aborted) return decision;
@@ -261,7 +368,10 @@ function apply(ctx, config) {
 			const lastInjection = latestInjectionTime(agent);
 			if (lastInjection !== void 0 && now >= lastInjection && now - lastInjection < refreshIntervalMs) return decision;
 		}
-		const text = renderText(now, turn, step, step === 1 ? precedingMessageTime(agent) : precedingStepContextTime(agent, turn), formatter, resolvedTimeZone);
+		const previous = step === 1 ? precedingMessageTime(agent) : precedingStepContextTime(agent, turn);
+		const browser = deriveBrowserTimeZoneContext(requestMessages(agent, turn, decision.messages));
+		const selectedTimeZone = browser.kind === "resolved" ? browser.timeZone : fallbackTimeZone;
+		const text = renderText(now, turn, step, previous, formatterFor(selectedTimeZone), selectedTimeZone, browser);
 		return {
 			kind: "enter",
 			messages: [...decision.messages, createUserMessage({

package/lib/invariant.js

@@ -1,51 +1,271 @@
+import { createRequire } from "node:module";
+import "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+//#region ../../util/timeout/src/index.ts
+/** Largest delay Node schedules without clamping it to one millisecond. */
+const MAX_TIMER_DELAY_MS = 2147483647;
+//#endregion
+//#region ../../llm/llm/src/error.ts
+/**
+* Canonical provider-neutral code for a response that completed normally but
+* carried no content blocks at all. Providers occasionally emit a degenerate
+* completion (a terminal stop with zero output); adapters classify it as this
+* failure instead of yielding an empty assistant message, because an empty
+* message silently ends the turn with nothing for the user or the loop to act
+* on. The attempt produced nothing durable, so retry policy treats it as safe
+* to repeat.
+*/
+const EMPTY_RESPONSE_CODE = "EMPTY_RESPONSE";
+new RegExp(String.raw`(?:^|[^a-z0-9])context[\s_-](?:length|window)[\s_-]` + String.raw`(?:exceed(?:ed|s)?|overflow(?:ed)?|limit[\s_-]exceeded)(?:$|[^a-z0-9])`, "i");
+new RegExp(String.raw`\b(?:request|prompt|input|messages?)\s+(?:is\s+|are\s+)?` + String.raw`too\s+(?:large|long)\s+for\s+(?:(?:this|the)\s+)?` + String.raw`(?:model(?:'s)?\s+)?context(?:\s+window)?\b`, "i");
+new RegExp(String.raw`\b(?:input|prompt|request|messages?)\b.{0,40}` + String.raw`\b(?:exceed(?:s|ed)?|overflows?|is\s+larger\s+than)\b.{0,40}` + String.raw`\b(?:the\s+)?(?:model(?:'s)?\s+)?context(?:\s+(?:length|window))?\b`, "i");
+//#endregion
+//#region ../../llm/llm/src/retry-policy.ts
+/**
+* Provider-owned request-retry policy configuration and resolution.
+*
+* Adapters expose one resolved policy per registered provider route; the
+* optional dsh-llm-retry plugin executes it on the agent's failed-step extension point.
+*
+* @module @deepseek-ai/dsh-llm/retry-policy
+*/
+const DEFAULT_MAX_RETRIES = 2;
+const DEFAULT_INITIAL_DELAY_MS = 500;
+const DEFAULT_MAX_DELAY_MS = 1e4;
+const DEFAULT_JITTER_RATIO = .1;
+const DEFAULT_RETRYABLE_CODES = Object.freeze([
+	EMPTY_RESPONSE_CODE,
+	"RATE_LIMIT",
+	"SERVER",
+	"TIMEOUT",
+	"TRANSPORT"
+]);
+const backoffSchema = z.object({
+	initialDelayMs: z.number().max(MAX_TIMER_DELAY_MS).default(DEFAULT_INITIAL_DELAY_MS),
+	maxDelayMs: z.number().max(MAX_TIMER_DELAY_MS).default(DEFAULT_MAX_DELAY_MS),
+	jitterRatio: z.number().min(0).max(1).default(DEFAULT_JITTER_RATIO)
+});
+const normalPolicySchema = z.object({
+	mode: z.const("normal").required(),
+	maxRetries: z.number().step(1).min(0).max(Number.MAX_SAFE_INTEGER).default(DEFAULT_MAX_RETRIES),
+	retryableCodes: z.array(z.string()).default([...DEFAULT_RETRYABLE_CODES]),
+	backoff: backoffSchema
+});
+const alwaysPolicySchema = z.object({
+	mode: z.const("always").required(),
+	backoff: backoffSchema
+});
+z.union([normalPolicySchema, alwaysPolicySchema]);
+//#endregion
+//#region ../../llm/llm/src/attribution.ts
+/**
+* Centralize the non-secret product identity every provider request sends as `User-Agent`, keeping
+* adapters from drifting. See
+* `.agents/notes/implemented/architecture/2026-06-21-mandatory-app-attribution-headers.md`.
+*
+* App-attribution vocabulary for provider requests.
+* @module @deepseek-ai/dsh-llm/attribution
+*/
+const { version } = createRequire(import.meta.url)("../package.json");
+//#endregion
+//#region ../../llm/llm/src/never.ts
+/**
+* Exhaustiveness helper for closed core unions. Use {@link assertNever} at the default branch so a
+* new variant fails compilation at every required handler. Do not use it for declaration-merged
+* unions such as session events or content blocks: handle known variants and explicitly fall
+* through because plugins may add valid unknown cases.
+* @module @deepseek-ai/dsh-llm/never
+*/
+/**
+* Mark an unreachable closed-union branch. A newly unhandled typed variant fails at the call site;
+* a value that escaped its type throws with diagnostics at runtime.
+* @param value - the impossible value; typed `never` so an unhandled variant fails compilation at the call site.
+* @param context - optional label (e.g. the switch site) prefixed into the throw message.
+* @returns never — it always throws, with the offending value JSON-rendered in the message.
+*/
+function assertNever(value, context) {
+	const rendered = JSON.stringify(value) ?? String(value);
+	throw new Error(`unreachable variant${context ? ` in ${context}` : ""}: ${rendered}`);
+}
+//#endregion
+//#region lib/types/request-zone.js
+/** Browser-zone derivation and model-facing policy text for one open request turn. */
+const IANA_TIME_ZONE = /^[A-Za-z][A-Za-z0-9_+.-]*(?:\/[A-Za-z0-9_+.-]+)+$/;
+/** Read and validate a Host-canonicalized browser zone from one ordinary user-rpc message. */
+function browserTimeZone(message) {
+	const source = message.source;
+	const value = source.kind === "user" && "rpcId" in source && typeof source.rpcId === "string" && "clientTimeZone" in source && typeof source.clientTimeZone === "string" ? source.clientTimeZone : void 0;
+	if (value === void 0) return void 0;
+	if (value !== "UTC" && !IANA_TIME_ZONE.test(value)) throw new TypeError(`browser time zone must be canonical UTC or IANA Area/Location: ${JSON.stringify(value)}`);
+	let canonical;
+	try {
+		canonical = new Intl.DateTimeFormat("en-US", { timeZone: value }).resolvedOptions().timeZone;
+	} catch (error) {
+		throw new TypeError(`browser time zone is unsupported: ${JSON.stringify(value)}`, { cause: error });
+	}
+	if (canonical !== value) throw new TypeError(`browser time zone must be canonical: ${JSON.stringify(value)}`);
+	return value;
+}
+/**
+* Derive the unique, mixed, or missing browser zone for one open turn.
+* @param messages - Entered and proposed user messages belonging to the turn.
+* @returns Sorted, duplicate-free browser-zone facts.
+* @throws TypeError when a user-rpc source carries an invalid or noncanonical zone.
+*/
+function deriveBrowserTimeZoneContext(messages) {
+	const timeZones = [...new Set(messages.flatMap((message) => {
+		const timeZone = browserTimeZone(message);
+		return timeZone === void 0 ? [] : [timeZone];
+	}))].sort();
+	const [timeZone, ...remaining] = timeZones;
+	if (timeZone === void 0) return { kind: "missing" };
+	if (remaining.length === 0) return {
+		kind: "resolved",
+		timeZone
+	};
+	return {
+		kind: "mixed",
+		timeZones
+	};
+}
+/**
+* Render the model instruction for one browser-zone context.
+* @param context - Browser-zone facts for the open turn.
+* @returns One durable policy line.
+*/
+function renderBrowserTimeZoneContext(context) {
+	switch (context.kind) {
+		case "resolved": return `Browser time zone for this request: ${context.timeZone}. Interpret otherwise-unqualified dates and times in this zone.`;
+		case "mixed": return `Browser time zone for this request: mixed ${JSON.stringify(context.timeZones)}. Ask the user to clarify otherwise-unqualified dates and times.`;
+		case "missing": return "Browser time zone for this request: unavailable. Ask the user to clarify otherwise-unqualified dates and times.";
+		/* v8 ignore next 2 -- the closed BrowserTimeZoneContext union is exhausted above. */
+		default: return assertNever(context, "BrowserTimeZoneContext");
+	}
+}
+//#endregion
+//#region lib/types/timestamp.js
+/** ISO-shaped time-context timestamp formatting shared by production and replay validation. */
+/**
+* Create the exact formatter used by durable time-context readings.
+* @param timeZone - Explicit display zone, or `undefined` for the process fallback.
+* @returns A formatter with stable numeric local fields and long numeric offset.
+*/
+function createTimestampFormatter(timeZone) {
+	return new Intl.DateTimeFormat("en-US", {
+		...timeZone === void 0 ? {} : { timeZone },
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit",
+		hourCycle: "h23",
+		timeZoneName: "longOffset"
+	});
+}
+/**
+* Format an epoch millisecond value as an ISO-shaped timestamp with offset and IANA zone.
+* @param now - Epoch milliseconds to display.
+* @param formatter - Formatter created for `timeZone`.
+* @param timeZone - Canonical zone label carried in brackets.
+* @returns The durable timestamp text.
+*/
+function formatTimestamp(now, formatter, timeZone) {
+	const parts = Object.fromEntries(formatter.formatToParts(now).map((part) => [part.type, part.value]));
+	const offset = parts.timeZoneName.replace(/^GMT$/, "GMT+00:00").slice(3);
+	return `${parts["year"]}-${parts["month"]}-${parts["day"]}T${parts["hour"]}:${parts["minute"]}:${parts["second"]}${offset}[${timeZone}]`;
+}
+//#endregion
 //#region lib/types/invariant.js
 /** Package-owned durable clock-context invariants. @module @deepseek-ai/dsh-time-context/invariant */
 const PACKAGE_NAME = "@deepseek-ai/dsh-time-context";
 const SOURCE_NAME = "time-context";
-const READING = /* @__PURE__ */ new RegExp("^Time sampled while preparing turn (\\d+), step (\\d+): (\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:Z|[+-]\\d{2}:\\d{2})\\[[^\\]]+\\])\\nElapsed since the preceding (model-visible message|step context): (?:unavailable|(?:(?:\\d+d )?(?:\\d+h )?(?:\\d+m )?\\d+s))\\.$");
+const READING = /* @__PURE__ */ new RegExp("^Time sampled while preparing turn (\\d+), step (\\d+): (\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:Z|[+-]\\d{2}:\\d{2})\\[[^\\]]+\\])\\n(Browser time zone for this request: .+)\\nElapsed since the preceding (model-visible message|step context): (?:unavailable|(?:(?:\\d+d )?(?:\\d+h )?(?:\\d+m )?\\d+s))\\.$");
 /** Cordis companion plugin name. */
 const name = "time-context-invariant";
 /** Service required before the companion can reserve package ownership. */
 const inject = ["invariants"];
-/** Derive the entered step boundary at which a time-context reading may append. */
+/** Derive the open step boundary at which a time-context reading may append. */
 function preparationPosition(history, fail) {
-	for (const event of history.slice().reverse()) switch (event.type) {
-		case "step/start": return {
-			turn: event.data.turn,
-			step: event.data.step
-		};
+	let openTurn;
+	let openStep;
+	let requestStarted = false;
+	for (const event of history) switch (event.type) {
 		case "turn/start":
+			openTurn = event.data.turn;
+			openStep = void 0;
+			requestStarted = false;
+			break;
+		case "step/start":
+			openStep = event.data.step;
+			requestStarted = false;
+			break;
+		case "request/header":
+			requestStarted = true;
+			break;
 		case "step/end":
+			openStep = void 0;
+			requestStarted = false;
+			break;
 		case "turn/end":
-		case "request/header":
-		case "assistant/chunk":
-		case "assistant/message":
-		case "tool/call":
-		case "tool/result":
-			fail("time-context reading must be appended during prompt assembly");
+			openTurn = void 0;
+			openStep = void 0;
+			requestStarted = false;
 			break;
 		default: break;
 	}
-	fail("time-context reading must be appended during prompt assembly");
+	if (openTurn === void 0) fail("time-context reading must be appended inside an open turn");
+	if (openStep === void 0) fail("time-context reading must follow step/start");
+	if (requestStarted) fail("time-context reading must precede request/header");
+	return {
+		turn: openTurn,
+		step: openStep
+	};
+}
+/** Collect the entered user messages belonging to one open turn. */
+function requestMessages(history, turn) {
+	const start = history.findLastIndex((event) => event.type === "turn/start" && event.data.turn === turn);
+	return history.slice(start + 1).flatMap((event) => event.type === "user/message" ? [event.data] : []);
 }
 /** Validate one plugin-attributed time reading against its session position and timestamp. */
 function validateReading(history, event, fail) {
-	const [block] = event.data.content;
-	if (event.data.content.length !== 1 || block?.type !== "text") fail("time-context messages must contain exactly one text block");
-	const match = READING.exec(block.text);
+	const blockValue = event.data.content[0];
+	const block = typeof blockValue === "object" && blockValue !== null ? blockValue : void 0;
+	const blockText = block?.text;
+	if (event.data.content.length !== 1 || block === void 0 || Object.keys(block).length !== 2 || block.type !== "text" || typeof blockText !== "string") fail("time-context messages must contain exactly one text block");
+	const match = READING.exec(blockText);
 	if (match === null) fail("time-context message does not match the durable reading format");
 	const turn = Number(match[1]);
 	const step = Number(match[2]);
 	if (!Number.isSafeInteger(turn) || turn < 1 || !Number.isSafeInteger(step) || step < 1) fail("time-context turn and step must be positive safe integers");
 	const expected = preparationPosition(history, fail);
 	if (turn !== expected.turn || step !== expected.step) fail(`time-context reading names turn ${turn}/step ${step}, expected turn ${expected.turn}/step ${expected.step}`);
-	const baseline = match[4];
+	const source = event.data.source;
+	/* v8 ignore next 2 -- replay and dispatch callers select this exact package-owned source before validation. */
+	if (source.kind !== "plugin" || source.plugin !== SOURCE_NAME) fail("time-context source must retain package ownership");
+	const sections = "sections" in source ? source.sections : void 0;
+	const sectionValue = Array.isArray(sections) ? sections[0] : void 0;
+	const section = typeof sectionValue === "object" && sectionValue !== null ? sectionValue : void 0;
+	if (Object.keys(source).length !== 4 || source.form !== "snapshot" || !Array.isArray(sections) || sections.length !== 1 || section === void 0 || Object.keys(section).length !== 2 || section.name !== SOURCE_NAME || section.text !== blockText) fail("time-context source must carry only the exact snapshot text, not request authority");
+	const renderedBrowserContext = match[4];
+	const browserContext = deriveBrowserTimeZoneContext(requestMessages(history, turn));
+	if (renderedBrowserContext !== renderBrowserTimeZoneContext(browserContext)) fail("time-context browser-zone text does not match current-turn user messages");
+	const baseline = match[5];
 	if (step === 1 !== (baseline === "model-visible message")) fail(`time-context step ${step} uses the wrong elapsed-time baseline ${JSON.stringify(baseline)}`);
 	const rendered = match[3];
 	/* v8 ignore next -- the preceding fixed regexp always supplies capture group three. */
 	if (rendered === void 0) fail("time-context reading omitted its rendered timestamp");
 	const renderedTime = Date.parse(rendered.replace(/\[[^\]]+\]$/, ""));
 	if (!Number.isFinite(renderedTime) || !Number.isSafeInteger(event.time) || event.time < renderedTime) fail("time-context rendered timestamp must parse and not postdate its durable event");
+	if (browserContext.kind === "resolved") {
+		let expectedTimestamp;
+		try {
+			expectedTimestamp = formatTimestamp(renderedTime, createTimestampFormatter(browserContext.timeZone), browserContext.timeZone);
+		} catch (error) {
+			fail(`time-context browser zone cannot format its durable timestamp: ${String(error)}`);
+		}
+		if (rendered !== expectedTimestamp) fail("time-context rendered timestamp does not match the unique browser zone");
+	}
 }
 /** Validate all package-owned readings already present in one session. */
 function validateSession(session, fail) {
@@ -57,6 +277,9 @@ function validateSession(session, fail) {
 /** Install validation for loaded and newly appended context readings. */
 const install = Object.assign((ctx, fail) => {
 	for (const session of ctx.sessions.list()) validateSession(session, fail);
+	ctx.on("session/created", (session) => {
+		validateSession(session, fail);
+	}, { global: true });
 	ctx.on("internal/dispatch", (_mode, eventName, args) => {
 		if (eventName !== "session/event") return;
 		const [session, event] = args;

package/lib/types/index.d.ts

@@ -12,7 +12,7 @@ export declare const name = "time-context";
 export declare const inject: string[];
 /** Request-preparation clock formatting and append scheduling. Invalid values fail plugin load. */
 export interface Config {
-    /** IANA time zone used for the rendered timestamp. Omit to resolve the Node process's system zone at plugin load. */
+    /** Fallback display zone when the open turn has no unique browser zone. Omit to use the process zone. */
     timeZone?: string;
     /** Minimum milliseconds between durable injections in one session. Omit or set to 0 to inject at every eligible step. */
     refreshIntervalMs?: number;

package/lib/types/request-zone.d.ts

@@ -0,0 +1,26 @@
+/** Browser-zone derivation and model-facing policy text for one open request turn. */
+import type { UserMessage } from '@deepseek-ai/dsh-llm';
+/** Browser-zone facts derived from user-rpc messages in one open turn. */
+export type BrowserTimeZoneContext = {
+    readonly kind: 'resolved';
+    readonly timeZone: string;
+} | {
+    readonly kind: 'mixed';
+    readonly timeZones: readonly string[];
+} | {
+    readonly kind: 'missing';
+};
+/**
+ * Derive the unique, mixed, or missing browser zone for one open turn.
+ * @param messages - Entered and proposed user messages belonging to the turn.
+ * @returns Sorted, duplicate-free browser-zone facts.
+ * @throws TypeError when a user-rpc source carries an invalid or noncanonical zone.
+ */
+export declare function deriveBrowserTimeZoneContext(messages: readonly UserMessage[]): BrowserTimeZoneContext;
+/**
+ * Render the model instruction for one browser-zone context.
+ * @param context - Browser-zone facts for the open turn.
+ * @returns One durable policy line.
+ */
+export declare function renderBrowserTimeZoneContext(context: BrowserTimeZoneContext): string;
+//# sourceMappingURL=request-zone.d.ts.map

package/lib/types/timestamp.d.ts

@@ -0,0 +1,16 @@
+/** ISO-shaped time-context timestamp formatting shared by production and replay validation. */
+/**
+ * Create the exact formatter used by durable time-context readings.
+ * @param timeZone - Explicit display zone, or `undefined` for the process fallback.
+ * @returns A formatter with stable numeric local fields and long numeric offset.
+ */
+export declare function createTimestampFormatter(timeZone?: string): Intl.DateTimeFormat;
+/**
+ * Format an epoch millisecond value as an ISO-shaped timestamp with offset and IANA zone.
+ * @param now - Epoch milliseconds to display.
+ * @param formatter - Formatter created for `timeZone`.
+ * @param timeZone - Canonical zone label carried in brackets.
+ * @returns The durable timestamp text.
+ */
+export declare function formatTimestamp(now: number, formatter: Intl.DateTimeFormat, timeZone: string): string;
+//# sourceMappingURL=timestamp.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-time-context",
   "description": "Opt-in durable per-step context with the current time and elapsed time",
-  "version": "0.0.1-rc.1",
+  "version": "0.0.1-rc.2",
   "publishConfig": {
     "access": "restricted"
   },
@@ -35,21 +35,21 @@
     "@deepseek-ai/schemastery": "^3.18.1-rc.1"
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh-agent": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-session": "^0.0.1-rc.1",
-    "@deepseek-ai/cordis": "^4.0.1-rc.1"
+    "@deepseek-ai/dsh-agent": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.2",
+    "@deepseek-ai/cordis": "^4.0.1-rc.1",
+    "@deepseek-ai/dsh-session": "^0.0.1-rc.2"
   },
   "devDependencies": {
-    "@deepseek-ai/dsh-agent-loop": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-agent-loop-testkit": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-llm": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-agent": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-loader-smoke": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-session": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-system-prompt": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-tools": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-agent": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-agent-loop": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-agent-loop-testkit": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-llm": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-loader-smoke": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-session": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-tools": "^0.0.1-rc.2",
     "@deepseek-ai/cordis": "^4.0.1-rc.1"
   }
 }