@gajae-code/coding-agent 0.14.2 → 0.15.0

package/src/session/artifacts.ts

@@ -34,6 +34,13 @@ function isSafeFilename(filename: string): boolean {
 	return /^[a-zA-Z0-9_.-]+$/.test(filename);
 }
 
+const MAX_ATTEMPT_ID_LENGTH = 128;
+
+function assertSafeAttemptId(attemptId: string): void {
+	if (!/^[A-Za-z0-9_-]{1,128}$/.test(attemptId) || attemptId.length > MAX_ATTEMPT_ID_LENGTH)
+		throw new Error("Unsafe artifact attempt id");
+}
+
 function parseManagedOutputGeneration(value: Uint8Array, outputFilenamePrefix: string): ManagedOutputGeneration | null {
 	try {
 		const parsed = JSON.parse(Buffer.from(value).toString("utf8")) as Partial<ManagedOutputGeneration>;
@@ -99,13 +106,29 @@ export class ArtifactManager {
 	#dirCreated = false;
 	#initialized: Promise<void> | undefined;
 	#initializedComplete = false;
+	readonly #attemptId: string | undefined;
+	readonly #allocatedIds = new Set<string>();
+	readonly #retiredIds = new Set<string>();
+	#reservations = new Map<string, { start: number; count: number; names: string[] }>();
+	readonly #stagingParentStore: ManagedSessionDescendantStore | undefined;
+	readonly #stagingRelativePath: string | undefined;
 
 	/**
 	 * @param dir Directory that will hold artifact files. Created lazily on first save.
 	 */
-	constructor(target: string | ManagedSessionDescendantStore) {
+	constructor(
+		target: string | ManagedSessionDescendantStore,
+		options?: {
+			readonly attemptId?: string;
+			readonly stagingParentStore?: ManagedSessionDescendantStore;
+			readonly stagingRelativePath?: string;
+		},
+	) {
 		this.#store = typeof target === "string" ? undefined : target;
 		this.#dir = typeof target === "string" ? target : target.dir;
+		this.#attemptId = options?.attemptId;
+		this.#stagingParentStore = options?.stagingParentStore;
+		this.#stagingRelativePath = options?.stagingRelativePath;
 	}
 
 	/**
@@ -188,8 +211,12 @@ export class ArtifactManager {
 	}
 
 	async #publish(content: string, filename: string): Promise<void> {
-		if (this.#store) await this.#store.publishNoReplace(filename, Buffer.from(content, "utf8"));
-		else await publishManagedFileNoReplace(path.join(this.#dir, filename), Buffer.from(content, "utf8"));
+		await this.#publishBytes(Buffer.from(content, "utf8"), filename);
+	}
+
+	async #publishBytes(bytes: Uint8Array, filename: string): Promise<void> {
+		if (this.#store) await this.#store.publishNoReplace(filename, bytes);
+		else await publishManagedFileNoReplace(path.join(this.#dir, filename), bytes);
 	}
 
 	async replaceNamed(filename: string, content: string): Promise<void> {
@@ -289,8 +316,19 @@ export class ArtifactManager {
 		if (!/^[a-zA-Z0-9_.-]+$/.test(filename)) return false;
 		try {
 			if (this.#store) {
+				const beforePaths = new Set(await fs.readdir(this.#store.dir));
 				const staged = this.#store.readExpected(filename);
 				if (staged) this.#store.removeExpected(filename, staged);
+				// Capture only root names outside retained authority so foreign sibling
+				// placeholders cannot make rollback fail before exact removal runs.
+				for (const basename of await fs.readdir(this.#store.dir)) {
+					const nativeResidue = /^\.gjc-/u.test(basename);
+					const ownQuarantine = basename === `${filename}.removing` || basename.startsWith(`${filename}.`);
+					if (beforePaths.has(basename) || (!nativeResidue && !ownQuarantine)) continue;
+					const residuePath = path.join(this.#store.dir, basename);
+					const stat = await fs.lstat(residuePath);
+					await fs.rm(residuePath, { recursive: stat.isDirectory(), force: true });
+				}
 			} else {
 				await fs.unlink(path.join(this.#dir, filename));
 			}
@@ -326,7 +364,10 @@ export class ArtifactManager {
 	 * Prefer `allocatePath` or `save`; this synchronous seam exists for pruning callbacks.
 	 */
 	allocateId(): number {
-		return this.#claimNextIdSync();
+		while (this.#retiredIds.has(String(this.#nextId))) this.#nextId++;
+		const id = this.#claimNextIdSync();
+		this.#allocatedIds.add(String(id));
+		return id;
 	}
 
 	/**
@@ -338,6 +379,7 @@ export class ArtifactManager {
 	async allocatePath(toolType: string): Promise<{ id: string; path?: string }> {
 		await this.#ensureDir();
 		const id = String(await this.#claimNextId());
+		this.#allocatedIds.add(id);
 		if (this.#store) return { id };
 		return { id, path: path.join(this.#dir, this.#filename(id, toolType)) };
 	}
@@ -350,6 +392,7 @@ export class ArtifactManager {
 	async save(content: string, toolType: string, options: ArtifactSaveOptions = {}): Promise<string> {
 		await this.#ensureDir();
 		const id = String(await this.#claimNextId());
+		this.#allocatedIds.add(id);
 		const maxBytes = Math.max(0, options.maxBytes ?? DEFAULT_ARTIFACT_MAX_BYTES);
 		const contentBytes = Buffer.byteLength(content, "utf-8");
 		const published =
@@ -378,11 +421,198 @@ export class ArtifactManager {
 	 */
 	async listFiles(): Promise<string[]> {
 		try {
+			if (this.#store) {
+				return this.#store
+					.captureTree("")
+					.entries.filter(entry => entry.kind === "file" && entry.relativePath.length > 0)
+					.map(entry => entry.relativePath);
+			}
 			return await fs.readdir(this.#dir);
 		} catch {
 			return [];
 		}
 	}
+	getAttemptId(): string | undefined {
+		return this.#attemptId;
+	}
+
+	getAllocatedIds(): readonly string[] {
+		return [...this.#allocatedIds].sort((a, b) => Number(a) - Number(b));
+	}
+
+	/** Create an isolated artifact manager rooted below this manager's staging area. */
+	createAttemptStaging(attemptId: string): ArtifactManager {
+		assertSafeAttemptId(attemptId);
+		const stagingRelativePath = path.posix.join(".staging", attemptId);
+		const target = this.#store
+			? this.#store.deriveSubtree(stagingRelativePath)
+			: path.join(this.#dir, stagingRelativePath);
+		return new ArtifactManager(target, {
+			attemptId,
+			...(this.#store ? { stagingParentStore: this.#store, stagingRelativePath } : {}),
+		});
+	}
+
+	/** Reserve and publish a candidate's staged artifacts with a contiguous parent ID block. */
+	async commitAttemptStaging(
+		staging: ArtifactManager,
+		attemptId: string,
+		options?: { beforePublish?: (mapping: ReadonlyMap<string, string>) => Promise<void> | void },
+	): Promise<ReadonlyMap<string, string>> {
+		if (staging.#attemptId !== attemptId) throw new Error("Artifact staging ownership mismatch");
+		assertSafeAttemptId(attemptId);
+		await this.#ensureDir();
+		await staging.#ensureDir();
+		const ids = staging.getAllocatedIds();
+		const start = this.#nextId;
+		this.#nextId += ids.length;
+		const mapping = new Map<string, string>();
+		for (let index = 0; index < ids.length; index++) mapping.set(ids[index]!, String(start + index));
+		const frozenMap = new Map(mapping) as Map<string, string> & ReadonlyMap<string, string>;
+		Object.defineProperties(frozenMap, {
+			set: {
+				value: () => {
+					throw new Error("Artifact ID map is immutable");
+				},
+			},
+			delete: {
+				value: () => {
+					throw new Error("Artifact ID map is immutable");
+				},
+			},
+			clear: {
+				value: () => {
+					throw new Error("Artifact ID map is immutable");
+				},
+			},
+		});
+		Object.freeze(frozenMap);
+		const publishedNames: string[] = [];
+		try {
+			await options?.beforePublish?.(frozenMap);
+			for (const filename of await staging.listFiles()) {
+				if (/^\.artifact-id-\d+$/.test(filename)) continue;
+				const bytes = staging.#store
+					? staging.#store.readExpected(filename)?.bytes
+					: await fs.readFile(path.join(staging.#dir, filename));
+				if (!bytes) continue;
+				const match = filename.match(/^(\d+)(\..*)$/);
+				const mappedFilename = match ? `${mapping.get(match[1]!) ?? match[1]}${match[2]}` : filename;
+				await this.#publishBytes(bytes, mappedFilename);
+				publishedNames.push(mappedFilename);
+			}
+			this.#reservations.set(attemptId, { start, count: ids.length, names: [...publishedNames] });
+			await staging.discardAttemptStaging();
+			return frozenMap;
+		} catch (error) {
+			// Cleanup is best-effort, but a durable removal failure must never be silent: it leaves a
+			// published artifact behind under an id we are about to retire. Surface it alongside the
+			// original publication error rather than dropping the boolean.
+			const unremoved: string[] = [];
+			for (const filename of publishedNames.reverse())
+				if (!(await this.removeNamedBestEffort(filename))) unremoved.push(filename);
+			// Only rewind the tail when every published artifact was actually removed. If any removal
+			// failed, the file still occupies its id, so retire the whole block instead of handing the
+			// ids out again.
+			if (unremoved.length === 0 && this.#nextId === start + ids.length) this.#nextId = start;
+			else for (const id of mapping.values()) this.#retiredIds.add(id);
+			if (unremoved.length > 0)
+				throw new AggregateError(
+					[error, new Error(`Failed to roll back published artifacts: ${unremoved.join(", ")}`)],
+					"Attempt-staging publication failed and rollback left artifacts behind.",
+				);
+			throw error;
+		}
+	}
+	async rollbackLastAttemptCommit(attemptId?: string): Promise<void> {
+		if (attemptId === undefined) return;
+		const reservation = this.#reservations.get(attemptId);
+		if (!reservation) return;
+		const unremoved: string[] = [];
+		for (const filename of [...reservation.names].reverse())
+			if (!(await this.removeNamedBestEffort(filename))) unremoved.push(filename);
+		// Only rewind the tail when every published artifact was actually removed; otherwise retire the
+		// whole block so a leaked file's id can never be reallocated.
+		if (unremoved.length === 0 && this.#nextId === reservation.start + reservation.count)
+			this.#nextId = reservation.start;
+		else
+			for (let index = 0; index < reservation.count; index++)
+				this.#retiredIds.add(String(reservation.start + index));
+		this.#reservations.delete(attemptId);
+		// The reservation is always released so ids can never be reused, but a failed durable removal
+		// is reported rather than swallowed.
+		if (unremoved.length > 0) throw new Error(`Failed to roll back published artifacts: ${unremoved.join(", ")}`);
+	}
+
+	finalizeLastAttemptCommit(attemptId?: string): void {
+		if (attemptId !== undefined) this.#reservations.delete(attemptId);
+	}
+
+	async discardAttemptStaging(): Promise<void> {
+		if (this.#store) {
+			const cleanupStore = this.#stagingParentStore ?? this.#store;
+			const cleanupPath = this.#stagingParentStore ? this.#stagingRelativePath! : "";
+			const parentCleanupPath = cleanupPath ? path.posix.dirname(cleanupPath) : "";
+			let parentBefore: ReturnType<ManagedSessionDescendantStore["captureTree"]> | undefined;
+			if (this.#stagingParentStore) {
+				try {
+					parentBefore = cleanupStore.captureTree(parentCleanupPath);
+				} catch {
+					parentBefore = undefined;
+				}
+			}
+			try {
+				const snapshot = cleanupStore.captureTree(cleanupPath);
+				cleanupStore.removeTreeExpected(cleanupPath, snapshot);
+			} catch (error) {
+				if (!(error instanceof Error && (error.message === "not_found" || error.message === "cleanup_pending")))
+					throw error;
+			}
+			if (this.#stagingParentStore && parentBefore) {
+				try {
+					const after = cleanupStore.captureTree(parentCleanupPath);
+					const beforePaths = new Set(parentBefore.entries.map(entry => entry.relativePath));
+					for (const entry of after.entries) {
+						if (
+							entry.kind === "directory" &&
+							entry.relativePath.length > 0 &&
+							!beforePaths.has(entry.relativePath) &&
+							/\.removing$/u.test(path.posix.basename(entry.relativePath))
+						) {
+							await fs.rm(path.join(cleanupStore.dir, parentCleanupPath, entry.relativePath), {
+								recursive: true,
+								force: true,
+							});
+							continue;
+						}
+						if (
+							entry.kind !== "file" ||
+							beforePaths.has(entry.relativePath) ||
+							!/^\\.gjc-(?:exact-unlink-placeholder|remove)-/u.test(path.posix.basename(entry.relativePath))
+						)
+							continue;
+						const relative = path.posix.join(parentCleanupPath, entry.relativePath);
+						const expected = cleanupStore.readExpected(relative);
+						if (expected) {
+							try {
+								cleanupStore.removeExpected(relative, expected);
+							} catch (cleanupError) {
+								if (!(cleanupError instanceof Error && cleanupError.message === "cleanup_pending"))
+									throw cleanupError;
+							}
+						}
+						await fs.rm(path.join(cleanupStore.dir, relative), { force: true }).catch(() => undefined);
+					}
+				} catch {
+					// Retained cleanup evidence is safe to leave for a later maintenance pass.
+				}
+			}
+			this.#store.close();
+		} else {
+			await fs.rm(this.#dir, { recursive: true, force: true });
+		}
+		this.#dirCreated = false;
+	}
 
 	/** Persist exact UTF-8 text for heap-eviction rehydration. */
 	async publishExactText(text: string, options: ArtifactPublishOptions = {}): Promise<ArtifactPublishOutcome> {

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

@@ -176,6 +176,7 @@ function sameDirectoryTreeSnapshotAfterRename(
 	);
 }
 
+/** A managed move outcome that reports whether the mutation is known not to have committed. */
 export class ManagedTreeMoveOutcomeError extends Error {
 	constructor(
 		message: string,
@@ -1391,14 +1392,21 @@ export class ManagedSessionDescendantStore {
 		try {
 			const directory = fs.opendirSync(this.#baseDir);
 			try {
+				// The limit bounds receipt reconciliation work, so it counts receipts —
+				// not every dirent in the directory. Counting all entries conflated
+				// "this scope has too many receipts to reconcile" with "this directory
+				// has many files", so a scope whose bulk was inert zero-byte remnants
+				// aborted before examining a single receipt (observed: 50,003 dirents,
+				// 0 receipts) and every mutation failed permanently. Unbounded receipt
+				// growth is still rejected, which is the case the limit exists for.
 				let examined = 0;
 				for (let entry = directory.readSync(); entry; entry = directory.readSync()) {
-					examined++;
-					if (examined > REPLACEMENT_CLEANUP_RECEIPT_SCAN_LIMIT)
-						throw new Error("managed_replace_cleanup_receipt_limit_exceeded");
 					const name = entry.name;
 					if (!name.startsWith(".gjc-replace-receipt-pending-") && !name.startsWith(".gjc-replace-cleanup-"))
 						continue;
+					examined++;
+					if (examined > REPLACEMENT_CLEANUP_RECEIPT_SCAN_LIMIT)
+						throw new Error("managed_replace_cleanup_receipt_limit_exceeded");
 					if (name.startsWith(".gjc-replace-receipt-pending-")) {
 						this.#reconcilePendingReplacementReceipt(path.join(this.#baseDir, name));
 						continue;
@@ -1427,9 +1435,21 @@ export class ManagedSessionDescendantStore {
 
 	#beforeMutation(): void {
 		this.#assertBound();
+		// Reaping is scheduled BEFORE reconciliation, not after. The receipt scan
+		// throws `managed_replace_cleanup_receipt_limit_exceeded` once the bound
+		// directory exceeds the dirent scan limit, and the only thing that brings a
+		// directory back under that limit is this reaper. Scheduling it after the
+		// scan made the recovery unreachable exactly when it was needed: a scope
+		// that crossed the limit failed every mutation forever, so tool-output
+		// eviction could never persist and its originals stayed resident in heap
+		// until the non-disableable emergency compaction floor cut the session
+		// (observed: 50,003 dirents, 47,043 of them zero-byte remnants, 55 failed
+		// evictions and 9 heap compactions in one day). Reaping is throttled,
+		// asynchronous, and never fails the triggering mutation, so hoisting it
+		// cannot make a healthy scope worse.
+		this.#scheduleRemnantReap();
 		this.#reconcileReplacementCleanupReceipts();
 		this.#assertBound();
-		this.#scheduleRemnantReap();
 	}
 
 	/**
@@ -2371,6 +2391,73 @@ export class ManagedSessionDescendantStore {
 		return movedSnapshot.snapshot;
 	}
 
+	/** Move one exact managed regular file to an absent destination through retained authority. */
+	moveFileNoReplace(
+		sourceRelativePath: string,
+		destinationRelativePath: string,
+		expected: ManagedFileSnapshot,
+		options?: {
+			/** Subtree store bound to the source's directory; keeps the verification read basename-scoped when this store lacks retained authority. */
+			sourceStore: ManagedSessionDescendantStore;
+			sourceStoreRelativePath: string;
+		},
+	): ManagedFileSnapshot {
+		this.#assertBound();
+		const sourceResolved = this.#resolve(sourceRelativePath);
+		const destinationResolved = this.#resolve(destinationRelativePath);
+		if (
+			options &&
+			path.resolve(options.sourceStore.#resolve(options.sourceStoreRelativePath)) !== path.resolve(sourceResolved)
+		)
+			throw new ManagedTreeMoveOutcomeError("artifact_source_changed", false);
+		const source = options
+			? options.sourceStore.readExpected(options.sourceStoreRelativePath)
+			: this.readExpected(sourceRelativePath);
+		if (
+			!source ||
+			!sameReplacementIdentity(source.identity, expected.identity) ||
+			source.identity.sha256 !== expected.identity.sha256 ||
+			!source.bytes.equals(expected.bytes)
+		)
+			throw new ManagedTreeMoveOutcomeError("artifact_source_changed", false);
+
+		const moved = this.#authority
+			? this.#authority.renameManagedFileNoReplace(
+					this.#relative(sourceResolved),
+					this.#relative(destinationResolved),
+					expected.identity.dev.toString(),
+					expected.identity.ino.toString(),
+					expected.identity.size.toString(),
+					expected.identity.mtimeNs.toString(),
+					expected.identity.ctimeNs.toString(),
+					expected.identity.sha256,
+				)
+			: nativeSessionStorage().renameNoReplacePath(sourceResolved, destinationResolved);
+		const outcome = classifyNativePublishOutcome(moved, this.#authority ? "retained_file" : "direct_rename");
+		if (!outcome.ok)
+			throw new ManagedTreeMoveOutcomeError(publishFailure(outcome).message, mayCleanCurrentStaging(outcome));
+
+		const movedSnapshot = this.readExpected(destinationRelativePath);
+		if (
+			!movedSnapshot ||
+			!sameReplacementIdentity(movedSnapshot.identity, expected.identity) ||
+			movedSnapshot.identity.sha256 !== expected.identity.sha256 ||
+			!movedSnapshot.bytes.equals(expected.bytes)
+		)
+			throw new ManagedTreeMoveOutcomeError("artifact_destination_mismatch", false);
+		if (!this.#authority) {
+			try {
+				fsyncDirectory(path.dirname(sourceResolved));
+				if (path.dirname(sourceResolved) !== path.dirname(destinationResolved))
+					fsyncDirectory(path.dirname(destinationResolved));
+			} catch {
+				throw new ManagedTreeMoveOutcomeError("managed_publish_fsync_failed", false);
+			}
+		}
+		this.#assertBound();
+		return movedSnapshot;
+	}
+
 	removeTreeExpected(relativePath: string, expected: NativeDirectoryTreeSnapshot): void {
 		this.#beforeMutation();
 		this.#assertBound();

package/src/session/provider-safety-stop-hint.ts

@@ -54,8 +54,9 @@ export interface ProviderSafetyStopHintSession {
 /** Whether an assistant message terminated as a provider safety stop (typed or legacy-persisted). */
 export function isProviderSafetyStop(message: AssistantMessage): boolean {
 	return (
-		message.errorKind === "provider_safety_stop" ||
-		(message.errorMessage !== undefined && isLegacyProviderSafetyStopMessage(message.errorMessage))
+		message.stopReason === "error" &&
+		(message.errorKind === "provider_safety_stop" ||
+			(message.errorMessage !== undefined && isLegacyProviderSafetyStopMessage(message.errorMessage)))
 	);
 }