@deepseek-ai/dsh-workspace 0.2.1-alpha.2 → 0.2.1-alpha.4

package/README.i18n.yaml

@@ -9,8 +9,8 @@
   en: 7a12adba4e7766e3
   zh: f6d5c8374f4512c8
 /deepseek-ai-dsh-workspace/summary:
-  en: 58d66b238882b849
-  zh: a427930afd293c6b
+  en: 30aea62cabd8e8a8
+  zh: b22b30ef08fd4713
 /deepseek-ai-dsh-workspace/table-of-contents:
   en: d152484eb41ac6b4
   zh: 09388d293f9be9cb
@@ -30,8 +30,8 @@
   en: 217475057b6506ed
   zh: be2312a29499c203
 /deepseek-ai-dsh-workspace/use-this-package/grouping-sessions-under-a-project:
-  en: 510be21d012de28c
-  zh: fdcb05447d6ba93c
+  en: 5a68da22516a6a3c
+  zh: a229d57acdab882c
 /deepseek-ai-dsh-workspace/use-this-package/hiding-and-restoring-sessions-and-removing-projects:
   en: 7b298aa5c48501d4
   zh: 8ffeec728c1c13fe
@@ -39,8 +39,8 @@
   en: 447ced401b3b14a8
   zh: 3ce2105605223945
 /deepseek-ai-dsh-workspace/understand-the-implementation/design-philosophy:
-  en: e8ff536e19566447
-  zh: 53ba4c15f10c1549
+  en: e969314497b99389
+  zh: 82eafc832617a1eb
 /deepseek-ai-dsh-workspace/understand-the-implementation/api-behavior:
   en: 69327adb9ea52680
   zh: fa32eea5019c7abb
@@ -75,8 +75,8 @@
   en: 524afbded27fb06b
   zh: 9dcf8539495e9c68
 /deepseek-ai-dsh-workspace/known-limitations-and-deferred-work:
-  en: 85694227357bbd7c
-  zh: 16ad935226c51022
+  en: 1a9c71a3dbfc4506
+  zh: 87b57414053f4d00
 /deepseek-ai-dsh-workspace/known-limitations-and-deferred-work/dev-note:
   en: ac1d08360a93382b
   zh: 6c58749bae9a6e65

package/README.md

@@ -9,7 +9,7 @@ English | [中文](README.zh.md)
 
 ## Summary
 
-Use this package to keep an ordered, persistent list of project directories and the sessions run in each directory. Hosts can build project sidebars, hide sessions from grouping without deleting their histories, and remove projects without deleting folders, files, or sessions. Re-adding a removed directory creates a fresh project, while sessions whose directories cannot be validated remain ungrouped. Choose it for GUI or host workflows that need durable project grouping; it is invisible to models and adds no prompt or request-context cost, but requires session persistence and storage backends.
+Use this package to keep an ordered, persistent list of project directories and the sessions run in each directory. Hosts can build project sidebars, hide sessions from grouping without deleting their histories, and remove projects without deleting folders, files, or sessions. Re-adding a removed directory creates a fresh project; an existing project's sessions stay grouped when its directory disappears. Choose it for GUI or host workflows that need durable project grouping; it is invisible to models and adds no prompt or request-context cost, but requires session persistence and storage backends.
 
 ## Table of Contents
 
@@ -70,7 +70,7 @@ The first successful registration records its identity durably. Repeated calls r
 
 ### Grouping sessions under a project
 
-A session joins the project of the directory it runs in: create a session in a project's directory and it appears under that project, newest first. A session can only belong to one project. A session whose directory cannot be validated — no recorded directory, or a moved or deleted folder — cannot join and stays ungrouped.
+A session joins the project of the directory it runs in: create a session in a project's directory and it appears under that project, newest first. A session can only belong to one project. A new session must have a recorded directory that resolves to the project's directory. Already-accounted sessions keep their project and order when their fully qualified recorded path is missing, including a dangling symlink; renaming or reordering the project does not remove that ownership. Missing headers, invalid recorded paths, existing mismatched directories, and filesystem failures other than ENOENT remain excluded. Keeping ownership does not recreate the directory or relax new-session attachment, so a fork can still fail to attach while the directory is missing.
 
 ### Hiding and restoring sessions, and removing projects
 
