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

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.

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

@@ -4,9 +4,62 @@
  * domain data form.
  * @module @deepseek-ai/dsh-workspace
  */
+var __addDisposableResource = (this && this.__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: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__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;
+});
 import { randomUUID } from 'node:crypto';
 import { mkdir, stat } from 'node:fs/promises';
 import { Service } from '@deepseek-ai/cordis';
+import { SessionAlreadyOwnedError } from '@deepseek-ai/dsh-session-persistence';
 import { WorkspaceEntity } from "./entity.js";
 export { WorkspaceMoveInvalidError } from "./entity.js";
 import { defaultWorkspaceTitle, fullyQualifiedWorkspacePath, realpathNormalize } from "./paths.js";
@@ -69,6 +122,21 @@ export class WorkspaceArchivedSessionPinError extends Error {
         this.name = 'WorkspaceArchivedSessionPinError';
     }
 }
+/** Permanent deletion requires an archived root and no active Session ownership. */
+export class WorkspaceSessionDeletionError 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. */
 export class WorkspaceOrderInvalidError extends Error {
     workspaceId;
@@ -134,6 +202,7 @@ export class WorkspaceRegistry 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();
@@ -296,6 +365,144 @@ export class WorkspaceRegistry 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 !== undefined && (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) !== undefined)
+                        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 !== undefined
+                    && 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 === undefined)
+                return;
+            const reservation = __addDisposableResource(env_2, await this.ctx.sessionPersistence.prepareDeletion(ids), true);
+            await reservation.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: 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: undefined,
+        });
+        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.
@@ -349,6 +556,8 @@ export class WorkspaceRegistry extends Service {
      */
     unarchiveSession(sessionId) {
         return this.enqueueOperation(async () => {
+            if (this.deletedSessionIds.includes(sessionId))
+                throw new WorkspaceSessionDeletionError(sessionId, 'deleted');
             // The chain slot serializes against every other registry write, so this
             // check-then-write pair cannot interleave with a concurrent archive.
             const state = this.requireState();
@@ -422,6 +631,8 @@ export class WorkspaceRegistry extends Service {
      * masquerade as an unknown session.
      */
     async sessionKnown(id) {
+        if (this.deletedSessionIds.includes(id))
+            return false;
         if (this.ctx.get('sessions')?.get(id) !== undefined)
             return true;
         if (this.headers.has(id))
@@ -766,13 +977,14 @@ export class WorkspaceRegistry extends Service {
     /** Every stored session's header, projected from the persistence snapshot listing. */
     async listStoredHeaders() {
         const snapshots = await this.ctx.sessionPersistence.list();
-        return snapshots.map(snapshot => snapshot.header);
+        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 === undefined)
             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()) {
@@ -829,6 +1041,7 @@ export class WorkspaceRegistry extends Service {
                 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();
@@ -839,6 +1052,10 @@ export class WorkspaceRegistry 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) {

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

@@ -46,6 +46,8 @@ export declare const workspaceDomainState: z.ZodObject<{
         operation: z.ZodLiteral<"delete">;
         workspaceId: z.ZodPipe<z.ZodString, z.ZodTransform<WorkspaceId, string>>;
     }, z.core.$strip>], "operation">>;
+    deletedSessionIds: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<SessionId, string>>>>;
+    pendingSessionDeletion: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<SessionId, string>>>>;
 }, z.core.$strip>;
 /** Durable registry state inferred from {@link workspaceDomainState}. */
 export type WorkspaceDomainState = z.infer<typeof workspaceDomainState>;
@@ -72,6 +74,8 @@ export declare const workspaceDomainSpec: {
                 operation: z.ZodLiteral<"delete">;
                 workspaceId: z.ZodPipe<z.ZodString, z.ZodTransform<WorkspaceId, string>>;
             }, z.core.$strip>], "operation">>;
+            deletedSessionIds: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<SessionId, string>>>>;
+            pendingSessionDeletion: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<SessionId, string>>>>;
         }, z.core.$strip>;
         initial: {
             initialized: boolean;