@gajae-code/coding-agent 0.12.21 → 0.13.0

package/src/session/blob-store.ts

@@ -387,7 +387,7 @@ function removeResidentCacheTreeNoFollow(pathname: string): void {
 	fs.unlinkSync(pathname);
 }
 
-function disposeVerifiedResidentCacheInstanceDir(instanceDir: string): void {
+export function disposeVerifiedResidentCacheInstanceDir(instanceDir: string): void {
 	const instanceKey = path.resolve(instanceDir);
 	const uid = residentCacheOwnerUid(instanceDir);
 	const quarantineDir = path.join(
@@ -444,7 +444,7 @@ function removePartialResidentCacheInstanceDir(instanceDir: string): void {
 }
 
 function isResidentCacheInstanceDirName(name: string): boolean {
-	return /^i-[A-Za-z0-9_-]+$/.test(name);
+	return /^(?:i-[A-Za-z0-9_-]+|s-[a-f0-9]{32})$/.test(name);
 }
 
 function residentCacheSweepLimit(value: number | undefined, ceiling: number): number {
@@ -591,7 +591,7 @@ function scheduleResidentCacheRootSweep(root: string): void {
  * directories; callers must use {@link EphemeralBlobStore.adoptVerifiedDir}
  * rather than the destructive EphemeralBlobStore constructor.
  */
-export function openVerifiedResidentCacheInstanceDir(root: string): string {
+function openVerifiedCacheInstanceDir(root: string, instanceName?: string): string {
 	const uid = residentCacheOwnerUid(root);
 	let rootDescriptor: number | null = null;
 	let instanceDir: string | null = null;
@@ -601,14 +601,32 @@ export function openVerifiedResidentCacheInstanceDir(root: string): string {
 		} catch (error) {
 			throw residentCacheTrustError("root_create_failed", root, error);
 		}
-
 		rootDescriptor = openVerifiedResidentCacheDirectory(root, uid);
 		try {
-			instanceDir = fs.mkdtempSync(path.join(root, "i-"));
+			if (instanceName === undefined) instanceDir = fs.mkdtempSync(path.join(root, "i-"));
+			else {
+				if (!/^s-[a-f0-9]{32}$/.test(instanceName))
+					throw new ResidentCacheTrustError("instance_name_invalid", instanceName);
+				const candidate = path.join(root, instanceName);
+				try {
+					fs.mkdirSync(candidate, { mode: BLOB_DIR_MODE });
+				} catch (error) {
+					if (errorCode(error) !== "EEXIST") throw error;
+					const staleInstance = readResidentCacheOwnerSnapshot(candidate, uid);
+					if (
+						staleInstance === null ||
+						!residentCacheOwnerIsStale(staleInstance.owner, new Map<number, number | null>()) ||
+						!reapResidentCacheInstanceDir(root, rootDescriptor, candidate, staleInstance, uid)
+					) {
+						throw error;
+					}
+					fs.mkdirSync(candidate, { mode: BLOB_DIR_MODE });
+				}
+				instanceDir = candidate;
+			}
 		} catch (error) {
 			throw residentCacheTrustError("instance_create_failed", root, error);
 		}
-
 		// Keep the root descriptor open while creating the nonce directory, then
 		// re-check the path against that descriptor before trusting the child.
 		assertResidentCacheDirectoryPathMatchesDescriptor(root, rootDescriptor, uid);
@@ -637,6 +655,15 @@ export function openVerifiedResidentCacheInstanceDir(root: string): string {
 	}
 }
 
+export function openVerifiedResidentCacheInstanceDir(root: string): string {
+	return openVerifiedCacheInstanceDir(root);
+}
+
+/** Open the deterministic per-session managed-sidecar instance in its separate cache root. */
+export function openVerifiedSidecarCacheInstanceDir(root: string, sessionHash: string): string {
+	return openVerifiedCacheInstanceDir(root, `s-${sessionHash}`);
+}
+
 function sha256Hex(data: Buffer): string {
 	return new Bun.SHA256().update(data).digest("hex");
 }
@@ -1539,6 +1566,8 @@ export interface CanonicalBlobEntry {
 	readonly path: string;
 	readonly bytes: number;
 	readonly mtimeMs: number;
+	readonly dev: number;
+	readonly ino: number;
 }
 
 const CANONICAL_BLOB_NAME = /^[0-9a-f]{64}$/;
@@ -1577,7 +1606,14 @@ export async function listCanonicalBlobs(dir: string): Promise<CanonicalBlobEntr
 			continue;
 		}
 		if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1) continue;
-		entries.push({ hash: name, path: blobPath, bytes: stat.size, mtimeMs: stat.mtimeMs });
+		entries.push({
+			hash: name,
+			path: blobPath,
+			bytes: stat.size,
+			mtimeMs: stat.mtimeMs,
+			dev: stat.dev,
+			ino: stat.ino,
+		});
 	}
 	return entries;
 }
@@ -1587,11 +1623,17 @@ export async function listCanonicalBlobs(dir: string): Promise<CanonicalBlobEntr
  * at scan time must still describe the file at unlink time (same inode, size and
  * mtime, still a single-link regular file), otherwise the blob is left in place.
  *
+ * `beforeUnlink` runs after this function has verified the blob and immediately
+ * before it calls unlink. Callers use it to bind external liveness evidence to
+ * the verified blob identity, so a live reference that appears while the blob is
+ * being revalidated prevents the destructive syscall.
+ *
  * `failed` distinguishes an actual IO failure (which a caller should surface as
  * a failed reclaim) from a revalidation refusal (which is an ordinary KEEP).
  */
 export async function removeCanonicalBlob(
 	entry: CanonicalBlobEntry,
+	options: { beforeUnlink?: () => Promise<boolean> } = {},
 ): Promise<{ removed: true } | { removed: false; reason: string; failed?: true }> {
 	let stat: fs.Stats;
 	try {
@@ -1603,7 +1645,17 @@ export async function removeCanonicalBlob(
 	if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1) {
 		return { removed: false, reason: "blob_not_plain_file" };
 	}
-	if (stat.size !== entry.bytes || stat.mtimeMs !== entry.mtimeMs) return { removed: false, reason: "blob_changed" };
+	if (
+		stat.dev !== entry.dev ||
+		stat.ino !== entry.ino ||
+		stat.size !== entry.bytes ||
+		stat.mtimeMs !== entry.mtimeMs
+	) {
+		return { removed: false, reason: "blob_changed" };
+	}
+	if (options.beforeUnlink && !(await options.beforeUnlink())) {
+		return { removed: false, reason: "blob_reference_evidence_changed" };
+	}
 	try {
 		await fsp.unlink(entry.path);
 		return { removed: true };

package/src/session/fallback-chain-controller.ts

@@ -17,6 +17,17 @@ export interface FallbackFailure {
 
 export type FallbackFailureResult = "retry" | "advance" | "exhausted";
 
+export interface FallbackChainRuntimeState {
+	activeIndex: number;
+	attemptsUsed: number;
+	totalAttemptsUsed: number;
+	attemptStarted: boolean;
+	restoredEntryIndices: number[];
+	tried: FallbackFailure[];
+	skips: Array<{ selector: string; reason: string }>;
+	exhaustedForTurn: boolean;
+}
+
 /**
  * In-memory policy state for one fallback-chain scope. A controller is deliberately
  * not serializable: configured chain intent is durable, current position is not.
@@ -43,6 +54,30 @@ export class FallbackChainController {
 		if (this.chain.entries.length === 0) this.exhaustedForTurn = true;
 	}
 
+	snapshotRuntimeState(): FallbackChainRuntimeState {
+		return {
+			activeIndex: this.activeIndex,
+			attemptsUsed: this.attemptsUsed,
+			totalAttemptsUsed: this.#totalAttemptsUsed,
+			attemptStarted: this.#attemptStarted,
+			restoredEntryIndices: [...this.#restoredEntryIndices],
+			tried: this.tried.map(failure => ({ ...failure })),
+			skips: this.skips.map(skip => ({ ...skip })),
+			exhaustedForTurn: this.exhaustedForTurn,
+		};
+	}
+
+	restoreRuntimeState(state: FallbackChainRuntimeState): void {
+		this.activeIndex = state.activeIndex;
+		this.attemptsUsed = state.attemptsUsed;
+		this.#totalAttemptsUsed = state.totalAttemptsUsed;
+		this.#attemptStarted = state.attemptStarted;
+		this.#restoredEntryIndices = new Set(state.restoredEntryIndices);
+		this.tried = state.tried.map(failure => ({ ...failure }));
+		this.skips = state.skips.map(skip => ({ ...skip }));
+		this.exhaustedForTurn = state.exhaustedForTurn;
+	}
+
 	get totalAttemptsUsed(): number {
 		return this.#totalAttemptsUsed;
 	}

package/src/session/internal/managed-session-scope.ts

@@ -51,6 +51,7 @@ import {
 	prepareManagedDirectoryRoot,
 	publishManagedFileNoReplace,
 	publishManagedTombstone,
+	reapScrubbedProtocolRemnantsSync,
 	retainManagedDirectoryAuthority,
 	validateManagedArtifactTree,
 	validateNativeSecurityResult,
@@ -193,8 +194,27 @@ export type ManagedScopeResolution =
 			cause?: { readonly classification: string; readonly diagnostic?: string };
 	  };
 
+/**
+ * Classify a failure for the operator-visible `cause`.
+ *
+ * Must agree with {@link managedScopeErrorCode}: the reported `code` and the
+ * `cause.classification` printed in the startup error are produced by separate
+ * helpers, so a message recognized by one and not the other still surfaces to
+ * the operator as `binding_invalid`.
+ */
 function managedScopeFailureCause(error: unknown): { readonly classification: string } {
-	return { classification: managedSecurityFailureClassification(error) ?? "binding_invalid" };
+	const security = managedSecurityFailureClassification(error);
+	if (security) return { classification: security };
+	return { classification: managedScopeErrorCode(error instanceof Error ? error.message : "") };
+}
+
+/**
+ * A scope whose directory outgrew a scan budget. The binding is untouched and
+ * canonical; only the surrounding entry count is over budget, so this must not
+ * be reported as binding corruption.
+ */
+function isManagedScopeCapacityMessage(message: string): boolean {
+	return message === "artifact_capacity_exceeded" || message === "managed_replace_cleanup_receipt_limit_exceeded";
 }
 
 const managedScopeFailureCodes = new Set<ManagedScopeErrorCode>([
@@ -214,7 +234,7 @@ const managedScopeFailureCodes = new Set<ManagedScopeErrorCode>([
  * corrupt binding, which sends operators to delete a healthy binding file.
  */
 function managedScopeErrorCode(message: string): ManagedScopeErrorCode {
-	if (message === "content_too_large") return "capacity_exceeded";
+	if (message === "content_too_large" || isManagedScopeCapacityMessage(message)) return "capacity_exceeded";
 	return managedScopeFailureCodes.has(message as ManagedScopeErrorCode)
 		? (message as ManagedScopeErrorCode)
 		: "binding_invalid";
@@ -224,7 +244,7 @@ function managedScopeFailureMessage(error: unknown, fallback: string): string {
 	const classification = managedSecurityFailureClassification(error);
 	if (classification) return classification;
 	if (!(error instanceof Error)) return fallback;
-	if (error.message === "content_too_large") return error.message;
+	if (error.message === "content_too_large" || isManagedScopeCapacityMessage(error.message)) return error.message;
 	return managedScopeFailureCodes.has(error.message as ManagedScopeErrorCode) ? error.message : fallback;
 }
 
@@ -1133,6 +1153,7 @@ export function prepareManagedSessionScopeForWriteSync(
 		ensureManagedDirectory(path.join(internal, MANAGED_RECEIPTS_DIRECTORY), root, policy);
 		stage = "tombstones_directory";
 		ensureManagedDirectory(path.join(internal, MANAGED_TOMBSTONES_DIRECTORY), root, policy);
+		reapScrubbedProtocolRemnantsSync(scope.directoryPath);
 		return { kind: "resolved", scope };
 	} catch (error) {
 		const publication = error instanceof ManagedPublishError ? error : undefined;
@@ -3713,6 +3734,7 @@ export async function prepareManagedSessionScopeForWrite(
 		ensureManagedDirectory(path.join(internal, MANAGED_RECEIPTS_DIRECTORY), root, policy);
 		ensureManagedDirectory(path.join(internal, MANAGED_TOMBSTONES_DIRECTORY), root, policy);
 		await reconcileManagedTombstones(scope, expectedCandidate);
+		reapScrubbedProtocolRemnantsSync(scope.directoryPath);
 		return { kind: "resolved", scope };
 	} catch (error) {
 		const publication = error instanceof ManagedPublishError ? error : undefined;