@@ -91,7 +91,7 @@ This section explains the design decisions behind the feature and points at the
 ### Design philosophy
 
 - **One record per canonical path.** `fs.realpath` is the single uniqueness canon: paths are stored canonicalized, so a symlink to an owned directory collides, and uniqueness is string equality of canonical paths.
-- **Membership is ownership plus a live cwd fact.** The record's ordered `sessionIds` is the ownership truth; the startup header index validates it, and `sessionIds` filters on read while the next mutation prunes durably.
+- **Membership starts from the recorded account.** The header index validates ordered `sessionIds`; missing-directory candidates retain their account, while other invalid candidates are filtered on read and pruned by the next mutation. The strict canonical-path index used for history bootstrap includes existing directories only.
 - **Header-only reads.** Bootstrap and attach validation read `SessionHeader` fields only; event bodies are never loaded.
 - **Two-write mutations with an explicit marker.** Create and delete persist a `pendingMutation` marker before the record/order pair can diverge, so startup completes exactly the interrupted operation and unmarked divergence fails loud as corruption.
 - **Serialized writes.** Registry operations run on one operation chain; entity mutations go through `table.update` on the domain write chain, stamping `updatedAt` and deciding membership at their chain slot.
@@ -166,7 +166,7 @@ Independent of live requests: the package never touches a request prefix, so it
 These limits define when the project list is a poor fit or needs special operational care. They are current package constraints, not a task backlog.
 
 - **Removal never deletes data** — removing a project leaves its folder, files, and session histories in place; those sessions become ungrouped, and session deletion or folder removal are separate, absent capabilities.
-- **A session joins only with a recorded directory** — a session belongs to a project only when its record carries a directory that resolves to the project's path; sessions without one stay ungrouped, and a session from another directory cannot be moved in.
+- **Missing paths retain recorded ownership, not verified symlink history** — a removed symlink and an incorrect but missing absolute cwd cannot be distinguished from existing records; both preserve an already-accounted id. No unaccounted session is assigned by this exception, and an account already removed from storage is not reconstructed.
 - **External changes are seen late** — if another process deletes or damages a directory, the project reflects it only at the next refresh or restart.
 - **Archive and unarchive enforce different session checks** — a restore only drops an id from the archive set, so an entry whose session is gone still unarchives and leaves no unknown referent; a restore of an id that is not archived resolves without writing, while `archiveSession` rejects a session that is neither live nor persisted.
 - **The activity check and the archive write are not one atomic step** — a turn that starts between the providers' answer and the durable write is hidden while running, and every model step whose `agent/pre-step` precedes the write still runs with its tool calls; the API Session Controller's gate ends the first step proposed after the write as `blocked`, so the exposure is bounded by that write's latency, in practice one model step.

package/README.zh.md

@@ -9,7 +9,7 @@ kind: "package-reference"
 
 ## 概述
 
-使用此包可以维护一个有序、持久的项目目录列表，以及在每个目录中运行的会话。宿主可以构建项目侧边栏、在不删除历史的情况下把会话从分组中隐藏，并在不删除文件夹、文件或会话的情况下移除项目。重新添加已移除的目录会创建一个全新项目，而目录无法校验的会话会保持 Ungrouped。需要持久项目分组的 GUI 或宿主工作流适合使用它；它对模型不可见，不增加提示词或请求上下文成本，但需要会话持久化与存储后端。
+使用此包可以维护一个有序、持久的项目目录列表，以及在每个目录中运行的会话。宿主可以构建项目侧边栏、在不删除历史的情况下把会话从分组中隐藏，并在不删除文件夹、文件或会话的情况下移除项目。重新添加已移除的目录会创建一个全新项目；已有项目的目录消失时，其会话仍保持原分组。需要持久项目分组的 GUI 或宿主工作流适合使用它；它对模型不可见，不增加提示词或请求上下文成本，但需要会话持久化与存储后端。
 
 ## 目录
 
