@gajae-code/coding-agent 0.12.5 → 0.12.6

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

@@ -89,6 +89,7 @@ function sameDirectoryTreeSnapshotAfterRename(
 				entry.kind === other.kind &&
 				entry.dev === other.dev &&
 				entry.ino === other.ino &&
+				entry.nlink === other.nlink &&
 				entry.size === other.size &&
 				entry.mtimeNs === other.mtimeNs &&
 				(entry.relativePath === "" || entry.ctimeNs === other.ctimeNs) &&
@@ -478,6 +479,7 @@ export class ManagedSessionDescendantStore {
 	/** Logical profile root inherited by nested managed session destinations. */
 	readonly #profileAgentDir: string;
 	readonly #subtreeRoot: ManagedDirectoryRoot;
+	#portableMutationFence?: ManagedStorageLock;
 
 	constructor(
 		root: ManagedDirectoryRoot,
@@ -546,6 +548,40 @@ export class ManagedSessionDescendantStore {
 		return this.#policy;
 	}
 
+	get hasRetainedAuthority(): boolean {
+		return this.#authority !== undefined;
+	}
+
+	async acquireMutationFence(name: string): Promise<ManagedStorageLock | undefined> {
+		if (this.#authority) return undefined;
+		if (!/^[a-zA-Z0-9_.-]+$/.test(name)) throw new Error("invalid_mutation_fence");
+		this.#assertBound();
+		if (this.#portableMutationFence) throw new Error("migration_busy");
+		const lock = await acquireManagedLock(this.#baseDir, `.gjc-${name}`, this.#subtreeRoot, this.#policy);
+		try {
+			this.#assertBound();
+			lock.assertOwned();
+		} catch (error) {
+			await lock.release();
+			throw error;
+		}
+		this.#portableMutationFence = lock;
+		return {
+			path: lock.path,
+			attemptId: lock.attemptId,
+			assertOwned: () => {
+				this.#assertBound();
+				lock.assertOwned();
+			},
+			release: async () => {
+				try {
+					await lock.release();
+				} finally {
+					if (this.#portableMutationFence === lock) this.#portableMutationFence = undefined;
+				}
+			},
+		};
+	}
 	get profileAgentDir(): string {
 		return this.#profileAgentDir;
 	}
@@ -623,7 +659,18 @@ export class ManagedSessionDescendantStore {
 		this.#assertBound();
 	}
 	#assertBound(): void {
-		if (!this.#authority) return;
+		if (!this.#authority) {
+			const named = fs.lstatSync(this.#baseDir, { bigint: true });
+			if (
+				!named.isDirectory() ||
+				named.isSymbolicLink() ||
+				named.dev !== this.#subtreeRoot.dev ||
+				named.ino !== this.#subtreeRoot.ino
+			) {
+				throw new Error("Managed descendant root binding changed");
+			}
+			return;
+		}
 		const named = fs.lstatSync(this.#baseDir, { bigint: true });
 		const retained =
 			this.#authorityBaseDir === this.#baseDir
@@ -669,24 +716,41 @@ export class ManagedSessionDescendantStore {
 	}
 
 	async publishNoReplace(relativePath: string, bytes: Uint8Array): Promise<void> {
+		this.#assertBound();
+		this.#portableMutationFence?.assertOwned();
 		const resolved = this.#resolve(relativePath);
 		if (this.#authority) {
-			this.#assertBound();
 			this.#publishRetainedNoReplace(this.#relative(resolved), bytes);
 			this.#assertBound();
 			return;
 		}
-		await publishManagedFileNoReplace(resolved, bytes, undefined, this.#root, this.#policy);
+		await publishManagedFileNoReplace(
+			resolved,
+			bytes,
+			this.#portableMutationFence ? () => this.#portableMutationFence?.assertOwned() : undefined,
+			this.#subtreeRoot,
+			this.#policy,
+		);
+		this.#assertBound();
+		this.#portableMutationFence?.assertOwned();
 	}
 
 	publishNoReplaceSync(relativePath: string, bytes: Uint8Array): void {
+		this.#assertBound();
+		this.#portableMutationFence?.assertOwned();
 		const resolved = this.#resolve(relativePath);
 		if (!this.#authority) {
-			publishManagedFileNoReplaceSync(resolved, bytes, this.#root, this.#policy);
+			publishManagedFileNoReplaceSync(
+				resolved,
+				bytes,
+				this.#subtreeRoot,
+				this.#policy,
+				this.#portableMutationFence ? () => this.#portableMutationFence?.assertOwned() : undefined,
+			);
 			this.#assertBound();
+			this.#portableMutationFence?.assertOwned();
 			return;
 		}
-		this.#assertBound();
 		this.#publishRetainedNoReplace(this.#relative(resolved), bytes);
 		this.#assertBound();
 	}
@@ -704,6 +768,34 @@ export class ManagedSessionDescendantStore {
 		this.#assertBound();
 	}
 
+	replaceExpected(relativePath: string, bytes: Uint8Array, expected: ManagedFileSnapshot): void {
+		this.#assertBound();
+		const resolved = this.#resolve(relativePath);
+		if (!this.#authority) {
+			const fence = this.#portableMutationFence;
+			if (!fence) throw new Error("managed_replace_exact_unavailable");
+			fence.assertOwned();
+			const current = captureManagedFileNoFollow(resolved);
+			if (!sameIdentity(current.identity, expected.identity) || current.identity.sha256 !== expected.identity.sha256)
+				throw new Error("managed_replace_identity_mismatch");
+			replaceManagedFileSync(resolved, bytes, this.#subtreeRoot, this.#policy, () => fence.assertOwned());
+			fence.assertOwned();
+			return;
+		}
+		const replaced = (this.#authority as RecoveryFsRoot & RetainedManagedReplacer).replaceManaged(
+			this.#relative(resolved),
+			bytes,
+			expected.identity.dev.toString(),
+			expected.identity.ino.toString(),
+			String(expected.identity.size),
+			expected.identity.mtimeNs.toString(),
+			expected.identity.ctimeNs.toString(),
+			expected.identity.sha256,
+		);
+		if (!replaced.ok) throw new Error(replaced.code ?? "managed_replace_failed");
+		this.#assertBound();
+	}
+
 	replaceSync(relativePath: string, bytes: Uint8Array): void {
 		this.#assertBound();
 		const resolved = this.#resolve(relativePath);
@@ -1433,6 +1525,7 @@ export function publishManagedFileNoReplaceSync(
 	bytes: Uint8Array,
 	root?: ManagedDirectoryRoot,
 	policy: ManagedSessionSecurityPolicy = "default",
+	assertOwned?: () => void,
 ): void {
 	const parent = path.dirname(destination);
 	ensureManagedDirectory(parent, root, policy);
@@ -1443,6 +1536,7 @@ export function publishManagedFileNoReplaceSync(
 	let outcome: NativePublishOutcome | undefined;
 
 	try {
+		assertOwned?.();
 		fd = fs.openSync(
 			staging,
 			fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY | fs.constants.O_NOFOLLOW,
@@ -1456,7 +1550,9 @@ export function publishManagedFileNoReplaceSync(
 		const staged = fs.fstatSync(fd, { bigint: true });
 		stagingIdentity = { dev: staged.dev, ino: staged.ino };
 
+		assertOwned?.();
 		outcome = classifyNativePublishOutcome(renameNoReplacePath(staging, destination));
+		assertOwned?.();
 		if (!outcome.ok) throw publishFailure(outcome);
 
 		const named = fs.lstatSync(destination, { bigint: true });
@@ -1492,6 +1588,7 @@ export function replaceManagedFileSync(
 	bytes: Uint8Array,
 	root: ManagedDirectoryRoot,
 	policy: ManagedSessionSecurityPolicy = "default",
+	assertFence?: () => void,
 ): void {
 	const parent = path.dirname(destination);
 	ensureManagedDirectory(parent, root, policy);
@@ -1499,6 +1596,7 @@ export function replaceManagedFileSync(
 	let fd: number | undefined;
 	let stagedIdentity: { dev: bigint; ino: bigint } | undefined;
 	try {
+		assertFence?.();
 		fd = fs.openSync(
 			staging,
 			fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY | fs.constants.O_NOFOLLOW,
@@ -1512,7 +1610,9 @@ export function replaceManagedFileSync(
 		const staged = fs.fstatSync(fd, { bigint: true });
 		stagedIdentity = { dev: staged.dev, ino: staged.ino };
 		assertManagedDirectoryRoot(root);
+		assertFence?.();
 		fs.renameSync(staging, destination);
+		assertFence?.();
 		assertManagedDirectoryRoot(root);
 		const named = fs.lstatSync(destination, { bigint: true });
 		if (!named.isFile() || named.isSymbolicLink() || named.dev !== staged.dev || named.ino !== staged.ino) {

package/src/session/messages.ts

@@ -194,14 +194,39 @@ function utf8Suffix(text: string, maxBytes: number): string {
  * next provider context is constructed. Byte boundaries never split UTF-8
  * code points, so head/tail recovery remains readable for emoji and CJK text.
  */
-export function createPreAdmissionArtifactSpillPreview(fullText: string, artifactId: string, digest: string): string {
+export function createPreAdmissionArtifactSpillPreview(
+	fullText: string,
+	artifactId: string,
+	digest: string,
+	options: { maxInlineBytes?: number; fullOutput?: boolean } = {},
+): string {
 	const totalBytes = Buffer.byteLength(fullText, "utf-8");
-	const head = utf8Prefix(fullText, PRE_ADMISSION_ARTIFACT_SPILL_HEAD_BYTES);
-	const tail = utf8Suffix(fullText, PRE_ADMISSION_ARTIFACT_SPILL_TAIL_BYTES);
-	const retainedBytes = Buffer.byteLength(head, "utf-8") + Buffer.byteLength(tail, "utf-8");
-	const omittedBytes = Math.max(0, totalBytes - retainedBytes);
-	const receipt = `[${omittedBytes} bytes omitted; sha256:${digest}; full output: artifact://${artifactId}]`;
-	return `${head}\n\n${receipt}\n\n${tail}`;
+	const maxInlineBytes = options.maxInlineBytes;
+	const referenceKind = options.fullOutput === false ? "retained output" : "full output";
+	let headBudget = PRE_ADMISSION_ARTIFACT_SPILL_HEAD_BYTES;
+	let tailBudget = PRE_ADMISSION_ARTIFACT_SPILL_TAIL_BYTES;
+	if (maxInlineBytes !== undefined) {
+		const receiptReserve = Buffer.byteLength(
+			`\n\n[${totalBytes} bytes omitted; sha256:${digest}; ${referenceKind}: artifact://${artifactId}]\n\n`,
+			"utf-8",
+		);
+		const contentBudget = Math.max(0, maxInlineBytes - receiptReserve);
+		headBudget = Math.min(headBudget, Math.ceil(contentBudget / 2));
+		tailBudget = Math.min(tailBudget, Math.floor(contentBudget / 2));
+	}
+	for (;;) {
+		const head = utf8Prefix(fullText, headBudget);
+		const tail = utf8Suffix(fullText, tailBudget);
+		const retainedBytes = Buffer.byteLength(head, "utf-8") + Buffer.byteLength(tail, "utf-8");
+		const omittedBytes = Math.max(0, totalBytes - retainedBytes);
+		const receipt = `[${omittedBytes} bytes omitted; sha256:${digest}; ${referenceKind}: artifact://${artifactId}]`;
+		const preview = `${head}\n\n${receipt}\n\n${tail}`;
+		if (maxInlineBytes === undefined || Buffer.byteLength(preview, "utf-8") <= maxInlineBytes) return preview;
+		if (headBudget === 0 && tailBudget === 0) return utf8Prefix(receipt, maxInlineBytes);
+		const overflow = Buffer.byteLength(preview, "utf-8") - maxInlineBytes;
+		if (tailBudget >= headBudget) tailBudget = Math.max(0, tailBudget - overflow);
+		else headBudget = Math.max(0, headBudget - overflow);
+	}
 }
 
 /**

package/src/session/session-manager.ts

@@ -37,7 +37,7 @@ import { assertSafePathComponent } from "../gjc-runtime/session-layout";
 import { writeTextAtomic } from "../gjc-runtime/state-writer";
 import type { ManagedLegacyLocalMigrationSource } from "../internal-urls/local-protocol";
 import * as git from "../utils/git";
-import { ArtifactManager } from "./artifacts";
+import { ArtifactManager, type ArtifactSaveReceipt } from "./artifacts";
 import {
 	type BlobPutResult,
 	BlobStore,
@@ -895,6 +895,7 @@ export interface ResumeSessionIdentity {
 	sessionId: string;
 	dev: bigint;
 	ino: bigint;
+	nlink?: bigint;
 	size: number;
 	mtimeMs: number;
 	mtimeNs: bigint;
@@ -1132,7 +1133,7 @@ export function createReadonlySessionManager(manager: SessionManager): ReadonlyS
 
 /** Internal artifact-writing capability. Read-only facades expose it only through a private weak-map lookup. */
 export type SessionArtifactCapability = Readonly<
-	Pick<SessionManager, "allocateArtifactPath" | "saveArtifact" | "putBlob">
+	Pick<SessionManager, "allocateArtifactPath" | "saveArtifact" | "getArtifactPath" | "putBlob">
 >;
 
 const sessionArtifactCapabilities = new WeakMap<SessionManager, SessionArtifactCapability>();
@@ -1149,6 +1150,7 @@ export function sessionArtifactCapability(value: unknown): SessionArtifactCapabi
 			capability = Object.freeze({
 				allocateArtifactPath: value.allocateArtifactPath.bind(value),
 				saveArtifact: value.saveArtifact.bind(value),
+				getArtifactPath: value.getArtifactPath.bind(value),
 				putBlob: value.putBlob.bind(value),
 			});
 			sessionArtifactCapabilities.set(value, capability);
@@ -1831,6 +1833,7 @@ function retainedTreeSnapshotEquals(
 				entry.kind === other.kind &&
 				entry.dev === other.dev &&
 				entry.ino === other.ino &&
+				entry.nlink === other.nlink &&
 				entry.size === other.size &&
 				entry.mtimeNs === other.mtimeNs &&
 				entry.ctimeNs === other.ctimeNs &&
@@ -1856,6 +1859,7 @@ function retainedTreeSnapshotEqualsAfterRename(
 				entry.kind === other.kind &&
 				entry.dev === other.dev &&
 				entry.ino === other.ino &&
+				entry.nlink === other.nlink &&
 				entry.size === other.size &&
 				entry.mtimeNs === other.mtimeNs &&
 				(entry.relativePath === "" || entry.ctimeNs === other.ctimeNs) &&
@@ -2147,6 +2151,7 @@ function sameResumeIdentity(left: ResumeSessionIdentity, right: ResumeSessionIde
 		left.sessionId === right.sessionId &&
 		left.dev === right.dev &&
 		left.ino === right.ino &&
+		left.nlink === right.nlink &&
 		left.size === right.size &&
 		left.mtimeMs === right.mtimeMs &&
 		left.mtimeNs === right.mtimeNs &&
@@ -2160,6 +2165,7 @@ function sameResumeStat(left: SessionStorageStat, right: SessionStorageStat): bo
 		right.isFile &&
 		left.dev === right.dev &&
 		left.ino === right.ino &&
+		left.nlink === right.nlink &&
 		left.size === right.size &&
 		left.mtimeMs === right.mtimeMs &&
 		left.mtimeNs === right.mtimeNs
@@ -2356,6 +2362,7 @@ function inspectResumeSessionFile(
 			sessionId: header.id,
 			dev: snapshot.dev,
 			ino: snapshot.ino,
+			nlink: snapshot.nlink,
 			size: snapshot.size,
 			mtimeMs: snapshot.mtimeMs,
 			mtimeNs: snapshot.mtimeNs,
@@ -2393,6 +2400,7 @@ function revalidateResumeSessionIdentity(
 		sessionId: expected.sessionId,
 		dev: snapshot.stat.dev,
 		ino: snapshot.stat.ino,
+		nlink: snapshot.stat.nlink,
 		size: snapshot.stat.size,
 		mtimeMs: snapshot.stat.mtimeMs,
 		mtimeNs: snapshot.stat.mtimeNs,
@@ -4764,10 +4772,6 @@ export class SessionManager {
 	// Subagents adopt the parent's manager so artifact IDs are unique across the
 	// whole agent tree and all files land in the parent's artifacts dir.
 	#adoptedArtifactManager: ArtifactManager | null = null;
-	// In-memory artifact fallback for non-persistent sessions (persist=false).
-	// Keyed by sequential numeric ID string; mirrors the file-based ArtifactManager ID scheme.
-	#inMemoryArtifacts: Map<string, string> | null = null;
-	#inMemoryArtifactCounter = 0;
 	readonly #blobStore: BlobStore;
 	#residentTextBlobStore: BlobStore = new MemoryBlobStore();
 	#residentImageBlobStore: BlobStore;
@@ -5361,8 +5365,6 @@ export class SessionManager {
 		this.#flushed = false;
 		this.#needsFullRewriteOnNextPersist = false;
 		this.#ensuredOnDisk = false;
-		this.#inMemoryArtifacts = null;
-		this.#inMemoryArtifactCounter = 0;
 		this.#artifactManager = null;
 		this.#artifactManagerSessionFile = null;
 		this.#adoptedArtifactManager = null;
@@ -5581,8 +5583,6 @@ export class SessionManager {
 				flushed: this.#flushed,
 				needsFullRewriteOnNextPersist: this.#needsFullRewriteOnNextPersist,
 				ensuredOnDisk: this.#ensuredOnDisk,
-				inMemoryArtifacts: this.#inMemoryArtifacts,
-				inMemoryArtifactCounter: this.#inMemoryArtifactCounter,
 				artifactManager: this.#artifactManager,
 				artifactManagerSessionFile: this.#artifactManagerSessionFile,
 				adoptedArtifactManager: this.#adoptedArtifactManager,
@@ -5605,8 +5605,6 @@ export class SessionManager {
 				this.#flushed = previous.flushed;
 				this.#needsFullRewriteOnNextPersist = previous.needsFullRewriteOnNextPersist;
 				this.#ensuredOnDisk = previous.ensuredOnDisk;
-				this.#inMemoryArtifacts = previous.inMemoryArtifacts;
-				this.#inMemoryArtifactCounter = previous.inMemoryArtifactCounter;
 				this.#artifactManager = previous.artifactManager;
 				this.#artifactManagerSessionFile = previous.artifactManagerSessionFile;
 				this.#adoptedArtifactManager = previous.adoptedArtifactManager;
@@ -6052,8 +6050,6 @@ export class SessionManager {
 		this.#flushed = stage.flushed;
 		this.#needsFullRewriteOnNextPersist = false;
 		this.#ensuredOnDisk = stage.flushed;
-		this.#inMemoryArtifacts = null;
-		this.#inMemoryArtifactCounter = 0;
 		this.#artifactManager = null;
 		this.#artifactManagerSessionFile = null;
 		this.#adoptedArtifactManager = null;
@@ -7983,17 +7979,19 @@ export class SessionManager {
 	}
 
 	/**
-	 * Save artifact content under the current session and return artifact ID.
-	 * Returns an artifact ID for all sessions (file-backed for persistent, in-memory fallback otherwise).
+	 * Save artifact content under the current persisted session and return its artifact ID.
+	 * In-memory sessions cannot produce protocol-resolvable artifact references.
 	 */
 	async saveArtifact(content: string, toolType: string): Promise<string | undefined> {
 		const manager = this.#getOrCreateArtifactManager();
 		if (manager) return manager.save(content, toolType);
-		// Non-persistent session: store in memory so spill truncation can proceed.
-		if (!this.#inMemoryArtifacts) this.#inMemoryArtifacts = new Map();
-		const id = String(this.#inMemoryArtifactCounter++);
-		this.#inMemoryArtifacts.set(id, content);
-		return id;
+		return undefined;
+	}
+
+	async saveArtifactReceipt(content: string, toolType: string): Promise<ArtifactSaveReceipt | undefined> {
+		const manager = this.#getOrCreateArtifactManager();
+		if (!manager) return undefined;
+		return manager.saveWithReceipt(content, toolType);
 	}
 
 	/**