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

package/runtime/node_modules/@deepseek-ai/dsh-api-workspace-controller/lib/types/client/service.d.ts

@@ -85,6 +85,19 @@ export interface IWorkspaces {
      * @param sessionId - Session to unarchive.
      */
     unarchiveSession(sessionId: SessionId): Promise<void>;
+    /**
+     * Preview the archived root and owned subagent identities before confirmation.
+     * @param sessionId - archived root identity.
+     * @returns the identities covered by confirmation.
+     */
+    sessionDeletionScope(sessionId: SessionId): Promise<readonly SessionId[]>;
+    /**
+     * Permanently delete exactly the confirmed scope; live or changed scopes reject.
+     * @param sessionId - archived root identity.
+     * @param expectedSessionIds - identities confirmed by the user.
+     * @returns the identities removed after durable cleanup.
+     */
+    deleteSession(sessionId: SessionId, expectedSessionIds: readonly SessionId[]): Promise<readonly SessionId[]>;
     /**
      * Pin a Session ahead of unpinned Sessions on Workspace grouping surfaces.
      * @param sessionId - Session to pin.
@@ -124,6 +137,8 @@ export declare class WorkspaceController extends Service implements IWorkspaces
         readonly stopActivity?: boolean;
     }): Promise<void>;
     unarchiveSession(sessionId: SessionId): Promise<void>;
+    sessionDeletionScope(sessionId: SessionId): Promise<readonly SessionId[]>;
+    deleteSession(sessionId: SessionId, expectedSessionIds: readonly SessionId[]): Promise<readonly SessionId[]>;
     pinSession(sessionId: SessionId): Promise<void>;
     unpinSession(sessionId: SessionId): Promise<void>;
     insertSessionBefore(workspaceId: WorkspaceId, sessionId: SessionId, beforeSessionId?: SessionId): Promise<WorkspaceView>;

package/runtime/node_modules/@deepseek-ai/dsh-api-workspace-controller/lib/types/client/service.js

@@ -75,6 +75,18 @@ export class WorkspaceController extends Service {
         if (!result.ok)
             throw commandError('session unarchive', result.error);
     }
+    async sessionDeletionScope(sessionId) {
+        const result = await this.model.sessionDeletionScope(sessionId);
+        if (!result.ok)
+            throw new WorkspaceArchiveError(result.error);
+        return result.value.sessionIds;
+    }
+    async deleteSession(sessionId, expectedSessionIds) {
+        const result = await this.model.deleteSession(sessionId, expectedSessionIds);
+        if (!result.ok)
+            throw new WorkspaceArchiveError(result.error);
+        return result.value.sessionIds;
+    }
     async pinSession(sessionId) {
         const result = await this.model.pinSession(sessionId);
         if (!result.ok)

package/runtime/node_modules/@deepseek-ai/dsh-api-workspace-controller/lib/types/commands.d.ts

@@ -1,6 +1,6 @@
 /** Workspace command implementation and stable Remote failure mapping. */
 import type { Context } from '@deepseek-ai/cordis';
-import type { WorkspaceArchiveSessionRequest, WorkspaceArchiveValue, WorkspaceCreateRequest, WorkspaceCreateValue, WorkspaceDeleteRequest, WorkspaceDeleteValue, WorkspaceInsertBeforeRequest, WorkspaceInsertSessionBeforeRequest, WorkspaceOrderValue, WorkspacePinSessionRequest, WorkspacePinValue, WorkspaceRenameRequest, WorkspaceUnarchiveSessionRequest, WorkspaceUnpinSessionRequest, WorkspaceValue } from './types.ts';
+import type { WorkspaceArchiveSessionRequest, WorkspaceArchiveValue, WorkspaceCreateRequest, WorkspaceCreateValue, WorkspaceDeleteRequest, WorkspaceDeleteValue, WorkspaceInsertBeforeRequest, WorkspaceInsertSessionBeforeRequest, WorkspaceOrderValue, WorkspacePinSessionRequest, WorkspacePinValue, WorkspaceRenameRequest, WorkspaceUnarchiveSessionRequest, WorkspaceUnpinSessionRequest, WorkspaceValue, WorkspaceSessionDeletionPreviewRequest, WorkspaceSessionDeletionRequest, WorkspaceSessionDeletionValue } from './types.ts';
 /** Implements Workspace mutations against the authoritative registry. */
 export declare class WorkspaceCommands {
     private readonly ctx;
@@ -54,6 +54,18 @@ export declare class WorkspaceCommands {
      * @returns the complete resulting archive set.
      */
     unarchiveSession(request: WorkspaceUnarchiveSessionRequest): Promise<WorkspaceArchiveValue>;
+    /**
+     * Preview the Session identities that would be permanently deleted.
+     * @param request - archived root to preview.
+     * @returns the complete deletion scope for confirmation.
+     */
+    sessionDeletionScope(request: WorkspaceSessionDeletionPreviewRequest): Promise<WorkspaceSessionDeletionValue>;
+    /**
+     * Delete an archived root and exactly its confirmed owned subagent scope.
+     * @param request - root and user-confirmed deletion scope.
+     * @returns identities removed after persistence and owner cleanup complete.
+     */
+    deleteSession(request: WorkspaceSessionDeletionRequest): Promise<WorkspaceSessionDeletionValue>;
     /**
      * Add one known unarchived Session to the registry-global pin set.
      * @param request - Session identity to pin.

package/runtime/node_modules/@deepseek-ai/dsh-api-workspace-controller/lib/types/commands.js

@@ -1,5 +1,5 @@
 /** Workspace command implementation and stable Remote failure mapping. */
-import { WorkspaceActiveSessionError, WorkspaceArchivedSessionPinError, WorkspaceId, WorkspaceMoveInvalidError, WorkspaceOrderInvalidError, WorkspaceUnknownSessionError, } from '@deepseek-ai/dsh-workspace';
+import { WorkspaceActiveSessionError, WorkspaceArchivedSessionPinError, WorkspaceId, WorkspaceMoveInvalidError, WorkspaceOrderInvalidError, WorkspaceUnknownSessionError, WorkspaceSessionDeletionError, } from '@deepseek-ai/dsh-workspace';
 import { RemoteError, remoteErrorOf } from '@deepseek-ai/dsh-typert-protocol';
 import { workspaceView } from "./feed.js";
 /** Implements Workspace mutations against the authoritative registry. */
@@ -138,9 +138,40 @@ export class WorkspaceCommands {
      * @returns the complete resulting archive set.
      */
     async unarchiveSession(request) {
-        await this.ctx.workspaceRegistry.unarchiveSession(request.sessionId);
+        try {
+            await this.ctx.workspaceRegistry.unarchiveSession(request.sessionId);
+        }
+        catch (error) {
+            throw deletionError(error, request.sessionId);
+        }
         return { archivedSessionIds: [...this.ctx.workspaceRegistry.archivedSessionIds] };
     }
+    /**
+     * Preview the Session identities that would be permanently deleted.
+     * @param request - archived root to preview.
+     * @returns the complete deletion scope for confirmation.
+     */
+    async sessionDeletionScope(request) {
+        try {
+            return { sessionIds: await this.ctx.workspaceRegistry.sessionDeletionScope(request.sessionId) };
+        }
+        catch (error) {
+            throw deletionError(error, request.sessionId);
+        }
+    }
+    /**
+     * Delete an archived root and exactly its confirmed owned subagent scope.
+     * @param request - root and user-confirmed deletion scope.
+     * @returns identities removed after persistence and owner cleanup complete.
+     */
+    async deleteSession(request) {
+        try {
+            return { sessionIds: await this.ctx.workspaceRegistry.deleteSession(request.sessionId, request.expectedSessionIds) };
+        }
+        catch (error) {
+            throw deletionError(error, request.sessionId);
+        }
+    }
     /**
      * Add one known unarchived Session to the registry-global pin set.
      * @param request - Session identity to pin.
@@ -187,6 +218,17 @@ export class WorkspaceCommands {
 function workspaceNotFound(workspaceId) {
     return new RemoteError('workspace/not-found', `Workspace "${workspaceId}" not found`, { workspaceId });
 }
+function deletionError(error, sessionId) {
+    if (error instanceof WorkspaceSessionDeletionError) {
+        return new RemoteError('workspace/session-delete-refused', 'Session deletion refused', {
+            sessionId, reason: error.reason,
+        }, { cause: error });
+    }
+    if (error instanceof WorkspaceActiveSessionError) {
+        return new RemoteError('workspace/session-active', error.message, { sessionId, activity: error.activity }, { cause: error });
+    }
+    return error;
+}
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }

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

@@ -2,7 +2,7 @@
 import { Context } from '@deepseek-ai/cordis';
 import z from '@deepseek-ai/schemastery';
 import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
-import type { WorkspaceArchiveSessionRequest, WorkspaceArchiveValue, WorkspaceCreateRequest, WorkspaceCreateValue, WorkspaceDeleteRequest, WorkspaceDeleteValue, WorkspaceFollowFrame, WorkspaceInsertBeforeRequest, WorkspaceInsertSessionBeforeRequest, WorkspaceOrderValue, WorkspacePinSessionRequest, WorkspacePinValue, WorkspaceRenameRequest, WorkspaceUnarchiveSessionRequest, WorkspaceUnpinSessionRequest, WorkspaceValue } from './types.ts';
+import type { WorkspaceArchiveSessionRequest, WorkspaceArchiveValue, WorkspaceCreateRequest, WorkspaceCreateValue, WorkspaceDeleteRequest, WorkspaceDeleteValue, WorkspaceFollowFrame, WorkspaceInsertBeforeRequest, WorkspaceInsertSessionBeforeRequest, WorkspaceOrderValue, WorkspacePinSessionRequest, WorkspacePinValue, WorkspaceRenameRequest, WorkspaceUnarchiveSessionRequest, WorkspaceSessionDeletionPreviewRequest, WorkspaceSessionDeletionRequest, WorkspaceSessionDeletionValue, WorkspaceUnpinSessionRequest, WorkspaceValue } from './types.ts';
 export type * from './types.ts';
 export { DirectoryPickerController } from './directory-picker.ts';
 /** First-use directory policy for the Host account. */
@@ -85,6 +85,18 @@ export declare class WorkspaceController extends TypertRemoteService {
      * @returns the complete resulting archive set.
      */
     unarchiveSession(request: WorkspaceUnarchiveSessionRequest): Promise<WorkspaceArchiveValue>;
+    /**
+     * Preview the archived root and owned subagent Sessions covered by deletion.
+     * @param request - archived root to preview.
+     * @returns complete deletion scope for confirmation.
+     */
+    sessionDeletionScope(request: WorkspaceSessionDeletionPreviewRequest): Promise<WorkspaceSessionDeletionValue>;
+    /**
+     * Permanently remove an archived Session and its confirmed owned subagents.
+     * @param request - archived root and confirmed scope.
+     * @returns identities permanently removed.
+     */
+    deleteSession(request: WorkspaceSessionDeletionRequest): Promise<WorkspaceSessionDeletionValue>;
     /**
      * Surface one known unarchived Session ahead of unpinned Sessions.
      * @param request - Session identity to pin.

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

@@ -52,6 +52,8 @@ let WorkspaceController = (() => {
     let _insertSessionBefore_decorators;
     let _archiveSession_decorators;
     let _unarchiveSession_decorators;
+    let _sessionDeletionScope_decorators;
+    let _deleteSession_decorators;
     let _pinSession_decorators;
     let _unpinSession_decorators;
     let _follow_decorators;
@@ -66,6 +68,8 @@ let WorkspaceController = (() => {
             _insertSessionBefore_decorators = [Remote('insertSessionBefore')];
             _archiveSession_decorators = [Remote('archiveSession')];
             _unarchiveSession_decorators = [Remote('unarchiveSession')];
+            _sessionDeletionScope_decorators = [Remote('sessionDeletionScope')];
+            _deleteSession_decorators = [Remote('deleteSession')];
             _pinSession_decorators = [Remote('pinSession')];
             _unpinSession_decorators = [Remote('unpinSession')];
             _follow_decorators = [Remote({ mode: 'stream' })];
@@ -77,6 +81,8 @@ let WorkspaceController = (() => {
             __esDecorate(this, null, _insertSessionBefore_decorators, { kind: "method", name: "insertSessionBefore", static: false, private: false, access: { has: obj => "insertSessionBefore" in obj, get: obj => obj.insertSessionBefore }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _archiveSession_decorators, { kind: "method", name: "archiveSession", static: false, private: false, access: { has: obj => "archiveSession" in obj, get: obj => obj.archiveSession }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _unarchiveSession_decorators, { kind: "method", name: "unarchiveSession", static: false, private: false, access: { has: obj => "unarchiveSession" in obj, get: obj => obj.unarchiveSession }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _sessionDeletionScope_decorators, { kind: "method", name: "sessionDeletionScope", static: false, private: false, access: { has: obj => "sessionDeletionScope" in obj, get: obj => obj.sessionDeletionScope }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _deleteSession_decorators, { kind: "method", name: "deleteSession", static: false, private: false, access: { has: obj => "deleteSession" in obj, get: obj => obj.deleteSession }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _pinSession_decorators, { kind: "method", name: "pinSession", static: false, private: false, access: { has: obj => "pinSession" in obj, get: obj => obj.pinSession }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _unpinSession_decorators, { kind: "method", name: "unpinSession", static: false, private: false, access: { has: obj => "unpinSession" in obj, get: obj => obj.unpinSession }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _follow_decorators, { kind: "method", name: "follow", static: false, private: false, access: { has: obj => "follow" in obj, get: obj => obj.follow }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -178,6 +184,22 @@ let WorkspaceController = (() => {
         unarchiveSession(request) {
             return this.commands.unarchiveSession(request);
         }
+        /**
+         * Preview the archived root and owned subagent Sessions covered by deletion.
+         * @param request - archived root to preview.
+         * @returns complete deletion scope for confirmation.
+         */
+        sessionDeletionScope(request) {
+            return this.commands.sessionDeletionScope(request);
+        }
+        /**
+         * Permanently remove an archived Session and its confirmed owned subagents.
+         * @param request - archived root and confirmed scope.
+         * @returns identities permanently removed.
+         */
+        deleteSession(request) {
+            return this.commands.deleteSession(request);
+        }
         /**
          * Surface one known unarchived Session ahead of unpinned Sessions.
          * @param request - Session identity to pin.

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

@@ -42,6 +42,11 @@ declare module '@deepseek-ai/dsh-typert-protocol' {
             readonly sessionId: SessionId;
             readonly activity: readonly SessionActivity[];
         };
+        /** Permanent deletion was refused before storage mutation. */
+        'workspace/session-delete-refused': {
+            readonly sessionId: SessionId;
+            readonly reason: 'not-archived' | 'in-use' | 'deleted' | 'scope-changed';
+        };
         /** The Session or its anchor is not in the Workspace's manual order. */
         'workspace/move-invalid': {
             readonly workspaceId: WorkspaceId;
@@ -123,6 +128,18 @@ export interface WorkspaceArchiveSessionRequest {
 export interface WorkspaceUnarchiveSessionRequest {
     readonly sessionId: SessionId;
 }
+/** Archived root whose deletion scope is requested. */
+export interface WorkspaceSessionDeletionPreviewRequest {
+    readonly sessionId: SessionId;
+}
+/** Archived root and the exact scope confirmed by the user. */
+export interface WorkspaceSessionDeletionRequest extends WorkspaceSessionDeletionPreviewRequest {
+    readonly expectedSessionIds: readonly SessionId[];
+}
+/** Root and owned subagent identities; independent forks are excluded. */
+export interface WorkspaceSessionDeletionValue {
+    readonly sessionIds: readonly SessionId[];
+}
 /** Complete archived Session set after a mutation. */
 export interface WorkspaceArchiveValue {
     readonly archivedSessionIds: readonly SessionId[];

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

@@ -3922,7 +3922,8 @@ const requiredStartupEntryIds = new Set([
 	"connection",
 	"headless-runner",
 	"acp",
-	"sdk-jsonrpc-server"
+	"sdk-jsonrpc-server",
+	"dsh-tui"
 ]);
 /** Render plugin stacks, nested causes, and aggregate member failures once per error. */
 function formatActivationError(error) {

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

@@ -1,6 +1,122 @@
 import { createHash, randomBytes } from "node:crypto";
-import { lstat, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
+import { link, lstat, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, win32 } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+//#region lib/types/windows-lock.js
+/** Exclusive Windows inspection for an empty or zero-filled lock left by a failed creator. */
+const execute = promisify(execFile);
+/**
+* Read a small lock only when no other handle has the file open.
+* @param path - lock path, protected by the caller's takeover claim.
+* @returns its record, or undefined if exclusive access or inspection fails.
+*/
+async function readUnopenedWindowsLock(path) {
+	const powershell = win32.join(process.env.SystemRoot ?? "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+	const script = [
+		"$ErrorActionPreference = 'Stop'",
+		`$file = [IO.File]::Open('${path.replaceAll("'", "''")}', [IO.FileMode]::Open, [IO.FileAccess]::Read, [IO.FileShare]::None)`,
+		"try {",
+		"  if ($file.Length -gt 64) { exit 1 }",
+		"  $reader = [IO.StreamReader]::new($file, [Text.Encoding]::UTF8, $false)",
+		"  try { [Console]::Out.Write([Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($reader.ReadToEnd()))) }",
+		"  finally { $reader.Dispose() }",
+		"} finally { $file.Dispose() }"
+	].join("\n");
+	try {
+		const { stdout } = await execute(powershell, [
+			"-NoLogo",
+			"-NoProfile",
+			"-NonInteractive",
+			"-EncodedCommand",
+			Buffer.from(script, "utf16le").toString("base64")
+		], {
+			encoding: "utf8",
+			windowsHide: true,
+			timeout: 2e3,
+			maxBuffer: 4096,
+			env: Object.fromEntries(Object.entries(process.env).filter(([name]) => !/KEY|SECRET|TOKEN|PASSWORD/i.test(name)))
+		});
+		const value = stdout.trim();
+		const bytes = Buffer.from(value, "base64");
+		if (bytes.length > 64 || bytes.toString("base64") !== value) return void 0;
+		return bytes.toString("utf8");
+	} catch (error) {
+		return;
+	}
+}
+//#endregion
+//#region lib/types/linux-lock.js
+/** Linux writer identity and complete-record publication; other platforms retain PID records. */
+const RECORD = /^(\d+)\r?\n(?:linux ([a-f0-9-]{36}) (\d+) ([a-f0-9]{24})\n)?$/u;
+let ownIdentity;
+/** Read kernel identity without treating inaccessible procfs as evidence of an exited writer. */
+async function identity(pid) {
+	try {
+		const [boot, stat] = await Promise.all([readFile("/proc/sys/kernel/random/boot_id", "utf8"), readFile(`/proc/${pid}/stat`, "utf8")]);
+		const end = stat.lastIndexOf(")");
+		const start = end < 0 ? void 0 : stat.slice(end + 2).trim().split(/\s+/u)[19];
+		if (!/^[a-f0-9-]{36}$/u.test(boot.trim()) || start === void 0 || !/^\d+$/u.test(start)) return void 0;
+		return `${boot.trim()} ${start}`;
+	} catch (error) {
+		return;
+	}
+}
+/**
+* Render a new acquisition's record; Linux adds boot identity, start ticks, and a unique claim token.
+* @returns the PID record, with Linux identity when the kernel exposes it.
+*/
+async function writerLockRecord() {
+	const pid = `${process.pid}\n`;
+	if (process.platform !== "linux") return pid;
+	const current = await (ownIdentity ??= identity(process.pid));
+	return current === void 0 ? pid : `${pid}linux ${current} ${randomBytes(12).toString("hex")}\n`;
+}
+/**
+* Exclusively publish a complete Linux identity record, or create a legacy PID lock.
+* @param path - lock sibling in an existing parent directory.
+* @param record - one acquisition's record from writerLockRecord.
+*/
+async function createWriterLock(path, record) {
+	const nonce = RECORD.exec(record)?.[4];
+	if (process.platform !== "linux" || nonce === void 0) {
+		await writeFile(path, record, {
+			mode: 384,
+			flag: "wx"
+		});
+		return;
+	}
+	const temp = `${path}.${nonce}.tmp`;
+	try {
+		await writeFile(temp, record, {
+			mode: 384,
+			flag: "wx"
+		});
+		await link(temp, path);
+	} finally {
+		await rm(temp, { force: true });
+	}
+}
+/**
+* Determine whether a recorded writer exited, including Linux PID reuse and a previous boot.
+* @param record - untrusted contents of an existing lock file.
+* @returns true only for ESRCH or a different observable Linux process identity.
+*/
+async function writerExited(record) {
+	const match = RECORD.exec(record);
+	if (match === null) return false;
+	const pid = Number(match[1]);
+	if (pid === 0 || pid > 2147483647) return false;
+	if (pid !== process.pid) try {
+		process.kill(pid, 0);
+	} catch (error) {
+		return error.code === "ESRCH";
+	}
+	if (process.platform !== "linux" || match[2] === void 0) return false;
+	const current = await identity(pid);
+	return current !== void 0 && current !== `${match[2]} ${match[3]}`;
+}
+//#endregion
 //#region lib/types/index.js
 /**
 * Zero-dependency atomic file replacement and writer coordination.
@@ -8,38 +124,41 @@ import { dirname } from "node:path";
 * the caller's permission bits, then renames it over the target, so readers
 * observe either the old or the new complete content and a replaced file ends
 * up with exactly the stated mode. `withFileLock` serializes cross-process
-* writers of one file through a `wx`-created `<file>.lock` sibling, so a
+* writers of one file through an exclusively published `<file>.lock` sibling, so a
 * read-modify-write cycle can never resurrect a state another writer just
 * replaced; readers stay lock-free because the rename commit is atomic. A lock
-* whose recorded holder process no longer exists is taken over.
+* whose recorded holder process no longer exists is taken over. Windows also
+* recovers empty or zero-filled records after an exclusive read proves no
+* creator still has the lock file open. Linux records also distinguish
+* a previous boot or reused PID through kernel process identity.
 * @module @deepseek-ai/dsh-atomic-write
 */
-const WINDOWS_TRANSIENT_RENAME_ERRORS = new Set([
+const WINDOWS_TRANSIENT_FILE_ERRORS = new Set([
 	"EACCES",
 	"EBUSY",
 	"EPERM"
 ]);
-const WINDOWS_RENAME_RETRY_INITIAL_MS = 20;
-const WINDOWS_RENAME_RETRY_MAX_MS = 200;
-const WINDOWS_RENAME_RETRY_LIMIT = 8;
+const WINDOWS_FILE_RETRY_INITIAL_MS = 20;
+const WINDOWS_FILE_RETRY_MAX_MS = 200;
+const WINDOWS_FILE_RETRY_LIMIT = 8;
 /** Whether Windows reported temporary interference with an atomic replacement. */
-function isTransientWindowsRenameError(error) {
+function isTransientWindowsFileError(error) {
 	if (process.platform !== "win32") return false;
-	return WINDOWS_TRANSIENT_RENAME_ERRORS.has(error?.code ?? "");
+	return WINDOWS_TRANSIENT_FILE_ERRORS.has(error?.code ?? "");
 }
-/** Replace the target after bounded retries for transient Windows interference. */
-async function renameAtomicTemp(temp, filename) {
-	let delay = WINDOWS_RENAME_RETRY_INITIAL_MS;
+/** Retry a replacement or lock release while Windows briefly holds the path open. */
+async function retryWindowsFileOperation(operation) {
+	let delay = WINDOWS_FILE_RETRY_INITIAL_MS;
 	for (let retries = 0;; retries += 1) {
 		try {
-			await rename(temp, filename);
+			await operation();
 			return;
 		} catch (error) {
-			if (!isTransientWindowsRenameError(error)) throw error;
-			if (retries >= WINDOWS_RENAME_RETRY_LIMIT) throw error;
+			if (!isTransientWindowsFileError(error)) throw error;
+			if (retries >= WINDOWS_FILE_RETRY_LIMIT) throw error;
 		}
 		await new Promise((resolve) => setTimeout(resolve, delay));
-		delay = Math.min(delay * 2, WINDOWS_RENAME_RETRY_MAX_MS);
+		delay = Math.min(delay * 2, WINDOWS_FILE_RETRY_MAX_MS);
 	}
 }
 /**
@@ -69,7 +188,7 @@ async function writeFileAtomic(filename, content, options) {
 			mode: options.mode,
 			flag: "wx"
 		});
-		await renameAtomicTemp(temp, filename);
+		await retryWindowsFileOperation(() => rename(temp, filename));
 	} catch (error) {
 		await rm(temp, { force: true });
 		throw error;
@@ -87,18 +206,13 @@ async function isLockContention(error, lockPath) {
 		return false;
 	}
 }
-/** Whether the holder a `<pid>\n` record names is proven gone: a signal probe finds no such process. */
-function holderExited(record) {
-	if (!/^\d+\n$/.test(record)) return false;
-	const pid = Number(record.trim());
-	if (pid === 0 || pid > 2147483647) return false;
-	if (pid === process.pid) return false;
-	try {
-		process.kill(pid, 0);
-		return false;
-	} catch (error) {
-		return error.code === "ESRCH";
-	}
+/** Whether the recorded writer is absent or has a different observable Linux identity. */
+async function holderExited(record) {
+	return writerExited(record);
+}
+/** A crash can leave an empty or zero-filled record before the holder's PID reaches disk. */
+function damagedRecord(record) {
+	return record.length <= 64 && /^\0*$/.test(record);
 }
 /** The lock file's content, or undefined when it cannot be read. */
 async function readLockRecord(lockPath) {
@@ -109,18 +223,21 @@ async function readLockRecord(lockPath) {
 	}
 }
 /**
-* Remove the lock when its recorded holder exited. Contenders that read the
+* Remove an exited holder's lock or a closed, damaged Windows lock. Contenders that read the
 * same record serialize on a claim file named after it. Under the claim, the
 * claimant re-reads the lock and probes its PID again, and removes it only
-* when it still holds that record and that PID is still gone: the record's
+* when it still holds that record and that PID is still gone. A damaged Windows
+* record instead requires an exclusive read after claiming it. The record's
 * holder can no longer release it, and no other contender can remove it
 * without the claim, so a removal never deletes a lock another contender
 * acquired after the dead holder's, including one whose holder reused the PID.
-* @returns Whether this call removed the dead holder's lock.
+* @returns Whether this call removed the abandoned lock.
 */
 async function takeOverExitedLock(lockPath) {
 	const record = await readLockRecord(lockPath);
-	if (record === void 0 || !holderExited(record)) return false;
+	if (record === void 0) return false;
+	const damaged = process.platform === "win32" && damagedRecord(record);
+	if (!damaged && !await holderExited(record)) return false;
 	const claim = `${lockPath}.takeover-${createHash("sha256").update(record).digest("hex").slice(0, 16)}`;
 	try {
 		await writeFile(claim, `${process.pid}\n`, {
@@ -133,7 +250,10 @@ async function takeOverExitedLock(lockPath) {
 		throw error;
 	}
 	try {
-		if (await readLockRecord(lockPath) !== record || !holderExited(record)) return false;
+		if (await readLockRecord(lockPath) !== record) return false;
+		if (damaged) {
+			if (await readUnopenedWindowsLock(lockPath) !== record) return false;
+		} else if (!await holderExited(record)) return false;
 		try {
 			await rm(lockPath, { force: true });
 		} catch (error) {
@@ -163,7 +283,7 @@ const LOCK_RETRY_MAX_MS = 200;
 const DEFAULT_LOCK_WAIT_MS = 2e3;
 /**
 * Hold the cross-process writer lock for `filename` around one operation. The
-* lock is a `wx`-created sibling (`<filename>.lock`); paired with the
+* lock is an exclusively published sibling (`<filename>.lock`); paired with the
 * rename-based commit of {@link writeFileAtomic}, readers stay lock-free and
 * only writers contend. `EEXIST` is contention directly; an `EPERM` is
 * contention only when a fresh `lstat` confirms the lock path exists, covering
@@ -172,9 +292,14 @@ const DEFAULT_LOCK_WAIT_MS = 2e3;
 * permission error is rethrown. The lock records its holder's PID. A contender
 * removes the lock and retries at once when no process with that PID exists
 * (`ESRCH`); any other lock, including one whose holder exists under another
-* user (`EPERM`) or whose record is incomplete, is waited for. Contention backs
-* off exponentially and times out after the deadline. A holder whose PID a
-* live process reused keeps its lock until an operator removes it. Takeover
+* user (`EPERM`) or whose record is incomplete, is waited for. On Windows,
+* empty or zero-filled records of at most 64 bytes can also be recovered after
+* exclusive inspection proves no creator still has the file open. A failed
+* inspection preserves the lock. Windows lock release retries transient file
+* interference for a bounded interval. Contention backs
+* off exponentially and times out after the deadline. Linux identity records
+* distinguish PID reuse and a previous boot; legacy PID-only records cannot.
+* Missing or inaccessible identity metadata never authorizes takeover. Takeover
 * proves only that the recorded process exited: an operation that starts other
 * writers must stop them with it or leave its successor a way to find them.
 * PIDs are compared on the contender's host, so writers on other hosts or in
@@ -187,15 +312,13 @@ const DEFAULT_LOCK_WAIT_MS = 2e3;
 */
 async function withFileLock(filename, operation, options) {
 	const lockPath = `${filename}.lock`;
+	const record = await writerLockRecord();
 	const deadline = Date.now() + (options?.waitMs ?? DEFAULT_LOCK_WAIT_MS);
 	let delay = LOCK_RETRY_INITIAL_MS;
 	let retriedUnconfirmedPermissionError = false;
 	for (;;) {
 		try {
-			await writeFile(lockPath, `${process.pid}\n`, {
-				mode: 384,
-				flag: "wx"
-			});
+			await createWriterLock(lockPath, record);
 			break;
 		} catch (error) {
 			if (!await isLockContention(error, lockPath)) {
@@ -210,7 +333,7 @@ async function withFileLock(filename, operation, options) {
 	try {
 		return await operation();
 	} finally {
-		await rm(lockPath, { force: true });
+		await retryWindowsFileOperation(() => rm(lockPath, { force: true }));
 	}
 }
 //#endregion

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

@@ -4,10 +4,13 @@
  * the caller's permission bits, then renames it over the target, so readers
  * observe either the old or the new complete content and a replaced file ends
  * up with exactly the stated mode. `withFileLock` serializes cross-process
- * writers of one file through a `wx`-created `<file>.lock` sibling, so a
+ * writers of one file through an exclusively published `<file>.lock` sibling, so a
  * read-modify-write cycle can never resurrect a state another writer just
  * replaced; readers stay lock-free because the rename commit is atomic. A lock
- * whose recorded holder process no longer exists is taken over.
+ * whose recorded holder process no longer exists is taken over. Windows also
+ * recovers empty or zero-filled records after an exclusive read proves no
+ * creator still has the lock file open. Linux records also distinguish
+ * a previous boot or reused PID through kernel process identity.
  * @module @deepseek-ai/dsh-atomic-write
  */
 /**
@@ -58,7 +61,7 @@ export interface FileLockOptions {
 }
 /**
  * Hold the cross-process writer lock for `filename` around one operation. The
- * lock is a `wx`-created sibling (`<filename>.lock`); paired with the
+ * lock is an exclusively published sibling (`<filename>.lock`); paired with the
  * rename-based commit of {@link writeFileAtomic}, readers stay lock-free and
  * only writers contend. `EEXIST` is contention directly; an `EPERM` is
  * contention only when a fresh `lstat` confirms the lock path exists, covering
@@ -67,9 +70,14 @@ export interface FileLockOptions {
  * permission error is rethrown. The lock records its holder's PID. A contender
  * removes the lock and retries at once when no process with that PID exists
  * (`ESRCH`); any other lock, including one whose holder exists under another
- * user (`EPERM`) or whose record is incomplete, is waited for. Contention backs
- * off exponentially and times out after the deadline. A holder whose PID a
- * live process reused keeps its lock until an operator removes it. Takeover
+ * user (`EPERM`) or whose record is incomplete, is waited for. On Windows,
+ * empty or zero-filled records of at most 64 bytes can also be recovered after
+ * exclusive inspection proves no creator still has the file open. A failed
+ * inspection preserves the lock. Windows lock release retries transient file
+ * interference for a bounded interval. Contention backs
+ * off exponentially and times out after the deadline. Linux identity records
+ * distinguish PID reuse and a previous boot; legacy PID-only records cannot.
+ * Missing or inaccessible identity metadata never authorizes takeover. Takeover
  * proves only that the recorded process exited: an operation that starts other
  * writers must stop them with it or leave its successor a way to find them.
  * PIDs are compared on the contender's host, so writers on other hosts or in

package/runtime/node_modules/@deepseek-ai/dsh-atomic-write/lib/types/linux-lock.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Render a new acquisition's record; Linux adds boot identity, start ticks, and a unique claim token.
+ * @returns the PID record, with Linux identity when the kernel exposes it.
+ */
+export declare function writerLockRecord(): Promise<string>;
+/**
+ * Exclusively publish a complete Linux identity record, or create a legacy PID lock.
+ * @param path - lock sibling in an existing parent directory.
+ * @param record - one acquisition's record from writerLockRecord.
+ */
+export declare function createWriterLock(path: string, record: string): Promise<void>;
+/**
+ * Determine whether a recorded writer exited, including Linux PID reuse and a previous boot.
+ * @param record - untrusted contents of an existing lock file.
+ * @returns true only for ESRCH or a different observable Linux process identity.
+ */
+export declare function writerExited(record: string): Promise<boolean>;
+//# sourceMappingURL=linux-lock.d.ts.map

package/runtime/node_modules/@deepseek-ai/dsh-atomic-write/lib/types/windows-lock.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Read a small lock only when no other handle has the file open.
+ * @param path - lock path, protected by the caller's takeover claim.
+ * @returns its record, or undefined if exclusive access or inspection fails.
+ */
+export declare function readUnopenedWindowsLock(path: string): Promise<string | undefined>;
+//# sourceMappingURL=windows-lock.d.ts.map