@@ -70,7 +70,7 @@ ctx.workspaceRegistry.list() // shows the project, newest first
 
 ### 将会话归入项目
 
-会话加入它运行目录所在的项目：在项目目录中创建会话，它就会出现在该项目下，新到旧排列。一个会话只能属于一个项目。目录无法校验的会话——没有记录目录，或目录被移动、删除——无法加入，保持 Ungrouped。
+会话加入它运行目录所在的项目：在项目目录中创建会话，它就会出现在该项目下，新到旧排列。一个会话只能属于一个项目。新会话必须记录可解析为项目目录的工作目录。已记账会话的完整绝对路径缺失时（包括悬空符号链接），仍保留原项目与顺序；重命名或排序项目不会移除该归属。头部缺失、无效记录路径、现存但不匹配的目录，以及 ENOENT 以外的文件系统错误仍会被排除。保留归属不会重建目录，也不放宽新会话挂接要求，因此目录缺失时 Fork 仍可能挂接失败。
 
 ### 隐藏、恢复会话与移除项目
 
@@ -91,7 +91,7 @@ Workspace 注册不意味着拥有其目录。未来的破坏性文件系统操
 ### 设计理念
 
 - **每个规范路径一条记录。** `fs.realpath` 是唯一的一套唯一性规范：路径以规范化形式存储，因此指向已有记录目录的符号链接会与之冲突，唯一性即规范路径的字符串相等。
-- **成员资格是所有权加实时 cwd 事实。** 记录的 `sessionIds` 顺序是所有权真源；启动时的头部索引校验它，`sessionIds` 在读取时过滤，下一次变更会持久化剪除无效项。
+- **成员资格以已记录的归属为起点。** 头部索引校验有序的 `sessionIds`；目录缺失的候选保留归属，其他无效候选在读取时过滤，并在下一次变更时剪除。历史引导使用的严格规范路径索引只包含现存目录。
 - **仅读取头部。** 引导与 attach 校验只读取 `SessionHeader` 字段；事件正文绝不加载。
 - **两次写入的变更带显式标记。** 创建与删除在记录/顺序对可能分叉之前先持久化 `pendingMutation` 标记，因此启动只补全被中断的操作，未标记的分叉作为损坏明确报错。
 - **串行化写入。** 注册表操作跑在同一条操作链上；实体变更通过领域写链上的 `table.update` 执行，写入 `updatedAt`，并在其所在的链位置决定成员资格。
@@ -167,7 +167,7 @@ Workspace 注册不意味着拥有其目录。未来的破坏性文件系统操
 这些限制说明项目列表何时不合适，或何时需要特别的运维注意。它们是当前包约束，不是任务积压。
 
 - **移除绝不删除数据**——移除项目会保留其文件夹、文件与会话历史；这些会话变成 Ungrouped，而会话删除与文件夹移除是彼此独立且尚未提供的功能。
-- **只有带记录目录的会话才能加入**——只有记录中带有可解析为项目路径的目录的会话才属于项目；没有目录的会话保持 Ungrouped，来自其他目录的会话无法移入。
+- **路径缺失时保留记录归属，而非重新验证符号链接历史**——现有记录无法区分被移除的符号链接与错误但不存在的绝对 cwd；两者均保留已记账 id。此例外不吸收未记账会话，也不重建已经从存储中删除的归属。
 - **外部变更延迟可见**——如果另一进程删除或损坏目录，项目只能在下次刷新或重启后反映出来。
 - **归档与取消归档执行不同的会话校验**——恢复只是从归档集合中移除 id，因此会话已不存在的条目仍能取消归档，也不会留下未知引用；对未归档 id 执行恢复不写盘即完成，而 `archiveSession` 会拒绝既非实时也未持久化的会话。
 - **活动检查与归档写入不是一个原子步骤**——在提供方作答与持久化写入之间开始的回合会在隐藏状态下运行，`agent/pre-step` 先于该写入的每个模型步连同其工具调用照常执行；API Session Controller 的门禁把写入之后提出的第一步以 `blocked` 收口，因此暴露面以该写入的时延为界，实际上是一个模型步。

