@sayknow-cli/coding-agent 0.4.6 → 0.5.0

package/src/session/blob-store.ts

@@ -5,6 +5,18 @@ import { isEnoent, logger } from "@sayknow-cli/utils";
 
 const BLOB_PREFIX = "blob:sha256:";
 
+/**
+ * Owner-only permissions for on-disk blob directories and files.
+ *
+ * Blob stores can live inside a managed session scope (e.g. the resident-cache
+ * `EphemeralBlobStore` created on the explicit session path). The managed-tree
+ * snapshot fails closed unless every descendant is owner-only, so blobs and
+ * their directories MUST be created 0700/0600 rather than inheriting a
+ * group/other-readable mode from the process umask.
+ */
+const BLOB_DIR_MODE = 0o700;
+const BLOB_FILE_MODE = 0o600;
+
 export interface BlobPutResult {
 	hash: string;
 	path: string;
@@ -112,7 +124,13 @@ export class BlobStore {
 			},
 		};
 
-		await Bun.write(blobPath, data);
+		// Create the blob directory 0700 and the file 0600 at creation, mirroring
+		// putSync/putImmutableSync. The previous Bun.write let the parent dir be
+		// created with the process umask (e.g. 0755) and the file at 0644 before a
+		// follow-up chmod, violating the owner-only contract above and leaving a
+		// group/other-readable window a managed-tree snapshot fails closed on.
+		await fsp.mkdir(this.dir, { recursive: true, mode: BLOB_DIR_MODE });
+		await fsp.writeFile(blobPath, data, { mode: BLOB_FILE_MODE });
 		return result;
 	}
 
@@ -131,8 +149,8 @@ export class BlobStore {
 				return `${BLOB_PREFIX}${hash}`;
 			},
 		};
-		fs.mkdirSync(this.dir, { recursive: true });
-		fs.writeFileSync(blobPath, data);
+		fs.mkdirSync(this.dir, { recursive: true, mode: BLOB_DIR_MODE });
+		fs.writeFileSync(blobPath, data, { mode: BLOB_FILE_MODE });
 		return result;
 	}
 
