@gajae-code/coding-agent 0.12.6 → 0.12.7

package/src/session/agent-session.ts

@@ -349,12 +349,7 @@ import {
 import { assertEditableFile } from "../tools/auto-generated-guard";
 import { releaseTabsForOwner } from "../tools/browser/tab-supervisor";
 import type { CheckpointState } from "../tools/checkpoint";
-import {
-	createArtifactFailurePreview,
-	type OutputMeta,
-	outputMeta,
-	wrapToolWithMetaNotice,
-} from "../tools/output-meta";
+import { outputMeta, wrapToolWithMetaNotice } from "../tools/output-meta";
 import { normalizeLocalScheme, resolveReadPath, resolveToCwd } from "../tools/path-utils";
 import { registerResourceGcSession } from "../tools/resource-gc";
 import { getLatestTodoPhasesFromEntries, type TodoItem, type TodoPhase } from "../tools/todo-write";
@@ -1062,102 +1057,6 @@ function boundAgentBashArtifactSaveDiagnostic(error: unknown): string {
 	return truncateHeadBytes(normalized, AGENT_BASH_ARTIFACT_SAVE_DIAGNOSTIC_MAX_BYTES).text;
 }
 
-const PRE_ADMISSION_ARTIFACT_SAVE_WAIT_MS = 500;
-const PRE_ADMISSION_ARTIFACT_MAX_PENDING_SAVES = 2;
-
-type PreAdmissionArtifactSaveOutcome =
-	| { kind: "saved"; saved: Awaited<ReturnType<SessionManager["saveArtifactReceipt"]>> }
-	| { kind: "failed"; error: unknown };
-
-interface PreAdmissionArtifactSaveAdmission {
-	readonly pending: Set<Promise<PreAdmissionArtifactSaveOutcome>>;
-}
-
-/**
- * Pre-admission spills are owned by their concrete SessionManager. A stalled
- * save remains admitted until its promise settles, so timeout does not turn
- * each subsequent tool result into another retained full payload.
- */
-const preAdmissionArtifactSaveAdmissions = new WeakMap<SessionManager, PreAdmissionArtifactSaveAdmission>();
-
-function preAdmissionArtifactSaveAdmissionFor(sessionManager: SessionManager): PreAdmissionArtifactSaveAdmission {
-	let admission = preAdmissionArtifactSaveAdmissions.get(sessionManager);
-	if (!admission) {
-		admission = { pending: new Set() };
-		preAdmissionArtifactSaveAdmissions.set(sessionManager, admission);
-	}
-	return admission;
-}
-
-function beginPreAdmissionArtifactSave(
-	sessionManager: SessionManager,
-	content: string,
-	toolType: string,
-): { kind: "capacity" } | { kind: "started"; outcome: Promise<PreAdmissionArtifactSaveOutcome> } {
-	const admission = preAdmissionArtifactSaveAdmissionFor(sessionManager);
-	if (admission.pending.size >= PRE_ADMISSION_ARTIFACT_MAX_PENDING_SAVES) return { kind: "capacity" };
-
-	let outcome: Promise<PreAdmissionArtifactSaveOutcome>;
-	try {
-		outcome = sessionManager.saveArtifactReceipt(content, toolType).then(
-			saved => ({ kind: "saved" as const, saved }),
-			error => ({ kind: "failed" as const, error }),
-		);
-	} catch (error) {
-		return { kind: "started", outcome: Promise.resolve({ kind: "failed", error }) };
-	}
-	admission.pending.add(outcome);
-	void outcome.then(
-		() => admission.pending.delete(outcome),
-		() => admission.pending.delete(outcome),
-	);
-	return { kind: "started", outcome };
-}
-
-function replaceToolResultWithArtifactFailurePreview(
-	message: ToolResultMessage,
-	fullText: string,
-	maxInlineBytes: number | undefined,
-	diagnostic: string,
-): void {
-	const preview = createArtifactFailurePreview(fullText, maxInlineBytes, diagnostic);
-	const existingDetails =
-		message.details && typeof message.details === "object" ? (message.details as Record<string, unknown>) : {};
-	const existingMeta =
-		existingDetails.meta && typeof existingDetails.meta === "object" ? (existingDetails.meta as OutputMeta) : {};
-	const existingTruncation = existingMeta.truncation;
-	const totalLines = fullText.length > 0 ? fullText.split("\n").length : 0;
-	const outputLines = preview.text.length > 0 ? preview.text.split("\n").length : 0;
-	const outputBytes = Buffer.byteLength(preview.text, "utf-8");
-	const truncation: NonNullable<OutputMeta["truncation"]> = {
-		...(existingTruncation ?? {}),
-		direction: "tail",
-		truncatedBy: "bytes",
-		noticeOwner: undefined,
-		totalLines,
-		totalBytes: Buffer.byteLength(fullText, "utf-8"),
-		outputLines,
-		outputBytes,
-		maxBytes: maxInlineBytes,
-		shownRange: undefined,
-		headRange: undefined,
-		tailRange: undefined,
-		nextOffset: undefined,
-		artifactId: undefined,
-		artifactVerified: false,
-		sourceCaptureIncomplete: true,
-		artifactFailureDiagnostic: diagnostic,
-	};
-	message.details = {
-		...existingDetails,
-		meta: { ...existingMeta, truncation },
-	};
-	message.content = [
-		...message.content.filter((block): block is ImageContent => block.type === "image"),
-		{ type: "text", text: preview.text },
-	];
-}
-
 function summarizeAgentBashArtifactSave(
 	artifactId: string,
 	originalText: string,
@@ -3782,101 +3681,39 @@ export class AgentSession {
 		const textParts = message.content.flatMap(block => (block.type === "text" ? [block.text] : []));
 		if (textParts.length === 0) return;
 		const fullText = textParts.join("\n");
-		const configuredInlineKiB = this.settings.get("tools.maxInlineResultBytes");
-		const maxInlineBytes =
-			configuredInlineKiB > 0 ? Math.max(1024, Math.floor(configuredInlineKiB * 1024)) : undefined;
-		const totalBytes = Buffer.byteLength(fullText, "utf-8");
-		const exceedsInlineCap = maxInlineBytes !== undefined && totalBytes > maxInlineBytes;
 		const contextWindow = this.model?.contextWindow;
 		const thresholdTokens = Math.min(
 			8_000,
 			contextWindow && contextWindow > 0 ? Math.floor(contextWindow * 0.05) : 8_000,
 		);
-		// The inline byte cap is an independent admission bound and must be checked
-		// before token heuristics can opt this result out of spilling.
-		if (!exceedsInlineCap && (thresholdTokens <= 0 || estimateTextTokensHeuristic(fullText) <= thresholdTokens))
-			return;
+		if (thresholdTokens <= 0 || estimateTextTokensHeuristic(fullText) <= thresholdTokens) return;
 
-		const saveAdmission = beginPreAdmissionArtifactSave(this.sessionManager, fullText, "tool-result");
-		if (saveAdmission.kind === "capacity") {
-			replaceToolResultWithArtifactFailurePreview(
-				message,
-				fullText,
-				maxInlineBytes,
-				"artifact save capacity exhausted; the previous save is still settling",
-			);
-			return;
-		}
 		try {
-			const saveOutcome = await Promise.race([
-				saveAdmission.outcome,
-				Bun.sleep(PRE_ADMISSION_ARTIFACT_SAVE_WAIT_MS).then(() => ({ kind: "timeout" as const })),
-			]);
-			if (saveOutcome.kind !== "saved" || !saveOutcome.saved) {
-				const diagnostic =
-					saveOutcome.kind === "timeout"
-						? `did not settle within ${PRE_ADMISSION_ARTIFACT_SAVE_WAIT_MS}ms`
-						: saveOutcome.kind === "failed"
-							? boundAgentBashArtifactSaveDiagnostic(saveOutcome.error)
-							: "artifact storage is unavailable";
-				replaceToolResultWithArtifactFailurePreview(message, fullText, maxInlineBytes, diagnostic);
-				return;
-			}
-			const saved = saveOutcome.saved;
-			const existingDetails = message.details;
-			const detailRecord =
-				existingDetails && typeof existingDetails === "object" ? (existingDetails as Record<string, unknown>) : {};
-			const existingMeta =
-				detailRecord.meta && typeof detailRecord.meta === "object" ? (detailRecord.meta as OutputMeta) : {};
-			const existingTruncation = existingMeta.truncation;
-			const priorLoss = existingTruncation !== undefined;
+			const artifactId = await this.sessionManager.saveArtifact(fullText, "tool-result");
+			if (!artifactId) return;
 			const digest = crypto.createHash("sha256").update(fullText).digest("hex");
-			const sourceCaptureIncomplete = priorLoss || !saved.complete || undefined;
-			const preview = createPreAdmissionArtifactSpillPreview(fullText, saved.id, digest, {
-				maxInlineBytes,
-				fullOutput: saved.complete && !priorLoss,
-			});
+			const preview = createPreAdmissionArtifactSpillPreview(fullText, artifactId, digest);
 			const spillMeta = outputMeta()
 				.truncationFromText(preview, {
 					direction: "middle",
 					totalLines: fullText.split("\n").length,
-					totalBytes,
-					artifactId: saved.id,
-					artifactVerified: true,
-					sourceCaptureIncomplete,
-					...(maxInlineBytes !== undefined ? { maxBytes: maxInlineBytes } : {}),
+					totalBytes: Buffer.byteLength(fullText, "utf-8"),
+					artifactId,
 				})
 				.get();
-			const spillTruncation = spillMeta?.truncation;
-			const artifactTruncatedBytes =
-				Math.max(existingTruncation?.artifactTruncatedBytes ?? 0, saved.omittedBytes ?? 0) || undefined;
-			const mergedTruncation = spillTruncation
-				? {
-						...existingTruncation,
-						...spillTruncation,
-						artifactId: saved.id,
-						artifactVerified: true,
-						artifactTruncatedBytes,
-						sourceTruncatedBytes: existingTruncation?.sourceTruncatedBytes,
-						sourceCaptureIncomplete,
-						columnDroppedBytes: existingTruncation?.columnDroppedBytes,
-						shownRange: sourceCaptureIncomplete ? undefined : spillTruncation.shownRange,
-						headRange: sourceCaptureIncomplete ? undefined : spillTruncation.headRange,
-						tailRange: sourceCaptureIncomplete ? undefined : spillTruncation.tailRange,
-						nextOffset: sourceCaptureIncomplete ? undefined : spillTruncation.nextOffset,
-					}
-				: existingTruncation;
-			message.details = {
-				...detailRecord,
-				meta: { ...existingMeta, ...spillMeta, truncation: mergedTruncation },
-			};
+			const existingDetails = message.details;
+			const detailRecord =
+				existingDetails && typeof existingDetails === "object" ? (existingDetails as Record<string, unknown>) : {};
+			const existingMeta =
+				detailRecord.meta && typeof detailRecord.meta === "object"
+					? (detailRecord.meta as Record<string, unknown>)
+					: {};
+			message.details = { ...detailRecord, meta: { ...existingMeta, ...spillMeta } };
 			message.content = [
 				...message.content.filter((block): block is ImageContent => block.type === "image"),
 				{ type: "text", text: preview },
 			];
 		} catch (error) {
-			const diagnostic = boundAgentBashArtifactSaveDiagnostic(error);
-			replaceToolResultWithArtifactFailurePreview(message, fullText, maxInlineBytes, diagnostic);
 			logger.warn("Failed to spill oversized tool result before context admission", {
 				toolName: message.toolName,
 				error: error instanceof Error ? error.message : String(error),

package/src/session/artifacts.ts

@@ -9,10 +9,8 @@ import { createHash, randomUUID } from "node:crypto";
 import * as fs from "node:fs/promises";
 
 import * as path from "node:path";
-import { isValidArtifactId } from "../utils/artifact-id";
 import {
 	ensureManagedDirectory,
-	type ManagedFileSnapshot,
 	type ManagedSessionDescendantStore,
 	publishManagedFileNoReplace,
 } from "./internal/managed-session-storage";
@@ -35,9 +33,6 @@ function isSafeFilename(filename: string): boolean {
 	return /^[a-zA-Z0-9_.-]+$/.test(filename);
 }
 
-const MANAGED_OUTPUT_GENERATION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
-const SHA256_PATTERN = /^[0-9a-f]{64}$/;
-
 function parseManagedOutputGeneration(value: Uint8Array, outputFilenamePrefix: string): ManagedOutputGeneration | null {
 	try {
 		const parsed = JSON.parse(Buffer.from(value).toString("utf8")) as Partial<ManagedOutputGeneration>;
@@ -48,19 +43,10 @@ function parseManagedOutputGeneration(value: Uint8Array, outputFilenamePrefix: s
 			typeof parsed.outputSha256 !== "string" ||
 			typeof parsed.metadataSizeBytes !== "number" ||
 			typeof parsed.metadataSha256 !== "string" ||
-			!Number.isSafeInteger(parsed.outputSizeBytes) ||
-			(parsed.outputSizeBytes ?? -1) < 0 ||
-			!Number.isSafeInteger(parsed.metadataSizeBytes) ||
-			(parsed.metadataSizeBytes ?? -1) < 0 ||
-			!SHA256_PATTERN.test(parsed.outputSha256) ||
-			!SHA256_PATTERN.test(parsed.metadataSha256) ||
 			!isSafeFilename(parsed.outputFilename) ||
 			!isSafeFilename(parsed.metadataFilename) ||
 			!parsed.outputFilename.startsWith(`${outputFilenamePrefix}.`) ||
 			!parsed.outputFilename.endsWith(".output") ||
-			!MANAGED_OUTPUT_GENERATION_ID_PATTERN.test(
-				parsed.outputFilename.slice(outputFilenamePrefix.length + 1, -".output".length),
-			) ||
 			parsed.metadataFilename !== `${parsed.outputFilename}.meta.json`
 		)
 			return null;
@@ -71,36 +57,12 @@ function parseManagedOutputGeneration(value: Uint8Array, outputFilenamePrefix: s
 }
 
 function sameGeneration(left: ManagedOutputGeneration, right: ManagedOutputGeneration): boolean {
-	return (
-		left.outputFilename === right.outputFilename &&
-		left.metadataFilename === right.metadataFilename &&
-		left.outputSizeBytes === right.outputSizeBytes &&
-		left.outputSha256 === right.outputSha256 &&
-		left.metadataSizeBytes === right.metadataSizeBytes &&
-		left.metadataSha256 === right.metadataSha256
-	);
-}
-
-function referencesGeneration(value: Uint8Array, generation: ManagedOutputGeneration): boolean {
-	try {
-		const parsed = JSON.parse(Buffer.from(value).toString("utf8")) as Partial<ManagedOutputGeneration>;
-		return (
-			parsed.outputFilename === generation.outputFilename && parsed.metadataFilename === generation.metadataFilename
-		);
-	} catch {
-		return false;
-	}
+	return left.outputFilename === right.outputFilename && left.metadataFilename === right.metadataFilename;
 }
 export interface ArtifactSaveOptions {
 	maxBytes?: number;
 }
 
-export interface ArtifactSaveReceipt {
-	id: string;
-	complete: boolean;
-	omittedBytes?: number;
-}
-
 /**
  * Manages artifact storage for a session.
  *
@@ -117,7 +79,6 @@ export class ArtifactManager {
 	readonly #store: ManagedSessionDescendantStore | undefined;
 	#dirCreated = false;
 	#initialized = false;
-	#initializing: Promise<void> | undefined;
 
 	/**
 	 * @param dir Directory that will hold artifact files. Created lazily on first save.
@@ -152,21 +113,15 @@ export class ArtifactManager {
 	}
 
 	async #ensureDir(): Promise<void> {
-		if (this.#initialized) return;
-		if (!this.#initializing) {
-			this.#initializing = (async () => {
-				if (!this.#dirCreated) {
-					if (this.#store) this.#store.ensureDirectory();
-					else ensureManagedDirectory(this.#dir);
-					this.#dirCreated = true;
-				}
-				await this.#scanExistingIds();
-				this.#initialized = true;
-			})().finally(() => {
-				this.#initializing = undefined;
-			});
+		if (!this.#dirCreated) {
+			if (this.#store) this.#store.ensureDirectory();
+			else ensureManagedDirectory(this.#dir);
+			this.#dirCreated = true;
+		}
+		if (!this.#initialized) {
+			await this.#scanExistingIds();
+			this.#initialized = true;
 		}
-		await this.#initializing;
 	}
 
 	#filename(id: string, toolType: string): string {
@@ -204,116 +159,58 @@ export class ArtifactManager {
 		}
 		await this.#ensureDir();
 		if (!this.#store) throw new Error("Managed output generation requires retained authority");
-		const mutationFence = await this.#store.acquireMutationFence(`${selectorFilename}.publish`);
-		try {
-			const priorSelector = this.#store.readExpected(selectorFilename);
-			const priorGeneration = priorSelector
-				? parseManagedOutputGeneration(priorSelector.bytes, outputFilenamePrefix)
-				: null;
-			const generationId = randomUUID();
-			const outputFilename = `${outputFilenamePrefix}.${generationId}.output`;
-			const metadataFilename = `${outputFilename}.meta.json`;
-			const generation: ManagedOutputGeneration = {
-				outputFilename,
-				metadataFilename,
-				outputSizeBytes: outputBytes.byteLength,
-				outputSha256: sha256(outputBytes),
-				metadataSizeBytes: metadataBytes.byteLength,
-				metadataSha256: sha256(metadataBytes),
-			};
-
-			// Immutable generations are not visible until the selector is replaced.
-			let stagedOutput: ManagedFileSnapshot | undefined;
-			let stagedMetadata: ManagedFileSnapshot | undefined;
-			const removeStaged = () => {
-				for (const [filename, snapshot] of [
-					[metadataFilename, stagedMetadata],
-					[outputFilename, stagedOutput],
-				] as const) {
-					if (!snapshot) continue;
-					try {
-						this.#store!.removeExpected(filename, snapshot);
-					} catch {
-						// An identity mismatch is not authority to remove a successor.
-					}
-				}
-			};
-			try {
-				await this.#store.publishNoReplace(outputFilename, outputBytes);
-				stagedOutput = this.#store.readExpected(outputFilename) ?? undefined;
-				if (
-					!stagedOutput ||
-					stagedOutput.bytes.byteLength !== generation.outputSizeBytes ||
-					sha256(stagedOutput.bytes) !== generation.outputSha256
-				) {
-					throw new Error("managed_output_generation_verification_failed");
-				}
-				await this.#store.publishNoReplace(metadataFilename, metadataBytes);
-				stagedMetadata = this.#store.readExpected(metadataFilename) ?? undefined;
-				if (
-					!stagedMetadata ||
-					stagedMetadata.bytes.byteLength !== generation.metadataSizeBytes ||
-					sha256(stagedMetadata.bytes) !== generation.metadataSha256
-				) {
-					throw new Error("managed_output_generation_verification_failed");
-				}
-			} catch (error) {
-				removeStaged();
-				throw error;
-			}
 
-			const rollbackSelector = (observed: ManagedFileSnapshot | null): boolean => {
-				if (!observed || !referencesGeneration(observed.bytes, generation)) return false;
-				try {
-					if (priorSelector) {
-						this.#store!.replaceExpected(selectorFilename, priorSelector.bytes, observed);
-					} else {
-						this.#store!.removeExpected(selectorFilename, observed);
-					}
-					return true;
-				} catch {
-					return false;
-				}
-			};
-			const selectorBytes = Buffer.from(JSON.stringify(generation), "utf8");
-			try {
-				if (priorSelector) this.#store.replaceExpected(selectorFilename, selectorBytes, priorSelector);
-				else await this.#store.publishNoReplace(selectorFilename, selectorBytes);
-			} catch (error) {
-				let observed: ManagedFileSnapshot | null = null;
-				let observedRead = false;
+		const priorSelector = this.#store.readExpected(selectorFilename);
+		const priorGeneration = priorSelector
+			? parseManagedOutputGeneration(priorSelector.bytes, outputFilenamePrefix)
+			: null;
+		const generationId = randomUUID();
+		const outputFilename = `${outputFilenamePrefix}.${generationId}.output`;
+		const metadataFilename = `${outputFilename}.meta.json`;
+		const generation: ManagedOutputGeneration = {
+			outputFilename,
+			metadataFilename,
+			outputSizeBytes: outputBytes.byteLength,
+			outputSha256: sha256(outputBytes),
+			metadataSizeBytes: metadataBytes.byteLength,
+			metadataSha256: sha256(metadataBytes),
+		};
+
+		// Immutable generations are not visible until the selector is replaced.
+		await this.#store.publishNoReplace(outputFilename, outputBytes);
+		await this.#store.publishNoReplace(metadataFilename, metadataBytes);
+		const stagedOutput = this.#store.readExpected(outputFilename);
+		const stagedMetadata = this.#store.readExpected(metadataFilename);
+		if (
+			!stagedOutput ||
+			!stagedMetadata ||
+			stagedOutput.bytes.byteLength !== generation.outputSizeBytes ||
+			stagedMetadata.bytes.byteLength !== generation.metadataSizeBytes ||
+			sha256(stagedOutput.bytes) !== generation.outputSha256 ||
+			sha256(stagedMetadata.bytes) !== generation.metadataSha256
+		) {
+			throw new Error("managed_output_generation_verification_failed");
+		}
+
+		await this.#store.replace(selectorFilename, Buffer.from(JSON.stringify(generation), "utf8"));
+		const publishedSelector = this.#store.readExpected(selectorFilename);
+		const publishedGeneration = publishedSelector
+			? parseManagedOutputGeneration(publishedSelector.bytes, outputFilenamePrefix)
+			: null;
+		if (!publishedGeneration || !sameGeneration(publishedGeneration, generation)) {
+			throw new Error("managed_output_selector_verification_failed");
+		}
+
+		// Cleanup cannot affect the selected generation or publication outcome.
+		if (priorGeneration && !sameGeneration(priorGeneration, generation)) {
+			for (const filename of [priorGeneration.outputFilename, priorGeneration.metadataFilename]) {
 				try {
-					observed = this.#store.readExpected(selectorFilename);
-					observedRead = true;
+					const previous = this.#store.readExpected(filename);
+					if (previous) this.#store.removeExpected(filename, previous);
 				} catch {
-					// Without an exact selector snapshot, staged files remain quarantined.
+					// Retain unreachable generations for a later safe cleanup.
 				}
-				if (observedRead && (!observed || !referencesGeneration(observed.bytes, generation))) removeStaged();
-				else if (rollbackSelector(observed)) removeStaged();
-				throw error;
 			}
-			const publishedSelector = this.#store.readExpected(selectorFilename);
-			const publishedGeneration = publishedSelector
-				? parseManagedOutputGeneration(publishedSelector.bytes, outputFilenamePrefix)
-				: null;
-			if (!publishedGeneration || !sameGeneration(publishedGeneration, generation)) {
-				if (rollbackSelector(publishedSelector)) removeStaged();
-				throw new Error("managed_output_selector_verification_failed");
-			}
-
-			// Cleanup cannot affect the selected generation or publication outcome.
-			if (priorGeneration && !sameGeneration(priorGeneration, generation)) {
-				for (const filename of [priorGeneration.outputFilename, priorGeneration.metadataFilename]) {
-					try {
-						const previous = this.#store.readExpected(filename);
-						if (previous) this.#store.removeExpected(filename, previous);
-					} catch {
-						// Retain unreachable generations for a later safe cleanup.
-					}
-				}
-			}
-		} finally {
-			await mutationFence?.release();
 		}
 	}
 	async publishNamedNoReplace(filename: string, bytes: Uint8Array): Promise<void> {
@@ -355,8 +252,8 @@ export class ArtifactManager {
 		for (const file of files) {
 			// Files are named: {id}.{toolType}.log
 			const match = file.match(/^(\d+)\..*\.log$/);
-			if (match && isValidArtifactId(match[1])) {
-				const id = Number(match[1]);
+			if (match) {
+				const id = parseInt(match[1], 10);
 				if (id > maxId) maxId = id;
 			}
 		}
@@ -368,9 +265,6 @@ export class ArtifactManager {
 	 * IDs are sequential within the session.
 	 */
 	allocateId(): number {
-		if (!Number.isSafeInteger(this.#nextId) || this.#nextId < 0) {
-			throw new Error("Artifact id space exhausted");
-		}
 		return this.#nextId++;
 	}
 
@@ -387,28 +281,25 @@ export class ArtifactManager {
 		return { id, path: path.join(this.#dir, this.#filename(id, toolType)) };
 	}
 
-	/** Save content and return the artifact ID plus exact storage completeness evidence. */
-	async saveWithReceipt(
-		content: string,
-		toolType: string,
-		options: ArtifactSaveOptions = {},
-	): Promise<ArtifactSaveReceipt> {
+	/**
+	 * Save content as an artifact and return the artifact ID.
+	 * Content is written to a private temporary inode, synced, and linked into
+	 * the artifact directory only after the complete terminal payload exists.
+	 */
+	async save(content: string, toolType: string, options: ArtifactSaveOptions = {}): Promise<string> {
 		await this.#ensureDir();
 		const id = String(this.allocateId());
 		const maxBytes = Math.max(0, options.maxBytes ?? DEFAULT_ARTIFACT_MAX_BYTES);
 		const contentBytes = Buffer.byteLength(content, "utf-8");
-		const truncated = contentBytes > maxBytes ? truncateHeadBytes(content, maxBytes) : undefined;
-		const omittedBytes = truncated ? contentBytes - truncated.bytes : undefined;
-		const published = truncated
-			? `${truncated.text}\n[artifact truncated after ${truncated.bytes} bytes; omitted at least ${omittedBytes} bytes]\n`
-			: content;
+		const published =
+			contentBytes > maxBytes
+				? (() => {
+						const truncated = truncateHeadBytes(content, maxBytes);
+						return `${truncated.text}\n[artifact truncated after ${truncated.bytes} bytes; omitted at least ${contentBytes - truncated.bytes} bytes]\n`;
+					})()
+				: content;
 		await this.#publish(published, this.#filename(id, toolType));
-		return { id, complete: omittedBytes === undefined, omittedBytes };
-	}
-
-	/** Save content as an artifact and return the artifact ID. */
-	async save(content: string, toolType: string, options: ArtifactSaveOptions = {}): Promise<string> {
-		return (await this.saveWithReceipt(content, toolType, options)).id;
+		return id;
 	}
 
 	/**
@@ -439,36 +330,8 @@ export class ArtifactManager {
 	 * @param id Artifact ID (numeric string)
 	 */
 	async getPath(id: string): Promise<string | null> {
-		if (!isValidArtifactId(id)) return null;
 		const files = await this.listFiles();
-		const matches = files.filter(filename => new RegExp(`^${id}\\.[a-zA-Z0-9_-]+\\.log$`, "u").test(filename));
-		if (matches.length !== 1) return null;
-		const filename = matches[0]!;
-		if (this.#store) {
-			try {
-				return this.#store.readExpected(filename) ? path.join(this.#dir, filename) : null;
-			} catch {
-				return null;
-			}
-		}
-		try {
-			const rootBefore = await fs.lstat(this.#dir, { bigint: true });
-			if (!rootBefore.isDirectory() || rootBefore.isSymbolicLink()) return null;
-			const artifactPath = path.join(this.#dir, filename);
-			const leaf = await fs.lstat(artifactPath, { bigint: true });
-			if (!leaf.isFile() || leaf.isSymbolicLink() || leaf.nlink !== 1n) return null;
-			const rootAfter = await fs.lstat(this.#dir, { bigint: true });
-			if (
-				!rootAfter.isDirectory() ||
-				rootAfter.isSymbolicLink() ||
-				rootAfter.dev !== rootBefore.dev ||
-				rootAfter.ino !== rootBefore.ino
-			) {
-				return null;
-			}
-			return artifactPath;
-		} catch {
-			return null;
-		}
+		const match = files.find(f => f.startsWith(`${id}.`));
+		return match ? path.join(this.#dir, match) : null;
 	}
 }

package/src/session/client-bridge.ts

@@ -56,31 +56,18 @@ export interface ClientBridgeTerminalOutput {
 
 export interface ClientBridgeTerminalHandle {
 	terminalId: string;
-	/** Exact provider lease/session identity that owns this terminal. */
-	providerLeaseId: string;
 	waitForExit(): Promise<ClientBridgeTerminalExitStatus>;
 	currentOutput(): Promise<ClientBridgeTerminalOutput>;
 	kill(): Promise<void>;
 	release(): Promise<void>;
-	/** Full authenticated provider identity, when supplied by the transport. */
-	providerLeaseIdentity?: ClientBridgeProviderLeaseIdentity;
-}
-
-export interface ClientBridgeProviderLeaseIdentity {
-	leaseId: string;
-	connectionId: string;
-	connectionGeneration: number;
-	fence: string;
 }
 
 export interface ClientBridgeCreateTerminalParams {
-	toolCallId: string;
 	command: string;
 	args?: string[];
 	env?: Array<{ name: string; value: string }>;
 	cwd?: string;
 	outputByteLimit?: number;
-	signal?: AbortSignal;
 }
 
 export interface ClientBridge {
@@ -90,8 +77,6 @@ export interface ClientBridge {
 	readTextFile?(params: { path: string; line?: number; limit?: number }): Promise<string>;
 	writeTextFile?(params: { path: string; content: string }): Promise<void>;
 	createTerminal?(params: ClientBridgeCreateTerminalParams): Promise<ClientBridgeTerminalHandle>;
-	/** Fence the exact provider identity after cleanup ownership becomes uncertain. */
-	quarantineProviderLease?(providerLease: string | ClientBridgeProviderLeaseIdentity, reason: string): Promise<void>;
 	requestPermission?(
 		toolCall: ClientBridgePermissionToolCall,
 		options: ClientBridgePermissionOption[],