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

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

@@ -202,7 +202,12 @@ let ScheduleService = (() => {
                 const stop = ctx.on('workspace/session-stop', async ({ sessionId }) => {
                     await this.stopSessionTasks(sessionId);
                 });
+                const deleted = ctx.on('session/deleting', async ({ sessionIds }) => {
+                    for (const sessionId of sessionIds)
+                        await this.stopSessionTasks(sessionId);
+                });
                 return () => {
+                    deleted();
                     stop();
                     activity();
                 };

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

@@ -50,6 +50,27 @@ declare module '@deepseek-ai/cordis' {
          * @mode emit
          */
         'session/disposed'(this: Scoped<Session>, session: Session): void;
+        /** Ask capability owners to release idle, archived Sessions before writer reservation.
+         * Owners release only handles they own; foreign or running Sessions remain protected.
+         * @param request - confirmed root and owned subagent identities.
+         * @mode parallel
+         */
+        'session/delete-release'(request: {
+            readonly sessionIds: readonly SessionId[];
+        }): Promise<void> | void;
+        /** Permanently remove secondary Session records after stored payload deletion.
+         * Listeners are idempotent; failures leave the deletion journal pending for recovery.
+         * @param request - confirmed root and owned subagent identities.
+         * @mode parallel
+         */
+        'session/deleting'(request: {
+            readonly sessionIds: readonly SessionId[];
+        }): Promise<void> | void;
+        /** Permanent deletion observed locally or from shared storage.
+         * @param sessionIds - removed identities, including owned descendants.
+         * @mode emit
+         */
+        'session/deleted'(sessionIds: readonly SessionId[]): void;
         /**
          * Post-commit, fire-and-forget append feed. The listener snapshot resolves
          * before the log push, but callbacks run after it; observer failures are

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

@@ -264,6 +264,18 @@ var SessionPersistence = class extends Service {
 	constructor(ctx) {
 		super(ctx, "sessionPersistence");
 	}
+	/**
+	* 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.
+	* @param sessionIds - 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.
+	*/
+	prepareDeletion(sessionIds) {
+		return Promise.reject(/* @__PURE__ */ new Error(`Session persistence does not support permanent deletion (${sessionIds.length} targets)`));
+	}
 };
 //#endregion
 export { SessionAlreadyExistsError, SessionAlreadyOwnedError, SessionFormatUnsupportedError, SessionHandleClosedError, SessionOwnershipLostError, SessionPersistence, SessionPersistence as default, SessionPersistenceCorruptionError, SessionPersistenceNotFoundError, SessionPersistenceRevision, SessionReadOnlyError, assertContiguous, assertStoredId, assertVersion, materializeAppendBatch, materializeCreateHeader, sessionFormatVersionRefusal, validateStoredEvents };

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

@@ -71,6 +71,11 @@ export interface SessionPersistenceListOptions {
     /** Optional cancellation for backend listing work. */
     readonly signal?: AbortSignal;
 }
+/** Exclusive reservation for an idempotent, recoverable deletion of stored Sessions. */
+export interface SessionDeletion extends AsyncDisposable {
+    /** Permanently remove owned payloads; already deleted identities remain deleted. */
+    commit(): Promise<void>;
+}
 declare module '@deepseek-ai/cordis' {
     interface Context {
         sessionPersistence: SessionPersistence;
@@ -155,6 +160,16 @@ export declare abstract class SessionPersistence extends Service {
      * @returns one snapshot per stored session.
      */
     abstract list(options?: SessionPersistenceListOptions): Promise<readonly SessionPersistenceSnapshot[]>;
+    /**
+     * 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.
+     * @param sessionIds - 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.
+     */
+    prepareDeletion(sessionIds: readonly SessionId[]): Promise<SessionDeletion>;
 }
 export default SessionPersistence;
 //# sourceMappingURL=index.d.ts.map

package/runtime/node_modules/@deepseek-ai/dsh-session-persistence-jsonl/lib/index.js

@@ -2,7 +2,7 @@ import z from "@deepseek-ai/schemastery";
 import { SessionFormatUnsupportedMigrationError, createSessionFormatCatalogWithChildren, historicalSessionFormatCatalog, sessionFormatCatalog } from "@deepseek-ai/dsh-session-format-catalog";
 import { readdirSync } from "node:fs";
 import { link, lstat, mkdir, mkdtemp, open, readFile, readdir, realpath, rm, stat, truncate } from "node:fs/promises";
-import { basename, dirname, isAbsolute, join, parse, resolve, toNamespacedPath } from "node:path";
+import { basename, dirname, isAbsolute, join, parse, resolve, sep, toNamespacedPath } from "node:path";
 import { performance } from "node:perf_hooks";
 import { scheduler } from "node:timers/promises";
 import { createHash, randomBytes } from "node:crypto";
@@ -2282,6 +2282,8 @@ async function prepareCatalogFacts(parentId, sources, compression, signal) {
 * log, so the memo only needs the sessions in flight between those steps.
 */
 const COLD_LOG_MEMO_MAX_ENTRIES = 2;
+/** Retained with the stable lock inode after payload deletion. Contains no conversation data. */
+const DELETED_FILENAME = ".deleted";
 const DEFAULT_COMPRESSION = "zstd";
 /**
 * Internal scheduling constant, not deployment configuration: balance
@@ -2434,6 +2436,7 @@ var JsonlSessionPersistence = class extends SessionPersistence {
 		toHeaderLine(snapshot, options?.inheritedEventCount);
 		const inheritedEventCount = SessionLogOffset(options?.inheritedEventCount ?? 0);
 		await this.ensureRootEncoding();
+		if (await this.wasDeleted(header.id)) throw new SessionAlreadyExistsError(header.id);
 		options?.signal?.throwIfAborted();
 		if (this.tracker.hasPending(snapshot.id) || await this.findLog(snapshot.id, options?.signal) !== void 0) throw new SessionAlreadyExistsError(snapshot.id);
 		options?.signal?.throwIfAborted();
@@ -2596,6 +2599,88 @@ var JsonlSessionPersistence = class extends SessionPersistence {
 		signal?.throwIfAborted();
 		return snapshots;
 	}
+	async prepareDeletion(sessionIds) {
+		const claimed = [];
+		const held = [];
+		let closed = false;
+		const release = async () => {
+			if (closed) return;
+			closed = true;
+			try {
+				const failures = (await Promise.allSettled(held.map((item) => item.lease.release()))).flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+				if (failures.length > 0) throw new AggregateError(failures, "Session deletion lock release failed");
+			} finally {
+				for (const id of claimed) this.tracker.releaseClaim(id);
+			}
+		};
+		try {
+			await this.ensureRootEncoding();
+			const root = await realpath(this.root).catch((error) => {
+				if (isENOENT(error)) return this.root;
+				throw error;
+			});
+			for (const id of [...new Set(sessionIds)].sort()) {
+				this.tracker.claimWrite(id);
+				claimed.push(id);
+				await this.stat(id);
+				for (const project of await this.listProjectDirs()) {
+					const dir = join(project, encodeSegment(id));
+					const info = await lstat(dir).catch((error) => {
+						if (isENOENT(error)) return void 0;
+						throw error;
+					});
+					if (info === void 0) continue;
+					if (!info.isDirectory()) throw new Error("Session deletion requires an owned directory");
+					const resolved = await realpath(dir).catch((error) => {
+						if (isENOENT(error)) return void 0;
+						throw error;
+					});
+					if (resolved === void 0) continue;
+					if (!resolved.startsWith(root + sep)) throw new Error("Session deletion path escapes its storage root");
+					held.push({
+						dir,
+						lease: await SessionWriteLease.acquire(dir, id)
+					});
+				}
+			}
+			return {
+				commit: async () => {
+					if (closed) throw new Error("Session deletion reservation is closed");
+					for (const { dir } of held) {
+						const marker = await open(join(dir, DELETED_FILENAME), "a", 384);
+						try {
+							await marker.sync();
+						} finally {
+							await marker.close();
+						}
+						await this.syncDirPosix(dir);
+						for (const entry of await readdir(dir)) if (entry !== "session.lock" && entry !== DELETED_FILENAME) await rm(join(dir, entry), {
+							recursive: true,
+							force: true
+						});
+						await this.syncDirPosix(dir);
+					}
+					for (const id of claimed) {
+						this.coldLogMemo.delete(id);
+						this.migrationPreparations.delete(id);
+					}
+				},
+				[Symbol.asyncDispose]: release
+			};
+		} catch (error) {
+			await release();
+			throw error;
+		}
+	}
+	async wasDeleted(id) {
+		for (const project of await this.listProjectDirs()) try {
+			await stat(join(project, encodeSegment(id), DELETED_FILENAME));
+			return true;
+		} catch (error) {
+			if (!isENOENT(error)) throw error;
+		}
+		return false;
+	}
 	/** Resolve and read one stored log, refusing loudly when the artifact is absent. */
 	async requireStoredLog(id, signal) {
 		const selected = await this.findLog(id, signal);
@@ -2931,7 +3016,14 @@ var JsonlSessionPersistence = class extends SessionPersistence {
 	*/
 	async acquireWriteLease(header) {
 		await this.rejectOppositeArtifact(header.cwd, header.id);
-		return this.acquireLease(header.id, header.cwd);
+		const lease = await this.acquireLease(header.id, header.cwd);
+		try {
+			if (await this.wasDeleted(header.id)) throw new SessionAlreadyExistsError(header.id);
+			return lease;
+		} catch (error) {
+			await lease.release();
+			throw error;
+		}
 	}
 	/** Decode complete frames and retain complete JSONL records from a torn final frame. */
 	async readZstdPrefix(buffer, signal) {
@@ -3334,6 +3426,7 @@ var JsonlSessionPersistence = class extends SessionPersistence {
 			throw error;
 		}
 		signal?.throwIfAborted();
+		if (entries.some((entry) => entry.name === DELETED_FILENAME)) return void 0;
 		const generations = [];
 		const opposite = [];
 		for (const entry of entries) {

package/runtime/node_modules/@deepseek-ai/dsh-session-persistence-jsonl/lib/types/index.d.ts

@@ -7,7 +7,7 @@
  */
 import { Context } from '@deepseek-ai/cordis';
 import z from '@deepseek-ai/schemastery';
-import { SessionPersistence, type SessionAccess, type SessionHandle, type SessionHandleReadResult, type SessionPersistenceCreateOptions, type SessionPersistenceListOptions, type SessionPersistenceOpenOptions, type SessionPersistenceSnapshot, type SessionPersistenceStatOptions, type SessionPersistenceRevision as PersistenceRevision } from '@deepseek-ai/dsh-session-persistence';
+import { SessionPersistence, type SessionAccess, type SessionHandle, type SessionDeletion, type SessionHandleReadResult, type SessionPersistenceCreateOptions, type SessionPersistenceListOptions, type SessionPersistenceOpenOptions, type SessionPersistenceSnapshot, type SessionPersistenceStatOptions, type SessionPersistenceRevision as PersistenceRevision } from '@deepseek-ai/dsh-session-persistence';
 import { JsonlSessionHandle } from './storage.ts';
 import { SessionWriteLease } from './lease.ts';
 import type { SessionEvent, SessionId, SessionHeader, SessionLogOffset as SessionLogOffsetType } from '@deepseek-ai/dsh-session';
@@ -118,6 +118,8 @@ declare class JsonlSessionPersistence extends SessionPersistence {
      * @returns one snapshot per session, in no promised order.
      */
     list(options?: SessionPersistenceListOptions): Promise<readonly SessionPersistenceSnapshot[]>;
+    prepareDeletion(sessionIds: readonly SessionId[]): Promise<SessionDeletion>;
+    private wasDeleted;
     /** Resolve and read one stored log, refusing loudly when the artifact is absent. */
     private requireStoredLog;
     /** Probe the memo and otherwise decode one historical generation under backend cancellation. */

package/runtime/node_modules/@deepseek-ai/dsh-session-projection-cache/lib/index.js

@@ -155,6 +155,7 @@ var SessionProjectionCache = class extends Service {
 	listingTable;
 	writes = Promise.resolve();
 	closed = false;
+	deleted = /* @__PURE__ */ new Set();
 	dirty = /* @__PURE__ */ new Map();
 	constructor(ctx, config) {
 		super(ctx, "sessionProjectionCache");
@@ -173,6 +174,24 @@ var SessionProjectionCache = class extends Service {
 			await this.writes;
 		}, "sessionProjectionCache.writeDrain");
 		this.installWritePath();
+		const cleanup = (ids) => {
+			for (const id of ids) this.deleted.add(id);
+			return this.enqueueWrite(async () => {
+				for (const id of ids) {
+					await this.requireTable().delete(id);
+					await this.requireListingTable().delete(id);
+				}
+			});
+		};
+		this.ctx.on("session/deleting", ({ sessionIds }) => cleanup(sessionIds));
+		this.ctx.on("session/deleted", (ids) => {
+			cleanup(ids).catch((error) => {
+				this.ctx.logger.warn(`session projection cache: deletion cleanup failed: ${String(error)}`);
+			});
+		});
+		this.ctx.inject(["workspaceRegistry"], async (ctx) => {
+			await cleanup(ctx.workspaceRegistry.deletedSessionIds);
+		});
 	}
 	/**
 	* The stored record for one session, accepted only when its bound log
@@ -185,6 +204,7 @@ var SessionProjectionCache = class extends Service {
 	* @returns the identity-matching record, or `undefined` (absent or unrelated).
 	*/
 	async recordFor(id, expected) {
+		if (this.deleted.has(id)) return void 0;
 		const record = await this.requireTable().read(id);
 		if (record === void 0) return void 0;
 		return identityMatches(record.identity, expected) ? record : void 0;
@@ -240,14 +260,17 @@ var SessionProjectionCache = class extends Service {
 	/** Read a small listing record, deriving it once from an older full checkpoint when needed. */
 	async listingRecord(id) {
 		await this.writes;
+		if (this.deleted.has(id)) return void 0;
 		const signature = this.ctx.sessionProjections.checkpointViewSignature();
 		const stored = await this.requireListingTable().read(id);
 		if (stored?.signature === signature) return stored.checkpoint;
+		if (this.deleted.has(id)) return void 0;
 		const record = await this.requireTable().read(id);
 		if (record === void 0) return void 0;
 		const listing = this.listingOf(record, signature);
 		await this.enqueueWrite(async () => {
-			if (await this.requireTable().read(id) === record) await this.requireListingTable().put(id, listing);
+			const current = await this.requireTable().read(id);
+			if (!this.deleted.has(id) && current === record) await this.requireListingTable().put(id, listing);
 		}).catch((error) => {
 			this.ctx.logger.warn(`session projection cache: listing write-back for "${id}" failed: ${String(error)}`);
 		});
@@ -402,6 +425,7 @@ var SessionProjectionCache = class extends Service {
 			rows: detached
 		};
 		await this.enqueueWrite(async () => {
+			if (this.deleted.has(id)) return;
 			await this.requireTable().put(id, record);
 			const listing = this.listingOf(record, this.ctx.sessionProjections.checkpointViewSignature());
 			await this.requireListingTable().put(id, listing);

package/runtime/node_modules/@deepseek-ai/dsh-session-projection-cache/lib/types/index.d.ts

@@ -57,6 +57,7 @@ export declare class SessionProjectionCache extends Service {
     private listingTable?;
     private writes;
     private closed;
+    private readonly deleted;
     private readonly dirty;
     constructor(ctx: Context, config: Config);
     /** Open both on-demand domains and install the write-behind listeners. */

package/runtime/node_modules/@deepseek-ai/dsh-session-projection-cache/package.json

@@ -45,6 +45,7 @@
     "@deepseek-ai/dsh-session-projection": "workspace:*",
     "@deepseek-ai/dsh-storage": "workspace:*",
     "@deepseek-ai/dsh-storage-domain": "workspace:*",
-    "@deepseek-ai/dsh-storage-json": "workspace:*"
+    "@deepseek-ai/dsh-storage-json": "workspace:*",
+    "@deepseek-ai/dsh-workspace": "workspace:*"
   }
 }

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

@@ -331,6 +331,13 @@ var SessionObservationReader = class {
 	cacheCapacity;
 	cache = /* @__PURE__ */ new Map();
 	/**
+	* Drop deleted identities while existing observation leases settle independently.
+	* @param ids - permanently deleted Session identities.
+	*/
+	forget(ids) {
+		for (const id of ids) this.cache.delete(id);
+	}
+	/**
 	* @param ctx - context carrying Session and optional persistence/projection services.
 	* @param cacheCapacity - maximum unpinned cold observations retained for reuse.
 	*/
@@ -1055,6 +1062,12 @@ var SessionQueryEngine = class extends Service {
 		if (!Number.isSafeInteger(preparedSessionCacheSize) || preparedSessionCacheSize < 1) throw new SessionQueryError("session-query: preparedSessionCacheSize must be a positive safe integer", "SESSION_QUERY_INVALID_CONFIG");
 		this._corpus = new SessionCorpus(ctx, persistedReadConcurrency);
 		this._observations = new SessionObservationReader(ctx, preparedSessionCacheSize);
+		ctx.on("session/deleting", ({ sessionIds }) => {
+			this._observations.forget(sessionIds);
+		});
+		ctx.on("session/deleted", (ids) => {
+			this._observations.forget(ids);
+		});
 	}
 	/**
 	* Observe one exact live or prepared Session without a persistence listing preflight.

package/runtime/node_modules/@deepseek-ai/dsh-session-query/lib/types/observation.d.ts

@@ -50,6 +50,11 @@ export declare class SessionObservationReader {
     private readonly ctx;
     private readonly cacheCapacity;
     private readonly cache;
+    /**
+     * Drop deleted identities while existing observation leases settle independently.
+     * @param ids - permanently deleted Session identities.
+     */
+    forget(ids: readonly SessionId[]): void;
     /**
      * @param ctx - context carrying Session and optional persistence/projection services.
      * @param cacheCapacity - maximum unpinned cold observations retained for reuse.

package/runtime/node_modules/@deepseek-ai/dsh-session-query-sqlite/lib/index.js

@@ -529,6 +529,32 @@ var SqliteSessionQueryEngine = class extends SessionQueryEngine {
 			return () => this._optionalPersistenceFiber.dispose();
 		}, "sessionQuerySqlite.optionalPersistence");
 		ctx.effect(() => async () => this.close(), "sessionQuerySqlite.close");
+		const cleanup = (ids) => this._serialized(void 0, async () => {
+			if (ids.length === 0 || this.config.openAt === "never") return;
+			await this._ensureReady(void 0);
+			const db = this._requireDb();
+			db.exec("BEGIN IMMEDIATE");
+			try {
+				for (const id of ids) {
+					this._deleteSession("persisted", id);
+					this._deleteSession("live", id);
+				}
+				db.exec("COMMIT");
+			} catch (error) {
+				db.exec("ROLLBACK");
+				throw error;
+			}
+			this._globalGeneration += 1;
+		});
+		ctx.on("session/deleting", ({ sessionIds }) => cleanup(sessionIds));
+		ctx.on("session/deleted", (ids) => {
+			cleanup(ids).catch((error) => {
+				ctx.logger.warn(`session query: deletion cleanup failed: ${String(error)}`);
+			});
+		});
+		ctx.inject(["workspaceRegistry"], async (ctx) => {
+			await cleanup(ctx.workspaceRegistry.deletedSessionIds);
+		});
 	}
 	/** Open eagerly only when activation owns the configured readiness boundary. */
 	async [Service.init]() {

package/runtime/node_modules/@deepseek-ai/dsh-session-query-sqlite/package.json

@@ -47,6 +47,7 @@
     "@deepseek-ai/dsh-session-persistence-jsonl": "workspace:*",
     "@deepseek-ai/dsh-session-query": "workspace:*",
     "@deepseek-ai/cordis": "workspace:~",
-    "@deepseek-ai/dsh-session-projection": "workspace:*"
+    "@deepseek-ai/dsh-session-projection": "workspace:*",
+    "@deepseek-ai/dsh-workspace": "workspace:*"
   }
 }

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

@@ -337,9 +337,13 @@ var KvTableImpl = class {
 	}
 	delete(key) {
 		return this.host.enqueue(async () => {
-			if (!this.records.has(key)) return false;
+			if (!(this.records.has(key) || this.host.readStored !== void 0 && await this.host.unit.readRecord(this.tableName, key) !== void 0)) {
+				this.loaded.add(key);
+				return false;
+			}
 			await this.host.unit.deleteRecord(this.tableName, key);
 			this.records.delete(key);
+			this.loaded.add(key);
 			this.host.emitChanged({
 				domain: this.host.domainName,
 				table: this.tableName,

package/runtime/node_modules/@deepseek-ai/dsh-storage-domain/lib/types/domain.d.ts

@@ -115,8 +115,8 @@ export interface Domain<S extends DomainSpec> {
      */
     close(): Promise<void>;
 }
-/** Keyed reads and complete replacements without whole-table enumeration. */
-export type RecordTable<K extends string, V> = Pick<KvTable<K, V>, 'read' | 'put'>;
+/** Keyed reads, complete replacements, and removals without whole-table enumeration. */
+export type RecordTable<K extends string, V> = Pick<KvTable<K, V>, 'read' | 'put' | 'delete'>;
 /** Per-record domain opened without loading its records. No global slot is exposed. */
 export interface RecordDomain<S extends DomainSpec> {
     /** Domain name from the spec. */

package/runtime/node_modules/@deepseek-ai/dsh-subagent/lib/types/control.d.ts

@@ -12,8 +12,8 @@ declare const CONTROL_ID_SCHEMAS: {
         childSessionId: z.ZodString;
         mode: z.ZodLiteral<"continuable">;
         delivery: z.ZodEnum<{
-            steer: "steer";
             queue: "queue";
+            steer: "steer";
         }>;
     }, z.core.$strip>;
     readonly 'subagent.interrupt': z.ZodObject<{