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

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

@@ -36,6 +36,10 @@ export class WorkspaceEntity {
         this.id = id;
         this.record = record;
     }
+    /** Replace the cached record without changing this entity's identity.
+     * @param record Latest validated workspace record.
+     */
+    replace(record) { this.record = record; }
     get path() {
         return this.record.path;
     }
@@ -134,23 +138,25 @@ export class WorkspaceEntity {
      * rewrites the medium nor emits a change event.
      */
     async mutate(fn) {
-        let next;
-        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);
-                if (changed === current && sessionIds.length === current.sessionIds.length) {
-                    throw unchangedSentinel;
-                }
-                return { ...changed, sessionIds, updatedAt: new Date().toISOString() };
-            });
-        }
-        catch (error) {
-            if (error === unchangedSentinel)
-                return;
-            throw error;
-        }
-        this.record = next;
+        await this.host.enqueue(async () => {
+            let next;
+            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);
+                    if (changed === current && sessionIds.length === current.sessionIds.length) {
+                        throw unchangedSentinel;
+                    }
+                    return { ...changed, sessionIds, updatedAt: new Date().toISOString() };
+                });
+            }
+            catch (error) {
+                if (error === unchangedSentinel)
+                    return;
+                throw error;
+            }
+            this.record = next;
+        });
     }
 }
 //# sourceMappingURL=entity.js.map

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;
@@ -82,6 +92,10 @@ declare module '@deepseek-ai/cordis' {
         workspaceRegistry: WorkspaceRegistry;
     }
     interface Events {
+        /** A refreshed cross-process workspace projection is ready for consumers.
+         * @mode emit
+         */
+        'workspace/refreshed'(): void;
         /**
          * Ask the composed providers what still runs for a session before it is
          * archived. A listener prepends its own {@link SessionActivity} entries to
@@ -120,6 +134,7 @@ declare module '@deepseek-ai/cordis' {
 export declare class WorkspaceRegistry extends Service {
     static inject: string[];
     private table?;
+    private domain?;
     private global?;
     private state?;
     private readonly entities;
@@ -127,10 +142,14 @@ export declare class WorkspaceRegistry extends Service {
     private readonly sessionPaths;
     private readonly invalidSessionPaths;
     private operationTail;
+    private stopping;
+    private refreshedState;
     private readonly host;
     constructor(ctx: Context);
     /** Open the domain, finish bootstrap when required, and rebuild the ordered cache. */
     protected [Service.init](): Promise<void>;
+    /** Refresh shared membership, pins and archives before reading a new view; never auto-attach detached sessions. */
+    refresh(): Promise<void>;
     /**
      * Create or reuse a workspace for an existing directory. The fully qualified
      * path is canonicalized through `fs.realpath`; a relative, nonexistent, or
@@ -193,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.
@@ -285,6 +325,7 @@ export declare class WorkspaceRegistry extends Service {
     private requireState;
     private setState;
     private enqueueOperation;
+    private snapshotIdentity;
 }
 export default WorkspaceRegistry;
 //# sourceMappingURL=index.d.ts.map

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;
@@ -93,6 +161,7 @@ const compareHeaders = (left, right) => right.createdAt - left.createdAt || Stri
 export class WorkspaceRegistry extends Service {
     static inject = ['storageDomain', 'sessionPersistence'];
     table;
+    domain;
     global;
     state;
     entities = new Map();
@@ -100,8 +169,11 @@ export class WorkspaceRegistry extends Service {
     sessionPaths = new Map();
     invalidSessionPaths = new Map();
     operationTail = Promise.resolve();
+    stopping = false;
+    refreshedState = '';
     host = {
         table: () => this.requireTable(),
+        enqueue: operation => this.enqueueOperation(operation),
         sessionPath: id => this.sessionPaths.get(id),
         readSessionHeader: id => this.readSessionHeader(id),
         rememberSessionPath: (id, path) => {
@@ -115,24 +187,57 @@ export class WorkspaceRegistry extends Service {
     /** Open the domain, finish bootstrap when required, and rebuild the ordered cache. */
     async [Service.init]() {
         const domain = await this.ctx.storageDomain.open(workspaceDomainSpec);
-        this.ctx.effect(() => () => domain.close(), 'workspace.domainClose');
+        this.domain = domain;
+        let timer;
+        this.ctx.effect(() => async () => {
+            this.stopping = true;
+            clearTimeout(timer);
+            await this.operationTail;
+            await domain.close();
+        }, 'workspace.domainClose');
         this.table = domain.table('workspaces');
         this.global = domain.global;
         this.state = domain.global.get();
-        await this.recoverPendingMutation();
-        this.validateStoredState(this.state);
-        if (!this.state.initialized) {
-            const headers = await this.listStoredHeaders();
-            await this.replaceHeaderIndex(headers);
-            await this.bootstrap(headers);
-        }
-        else if (this.table.size > 0) {
-            await this.replaceHeaderIndex(await this.listStoredHeaders());
-        }
-        await this.indexLiveSessions();
-        this.validateStoredState(this.requireState());
-        this.rebuildEntities();
-        this.reportFilteredCandidates();
+        await domain.exclusive(async () => {
+            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();
+                await this.replaceHeaderIndex(headers);
+                await this.bootstrap(headers);
+            }
+            else if (this.requireTable().size > 0) {
+                await this.replaceHeaderIndex(await this.listStoredHeaders());
+            }
+            await this.indexLiveSessions();
+            this.validateStoredState(this.requireState());
+            this.rebuildEntities();
+            this.reportFilteredCandidates();
+            this.refreshedState = this.snapshotIdentity();
+        });
+        const poll = async () => {
+            try {
+                await this.refresh();
+            }
+            catch (error) {
+                this.ctx.logger.warn(`workspace: shared state refresh failed: ${String(error)}`);
+            }
+            finally {
+                if (!this.stopping) {
+                    timer = setTimeout(() => { void poll(); }, 1500);
+                    timer.unref();
+                }
+            }
+        };
+        timer = setTimeout(() => { void poll(); }, 1500);
+        timer.unref();
+    }
+    /** Refresh shared membership, pins and archives before reading a new view; never auto-attach detached sessions. */
+    refresh() {
+        return this.enqueueOperation(async () => { });
     }
     /**
      * Create or reuse a workspace for an existing directory. The fully qualified
@@ -260,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.
@@ -313,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();
@@ -386,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))
@@ -684,10 +931,17 @@ export class WorkspaceRegistry extends Service {
         }
     }
     rebuildEntities() {
-        this.entities.clear();
+        const ids = new Set(this.requireState().workspaceIds);
+        for (const id of this.entities.keys())
+            if (!ids.has(id))
+                this.entities.delete(id);
         for (const id of this.requireState().workspaceIds) {
             const record = this.requireTable().get(id);
-            this.entities.set(id, new WorkspaceEntity(this.host, id, record));
+            const entity = this.entities.get(id);
+            if (entity === undefined)
+                this.entities.set(id, new WorkspaceEntity(this.host, id, record));
+            else
+                entity.replace(record);
         }
     }
     async replaceHeaderIndex(headers) {
@@ -723,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()) {
@@ -778,15 +1033,51 @@ export class WorkspaceRegistry extends Service {
         this.state = state;
     }
     enqueueOperation(operation) {
+        if (this.stopping)
+            return Promise.reject(new Error('workspace registry is closing'));
         const result = this.operationTail.then(async () => {
-            // A committed delete may leave only its marker cleanup pending. Retry
-            // recovery before another create/delete can overwrite that pending operation record.
-            await this.recoverPendingMutation();
-            return await operation();
+            const domain = this.domain;
+            if (domain === undefined)
+                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();
+                const missingHeaders = [...this.requireTable().entries()].some(([, record]) => record.sessionIds.some(id => !this.sessionPaths.has(id)));
+                if (changed || missingHeaders) {
+                    await this.replaceHeaderIndex(await this.listStoredHeaders());
+                    await this.indexLiveSessions();
+                    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 {
+                        this.ctx.emit('workspace/refreshed');
+                    }
+                    catch (error) {
+                        this.ctx.logger.warn(`workspace: refresh listener failed: ${String(error)}`);
+                    }
+                }
+                this.refreshedState = this.snapshotIdentity();
+                const result = await operation();
+                this.refreshedState = this.snapshotIdentity();
+                return result;
+            });
         });
         this.operationTail = result.then(() => { }, () => { });
         return result;
     }
+    snapshotIdentity() {
+        return JSON.stringify([this.domain?.global.get(), [...this.requireTable().entries()]]);
+    }
 }
 const sameSessionIds = (left, right) => left.length === right.length && left.every((id, index) => id === right[index]);
 export default WorkspaceRegistry;

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;

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

@@ -51,6 +51,10 @@ export const workspaceDomainState = z.object({
     archivedSessionIds: z.array(sessionId).default([]),
     pinnedSessionIds: z.array(sessionId).default([]),
     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

package/lib/dump-config-CijLv_kn.js

@@ -1,2 +0,0 @@
-import { n as runDumpConfig } from "./dump-config-CauO75nE.js";
-export { runDumpConfig };