@gajae-code/coding-agent 0.4.5 → 0.5.1

package/src/harness-control-plane/storage.ts

@@ -18,6 +18,8 @@ import * as fsSync from "node:fs";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
+import { appendReceiptToConfiguredSpool } from "./receipt-spool";
+import type { ReceiptEnvelope } from "./receipts";
 import type { EventEnvelope, ReceiptFamily, SessionState } from "./types";
 
 interface HarnessRootRegistryEntry {
@@ -30,6 +32,18 @@ interface HarnessRootRegistry {
 	roots: HarnessRootRegistryEntry[];
 }
 
+export interface HarnessRootRegistryForGc {
+	sessionId: string;
+	roots: HarnessRootRegistryEntry[];
+}
+
+export interface HarnessRootRegistryListingForGc {
+	sessionId: string;
+	file: string;
+	roots: HarnessRootRegistryEntry[];
+	error?: string;
+}
+
 interface ResolveHarnessSessionRootOptions {
 	expectedWorkspace?: string;
 }
@@ -99,6 +113,64 @@ async function writeHarnessRootRegistry(
 	const file = harnessRootRegistryPath(registry.sessionId, env);
 	await writeJsonAtomicPrivate(file, registry);
 }
+
+function parseHarnessRootRegistryForGc(value: unknown, fallbackSessionId: string): HarnessRootRegistryForGc | null {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const registry = value as Record<string, unknown>;
+	if (typeof registry.sessionId !== "string" || !Array.isArray(registry.roots)) return null;
+	const roots: HarnessRootRegistryEntry[] = [];
+	for (const entry of registry.roots) {
+		if (!entry || typeof entry !== "object" || Array.isArray(entry)) return null;
+		const rootEntry = entry as Record<string, unknown>;
+		if (typeof rootEntry.root !== "string" || typeof rootEntry.updatedAt !== "string") return null;
+		roots.push({ root: rootEntry.root, updatedAt: rootEntry.updatedAt });
+	}
+	return { sessionId: registry.sessionId || fallbackSessionId, roots };
+}
+
+/** @internal */
+export async function listHarnessRootRegistriesForGc(
+	env: NodeJS.ProcessEnv = process.env,
+): Promise<HarnessRootRegistryListingForGc[]> {
+	const dir = harnessRootRegistryDir(env);
+	let entries: string[];
+	try {
+		entries = await fs.readdir(dir);
+	} catch (error) {
+		const code = (error as NodeJS.ErrnoException).code;
+		if (code === "ENOENT") return [];
+		return [{ sessionId: "", file: dir, roots: [], error: (error as Error).message }];
+	}
+
+	const registries: HarnessRootRegistryListingForGc[] = [];
+	for (const entry of entries) {
+		if (!entry.endsWith(".json")) continue;
+		const file = path.join(dir, entry);
+		const fallbackSessionId = entry.slice(0, -".json".length);
+		try {
+			const raw = await fs.readFile(file, "utf8");
+			const parsed = parseHarnessRootRegistryForGc(JSON.parse(raw), fallbackSessionId);
+			if (!parsed) {
+				registries.push({ sessionId: fallbackSessionId, file, roots: [], error: "malformed_registry" });
+				continue;
+			}
+			registries.push({ sessionId: parsed.sessionId, file, roots: parsed.roots });
+		} catch (error) {
+			registries.push({ sessionId: fallbackSessionId, file, roots: [], error: (error as Error).message });
+		}
+	}
+	return registries;
+}
+
+/** @internal */
+export async function rewriteHarnessRootRegistryForGc(file: string, registry: HarnessRootRegistryForGc): Promise<void> {
+	await writeJsonAtomicPrivate(file, registry);
+}
+
+/** @internal */
+export async function removeHarnessRootRegistryFileForGc(file: string): Promise<void> {
+	await fs.rm(file, { force: true });
+}
 const SESSION_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 export const MAX_UNIX_SOCKET_PATH_BYTES = 100;
 
@@ -227,6 +299,26 @@ async function readJson<T>(file: string): Promise<T | null> {
 		throw error;
 	}
 }