@@ -147,7 +165,7 @@ export class BlobStore {
 		const hash = sha256Hex(data);
 		const blobPath = path.join(this.dir, hash);
 		const result = makeBlobPutResult(hash, blobPath, data.byteLength);
-		fs.mkdirSync(this.dir, { recursive: true });
+		fs.mkdirSync(this.dir, { recursive: true, mode: BLOB_DIR_MODE });
 
 		if (fs.existsSync(blobPath)) {
 			verifyBlobFileSync(hash, blobPath);
@@ -156,7 +174,7 @@ export class BlobStore {
 
 		const tempPath = uniqueTempBlobPath(this.dir, hash);
 		try {
-			const fd = fs.openSync(tempPath, "wx");
+			const fd = fs.openSync(tempPath, "wx", BLOB_FILE_MODE);
 			try {
 				fs.writeFileSync(fd, data);
 				fs.fsyncSync(fd);
@@ -274,7 +292,7 @@ export class EphemeralBlobStore extends BlobStore {
 	constructor(dir: string) {
 		super(dir);
 		fs.rmSync(dir, { recursive: true, force: true });
-		fs.mkdirSync(dir, { recursive: true });
+		fs.mkdirSync(dir, { recursive: true, mode: BLOB_DIR_MODE });
 	}
 
 	#cachePut(hash: string, data: Buffer): void {
@@ -333,7 +351,7 @@ export class EphemeralBlobStore extends BlobStore {
 		this.#bufferCache.clear();
 		this.#bufferCacheBytes = 0;
 		fs.rmSync(this.dir, { recursive: true, force: true });
-		fs.mkdirSync(this.dir, { recursive: true });
+		fs.mkdirSync(this.dir, { recursive: true, mode: BLOB_DIR_MODE });
 	}
 
 	dispose(): void {

package/src/session/btw-contract.ts

@@ -0,0 +1,59 @@
+export const BTW_MAX_CONTEXT_TURNS = 12;
+export const BTW_MAX_CONTEXT_UTF8_BYTES = 64 * 1024;
+export const BTW_MAX_QUESTION_UTF8_BYTES = 16 * 1024;
+export const BTW_MAX_ANSWER_UTF8_BYTES = 32 * 1024;
+export const BTW_MAX_ERROR_UTF8_BYTES = 4 * 1024;
+export const BTW_STREAM_IDLE_TIMEOUT_MS = 30_000;
+export const BTW_STREAM_TOTAL_TIMEOUT_MS = 120_000;
+
+export interface BtwTextExchange {
+	question: string;
+	answer: string;
+}
+
+export function utf8ByteLength(text: string): number {
+	return Buffer.byteLength(text, "utf8");
+}
+
+export function truncateUtf8(text: string, maxBytes: number): string {
+	if (utf8ByteLength(text) <= maxBytes) return text;
+	let bytes = 0;
+	let result = "";
+	for (const character of text) {
+		const characterBytes = utf8ByteLength(character);
+		if (bytes + characterBytes > maxBytes) break;
+		result += character;
+		bytes += characterBytes;
+	}
+	return result;
+}
+
+export function sanitizeBtwError(text: string): string {
+	const sanitized = text
+		.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, " ")
+		.replace(/[\u202A-\u202E\u2066-\u2069]/g, "")
+		.replace(/\s+/g, " ")
+		.trim();
+	return truncateUtf8(sanitized || "Side-chat request failed.", BTW_MAX_ERROR_UTF8_BYTES);
+}
+export function exchangeUtf8Bytes(exchange: BtwTextExchange): number {
+	return utf8ByteLength(exchange.question) + utf8ByteLength(exchange.answer);
+}
+
+export function boundBtwExchanges(exchanges: readonly BtwTextExchange[]): BtwTextExchange[] {
+	const bounded: BtwTextExchange[] = [];
+	let totalBytes = 0;
+	for (let index = exchanges.length - 1; index >= 0 && bounded.length < BTW_MAX_CONTEXT_TURNS; index -= 1) {
+		const exchange = exchanges[index];
+		if (!exchange) continue;
+		const normalized = {
+			question: truncateUtf8(exchange.question, BTW_MAX_QUESTION_UTF8_BYTES),
+			answer: truncateUtf8(exchange.answer, BTW_MAX_ANSWER_UTF8_BYTES),
+		};
+		const bytes = exchangeUtf8Bytes(normalized);
+		if (bytes > BTW_MAX_CONTEXT_UTF8_BYTES - totalBytes) break;
+		bounded.unshift(normalized);
+		totalBytes += bytes;
+	}
+	return bounded;
+}

package/src/session/fallback-chain-controller.ts

@@ -30,6 +30,7 @@ export class FallbackChainController {
 
 	#attemptStarted = false;
 	#totalAttemptsUsed = 0;
+	#restoredEntryIndices = new Set<number>();
 	skips: Array<{ selector: string; reason: string }> = [];
 	exhaustedForTurn = false;
 
@@ -46,6 +47,10 @@ export class FallbackChainController {
 		return this.#totalAttemptsUsed;
 	}
 
+	#maxTotalAttempts(): number {
+		return this.maxAttempts * this.chain.entries.length + this.#restoredEntryIndices.size;
+	}
+
 	currentSelector(): string | undefined {
 		return this.chain.entries[this.activeIndex];
 	}
@@ -59,7 +64,7 @@ export class FallbackChainController {
 	/** Charge an upstream request at its concrete transport boundary. */
 	onAttemptStarted(): void {
 		if (!this.currentSelector() || this.exhaustedForTurn) return;
-		if (this.#totalAttemptsUsed >= this.maxAttempts * this.chain.entries.length) {
+		if (this.#totalAttemptsUsed >= this.#maxTotalAttempts()) {
 			this.activeIndex = this.chain.entries.length;
 			this.exhaustedForTurn = true;
 			return;
@@ -82,6 +87,7 @@ export class FallbackChainController {
 		this.attemptsUsed = 0;
 		this.#totalAttemptsUsed = 0;
 		this.tried = [];
+		this.#restoredEntryIndices.clear();
 		this.#attemptStarted = false;
 	}
 
@@ -91,6 +97,7 @@ export class FallbackChainController {
 		this.skips = [...skips];
 		this.attemptsUsed = 0;
 		this.#totalAttemptsUsed = 0;
+		this.#restoredEntryIndices.clear();
 		this.#attemptStarted = false;
 		this.exhaustedForTurn = this.activeIndex >= this.chain.entries.length;
 	}
@@ -104,7 +111,7 @@ export class FallbackChainController {
 		}
 		this.#attemptStarted = false;
 		this.tried.push({ selector, triggerClass, reason });
-		if (this.#totalAttemptsUsed >= this.maxAttempts * this.chain.entries.length) {
+		if (this.#totalAttemptsUsed >= this.#maxTotalAttempts()) {
 			this.activeIndex = this.chain.entries.length;
 			this.exhaustedForTurn = true;
 			return "exhausted";
@@ -126,19 +133,23 @@ export class FallbackChainController {
 	}
 
 	/**
-	 * Restore the entry that just advanced when credential rotation permits a retry.
-	 * The chain-wide budget and failure history remain charged.
+	 * Restore the entry that just advanced for one attempt with a rotated credential.
+	 * Each non-terminal entry may be restored once, so credential rotation remains
+	 * bounded and cannot consume the attempts reserved for downstream entries.
 	 */
 	restorePreviousEntryForRetry(): boolean {
+		const previousIndex = this.activeIndex - 1;
 		if (
-			this.activeIndex === 0 ||
+			previousIndex < 0 ||
 			this.exhaustedForTurn ||
-			this.#totalAttemptsUsed >= this.maxAttempts * this.chain.entries.length
+			this.#restoredEntryIndices.has(previousIndex) ||
+			this.#totalAttemptsUsed >= this.#maxTotalAttempts()
 		) {
 			return false;
 		}
-		this.activeIndex -= 1;
-		this.attemptsUsed = 0;
+		this.#restoredEntryIndices.add(previousIndex);
+		this.activeIndex = previousIndex;
+		this.attemptsUsed = this.maxAttempts - 1;
 		this.exhaustedForTurn = false;
 		this.#attemptStarted = false;
 		return true;
@@ -157,6 +168,7 @@ export class FallbackChainController {
 		this.attemptsUsed = 0;
 		this.#totalAttemptsUsed = 0;
 		this.tried = [];
+		this.#restoredEntryIndices.clear();
 		this.skips = [];
 		this.exhaustedForTurn = this.chain.entries.length === 0;
 		this.#attemptStarted = false;
@@ -174,6 +186,33 @@ export function cappedExponentialWithFullJitter(
 	return Math.floor(Math.max(0, cap) * Math.max(0, Math.min(1, random())));
 }
 
+/**
+ * Legacy auto-compaction retry delay.
+ *
+ * Deliberately the mirror image of `effectiveFallbackDelay`: this path recovers
+ * Retry-After by regex over provider error prose (`#parseRetryAfterMsFromError`),
+ * so it follows the documented legacy rule — `retry.maxDelayMs` caps every
+ * legacy session retry delay, including provider retry-after hints. Managed
+ * fallback stays uncapped because it retries within its own per-entry budget;
+ * compaction has no such budget, so the final candidate would otherwise sleep
+ * for the full server-suggested duration.
+ *
+ * `maxDelayMs <= 0` means "no cap", matching `cappedExponentialWithFullJitter`.
+ * A missing, NaN, or infinite hint collapses to "no usable hint".
+ */
+export function compactionRetryDelay(
+	baseDelayMs: number,
+	maxDelayMs: number,
+	attempt: number,
+	retryAfterMs: number | undefined,
+): number {
+	const exponential = baseDelayMs * 2 ** Math.max(0, attempt);
+	const hint = Number.isFinite(retryAfterMs) ? Math.max(0, retryAfterMs as number) : 0;
+	const hinted = Math.max(exponential, hint);
+	const bounded = maxDelayMs > 0 ? Math.min(hinted, maxDelayMs) : hinted;
+	return Math.max(0, bounded);
+}
+
 /** Retry-After is intentionally uncapped. */
 export function effectiveFallbackDelay(
 	baseDelayMs: number,