@gajae-code/coding-agent 0.15.6 → 0.16.1

package/src/session/blob-store.ts

@@ -6,8 +6,13 @@ import { exactUnlink } from "@gajae-code/natives";
 import { isEnoent, logger, postmortem } from "@gajae-code/utils";
 
 const BLOB_PREFIX = "blob:sha256:";
+const CANONICAL_BLOB_NAME = /^[0-9a-f]{64}$/;
 const TAKE_BLOB_BUFFER_OWNERSHIP = Symbol("takeBlobBufferOwnership");
 
+function isCanonicalBlobHash(hash: string): boolean {
+	return hash.length === 64 && CANONICAL_BLOB_NAME.test(hash);
+}
+
 /**
  * Owner-only permissions for on-disk blob directories and files.
  *
@@ -1126,6 +1131,7 @@ export class BlobStore {
 
 	/** Read blob by hash, returns Buffer or null if not found. */
 	async get(hash: string): Promise<Buffer | null> {
+		if (!isCanonicalBlobHash(hash)) return null;
 		const blobPath = path.join(this.dir, hash);
 		try {
 			const file = Bun.file(blobPath);
@@ -1139,6 +1145,7 @@ export class BlobStore {
 
 	/** Synchronously read blob by hash, returns Buffer or null if not found. */
 	getSync(hash: string): Buffer | null {
+		if (!isCanonicalBlobHash(hash)) return null;
 		const blobPath = path.join(this.dir, hash);
 		try {
 			return fs.readFileSync(blobPath);
@@ -1155,6 +1162,7 @@ export class BlobStore {
 
 	/** Synchronously read blob by hash and verify its content hash; returns null if not found. */
 	getCheckedSync(hash: string): Buffer | null {
+		if (!isCanonicalBlobHash(hash)) return null;
 		const blobPath = path.join(this.dir, hash);
 		try {
 			return verifyBlobFileSync(hash, blobPath);
@@ -1166,6 +1174,7 @@ export class BlobStore {
 
 	/** Check if a blob exists. */
 	async has(hash: string): Promise<boolean> {
+		if (!isCanonicalBlobHash(hash)) return false;
 		try {
 			await fsp.access(path.join(this.dir, hash));
 			return true;
@@ -1321,6 +1330,7 @@ export class EphemeralBlobStore extends BlobStore {
 	}
 
 	getSync(hash: string): Buffer | null {
+		if (!isCanonicalBlobHash(hash)) return null;
 		const cached = this.#bufferCache.get(hash);
 		if (cached) {
 			const blobPath = path.join(this.dir, hash);
@@ -1374,7 +1384,7 @@ export class EphemeralBlobStore extends BlobStore {
 				const blobPath = path.join(this.dir, entry);
 				const stat = fs.lstatSync(blobPath);
 				if (
-					!/^[a-f0-9]{64}$/.test(entry) ||
+					!isCanonicalBlobHash(entry) ||
 					!stat.isFile() ||
 					stat.isSymbolicLink() ||
 					stat.uid !== uid ||
@@ -1534,13 +1544,14 @@ export class ResidentBlobMissingError extends Error {
 
 /** Check if a data string is a blob reference. */
 export function isBlobRef(data: string): boolean {
-	return data.startsWith(BLOB_PREFIX);
+	return parseBlobRef(data) !== null;
 }
 
 /** Extract the SHA-256 hash from a blob reference string. */
 export function parseBlobRef(data: string): string | null {
 	if (!data.startsWith(BLOB_PREFIX)) return null;
-	return data.slice(BLOB_PREFIX.length);
+	const hash = data.slice(BLOB_PREFIX.length);
+	return isCanonicalBlobHash(hash) ? hash : null;
 }
 
 /** Identify provider transport image data URLs so persistence can externalize and restore them losslessly. */
@@ -1731,7 +1742,6 @@ export interface CanonicalBlobEntry {
 	readonly nlink: bigint;
 }
 
-const CANONICAL_BLOB_NAME = /^[0-9a-f]{64}$/;
 const BLOB_REFERENCE = /blob:sha256:([0-9a-f]{64})/g;
 
 /** Longest possible `blob:sha256:<hash>` reference, used to bound chunked scans. */
@@ -1758,7 +1768,7 @@ export async function listCanonicalBlobs(dir: string): Promise<CanonicalBlobEntr
 
 	const entries: CanonicalBlobEntry[] = [];
 	for (const name of names) {
-		if (!CANONICAL_BLOB_NAME.test(name)) continue;
+		if (!isCanonicalBlobHash(name)) continue;
 		const blobPath = path.join(dir, name);
 		let stat: fs.BigIntStats;
 		try {

package/src/session/credential-store-errors.ts

@@ -0,0 +1,2 @@
+export const CREDENTIAL_STORE_UNREADABLE_MESSAGE =
+	"Credential store is unreadable. Back up the database, then have an operator run PRAGMA integrity_check or REINDEX; no automatic repair was attempted.";

package/src/session/fold-coordinator.ts

@@ -23,7 +23,7 @@
  *    delivery therefore still carries its receipt and can never silently
  *    degrade into an ordinary receipt-less completion.
  */
-import type { AsyncJob } from "../async/job-manager";
+import type { AsyncJob, FoldReason } from "../async/job-manager";
 import foldReceiptPrompt from "../prompts/tools/fold-receipt.md" with { type: "text" };
 
 /**
@@ -68,6 +68,8 @@ export interface FoldReceipt {
 	foldedAt: number;
 	/** Only command kinds can change directory; task-style waits never do. */
 	cwdSensitive: boolean;
+	/** What triggered the fold; recorded on the job as `metadata.foldReason`. */
+	reason: FoldReason;
 }
 
 /** A terminal completion observed for a folded job. */
@@ -106,6 +108,34 @@ export type FoldRequestResult =
 	| { status: "already-terminal"; reason: string }
 	| { status: "capture-failed"; reason: string };
 
+/**
+ * Session-level answer to "fold the foreground bash now". Consumed by the SDK
+ * `bash.background` control, whose declared error codes are exactly these
+ * non-folded statuses.
+ */
+export type ForegroundFoldOutcome =
+	| { status: "folded"; jobId: string }
+	| { status: "already_backgrounded" }
+	| { status: "no_active_bash" }
+	| { status: "not_foldable"; reason: string };
+
+/** Map a non-folded outcome onto the C52 `bash.background` error contract (`not_foldable` | `already_backgrounded` | `no_active_bash`). */
+export function bashBackgroundControlError(outcome: Exclude<ForegroundFoldOutcome, { status: "folded" }>): Error {
+	switch (outcome.status) {
+		case "already_backgrounded":
+			return Object.assign(new Error("The active bash command has already been moved to a background job."), {
+				code: "already_backgrounded",
+			});
+		case "no_active_bash":
+			return Object.assign(new Error("No foreground bash command is running."), { code: "no_active_bash" });
+		case "not_foldable":
+			return Object.assign(
+				new Error(`The active bash command cannot be moved to a managed background job: ${outcome.reason}`),
+				{ code: "not_foldable" },
+			);
+	}
+}
+
 /** What a delivery should carry, decided by the durable slot state (T2). */
 export type FoldDeliveryDisposition =
 	| { kind: "ordinary" }
@@ -225,8 +255,13 @@ export class FoldCoordinator {
 	 * Nothing awaits before the slot is reserved and the fence is armed, so a
 	 * completion or a steering submission that races the capture cannot slip
 	 * past into the old turn.
+	 *
+	 * A `steer` fold is the one trigger that does NOT end the turn: the steer
+	 * that caused it must be consumed by the same run at the tool boundary
+	 * right after the fold result (subagent-await parity), so no fence is
+	 * armed, no stop is requested, and no remaining intent is captured.
 	 */
-	async requestFold(explicit?: FoldAdapter): Promise<FoldRequestResult> {
+	async requestFold(explicit?: FoldAdapter, reason: FoldReason = "chord"): Promise<FoldRequestResult> {
 		// S1 resolve target.
 		const adapter = explicit ?? this.resolveTarget();
 		if (!adapter) return { status: "unavailable", reason: "no foldable wait is registered" };
@@ -244,7 +279,8 @@ export class FoldCoordinator {
 		// S3 claim + reserve, S4 hand-off is the reservation itself, S5 arm the fence.
 		this.#folding.add(job);
 		this.#slots.set(job, { state: "reserved", adapter, parked: undefined, parkedAt: undefined });
-		const fencesOriginatingTurn = adapter.originatingTurn ?? this.#deps.hasActiveTurn?.() ?? true;
+		const fencesOriginatingTurn =
+			reason !== "steer" && (adapter.originatingTurn ?? this.#deps.hasActiveTurn?.() ?? true);
 		const releaseFence = fencesOriginatingTurn ? this.#deps.armSteeringFence() : () => {};
 
 		let remainingIntent: string | undefined;
@@ -293,6 +329,7 @@ export class FoldCoordinator {
 			remainingIntent,
 			foldedAt: Date.now(),
 			cwdSensitive: adapter.cwdSensitive,
+			reason,
 		};
 
 		// A2 promote to present, preserving any payload parked during capture.