package/lib/index.js

@@ -100,7 +100,7 @@ var WorkspaceEntity = class {
 		return this.record.updatedAt;
 	}
 	get sessionIds() {
-		return this.record.sessionIds.filter((id) => this.host.sessionPath(id) === this.record.path);
+		return this.record.sessionIds.filter((id) => this.host.candidateMatches(id, this.record.path));
 	}
 	async setTitle(title) {
 		await this.mutate((record) => ({
@@ -161,7 +161,7 @@ var WorkspaceEntity = class {
 	/**
 	* The single write path: run `fn` on the domain write chain via
 	* `table.update`, stamping `updatedAt` and pruning candidates that no
-	* longer pass the id-plus-canonical-cwd membership check, then swap the
+	* longer pass the candidate membership check, then swap the
 	* snapshot.
 	*
 	* `fn` sees the value current at its chain slot, so membership decisions
@@ -175,7 +175,7 @@ var WorkspaceEntity = class {
 		try {
 			next = await this.host.table().update(this.id, (current) => {
 				const changed = fn(current);
-				const sessionIds = changed.sessionIds.filter((id) => this.host.sessionPath(id) === changed.path);
+				const sessionIds = changed.sessionIds.filter((id) => this.host.candidateMatches(id, changed.path));
 				if (changed === current && sessionIds.length === current.sessionIds.length) throw unchangedSentinel;
 				return {
 					...changed,
@@ -359,14 +359,16 @@ var WorkspaceRegistry = class extends Service {
 	entities = /* @__PURE__ */ new Map();
 	headers = /* @__PURE__ */ new Map();
 	sessionPaths = /* @__PURE__ */ new Map();
+	missingSessionPaths = /* @__PURE__ */ new Set();
 	invalidSessionPaths = /* @__PURE__ */ new Map();
 	operationTail = Promise.resolve();
 	host = {
 		table: () => this.requireTable(),
-		sessionPath: (id) => this.sessionPaths.get(id),
+		candidateMatches: (id, path) => this.sessionPaths.get(id) === path || this.missingSessionPaths.has(id),
 		readSessionHeader: (id) => this.readSessionHeader(id),
 		rememberSessionPath: (id, path) => {
 			this.sessionPaths.set(id, path);
+			this.missingSessionPaths.delete(id);
 			this.invalidSessionPaths.delete(id);
 		}
 	};
@@ -863,6 +865,7 @@ var WorkspaceRegistry = class extends Service {
 	async replaceHeaderIndex(headers) {
 		this.headers.clear();
 		this.sessionPaths.clear();
+		this.missingSessionPaths.clear();
 		this.invalidSessionPaths.clear();
 		await this.indexHeaders(headers);
 	}
@@ -872,6 +875,7 @@ var WorkspaceRegistry = class extends Service {
 	async indexHeader(header) {
 		this.headers.set(header.id, header);
 		this.sessionPaths.delete(header.id);
+		this.missingSessionPaths.delete(header.id);
 		if (header.cwd === void 0) {
 			this.invalidSessionPaths.set(header.id, "header has no cwd");
 			return;
@@ -884,7 +888,8 @@ var WorkspaceRegistry = class extends Service {
 			}
 			this.sessionPaths.set(header.id, path);
 			this.invalidSessionPaths.delete(header.id);
-		} catch {
+		} catch (error) {
+			if (fullyQualifiedWorkspacePath(header.cwd) && error instanceof Error && "code" in error && error.code === "ENOENT") this.missingSessionPaths.add(header.id);
 			this.invalidSessionPaths.set(header.id, `cwd '${header.cwd}' does not resolve`);
 		}
 	}
@@ -901,8 +906,8 @@ var WorkspaceRegistry = class extends Service {
 		for (const entity of this.entities.values()) {
 			const record = this.requireTable().get(entity.id);
 			for (const sessionId of record.sessionIds) {
+				if (this.host.candidateMatches(sessionId, record.path)) continue;
 				const path = this.sessionPaths.get(sessionId);
-				if (path === record.path) continue;
 				const reason = this.invalidSessionPaths.get(sessionId) ?? (this.headers.has(sessionId) ? `canonical cwd '${path}' differs from workspace path '${record.path}'` : "session header is missing");
 				this.ctx.logger.warn(`workspace '${entity.id}' filtered session '${sessionId}' from membership: ${reason}`);
 			}

package/lib/types/entity.d.ts

@@ -30,12 +30,13 @@ export interface WorkspaceEntityHost {
      */
     table(): KvTable<WorkspaceId, WorkspaceRecord>;
     /**
-     * Read a session's canonical directory from the registry's header index.
-     * @param id - Session whose indexed path is requested.
-     * @returns the canonical directory, or `undefined` when the header is
-     * missing or its cwd cannot identify an existing directory.
+     * Validate an already-accounted session, preserving ownership when its fully
+     * qualified cwd cannot resolve because a path component is missing.
+     * @param id - Session already present in this workspace's candidate account.
+     * @param path - Workspace's stored canonical directory.
+     * @returns whether the candidate remains a member.
      */
-    sessionPath(id: SessionId): string | undefined;
+    candidateMatches(id: SessionId, path: string): boolean;
     /**
      * Read one stored session header for attach validation.
      * @param id - The session whose header to read.
@@ -74,7 +75,7 @@ export declare class WorkspaceEntity implements Workspace {
     /**
      * The single write path: run `fn` on the domain write chain via
      * `table.update`, stamping `updatedAt` and pruning candidates that no
-     * longer pass the id-plus-canonical-cwd membership check, then swap the
+     * longer pass the candidate membership check, then swap the
      * snapshot.
      *
      * `fn` sees the value current at its chain slot, so membership decisions

package/lib/types/entity.js

@@ -49,7 +49,7 @@ export class WorkspaceEntity {
         return this.record.updatedAt;
     }
     get sessionIds() {
-        return this.record.sessionIds.filter(id => this.host.sessionPath(id) === this.record.path);
+        return this.record.sessionIds.filter(id => this.host.candidateMatches(id, this.record.path));
     }
     async setTitle(title) {
         await this.mutate(record => ({ ...record, title }));
@@ -124,7 +124,7 @@ export class WorkspaceEntity {
     /**
      * The single write path: run `fn` on the domain write chain via
      * `table.update`, stamping `updatedAt` and pruning candidates that no
-     * longer pass the id-plus-canonical-cwd membership check, then swap the
+     * longer pass the candidate membership check, then swap the
      * snapshot.
      *
      * `fn` sees the value current at its chain slot, so membership decisions
@@ -138,7 +138,7 @@ export class WorkspaceEntity {
         try {
             next = await this.host.table().update(this.id, (current) => {
                 const changed = fn(current);
-                const sessionIds = changed.sessionIds.filter(id => this.host.sessionPath(id) === changed.path);
+                const sessionIds = changed.sessionIds.filter(id => this.host.candidateMatches(id, changed.path));
                 if (changed === current && sessionIds.length === current.sessionIds.length) {
                     throw unchangedSentinel;
                 }

package/lib/types/index.d.ts

@@ -125,6 +125,7 @@ export declare class WorkspaceRegistry extends Service {
     private readonly entities;
     private readonly headers;
     private readonly sessionPaths;
+    private readonly missingSessionPaths;
     private readonly invalidSessionPaths;
     private operationTail;
     private readonly host;

package/lib/types/index.js

@@ -98,14 +98,16 @@ export class WorkspaceRegistry extends Service {
     entities = new Map();
     headers = new Map();
     sessionPaths = new Map();
+    missingSessionPaths = new Set();
     invalidSessionPaths = new Map();
     operationTail = Promise.resolve();
     host = {
         table: () => this.requireTable(),
-        sessionPath: id => this.sessionPaths.get(id),
+        candidateMatches: (id, path) => this.sessionPaths.get(id) === path || this.missingSessionPaths.has(id),
         readSessionHeader: id => this.readSessionHeader(id),
         rememberSessionPath: (id, path) => {
             this.sessionPaths.set(id, path);
+            this.missingSessionPaths.delete(id);
             this.invalidSessionPaths.delete(id);
         },
     };
@@ -693,6 +695,7 @@ export class WorkspaceRegistry extends Service {
     async replaceHeaderIndex(headers) {
         this.headers.clear();
         this.sessionPaths.clear();
+        this.missingSessionPaths.clear();
         this.invalidSessionPaths.clear();
         await this.indexHeaders(headers);
     }
@@ -703,6 +706,7 @@ export class WorkspaceRegistry extends Service {
     async indexHeader(header) {
         this.headers.set(header.id, header);
         this.sessionPaths.delete(header.id);
+        this.missingSessionPaths.delete(header.id);
         if (header.cwd === undefined) {
             this.invalidSessionPaths.set(header.id, 'header has no cwd');
             return;
@@ -716,7 +720,11 @@ export class WorkspaceRegistry extends Service {
             this.sessionPaths.set(header.id, path);
             this.invalidSessionPaths.delete(header.id);
         }
-        catch {
+        catch (error) {
+            if (fullyQualifiedWorkspacePath(header.cwd)
+                && error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+                this.missingSessionPaths.add(header.id);
+            }
             this.invalidSessionPaths.set(header.id, `cwd '${header.cwd}' does not resolve`);
         }
     }
@@ -735,9 +743,9 @@ export class WorkspaceRegistry extends Service {
         for (const entity of this.entities.values()) {
             const record = this.requireTable().get(entity.id);
             for (const sessionId of record.sessionIds) {
-                const path = this.sessionPaths.get(sessionId);
-                if (path === record.path)
+                if (this.host.candidateMatches(sessionId, record.path))
                     continue;
+                const path = this.sessionPaths.get(sessionId);
                 const reason = this.invalidSessionPaths.get(sessionId)
                     ?? (this.headers.has(sessionId)
                         ? `canonical cwd '${path}' differs from workspace path '${record.path}'`

package/lib/types/types.d.ts

@@ -6,12 +6,17 @@
  */
 import type { Branded } from '@deepseek-ai/dsh-brand';
 import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { TypertResource } from '@deepseek-ai/dsh-typert-protocol';
 /**
  * Identifies one workspace record. A generated uuid, never the path: path
  * normalization rewrites paths, and a reference anchor must stay stable.
  */
 export type WorkspaceId = Branded<'WorkspaceId'>;
 declare module '@deepseek-ai/dsh-typert-protocol' {
+    interface TypertResourceMap {
+        /** One Workspace; the Workspace Controller registers its default `workspaceId` wire field. */
+        workspace: TypertResource<WorkspaceId>;
+    }
     interface RemoteErrorDetailsMap {
         /** No registration carries that Workspace identity. */
         'workspace/not-found': {
@@ -50,9 +55,10 @@ export interface SessionActivity {
 }
 /**
  * One workspace: a stable id over an existing directory, a display title, and
- * an ordered candidate account of sessions. Membership requires both an id in
- * that account and a session header whose canonical cwd equals the workspace
- * path. Consumers only see this interface; the implementation stays private.
+ * an ordered candidate account of sessions. Membership validates header cwd
+ * against the workspace path, but preserves an existing account when its
+ * fully qualified cwd is missing. Consumers only see this interface; the
+ * implementation stays private.
  */
 export interface Workspace {
     /** Stable record id (generated uuid). */
@@ -74,8 +80,11 @@ export interface Workspace {
      * prepended at attach, explicit reordering goes through
      * `insertSessionBefore`, and activity never reorders. The durable candidate
      * account is filtered synchronously: missing headers, invalid cwd values,
-     * and canonical cwd mismatches are never returned. A subsequent workspace
-     * mutation prunes those filtered candidates durably.
+     * and canonical cwd mismatches are never returned. A fully qualified cwd
+     * whose realpath or directory stat fails with ENOENT preserves an existing
+     * candidate, including a dangling symlink; other filesystem failures do not.
+     * A subsequent mutation prunes filtered candidates, not missing-directory
+     * candidates. This does not admit new sessions or recreate directories.
      */
     readonly sessionIds: readonly SessionId[];
     /**

package/locale/en.json

@@ -0,0 +1,5 @@
+{
+  "meta": {
+    "title": "workspace"
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "工作区管理",
+    "description": "保存工作区信息，并管理工作区与会话的关联。"
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-workspace",
   "description": "Workspace entity registry (ctx.workspaceRegistry): durable workspace records with validated session attachment over the domain data form for the DeepSeek Harness",
-  "version": "0.2.1-alpha.2",
+  "version": "0.2.1-alpha.4",
   "publishConfig": {
     "access": "public"
   },
@@ -23,32 +23,34 @@
       "default": "./lib/types/types.js"
     },
     "./src/*": "./src/*",
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./locale/*.json": "./locale/*.json"
   },
   "files": [
+    "locale/*.json",
     "lib/index.js",
     "lib/types/**/*.js",
     "lib/types/**/*.d.ts"
   ],
   "license": "MIT",
   "peerDependencies": {
-    "@deepseek-ai/cordis": "~4.0.5-alpha.1",
-    "@deepseek-ai/dsh-session": "0.2.1-alpha.2",
-    "@deepseek-ai/dsh-session-persistence": "0.2.1-alpha.2",
-    "@deepseek-ai/dsh-storage": "0.2.1-alpha.2",
-    "@deepseek-ai/dsh-storage-domain": "0.2.1-alpha.2",
-    "@deepseek-ai/dsh-typert-protocol": "0.2.1-alpha.2"
+    "@deepseek-ai/cordis": "~4.0.5-alpha.2",
+    "@deepseek-ai/dsh-session": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-session-persistence": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-storage": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-storage-domain": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-typert-protocol": "0.2.1-alpha.4"
   },
   "dependencies": {
-    "@deepseek-ai/dsh-brand": "0.2.1-alpha.2",
-    "zod": "^4.4.3"
+    "@deepseek-ai/dsh-brand": "0.2.1-alpha.4",
+    "zod": "4.4.3"
   },
   "devDependencies": {
-    "@deepseek-ai/cordis": "~4.0.5-alpha.1",
-    "@deepseek-ai/dsh-session": "0.2.1-alpha.2",
-    "@deepseek-ai/dsh-session-persistence": "0.2.1-alpha.2",
-    "@deepseek-ai/dsh-storage": "0.2.1-alpha.2",
-    "@deepseek-ai/dsh-storage-domain": "0.2.1-alpha.2",
-    "@deepseek-ai/dsh-typert-protocol": "0.2.1-alpha.2"
+    "@deepseek-ai/cordis": "~4.0.5-alpha.2",
+    "@deepseek-ai/dsh-session": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-session-persistence": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-storage": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-storage-domain": "0.2.1-alpha.4",
+    "@deepseek-ai/dsh-typert-protocol": "0.2.1-alpha.4"
   }
 }