@gajae-code/coding-agent 0.18.11 → 0.19.0

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

@@ -80,6 +80,7 @@ export class ManagedPublishError extends Error {
 		| "invalid_request"
 		| "durability_not_provable"
 		| "identity_mismatch"
+		| "permission_denied"
 		| "io_error"
 		| "durability_failed";
 	readonly diagnostic: string;
@@ -141,17 +142,19 @@ function publishFailure(outcome: NativePublishOutcome): ManagedPublishError {
 	const classification =
 		outcome.reason === "destination_exists"
 			? "destination_conflict"
-			: outcome.reason === "atomic_unavailable"
-				? "atomic_unavailable"
-				: outcome.reason === "invalid_request"
-					? "invalid_request"
-					: outcome.reason === "durability_not_provable"
-						? "durability_not_provable"
-						: outcome.reason === "identity_violation"
-							? "identity_mismatch"
-							: outcome.reason === "io_failure"
-								? "io_error"
-								: "durability_failed";
+			: outcome.reason === "access_denied" || outcome.reason === "permission_denied"
+				? "permission_denied"
+				: outcome.reason === "atomic_unavailable"
+					? "atomic_unavailable"
+					: outcome.reason === "invalid_request"
+						? "invalid_request"
+						: outcome.reason === "durability_not_provable"
+							? "durability_not_provable"
+							: outcome.reason === "identity_violation"
+								? "identity_mismatch"
+								: outcome.reason === "io_failure"
+									? "io_error"
+									: "durability_failed";
 	return new ManagedPublishError(classification, outcome);
 }
 
@@ -167,7 +170,11 @@ function exactUnlinkCompleted(result: NativeExactUnlinkResult): boolean {
 }
 
 function isRetryableReplacementReceiptCleanupError(error: unknown): boolean {
-	return error instanceof Error && error.message === "managed_replace_receipt_cleanup_pending:io_error";
+	return (
+		error instanceof Error &&
+		(error.message === "managed_replace_receipt_cleanup_pending:io_error" ||
+			error.message === "managed_replace_receipt_cleanup_pending:access_denied")
+	);
 }
 
 /**
@@ -447,6 +454,17 @@ function replacementReceiptIsOwned(bytes: Uint8Array): boolean {
 	return observed.status !== "present" || observed.incarnation === publisher.incarnation;
 }
 
+/** Only positive local process-incarnation evidence proves a mismatched receipt's publisher is stale. */
+function replacementReceiptPublisherIsVerifiedDead(bytes: Uint8Array): boolean {
+	const publisher = replacementReceiptPublisher(bytes);
+	if (!publisher || publisher.host !== os.hostname()) return false;
+	if (publisher.pid === process.pid && publisher.ownerId === replacementPublisherOwnerId) return false;
+	const observed = observeProcessIncarnation(publisher.pid);
+	return (
+		observed.status === "absent" || (observed.status === "present" && observed.incarnation !== publisher.incarnation)
+	);
+}
+
 type LegacyReplacementCleanupIdentity = {
 	dev: bigint;
 	ino: bigint;
@@ -1097,6 +1115,7 @@ const GENERAL_FAILURE_CODES = new Set([
 	"identity_unavailable",
 	"identity_mismatch",
 	"owner_mismatch",
+	"access_denied",
 	"mode_mismatch",
 	"io_error",
 ]);
@@ -1961,6 +1980,59 @@ export class ManagedSessionDescendantStore {
 		return true;
 	}
 
+	#recoverRenumberedReplacementCleanupReceipt(
+		receiptPath: string,
+		binding: { predecessor: { dev: bigint; ino: bigint }; receipt: { dev: bigint; ino: bigint } },
+		receipt: ManagedFileSnapshot,
+	): boolean {
+		const parsed = parseReplacementCleanupReceipt(receipt.bytes);
+		const predecessor = parsed ? parseReplacementIdentity(parsed.predecessor) : undefined;
+		if (
+			receipt.identity.dev === binding.receipt.dev ||
+			receipt.identity.ino !== binding.receipt.ino ||
+			!parsed ||
+			!predecessor ||
+			predecessor.dev !== binding.predecessor.dev ||
+			predecessor.ino !== binding.predecessor.ino ||
+			!replacementReceiptPublisherIsVerifiedDead(receipt.bytes)
+		)
+			return false;
+
+		// The filename's device is the only identity component allowed to drift.
+		// The no-follow snapshot supplies the exact current size and digest, and
+		// detachOnly preserves those bytes under a non-canonical quarantine name.
+		const quarantineName = replacementReceiptRetirementName(receipt.identity, binding.predecessor);
+		const detached = nativeSessionStorage().exactUnlink(receiptPath, {
+			dev: receipt.identity.dev,
+			ino: receipt.identity.ino,
+			nlink: receipt.identity.nlink,
+			parentDev: this.#subtreeRoot.dev,
+			parentIno: this.#subtreeRoot.ino,
+			size: BigInt(receipt.identity.size),
+			mtimeNs: receipt.identity.mtimeNs,
+			sha256: receipt.identity.sha256,
+			detachOnly: true,
+			quarantineName,
+		});
+		if (isPeerOwnedReceiptRetirement(detached)) return true;
+		if (
+			!detached.ok &&
+			detached.code === "not_found" &&
+			detached.retainedSuccessorPath === undefined &&
+			detached.retainedUnknownPath === undefined
+		)
+			return true;
+		if (
+			(!detached.ok && detached.code !== "cleanup_pending") ||
+			detached.detachedPath !== path.join(this.#baseDir, quarantineName) ||
+			detached.retainedSuccessorPath ||
+			detached.retainedUnknownPath
+		)
+			throw new Error(`managed_replace_receipt_cleanup_pending:${detached.code ?? "unknown"}`);
+		fsyncDirectory(this.#baseDir);
+		return true;
+	}
+
 	#detachReplacementCleanupReceipt(receiptPath: string): void {
 		const binding = replacementCleanupReceiptBinding(path.basename(receiptPath));
 		if (!binding) throw new Error("managed_replace_cleanup_receipt_invalid");
@@ -1972,6 +2044,7 @@ export class ManagedSessionDescendantStore {
 			throw error;
 		}
 		if (receipt.identity.dev !== binding.receipt.dev || receipt.identity.ino !== binding.receipt.ino) {
+			if (this.#recoverRenumberedReplacementCleanupReceipt(receiptPath, binding, receipt)) return;
 			if (this.#recoverReplacementCleanupPlaceholder(receiptPath, binding, receipt)) return;
 			throw new Error("managed_replace_cleanup_receipt_invalid");
 		}

package/src/session/internal/native-publish-outcome.ts

@@ -6,6 +6,7 @@ export type NativePublishReason =
 	| "atomic_unavailable"
 	| "cross_device"
 	| "permission_denied"
+	| "access_denied"
 	| "io_failure"
 	| "interrupted"
 	| "invalid_request"
@@ -77,6 +78,7 @@ const reasons = new Set<NativePublishReason>([
 	"atomic_unavailable",
 	"cross_device",
 	"permission_denied",
+	"access_denied",
 	"io_failure",
 	"interrupted",
 	"invalid_request",
@@ -109,6 +111,7 @@ const preMutationReasons = new Set<NativePublishReason>([
 	"atomic_unavailable",
 	"cross_device",
 	"permission_denied",
+	"access_denied",
 	"io_failure",
 	"interrupted",
 	"invalid_request",
@@ -184,11 +187,12 @@ function legalOutcome(outcome: NativePublishOutcome): boolean {
 					"atomic_unavailable",
 					"cross_device",
 					"permission_denied",
+					"access_denied",
 					"io_failure",
 					"interrupted",
 				].includes(outcome.reason)) ||
 				(outcome.phase === "preflight" &&
-					!["atomic_unavailable", "cross_device", "interrupted"].includes(outcome.reason)) ||
+					!["atomic_unavailable", "cross_device", "interrupted", "access_denied"].includes(outcome.reason)) ||
 				(outcome.phase === "file_sync" && outcome.reason === "io_failure"))
 		);
 	if (outcome.mutationState === "unknown")

package/src/session/messages.ts

@@ -158,6 +158,34 @@ function getPrunedToolResultContent(message: ToolResultMessage): (TextContent |
 export const PRE_ADMISSION_ARTIFACT_SPILL_HEAD_BYTES = 4096;
 export const PRE_ADMISSION_ARTIFACT_SPILL_TAIL_BYTES = 4096;
 
+/**
+ * Keep an authenticated `#GJC1_` placeholder whole when the byte cut lands
+ * inside it. Short inputs whose head and tail already overlap stay on the
+ * original byte limits.
+ */
+function retainStraddlingPlaceholders(text: string, head: string, tail: string): { head: string; tail: string } {
+	const headEnd = head.length;
+	const tailStart = text.length - tail.length;
+	if (headEnd > tailStart) return { head, tail };
+
+	let nextHeadEnd = headEnd;
+	let nextTailStart = tailStart;
+	const placeholder = /#GJC1_[A-Za-z0-9_-]{22}#/g;
+	for (;;) {
+		const match = placeholder.exec(text);
+		if (match === null) break;
+		const start = match.index;
+		const stop = start + match[0].length;
+		if (start < headEnd && stop > headEnd) nextHeadEnd = Math.max(nextHeadEnd, stop);
+		if (start < tailStart && stop > tailStart) nextTailStart = Math.min(nextTailStart, start);
+	}
+	if (nextHeadEnd > nextTailStart) return { head, tail };
+	return {
+		head: nextHeadEnd === headEnd ? head : text.slice(0, nextHeadEnd),
+		tail: nextTailStart === tailStart ? tail : text.slice(nextTailStart),
+	};
+}
+
 function utf8Prefix(text: string, maxBytes: number): string {
 	if (Buffer.byteLength(text, "utf-8") <= maxBytes) return text;
 	let bytes = 0;
@@ -193,15 +221,28 @@ function utf8Suffix(text: string, maxBytes: number): string {
  * Build the deterministic inline receipt for a tool result saved before the
  * next provider context is constructed. Byte boundaries never split UTF-8
  * code points, so head/tail recovery remains readable for emoji and CJK text.
+ *
+ * `redact` runs on the complete text before the cut. The digest stays the
+ * caller's hash of the stored artifact; the omitted count is the redacted
+ * preview's omitted bytes.
  */
-export function createPreAdmissionArtifactSpillPreview(fullText: string, artifactId: string, digest: string): 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");
+export function createPreAdmissionArtifactSpillPreview(
+	fullText: string,
+	artifactId: string,
+	digest: string,
+	redact?: (text: string) => string,
+): string {
+	const source = redact ? redact(fullText) : fullText;
+	const totalBytes = Buffer.byteLength(source, "utf-8");
+	const head = utf8Prefix(source, PRE_ADMISSION_ARTIFACT_SPILL_HEAD_BYTES);
+	const tail = utf8Suffix(source, PRE_ADMISSION_ARTIFACT_SPILL_TAIL_BYTES);
+	// Without redaction the cut stays on the historical byte limits, including
+	// when the tool text itself contains a placeholder-shaped string.
+	const retained = redact ? retainStraddlingPlaceholders(source, head, tail) : { head, tail };
+	const retainedBytes = Buffer.byteLength(retained.head, "utf-8") + Buffer.byteLength(retained.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}`;
+	return `${retained.head}\n\n${receipt}\n\n${retained.tail}`;
 }
 
 /**