+function isReceiptEnvelope(value: unknown): value is ReceiptEnvelope<unknown> {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const envelope = value as Record<string, unknown>;
+	return (
+		typeof envelope.receiptId === "string" &&
+		typeof envelope.schemaVersion === "number" &&
+		typeof envelope.sessionId === "string" &&
+		typeof envelope.family === "string" &&
+		typeof envelope.valid === "boolean" &&
+		typeof envelope.createdAt === "string" &&
+		typeof envelope.source === "string" &&
+		envelope.subject !== null &&
+		typeof envelope.subject === "object" &&
+		envelope.evidence !== null &&
+		typeof envelope.evidence === "object" &&
+		envelope.artifactHashes !== null &&
+		typeof envelope.artifactHashes === "object" &&
+		typeof envelope.sha256 === "string"
+	);
+}
 
 export async function readSessionState(root: string, sessionId: string): Promise<SessionState | null> {
 	return readJson<SessionState>(sessionPaths(root, sessionId).state);
@@ -372,6 +464,7 @@ export async function writeReceiptImmutable(
 		path: file,
 	};
 	await fs.appendFile(paths.receiptsIndex, `${JSON.stringify(entry)}\n`, "utf8");
+	if (isReceiptEnvelope(value)) await appendReceiptToConfiguredSpool(value);
 	return entry;
 }
 

package/src/harness-control-plane/types.ts

@@ -210,6 +210,10 @@ export interface Observation {
 	rpcLive?: boolean;
 	/** ISO timestamp of the most recent RPC frame the owner observed, if any. */
 	rpcLastFrameAt?: string | null;
+	/** True only when owner/rpc/lifecycle gates indicate a prompt can be submitted now. */
+	readyForSubmit?: boolean;
+	/** Present when readyForSubmit is false; mirrors submit's nextAllowedActions reason. */
+	submitUnavailableReason?: string | null;
 }
 
 /** Input to the deterministic recovery classifier. */

package/src/hindsight/mental-models.ts

@@ -295,12 +295,12 @@ export function summarizeMentalModel(model: MentalModelSummary): string {
  * snapshot only; the diff is computed locally for display purposes.
  *
  * This is intentionally minimal — for "what changed" at a glance, not for a
- * full structural diff. Each side is capped at `MAX_LCS_LINES` lines BEFORE
- * the O(n*m) LCS table is built so a long curated model can never hang the
- * TUI; output is then capped at `maxLines` so the rendered diff stays
- * readable. The cap is signalled inline.
+ * full structural diff. Each side is capped at `MAX_LCS_LINES` lines before
+ * the Hunt-Szymanski LCS pass so a long curated model can never hang the TUI;
+ * output is then capped at `maxLines` so the rendered diff stays readable. The
+ * cap is signalled inline.
  */
-/** Hard cap on input line count per side before LCS. Keeps the O(n*m) table tractable. */
+/** Hard cap on input line count per side before LCS. Keeps worst-case repeated-line matching bounded. */
 export const MAX_LCS_LINES = 1_000;
 
 export function diffMentalModelContent(previous: string | null, current: string, maxLines = 200): string {
@@ -346,24 +346,25 @@ export function diffMentalModelContent(previous: string | null, current: string,
 }
 
 function longestCommonSubsequence(a: string[], b: string[]): string[] {
-	const n = a.length;
-	const m = b.length;
-	if (n === 0 || m === 0) return [];
-	const table: number[][] = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
-	for (let i = 0; i < n; i++) {
-		for (let j = 0; j < m; j++) {
-			table[i + 1][j + 1] = a[i] === b[j] ? table[i][j] + 1 : Math.max(table[i + 1][j], table[i][j + 1]);
+	return longestCommonSubsequenceDense(a, b);
+}
+
+function longestCommonSubsequenceDense(a: string[], b: string[]): string[] {
+	const table: number[][] = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
+	for (let i = 0; i < a.length; i++) {
+		for (let j = 0; j < b.length; j++) {
+			table[i + 1]![j + 1] = a[i] === b[j] ? table[i]![j]! + 1 : Math.max(table[i + 1]![j]!, table[i]![j + 1]!);
 		}
 	}
 	const out: string[] = [];
-	let i = n;
-	let j = m;
+	let i = a.length;
+	let j = b.length;
 	while (i > 0 && j > 0) {
 		if (a[i - 1] === b[j - 1]) {
-			out.push(a[i - 1]);
+			out.push(a[i - 1]!);
 			i--;
 			j--;
-		} else if (table[i - 1][j] >= table[i][j - 1]) {
+		} else if (table[i - 1]![j]! >= table[i]![j - 1]!) {
 			i--;
 		} else {
 			j--;