@chatcode/chatcode-cli 3.0.4-rc.1 → 3.0.4-rc.2

package/runtime/node_modules/@deepseek-ai/dsh-tianti/lib/types/tools.d.ts

@@ -1,10 +1,10 @@
 /** Model-facing Tianti queries and review proposals; human commands execute writes. */
 import type { Context } from '@deepseek-ai/cordis';
 import { TiantiRuntime } from './runtime.ts';
-/** Install reversible model tools with invocation-owned cancellation.
+/** Install model tools for one enabled Tianti activation; its owner unregisters them on off.
  * @param ctx Harness tool registry.
  * @param runtime Plugin-owned endpoint and switch state.
- * @param signal Plugin lifetime cancellation.
+ * @param signal Cancellation for this activation, aborted on off or plugin disposal.
  * @param track Track active work until plugin disposal settles.
  * @returns Registration disposers, removed before active work is drained.
  */

package/runtime/node_modules/@deepseek-ai/dsh-tianti/package.json

@@ -35,6 +35,8 @@
     "@deepseek-ai/dsh-home-paths": "workspace:*"
   },
   "devDependencies": {
+    "@deepseek-ai/dsh-agent-loop": "workspace:*",
+    "@deepseek-ai/dsh-session-projection": "workspace:*",
     "@deepseek-ai/dsh-bash-local": "workspace:*",
     "@deepseek-ai/dsh-subprocess-local": "workspace:*",
     "@deepseek-ai/cordis": "workspace:~",

package/runtime/node_modules/@deepseek-ai/dsh-tool-cordis/lib/types/api-catalog.js

@@ -20,20 +20,32 @@ export const SERVICE_API = [
         methods: [
             {
                 signature: 'currentSelection(): ModelSelection',
-                description: 'Read the current default model selection.',
+                description: 'Read the current default model selection. A first launch without a valid preference adopts the first complete Config default when it arrives; that process-local choice then stays cached.',
                 parameters: [],
                 returns: 'a detached provider, model, and optional reasoning selection.',
             },
+            {
+                signature: 'usesSharedPreference(): boolean',
+                description: 'Whether this product uses a process-local selection initialized from Home at startup.',
+                parameters: [],
+                returns: 'true for the integrated ChatCode CLI and Web profiles.',
+            },
+            {
+                signature: 'async resolveSelection(): Promise<ModelSelection>',
+                description: 'Resolve the cached route against the live catalog without reading or writing preferences. A first launch without a valid preference may adopt an advertised fallback until its first available default is resolved. Saved or initialized choices never switch implicitly. Catalog errors preserve the candidate for retry.',
+                parameters: [],
+                returns: 'the exact available selection, an unverified candidate, or an empty provider/model pair.',
+            },
             {
                 signature: 'sharedDisplayName(): { provider: string; model: string; name: string } | undefined',
-                description: 'Read the latest shared display name without changing this process\'s model selection.',
+                description: 'Read this process\'s cached display name without observing another process\'s saves.',
                 parameters: [],
                 returns: 'The saved provider/model/name tuple, or undefined for missing or invalid name metadata.',
             },
             {
-                signature: 'async saveSelection(next: ModelSelection): Promise<void>',
-                description: 'Save the complete default model selection to the shared ChatCode Home file, or the owning profile entry in other deployments. Saves commit in submission order; a failed save rejects its caller without blocking later saves. A shared save also retains an available catalog name; metadata failures do not reject the route save.',
-                parameters: [{ name: 'next', description: 'resolved selection accepted by an entry point.' }],
+                signature: 'async saveSelection(next: ModelSelection, name?: string): Promise<void>',
+                description: 'Save the complete default model selection to the shared ChatCode Home file, or the owning profile entry in other deployments. Saves commit in submission order; a failed save rejects its caller without blocking later saves. A shared save uses the caller\'s already resolved catalog name without an additional lookup.',
+                parameters: [{ name: 'next', description: 'resolved selection accepted by an entry point.' }, { name: 'name', description: 'optional display name from the entry point\'s catalog.' }],
                 returns: 'fulfillment after the preference or optional profile write settles.',
             },
         ],
@@ -1843,20 +1855,20 @@ export const SERVICE_API = [
                 returns: 'authorized bounded Session search results.',
             },
             {
-                signature: '@Remote(\'create\') create(request: SessionCreateRequest): Promise<SessionCreateValue>',
+                signature: '@Remote(\'create\') async create(request: SessionCreateRequest): Promise<SessionCreateValue>',
                 description: 'Create or idempotently adopt one ordinary Session.',
                 parameters: [{ name: 'request', description: 'requested identity, location, and Agent preset.' }],
                 returns: 'the Session identity and resolved preset when configured.',
             },
             {
                 signature: '@Remote(\'selectModel\') selectModel(request: SessionSelectModelRequest): Promise<SessionSelectModelValue>',
-                description: 'Select one Session-local model after explicitly resuming the Session; save the default in the background.',
+                description: 'Select a model after explicitly resuming the Session and awaiting default persistence.',
                 parameters: [{ name: 'request', description: 'Session identity and requested model selection.' }],
-                returns: 'the normalized selection installed for the Session, without waiting for default persistence.',
+                returns: 'the normalized selection after the shared save and Session selection succeed.',
             },
             {
                 signature: '@Remote async initializeDefaultModel(): Promise<void>',
-                description: 'Select the first available account model after login when no provider API key is configured.',
+                description: 'Initialize legacy account deployments without changing a product process\'s cached selection.',
                 parameters: [],
                 returns: 'after saving the first available model or retaining the existing default.',
             },
@@ -1935,7 +1947,7 @@ export const SERVICE_API = [
                 returns: 'one chronological page.',
             },
             {
-                signature: '@Remote({ mode: \'stream\' }) follow(request: SessionFollowRequest, signal: AbortSignal): AsyncIterable<SessionFollowFrame>',
+                signature: '@Remote({ mode: \'stream\' }) async *follow(request: SessionFollowRequest, signal: AbortSignal): AsyncIterable<SessionFollowFrame>',
                 description: 'Follow one Session log from its opening or resume cursor.',
                 parameters: [{ name: 'request', description: 'durable address and last committed sequence already held by the caller.' }, { name: 'signal', description: 'cancellation owned by the Remote stream carrier.' }],
                 returns: 'a complete opening snapshot followed by gap-free durable event frames and optional cursorless assistant-stream frames.',
@@ -2023,6 +2035,13 @@ export const SERVICE_API = [
                 parameters: [{ name: 'options', description: 'optional cancellation.' }],
                 returns: 'one snapshot per stored session.',
             },
+            {
+                signature: 'prepareDeletion(sessionIds: readonly SessionId[]): Promise<SessionDeletion>',
+                description: 'Reserve every target\'s write ownership before any deletion is committed. The caller persists its recovery journal while this reservation is held, calls commit, and always disposes it to release ownership. Backends must retain deletion identities so old generations cannot reappear or be recreated.',
+                parameters: [{ name: 'sessionIds', description: 'complete deletion scope, including owned descendants.' }],
+                returns: 'an exclusive deletion reservation; missing targets are idempotent.',
+                throws: ['when a writer holds any target, or the backend does not support deletion.'],
+            },
         ],
     },
     {
@@ -3526,6 +3545,18 @@ export const SERVICE_API = [
                 parameters: [{ name: 'request', description: 'Session identity to unarchive.' }],
                 returns: 'the complete resulting archive set.',
             },
+            {
+                signature: '@Remote(\'sessionDeletionScope\') sessionDeletionScope(request: WorkspaceSessionDeletionPreviewRequest): Promise<WorkspaceSessionDeletionValue>',
+                description: 'Preview the archived root and owned subagent Sessions covered by deletion.',
+                parameters: [{ name: 'request', description: 'archived root to preview.' }],
+                returns: 'complete deletion scope for confirmation.',
+            },
+            {
+                signature: '@Remote(\'deleteSession\') deleteSession(request: WorkspaceSessionDeletionRequest): Promise<WorkspaceSessionDeletionValue>',
+                description: 'Permanently remove an archived Session and its confirmed owned subagents.',
+                parameters: [{ name: 'request', description: 'archived root and confirmed scope.' }],
+                returns: 'identities permanently removed.',
+            },
             {
                 signature: '@Remote(\'pinSession\') pinSession(request: WorkspacePinSessionRequest): Promise<WorkspacePinValue>',
                 description: 'Surface one known unarchived Session ahead of unpinned Sessions.',
@@ -3630,6 +3661,18 @@ export const SERVICE_API = [
                 parameters: [{ name: 'id', description: 'Workspace to move.' }, { name: 'beforeId', description: 'Workspace anchor; omitted appends.' }],
                 returns: 'the complete committed workspace order.',
             },
+            {
+                signature: 'deleteSession(sessionId: SessionId, expectedIds?: readonly SessionId[]): Promise<readonly SessionId[]>',
+                description: 'Permanently delete an archived, inactive root and its owned subagent descendants. Independent forks are preserved. Reserve every writer before recording a recovery marker; a failure after that marker is retried on refresh or restart.',
+                parameters: [{ name: 'sessionId', description: 'archived root identity; repeated deletion is idempotent.' }, { name: 'expectedIds', description: 'identities confirmed by the user; a changed scope refuses deletion.' }],
+                returns: 'deleted root and descendant identities after durable cleanup.',
+            },
+            {
+                signature: 'sessionDeletionScope(sessionId: SessionId): Promise<readonly SessionId[]>',
+                description: 'Preview the root and owned descendants without opening their histories.',
+                parameters: [{ name: 'sessionId', description: 'archived root to preview.' }],
+                returns: 'identities to show in the deletion confirmation.',
+            },
             {
                 signature: 'archiveSession(sessionId: SessionId, options: ArchiveSessionOptions = {}): Promise<void>',
                 description: 'Archive one session durably. The session must exist (live or in session persistence); its workspace accounting — or lack of one — is irrelevant. Without `stopActivity` the session must also be inactive: the `workspace/session-activity` waterfall is asked once, and any reported activity rejects with WorkspaceActiveSessionError before anything is written. With `stopActivity` the archive is written without an activity check, and the `workspace/session-stop` providers are then asked to stop the session\'s work: the durable archive set is what a provider\'s `agent/pre-step` gate reads, so every wake the stops induce is already blocked. Archiving drops the session\'s pin in the same durable write (pinning and archival are mutually exclusive). An already archived id resolves without writing, asking, or stopping.',
@@ -3801,6 +3844,14 @@ export const EVENT_API = [
         description: 'One Agent failed outside a durable turn position.',
         parameters: [{ name: 'sessionId', description: 'Agent and Session identity.' }, { name: 'message', description: 'user-safe failure chain.' }],
     },
+    {
+        name: 'api-session/model-updated',
+        mode: 'emit',
+        signature: '\'api-session/model-updated\'(): void',
+        summary: 'The Host process committed a user-selected default; browser catalogs must reload from that process.',
+        description: 'The Host process committed a user-selected default; browser catalogs must reload from that process.',
+        parameters: [],
+    },
     {
         name: 'api-session/removed',
         mode: 'emit',
@@ -4097,6 +4148,30 @@ export const EVENT_API = [
         description: 'Creation announcement during session publication. A synchronous throw vetoes and rolls back with a paired disposal; detach requested during dispatch is deferred. A returned-promise rejection is logged but cannot retroactively veto this synchronous boundary. Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners receive only sessions entered through that agent\'s context.',
         parameters: [{ name: 'session', description: 'the session just entered and announced.' }],
     },
+    {
+        name: 'session/delete-release',
+        mode: 'parallel',
+        signature: '\'session/delete-release\'(request: { readonly sessionIds: readonly SessionId[] }): Promise<void> | void',
+        summary: 'Ask capability owners to release idle, archived Sessions before writer reservation.',
+        description: 'Ask capability owners to release idle, archived Sessions before writer reservation. Owners release only handles they own; foreign or running Sessions remain protected.',
+        parameters: [{ name: 'request', description: 'confirmed root and owned subagent identities.' }],
+    },
+    {
+        name: 'session/deleted',
+        mode: 'emit',
+        signature: '\'session/deleted\'(sessionIds: readonly SessionId[]): void',
+        summary: 'Permanent deletion observed locally or from shared storage.',
+        description: 'Permanent deletion observed locally or from shared storage.',
+        parameters: [{ name: 'sessionIds', description: 'removed identities, including owned descendants.' }],
+    },
+    {
+        name: 'session/deleting',
+        mode: 'parallel',
+        signature: '\'session/deleting\'(request: { readonly sessionIds: readonly SessionId[] }): Promise<void> | void',
+        summary: 'Permanently remove secondary Session records after stored payload deletion.',
+        description: 'Permanently remove secondary Session records after stored payload deletion. Listeners are idempotent; failures leave the deletion journal pending for recovery.',
+        parameters: [{ name: 'request', description: 'confirmed root and owned subagent identities.' }],
+    },
     {
         name: 'session/disposed',
         mode: 'emit',
@@ -5714,7 +5789,7 @@ export const TYPE_API = [
     },
     {
         name: 'ModelCatalog',
-        declaration: 'export interface ModelCatalog {\n    readonly default: ModelSelection;\n    readonly savedDisplayName?: {\n        readonly provider: string;\n        readonly model: string;\n        readonly name: string;\n    };\n    readonly routableProviders: readonly string[];\n    readonly groups: readonly ModelProviderGroup[];\n    readonly failures: readonly ModelCatalogFailure[];\n}',
+        declaration: 'export interface ModelCatalog {\n    readonly default: ModelSelection;\n    readonly selectionScope?: \'process\';\n    readonly savedDisplayName?: {\n        readonly provider: string;\n        readonly model: string;\n        readonly name: string;\n    };\n    readonly routableProviders: readonly string[];\n    readonly groups: readonly ModelProviderGroup[];\n    readonly failures: readonly ModelCatalogFailure[];\n}',
     },
     {
         name: 'ModelCatalogFailure',
@@ -6066,7 +6141,7 @@ export const TYPE_API = [
     },
     {
         name: 'RecordTable',
-        declaration: 'export type RecordTable<K extends string, V> = Pick<KvTable<K, V>, \'read\' | \'put\'>;',
+        declaration: 'export type RecordTable<K extends string, V> = Pick<KvTable<K, V>, \'read\' | \'put\' | \'delete\'>;',
     },
     {
         name: 'RecurringScheduleRecord',
@@ -6408,6 +6483,10 @@ export const TYPE_API = [
         name: 'SessionCreateValue',
         declaration: 'export interface SessionCreateValue {\n    readonly sessionId: SessionId;\n    readonly agentPreset?: string;\n}',
     },
+    {
+        name: 'SessionDeletion',
+        declaration: 'export interface SessionDeletion extends AsyncDisposable {\n    commit(): Promise<void>;\n}',
+    },
     {
         name: 'SessionEvent',
         declaration: 'export type SessionEvent<T extends SessionEventType = SessionEventType> = {\n    [K in SessionEventType]: {\n        type: K;\n        seq: SessionSeq;\n        time: number;\n        data: SessionEventMap[K];\n        ignorable?: true;\n    } & (K extends SurfaceEventType ? SurfaceIntent<K> : {\n        surfaceOp?: never;\n        sourceEventSeqs?: never;\n    });\n}[T];',
@@ -8028,6 +8107,18 @@ export const TYPE_API = [
         name: 'WorkspaceRenameRequest',
         declaration: 'export interface WorkspaceRenameRequest {\n    readonly workspaceId: WorkspaceId;\n    readonly title: string;\n}',
     },
+    {
+        name: 'WorkspaceSessionDeletionPreviewRequest',
+        declaration: 'export interface WorkspaceSessionDeletionPreviewRequest {\n    readonly sessionId: SessionId;\n}',
+    },
+    {
+        name: 'WorkspaceSessionDeletionRequest',
+        declaration: 'export interface WorkspaceSessionDeletionRequest extends WorkspaceSessionDeletionPreviewRequest {\n    readonly expectedSessionIds: readonly SessionId[];\n}',
+    },
+    {
+        name: 'WorkspaceSessionDeletionValue',
+        declaration: 'export interface WorkspaceSessionDeletionValue {\n    readonly sessionIds: readonly SessionId[];\n}',
+    },
     {
         name: 'WorkspaceUnarchiveSessionRequest',
         declaration: 'export interface WorkspaceUnarchiveSessionRequest {\n    readonly sessionId: SessionId;\n}',

package/runtime/node_modules/@deepseek-ai/dsh-workspace/lib/index.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { mkdir, realpath, stat } from "node:fs/promises";
 import { Service } from "@deepseek-ai/cordis";
+import { SessionAlreadyOwnedError } from "@deepseek-ai/dsh-session-persistence";
 import { posix, win32 } from "node:path";
 import { z } from "zod";
 import { brandString } from "@deepseek-ai/dsh-brand";
@@ -252,7 +253,11 @@ const workspaceDomainState = z.object({
 	workspaceIds: z.array(workspaceId),
 	archivedSessionIds: z.array(sessionId).default([]),
 	pinnedSessionIds: z.array(sessionId).default([]),
-	pendingMutation: workspacePendingMutation.optional()
+	pendingMutation: workspacePendingMutation.optional(),
+	/** Payload deletion committed identities; old processes must never restore these Sessions. */
+	deletedSessionIds: z.array(sessionId).optional(),
+	/** Complete deletion scope retained until payloads and secondary owners finish cleanup. */
+	pendingSessionDeletion: z.array(sessionId).optional()
 });
 /**
 * The workspace domain spec: one `workspaces` table keyed by
@@ -282,6 +287,64 @@ const workspaceDomainSpec = defineDomain({
 * domain data form.
 * @module @deepseek-ai/dsh-workspace
 */
+var __addDisposableResource = function(env, value, async) {
+	if (value !== null && value !== void 0) {
+		if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+		var dispose, inner;
+		if (async) {
+			if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+			dispose = value[Symbol.asyncDispose];
+		}
+		if (dispose === void 0) {
+			if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+			dispose = value[Symbol.dispose];
+			if (async) inner = dispose;
+		}
+		if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+		if (inner) dispose = function() {
+			try {
+				inner.call(this);
+			} catch (e) {
+				return Promise.reject(e);
+			}
+		};
+		env.stack.push({
+			value,
+			dispose,
+			async
+		});
+	} else if (async) env.stack.push({ async: true });
+	return value;
+};
+var __disposeResources = (function(SuppressedError) {
+	return function(env) {
+		function fail(e) {
+			env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+			env.hasError = true;
+		}
+		var r, s = 0;
+		function next() {
+			while (r = env.stack.pop()) try {
+				if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+				if (r.dispose) {
+					var result = r.dispose.call(r.value);
+					if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+						fail(e);
+						return next();
+					});
+				} else s |= 1;
+			} catch (e) {
+				fail(e);
+			}
+			if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+			if (env.hasError) throw env.error;
+		}
+		return next();
+	};
+})(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+	var e = new Error(message);
+	return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 /**
 * Brand a string as a {@link WorkspaceId}.
 * @param id - Raw workspace id string.
@@ -338,6 +401,21 @@ var WorkspaceArchivedSessionPinError = class extends Error {
 		this.name = "WorkspaceArchivedSessionPinError";
 	}
 };
+/** Permanent deletion requires an archived root and no active Session ownership. */
+var WorkspaceSessionDeletionError = class extends Error {
+	sessionId;
+	reason;
+	/**
+	* @param sessionId - identity whose lifecycle prevents the requested operation.
+	* @param reason - stable refusal discriminant shared by the Web and TUI.
+	*/
+	constructor(sessionId, reason) {
+		super(`cannot delete session '${sessionId}': ${reason}`);
+		this.sessionId = sessionId;
+		this.reason = reason;
+		this.name = "WorkspaceSessionDeletionError";
+	}
+};
 /** A workspace reorder named a source or anchor absent from the durable registry order. */
 var WorkspaceOrderInvalidError = class extends Error {
 	workspaceId;
@@ -403,6 +481,7 @@ var WorkspaceRegistry = class extends Service {
 			await domain.refresh();
 			this.state = domain.global.get();
 			await this.recoverPendingMutation();
+			await this.recoverSessionDeletion();
 			this.validateStoredState(this.requireState());
 			if (!this.requireState().initialized) {
 				const headers = await this.listStoredHeaders();
@@ -550,6 +629,130 @@ var WorkspaceRegistry = class extends Service {
 	get archivedSessionIds() {
 		return this.requireState().archivedSessionIds;
 	}
+	/** Permanently deleted identities retained for cross-process invalidation and stale-operation refusal. */
+	get deletedSessionIds() {
+		return this.requireState().deletedSessionIds ?? [];
+	}
+	/**
+	* Permanently delete an archived, inactive root and its owned subagent descendants.
+	* Independent forks are preserved. Reserve every writer before recording a recovery
+	* marker; a failure after that marker is retried on refresh or restart.
+	* @param sessionId - archived root identity; repeated deletion is idempotent.
+	* @param expectedIds - identities confirmed by the user; a changed scope refuses deletion.
+	* @returns deleted root and descendant identities after durable cleanup.
+	*/
+	deleteSession(sessionId, expectedIds) {
+		return this.enqueueOperation(async () => {
+			const env_1 = {
+				stack: [],
+				error: void 0,
+				hasError: false
+			};
+			try {
+				if (this.deletedSessionIds.includes(sessionId)) return [sessionId];
+				if (!this.archivedSessionIds.includes(sessionId)) throw new WorkspaceSessionDeletionError(sessionId, "not-archived");
+				const ids = new Set(await this.collectSessionDeletionScope(sessionId));
+				if (expectedIds !== void 0 && (expectedIds.length !== ids.size || new Set(expectedIds).size !== ids.size || expectedIds.some((id) => !ids.has(id)))) throw new WorkspaceSessionDeletionError(sessionId, "scope-changed");
+				for (const id of ids) {
+					const activity = await this.ctx.waterfall("workspace/session-activity", { sessionId: id }, () => Promise.resolve([]));
+					if (activity.length > 0) throw new WorkspaceActiveSessionError(id, activity);
+				}
+				const targets = [...ids];
+				await this.ctx.parallel("session/delete-release", { sessionIds: targets });
+				for (const id of ids) if (this.ctx.get("sessions")?.get(id) !== void 0) throw new WorkspaceSessionDeletionError(id, "in-use");
+				const reservation = __addDisposableResource(env_1, await this.ctx.sessionPersistence.prepareDeletion(targets).catch((error) => {
+					if (error instanceof SessionAlreadyOwnedError) throw new WorkspaceSessionDeletionError(sessionId, "in-use");
+					throw error;
+				}), true);
+				await this.setState({
+					...this.requireState(),
+					pendingSessionDeletion: targets
+				});
+				await reservation.commit();
+				await this.finishSessionDeletion(targets);
+				return targets;
+			} catch (e_1) {
+				env_1.error = e_1;
+				env_1.hasError = true;
+			} finally {
+				const result_1 = __disposeResources(env_1);
+				if (result_1) await result_1;
+			}
+		});
+	}
+	/**
+	* Preview the root and owned descendants without opening their histories.
+	* @param sessionId - archived root to preview.
+	* @returns identities to show in the deletion confirmation.
+	*/
+	sessionDeletionScope(sessionId) {
+		return this.enqueueOperation(async () => {
+			if (!this.archivedSessionIds.includes(sessionId)) throw new WorkspaceSessionDeletionError(sessionId, "not-archived");
+			return this.collectSessionDeletionScope(sessionId);
+		});
+	}
+	async collectSessionDeletionScope(sessionId) {
+		const headers = await this.listStoredHeaders();
+		const ids = new Set([sessionId]);
+		for (let changed = true; changed;) {
+			changed = false;
+			for (const header of headers) if (header.origin === "subagent" && header.parentSession !== void 0 && ids.has(header.parentSession) && !ids.has(header.id)) {
+				ids.add(header.id);
+				changed = true;
+			}
+		}
+		return [...ids];
+	}
+	async recoverSessionDeletion() {
+		const env_2 = {
+			stack: [],
+			error: void 0,
+			hasError: false
+		};
+		try {
+			const ids = this.requireState().pendingSessionDeletion;
+			if (ids === void 0) return;
+			await __addDisposableResource(env_2, await this.ctx.sessionPersistence.prepareDeletion(ids), true).commit();
+			await this.finishSessionDeletion(ids);
+		} catch (e_2) {
+			env_2.error = e_2;
+			env_2.hasError = true;
+		} finally {
+			const result_2 = __disposeResources(env_2);
+			if (result_2) await result_2;
+		}
+	}
+	notifyDeleted(ids) {
+		try {
+			this.ctx.emit("session/deleted", ids);
+		} catch (error) {
+			this.ctx.logger.warn(`workspace: deletion listener failed: ${String(error)}`);
+		}
+	}
+	async finishSessionDeletion(ids) {
+		await this.ctx.parallel("session/deleting", { sessionIds: ids });
+		const removed = new Set(ids);
+		for (const [id, record] of this.requireTable().entries()) if (record.sessionIds.some((member) => removed.has(member))) await this.requireTable().update(id, (current) => ({
+			...current,
+			sessionIds: current.sessionIds.filter((member) => !removed.has(member)),
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		}));
+		const state = this.requireState();
+		await this.setState({
+			...state,
+			archivedSessionIds: state.archivedSessionIds.filter((id) => !removed.has(id)),
+			pinnedSessionIds: state.pinnedSessionIds.filter((id) => !removed.has(id)),
+			deletedSessionIds: [...new Set([...state.deletedSessionIds ?? [], ...ids])],
+			pendingSessionDeletion: void 0
+		});
+		for (const id of ids) {
+			this.headers.delete(id);
+			this.sessionPaths.delete(id);
+			this.invalidSessionPaths.delete(id);
+		}
+		this.rebuildEntities();
+		this.notifyDeleted(ids);
+	}
 	/**
 	* Archive one session durably. The session must exist (live or in session
 	* persistence); its workspace accounting — or lack of one — is irrelevant.
@@ -596,6 +799,7 @@ var WorkspaceRegistry = class extends Service {
 	*/
 	unarchiveSession(sessionId) {
 		return this.enqueueOperation(async () => {
+			if (this.deletedSessionIds.includes(sessionId)) throw new WorkspaceSessionDeletionError(sessionId, "deleted");
 			const state = this.requireState();
 			if (!state.archivedSessionIds.includes(sessionId)) return;
 			await this.setState({
@@ -656,6 +860,7 @@ var WorkspaceRegistry = class extends Service {
 	* masquerade as an unknown session.
 	*/
 	async sessionKnown(id) {
+		if (this.deletedSessionIds.includes(id)) return false;
 		if (this.ctx.get("sessions")?.get(id) !== void 0) return true;
 		if (this.headers.has(id)) return true;
 		await this.indexHeaders(await this.listStoredHeaders());
@@ -939,12 +1144,14 @@ var WorkspaceRegistry = class extends Service {
 	}
 	/** Every stored session's header, projected from the persistence snapshot listing. */
 	async listStoredHeaders() {
-		return (await this.ctx.sessionPersistence.list()).map((snapshot) => snapshot.header);
+		const snapshots = await this.ctx.sessionPersistence.list();
+		const deleted = new Set(this.deletedSessionIds);
+		return snapshots.map((snapshot) => snapshot.header).filter((header) => !deleted.has(header.id));
 	}
 	async indexLiveSessions() {
 		const sessions = this.ctx.get("sessions");
 		if (sessions === void 0) return;
-		await this.indexHeaders(sessions.list().map((session) => session.header));
+		await this.indexHeaders(sessions.list().filter((session) => !this.deletedSessionIds.includes(session.id)).map((session) => session.header));
 	}
 	reportFilteredCandidates() {
 		for (const entity of this.entities.values()) {
@@ -990,6 +1197,7 @@ var WorkspaceRegistry = class extends Service {
 			if (domain === void 0) throw new Error("workspace registry is not started yet");
 			return await domain.exclusive(async () => {
 				const before = JSON.stringify([...this.entities.values()].map((entity) => [entity.id, entity.sessionIds]));
+				const previousDeleted = new Set(this.deletedSessionIds);
 				await domain.refresh();
 				const changed = this.snapshotIdentity() !== this.refreshedState;
 				this.state = domain.global.get();
@@ -1000,6 +1208,9 @@ var WorkspaceRegistry = class extends Service {
 					this.rebuildEntities();
 				}
 				await this.recoverPendingMutation();
+				await this.recoverSessionDeletion();
+				const newlyDeleted = this.deletedSessionIds.filter((id) => !previousDeleted.has(id));
+				if (newlyDeleted.length > 0) this.notifyDeleted(newlyDeleted);
 				this.validateStoredState(this.requireState());
 				const after = JSON.stringify([...this.entities.values()].map((entity) => [entity.id, entity.sessionIds]));
 				if (changed || before !== after) try {
@@ -1022,4 +1233,4 @@ var WorkspaceRegistry = class extends Service {
 };
 const sameSessionIds = (left, right) => left.length === right.length && left.every((id, index) => id === right[index]);
 //#endregion
-export { WorkspaceActiveSessionError, WorkspaceArchivedSessionPinError, WorkspaceId, WorkspaceMoveInvalidError, WorkspaceOrderInvalidError, WorkspaceRegistry, WorkspaceRegistry as default, WorkspaceUnknownSessionError, realpathNormalize, workspaceDomainSpec, workspaceDomainState, workspaceRecord };
+export { WorkspaceActiveSessionError, WorkspaceArchivedSessionPinError, WorkspaceId, WorkspaceMoveInvalidError, WorkspaceOrderInvalidError, WorkspaceRegistry, WorkspaceRegistry as default, WorkspaceSessionDeletionError, WorkspaceUnknownSessionError, realpathNormalize, workspaceDomainSpec, workspaceDomainState, workspaceRecord };

package/runtime/node_modules/@deepseek-ai/dsh-workspace/lib/invariant.js

@@ -1,6 +1,7 @@
 import "node:crypto";
 import "node:fs/promises";
 import { Service } from "@deepseek-ai/cordis";
+import "@deepseek-ai/dsh-session-persistence";
 import "node:path";
 import { z } from "zod";
 import { brandString } from "@deepseek-ai/dsh-brand";
@@ -51,7 +52,11 @@ defineDomain({
 			workspaceIds: z.array(workspaceId),
 			archivedSessionIds: z.array(sessionId).default([]),
 			pinnedSessionIds: z.array(sessionId).default([]),
-			pendingMutation: workspacePendingMutation.optional()
+			pendingMutation: workspacePendingMutation.optional(),
+			/** Payload deletion committed identities; old processes must never restore these Sessions. */
+			deletedSessionIds: z.array(sessionId).optional(),
+			/** Complete deletion scope retained until payloads and secondary owners finish cleanup. */
+			pendingSessionDeletion: z.array(sessionId).optional()
 		}),
 		initial: {
 			initialized: false,

package/runtime/node_modules/@deepseek-ai/dsh-workspace/lib/types/index.d.ts

@@ -55,6 +55,16 @@ export declare class WorkspaceArchivedSessionPinError extends Error {
      */
     constructor(sessionId: SessionId);
 }
+/** Permanent deletion requires an archived root and no active Session ownership. */
+export declare class WorkspaceSessionDeletionError extends Error {
+    readonly sessionId: SessionId;
+    readonly reason: 'not-archived' | 'in-use' | 'deleted' | 'scope-changed';
+    /**
+     * @param sessionId - identity whose lifecycle prevents the requested operation.
+     * @param reason - stable refusal discriminant shared by the Web and TUI.
+     */
+    constructor(sessionId: SessionId, reason: 'not-archived' | 'in-use' | 'deleted' | 'scope-changed');
+}
 /** A workspace reorder named a source or anchor absent from the durable registry order. */
 export declare class WorkspaceOrderInvalidError extends Error {
     readonly workspaceId: WorkspaceId;
@@ -202,6 +212,27 @@ export declare class WorkspaceRegistry extends Service {
      * @returns the archived session ids in archive order.
      */
     get archivedSessionIds(): readonly SessionId[];
+    /** Permanently deleted identities retained for cross-process invalidation and stale-operation refusal. */
+    get deletedSessionIds(): readonly SessionId[];
+    /**
+     * Permanently delete an archived, inactive root and its owned subagent descendants.
+     * Independent forks are preserved. Reserve every writer before recording a recovery
+     * marker; a failure after that marker is retried on refresh or restart.
+     * @param sessionId - archived root identity; repeated deletion is idempotent.
+     * @param expectedIds - identities confirmed by the user; a changed scope refuses deletion.
+     * @returns deleted root and descendant identities after durable cleanup.
+     */
+    deleteSession(sessionId: SessionId, expectedIds?: readonly SessionId[]): Promise<readonly SessionId[]>;
+    /**
+     * Preview the root and owned descendants without opening their histories.
+     * @param sessionId - archived root to preview.
+     * @returns identities to show in the deletion confirmation.
+     */
+    sessionDeletionScope(sessionId: SessionId): Promise<readonly SessionId[]>;
+    private collectSessionDeletionScope;
+    private recoverSessionDeletion;
+    private notifyDeleted;
+    private finishSessionDeletion;
     /**
      * Archive one session durably. The session must exist (live or in session
      * persistence); its workspace accounting — or lack of one — is irrelevant.