@gajae-code/coding-agent 0.11.11 → 0.12.1

package/src/gjc-runtime/gc-render.ts

@@ -12,6 +12,7 @@ const STORE_HEADINGS: Record<GcStore, string> = {
 	file_locks: "Config file-locks",
 	tmux_sessions: "Tmux sessions",
 	registry_entries: "Harness-root registry entries",
+	local_roots: "Session local roots",
 };
 
 function actionLabel(record: GcRecord): string {

package/src/gjc-runtime/gc-runtime.ts

@@ -19,7 +19,13 @@ import { UnsupportedStateVersionError } from "../sdk/broker/state-version";
 
 import { buildGcReportText } from "./gc-render";
 
-export type GcStore = "harness_leases" | "team_workers" | "file_locks" | "tmux_sessions" | "registry_entries";
+export type GcStore =
+	| "harness_leases"
+	| "team_workers"
+	| "file_locks"
+	| "tmux_sessions"
+	| "registry_entries"
+	| "local_roots";
 
 export const GC_STORES: readonly GcStore[] = [
 	"harness_leases",
@@ -27,6 +33,7 @@ export const GC_STORES: readonly GcStore[] = [
 	"file_locks",
 	"tmux_sessions",
 	"registry_entries",
+	"local_roots",
 ] as const;
 
 /** Why a probed pid is kept instead of treated as dead. */
@@ -452,11 +459,13 @@ export async function defaultGcAdapters(): Promise<GcStoreAdapter[]> {
 		{ fileLocksGcAdapter },
 		{ teamWorkersGcAdapter },
 		{ tmuxSessionsGcAdapter },
+		{ localRootsGcAdapter },
 	] = await Promise.all([
 		import("../harness-control-plane/gc-adapter"),
 		import("../config/file-lock-gc"),
 		import("./team-gc"),
 		import("./tmux-gc"),
+		import("../internal-urls/local-root-gc"),
 	]);
 	return [
 		harnessLeasesGcAdapter,
@@ -464,5 +473,6 @@ export async function defaultGcAdapters(): Promise<GcStoreAdapter[]> {
 		fileLocksGcAdapter,
 		tmuxSessionsGcAdapter,
 		registryEntriesGcAdapter,
+		localRootsGcAdapter,
 	];
 }

package/src/gjc-runtime/launch-tmux.ts

@@ -172,7 +172,7 @@ export interface TmuxLaunchPlan {
 	/** Native tmux session identity emitted atomically by `new-session -P -F`. */
 	createdSessionId?: string;
 	/** Safe server identity proven immediately after creation. */
-	createdServerIdentity?: { pid: number; startTime: string };
+	createdServerIdentity?: { pid: number; startTime: string; pidProven?: boolean };
 	isPsmux: boolean;
 	platform: NodeJS.Platform;
 }
@@ -793,7 +793,12 @@ function cleanupCreatedTmuxSession(
 	if (!isCreatedTmuxSessionIdentityStable(plan, spawnSync, options, probe))
 		throw new Error("gjc_tmux_exact_cleanup_uncertain");
 	const nativeSessionId = plan.createdSessionId!;
-	const expectedPid = plan.createdServerIdentity!.pid;
+	// Emit the `#{pid}` clause only when the server proof proved a PID. Non-Linux
+	// probes report a placeholder PID, and pinning `#{pid}` to it yields a
+	// predicate no live tmux server can satisfy, which turns every guarded
+	// cleanup on those platforms into `gjc_tmux_exact_cleanup_uncertain`.
+	const createdServer = plan.createdServerIdentity!;
+	const serverPidPredicate = createdServer.pidProven === false ? "1" : `#{==:#{pid},${createdServer.pid}}`;
 	const guarded = spawnSync(
 		plan.tmuxCommand,
 		[
@@ -801,7 +806,7 @@ function cleanupCreatedTmuxSession(
 			"-t",
 			nativeSessionId,
 			"-F",
-			`#{&&:#{==:#{pid},${expectedPid}},#{&&:#{==:#{session_id},${nativeSessionId}},#{==:#{session_name},${plan.sessionName}}}}`,
+			`#{&&:${serverPidPredicate},#{&&:#{==:#{session_id},${nativeSessionId}},#{==:#{session_name},${plan.sessionName}}}}`,
 			`kill-session -t ${nativeSessionId} \\; display-message -p __gjc_tmux_guarded_cleanup_ok__`,
 			"display-message -p __gjc_tmux_guarded_cleanup_refused__",
 		],
@@ -1141,7 +1146,13 @@ function defaultOwnerIsolationProbe(
 	const stateDir = path.dirname(plan.sessionStateFile ?? path.join(plan.cwd, ".gjc", "runtime"));
 	const probeServer = (): TmuxServerProof => {
 		if (plan.platform !== "linux") {
-			return { state: "safe", pid: 1, startTime: "not-applicable", cgroup: { classification: "not_applicable" } };
+			return {
+				state: "safe",
+				pid: 1,
+				startTime: "not-applicable",
+				cgroup: { classification: "not_applicable" },
+				pidProven: false,
+			};
 		}
 		const probe = spawn(plan.tmuxCommand, ["display-message", "-p", "#{pid}"], {
 			cwd: plan.cwd,
@@ -1268,7 +1279,11 @@ function createIsolatedTmuxSession(
 		isCurrentGeneration: () => isOwnerGenerationBaselineCurrentSync(stateDir, sessionId, baseline),
 		cleanupSpawned: ({ nativeSessionId, server }) => {
 			plan.createdSessionId = nativeSessionId;
-			plan.createdServerIdentity = { pid: server.pid!, startTime: server.startTime! };
+			plan.createdServerIdentity = {
+				pid: server.pid!,
+				startTime: server.startTime!,
+				pidProven: server.pidProven,
+			};
 			cleanupCreatedTmuxSessionAfterFailure(plan, spawn, options, probe, new Error("owner_generation_stale"));
 		},
 	});
@@ -1281,7 +1296,11 @@ function createIsolatedTmuxSession(
 		return { exitCode: 1, stderr: outcome.diagnostic };
 	}
 	if (!plan.isPsmux && outcome.native_session_id) plan.createdSessionId = outcome.native_session_id;
-	plan.createdServerIdentity = { pid: outcome.server_pid, startTime: outcome.server_start_time };
+	plan.createdServerIdentity = {
+		pid: outcome.server_pid,
+		startTime: outcome.server_start_time,
+		pidProven: plan.platform === "linux" ? undefined : false,
+	};
 	return executed ?? { exitCode: 1, stderr: "tmux owner isolation did not execute" };
 }
 

package/src/gjc-runtime/managed-owner-admission.ts

@@ -51,7 +51,7 @@ function ownerEnvironment(): {
 	const generation = process.env[MANAGED_OWNER_GENERATION_ENV]?.trim();
 	const runId = process.env[MANAGED_OWNER_RUN_ID_ENV]?.trim();
 	const incarnation = process.env[MANAGED_OWNER_INCARNATION_ENV]?.trim();
-	if (!stateDir && !sessionId && !generation && !runId && !incarnation) return null;
+	if (!stateDir && !generation && !runId && !incarnation) return null;
 	if (!stateDir || !sessionId || !generation || !runId || !incarnation || !path.isAbsolute(stateDir))
 		throw new Error("managed_owner_admission_metadata_invalid");
 	for (const [value, label] of [

package/src/gjc-runtime/memory-guard-owner-claims.ts

@@ -0,0 +1,389 @@
+import { Database } from "bun:sqlite";
+import * as fs from "node:fs/promises";
+import { type LinuxProcPidProbeResult, probeLinuxProcPid } from "./linux-proc";
+import { assertSafePathComponent } from "./session-layout";
+import { memoryGuardClaimPaths } from "./tmux-owner-isolation";
+
+const MEMORY_GUARD_CLAIM_RESOURCES = ["writer", "tty"] as const;
+const MEMORY_GUARD_SQLITE_BUSY_TIMEOUT_MS = 5_000;
+type MemoryGuardClaimResource = (typeof MEMORY_GUARD_CLAIM_RESOURCES)[number];
+
+export interface MemoryGuardClaimOwner {
+	sessionId: string;
+	generation: string;
+	runId: string;
+	childToken: string;
+	pid: number;
+	processStartTime: string;
+	ttyDevice: string;
+}
+
+export interface MemoryGuardClaimsLease {
+	writerEpoch: number;
+	ttyEpoch: number;
+	owner: MemoryGuardClaimOwner;
+	claimStorePath: string;
+}
+
+const issuedMemoryGuardClaimsLeases = new WeakSet<MemoryGuardClaimsLease>();
+
+function issueMemoryGuardClaimsLease(lease: MemoryGuardClaimsLease): MemoryGuardClaimsLease {
+	const owner = Object.freeze({ ...lease.owner });
+	const issued = Object.freeze({ ...lease, owner });
+	issuedMemoryGuardClaimsLeases.add(issued);
+	return issued;
+}
+
+export function isMemoryGuardClaimsLease(value: unknown): value is MemoryGuardClaimsLease {
+	return (
+		typeof value === "object" && value !== null && issuedMemoryGuardClaimsLeases.has(value as MemoryGuardClaimsLease)
+	);
+}
+export function isMemoryGuardClaimsLeaseForStateDir(value: unknown, stateDir: string): value is MemoryGuardClaimsLease {
+	return (
+		isMemoryGuardClaimsLease(value) &&
+		value.claimStorePath === memoryGuardClaimPaths(stateDir, value.owner.sessionId).databaseFile
+	);
+}
+
+export type MemoryGuardClaimsReleasedProof = MemoryGuardClaimsLease;
+
+interface PersistedMemoryGuardClaimRow {
+	resource: MemoryGuardClaimResource;
+	epoch: number;
+	session_id: string;
+	generation: string;
+	run_id: string;
+	child_token: string;
+	pid: number;
+	process_start_time: string;
+	tty_device: string;
+	acquired_at: string;
+}
+
+export interface MemoryGuardOwnerClaimsDeps {
+	probePid(pid: number): Promise<LinuxProcPidProbeResult>;
+	now(): string;
+}
+
+const defaultDeps: MemoryGuardOwnerClaimsDeps = {
+	probePid,
+	now: () => new Date().toISOString(),
+};
+
+function probePid(pid: number): Promise<LinuxProcPidProbeResult> {
+	return probeLinuxProcPid(pid);
+}
+
+function assertClaimOwner(owner: MemoryGuardClaimOwner): void {
+	for (const [value, label] of [
+		[owner.sessionId, "memory guard session id"],
+		[owner.generation, "memory guard generation"],
+		[owner.runId, "memory guard run id"],
+		[owner.childToken, "memory guard child token"],
+	] as const) {
+		assertSafePathComponent(value, label);
+	}
+	if (!Number.isSafeInteger(owner.pid) || owner.pid <= 0) throw new Error("memory_guard_claim_invalid_pid");
+	if (!/^\d+$/.test(owner.processStartTime)) throw new Error("memory_guard_claim_invalid_process_start_time");
+	if (!/^-?\d+$/.test(owner.ttyDevice)) throw new Error("memory_guard_claim_invalid_tty_device");
+}
+
+async function prepareClaimDirectory(root: string): Promise<void> {
+	await fs.mkdir(root, { recursive: true, mode: 0o700 });
+	await fs.chmod(root, 0o700);
+}
+
+async function enforceDatabaseModes(databaseFile: string): Promise<void> {
+	for (const file of [databaseFile, `${databaseFile}-wal`, `${databaseFile}-shm`]) {
+		await fs.chmod(file, 0o600).catch(() => undefined);
+	}
+}
+
+function configureClaimsDatabase(database: Database): void {
+	database.exec("PRAGMA journal_mode = WAL");
+	database.exec("PRAGMA synchronous = FULL");
+	database.exec(`PRAGMA busy_timeout = ${MEMORY_GUARD_SQLITE_BUSY_TIMEOUT_MS}`);
+	database.exec(`
+		CREATE TABLE IF NOT EXISTS meta(
+			key TEXT PRIMARY KEY,
+			value TEXT NOT NULL
+		);
+		INSERT OR IGNORE INTO meta(key, value) VALUES ('epoch', '0');
+		CREATE TABLE IF NOT EXISTS claims(
+			resource TEXT PRIMARY KEY CHECK(resource IN ('writer', 'tty')),
+			epoch INTEGER NOT NULL,
+			session_id TEXT NOT NULL,
+			generation TEXT NOT NULL,
+			run_id TEXT NOT NULL,
+			child_token TEXT NOT NULL,
+			pid INTEGER NOT NULL,
+			process_start_time TEXT NOT NULL,
+			tty_device TEXT NOT NULL,
+			acquired_at TEXT NOT NULL
+		);
+	`);
+}
+
+async function openClaimsDatabase(
+	stateDir: string,
+	sessionId: string,
+): Promise<{ database: Database; databaseFile: string }> {
+	assertSafePathComponent(sessionId, "memory guard session id");
+	const paths = memoryGuardClaimPaths(stateDir, sessionId);
+	await prepareClaimDirectory(paths.root);
+	const database = new Database(paths.databaseFile, { create: true });
+	configureClaimsDatabase(database);
+	await enforceDatabaseModes(paths.databaseFile);
+	return { database, databaseFile: paths.databaseFile };
+}
+
+function readEpoch(database: Database): number {
+	const row = database.prepare("SELECT value FROM meta WHERE key = 'epoch'").get() as { value: string } | null;
+	if (!row || !/^\d+$/.test(row.value)) throw new Error("memory_guard_claim_epoch_invalid");
+	const value = Number(row.value);
+	if (!Number.isSafeInteger(value) || value < 0) throw new Error("memory_guard_claim_epoch_invalid");
+	return value;
+}
+
+function allocateEpoch(database: Database): number {
+	const next = readEpoch(database) + 1;
+	if (!Number.isSafeInteger(next) || next <= 0) throw new Error("memory_guard_claim_epoch_overflow");
+	database.prepare("UPDATE meta SET value = ? WHERE key = 'epoch'").run(String(next));
+	return next;
+}
+
+function readClaimRows(database: Database): PersistedMemoryGuardClaimRow[] {
+	const rows = database
+		.prepare(
+			"SELECT resource, epoch, session_id, generation, run_id, child_token, pid, process_start_time, tty_device, acquired_at FROM claims ORDER BY resource ASC",
+		)
+		.all() as PersistedMemoryGuardClaimRow[];
+	for (const row of rows) {
+		if (!MEMORY_GUARD_CLAIM_RESOURCES.includes(row.resource)) throw new Error("memory_guard_claim_resource_invalid");
+		if (!Number.isSafeInteger(row.epoch) || row.epoch <= 0) throw new Error("memory_guard_claim_epoch_invalid");
+	}
+	return rows;
+}
+
+async function assertLiveOwner(owner: MemoryGuardClaimOwner, deps: MemoryGuardOwnerClaimsDeps): Promise<void> {
+	const probe = await deps.probePid(owner.pid);
+	if (probe.kind !== "live")
+		throw new Error(
+			`memory_guard_claim_owner_unverifiable:${probe.kind === "unverifiable" ? probe.reason : "absent"}`,
+		);
+	if (probe.startTime !== owner.processStartTime) throw new Error("memory_guard_claim_owner_start_time_mismatch");
+	if (probe.ttyDevice !== owner.ttyDevice) throw new Error("memory_guard_claim_owner_tty_mismatch");
+}
+
+async function classifyExistingRow(
+	row: PersistedMemoryGuardClaimRow,
+	deps: MemoryGuardOwnerClaimsDeps,
+): Promise<"live" | "reclaim"> {
+	const probe = await deps.probePid(row.pid);
+	if (probe.kind === "absent") return "reclaim";
+	if (probe.kind === "live") return probe.startTime === row.process_start_time ? "live" : "reclaim";
+	throw new Error(`memory_guard_claim_existing_owner_unverifiable:${probe.reason}`);
+}
+
+function claimRowsEqual(left: PersistedMemoryGuardClaimRow[], right: PersistedMemoryGuardClaimRow[]): boolean {
+	return JSON.stringify(left) === JSON.stringify(right);
+}
+
+async function inspectExistingRows(
+	rows: PersistedMemoryGuardClaimRow[],
+	deps: MemoryGuardOwnerClaimsDeps,
+	liveError: (resource: MemoryGuardClaimResource) => Error,
+): Promise<void> {
+	for (const row of rows) {
+		const state = await classifyExistingRow(row, deps);
+		if (state === "live") throw liveError(row.resource);
+	}
+}
+
+function insertClaimRow(
+	database: Database,
+	resource: MemoryGuardClaimResource,
+	epoch: number,
+	owner: MemoryGuardClaimOwner,
+	acquiredAt: string,
+): void {
+	database
+		.prepare(
+			"INSERT INTO claims(resource, epoch, session_id, generation, run_id, child_token, pid, process_start_time, tty_device, acquired_at) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+		)
+		.run(
+			resource,
+			epoch,
+			owner.sessionId,
+			owner.generation,
+			owner.runId,
+			owner.childToken,
+			owner.pid,
+			owner.processStartTime,
+			owner.ttyDevice,
+			acquiredAt,
+		);
+}
+
+function deleteExactClaimRow(
+	database: Database,
+	resource: MemoryGuardClaimResource,
+	epoch: number,
+	owner: MemoryGuardClaimOwner,
+): number {
+	return database
+		.prepare(
+			"DELETE FROM claims WHERE resource = ? AND epoch = ? AND session_id = ? AND generation = ? AND run_id = ? AND child_token = ? AND pid = ? AND process_start_time = ? AND tty_device = ?",
+		)
+		.run(
+			resource,
+			epoch,
+			owner.sessionId,
+			owner.generation,
+			owner.runId,
+			owner.childToken,
+			owner.pid,
+			owner.processStartTime,
+			owner.ttyDevice,
+		).changes;
+}
+
+function rollbackQuietly(database: Database): void {
+	try {
+		database.exec("ROLLBACK");
+	} catch {
+		return;
+	}
+}
+
+export function memoryGuardClaimsDatabaseFile(stateDir: string, sessionId: string): string {
+	return memoryGuardClaimPaths(stateDir, sessionId).databaseFile;
+}
+
+export async function acquireMemoryGuardClaims(
+	stateDir: string,
+	owner: MemoryGuardClaimOwner,
+	deps: MemoryGuardOwnerClaimsDeps = defaultDeps,
+): Promise<MemoryGuardClaimsLease> {
+	assertClaimOwner(owner);
+	await assertLiveOwner(owner, deps);
+	const { database, databaseFile } = await openClaimsDatabase(stateDir, owner.sessionId);
+	try {
+		for (let attempt = 0; attempt < 3; attempt += 1) {
+			const inspectedRows = readClaimRows(database);
+			await inspectExistingRows(
+				inspectedRows,
+				deps,
+				resource => new Error(`memory_guard_claim_live_contention:${resource}`),
+			);
+			database.exec("BEGIN IMMEDIATE");
+			try {
+				if (!claimRowsEqual(inspectedRows, readClaimRows(database))) {
+					database.exec("ROLLBACK");
+					continue;
+				}
+				database.exec("DELETE FROM claims");
+				const acquiredAt = deps.now();
+				const writerEpoch = allocateEpoch(database);
+				insertClaimRow(database, "writer", writerEpoch, owner, acquiredAt);
+				const ttyEpoch = allocateEpoch(database);
+				insertClaimRow(database, "tty", ttyEpoch, owner, acquiredAt);
+				database.exec("COMMIT");
+				await enforceDatabaseModes(databaseFile);
+				return issueMemoryGuardClaimsLease({ writerEpoch, ttyEpoch, owner, claimStorePath: databaseFile });
+			} catch (error) {
+				rollbackQuietly(database);
+				throw error;
+			}
+		}
+		throw new Error("memory_guard_claim_rows_changed");
+	} finally {
+		database.close();
+	}
+}
+
+export async function releaseMemoryGuardClaims(stateDir: string, claim: MemoryGuardClaimsLease): Promise<void> {
+	if (!issuedMemoryGuardClaimsLeases.has(claim)) throw new Error("memory_guard_claim_lease_invalid");
+	assertClaimOwner(claim.owner);
+	const expectedDatabaseFile = memoryGuardClaimPaths(stateDir, claim.owner.sessionId).databaseFile;
+	if (claim.claimStorePath !== expectedDatabaseFile) throw new Error("memory_guard_claim_store_mismatch");
+	const { database } = await openClaimsDatabase(stateDir, claim.owner.sessionId);
+	try {
+		database.exec("BEGIN IMMEDIATE");
+		const writerChanges = deleteExactClaimRow(database, "writer", claim.writerEpoch, claim.owner);
+		const ttyChanges = deleteExactClaimRow(database, "tty", claim.ttyEpoch, claim.owner);
+		if (writerChanges !== 1 || ttyChanges !== 1) throw new Error("memory_guard_claim_release_mismatch");
+		database.exec("COMMIT");
+		issuedMemoryGuardClaimsLeases.delete(claim);
+	} catch (error) {
+		rollbackQuietly(database);
+		throw error;
+	} finally {
+		database.close();
+	}
+}
+
+export async function probeMemoryGuardClaimsReleased(
+	stateDir: string,
+	owner: MemoryGuardClaimOwner,
+	deps: MemoryGuardOwnerClaimsDeps = defaultDeps,
+): Promise<MemoryGuardClaimsReleasedProof> {
+	assertClaimOwner(owner);
+	await assertLiveOwner(owner, deps);
+	const { database, databaseFile } = await openClaimsDatabase(stateDir, owner.sessionId);
+	try {
+		for (let attempt = 0; attempt < 3; attempt += 1) {
+			const inspectedRows = readClaimRows(database);
+			await inspectExistingRows(
+				inspectedRows,
+				deps,
+				resource => new Error(`memory_guard_claims_still_live:${resource}`),
+			);
+			database.exec("BEGIN IMMEDIATE");
+			try {
+				if (!claimRowsEqual(inspectedRows, readClaimRows(database))) {
+					database.exec("ROLLBACK");
+					continue;
+				}
+				database.exec("DELETE FROM claims");
+				const acquiredAt = deps.now();
+				const writerEpoch = allocateEpoch(database);
+				insertClaimRow(database, "writer", writerEpoch, owner, acquiredAt);
+				const ttyEpoch = allocateEpoch(database);
+				insertClaimRow(database, "tty", ttyEpoch, owner, acquiredAt);
+				database.exec("COMMIT");
+				await enforceDatabaseModes(databaseFile);
+				const proof = issueMemoryGuardClaimsLease({ writerEpoch, ttyEpoch, owner, claimStorePath: databaseFile });
+				await releaseMemoryGuardClaims(stateDir, proof);
+				return proof;
+			} catch (error) {
+				rollbackQuietly(database);
+				throw error;
+			}
+		}
+		throw new Error("memory_guard_claim_rows_changed");
+	} finally {
+		database.close();
+	}
+}
+
+export interface PersistedMemoryGuardClaimsSnapshot {
+	epoch: number;
+	claims: PersistedMemoryGuardClaimRow[];
+}
+
+export async function readMemoryGuardClaimsForTest(
+	stateDir: string,
+	sessionId: string,
+): Promise<PersistedMemoryGuardClaimsSnapshot> {
+	const { database } = await openClaimsDatabase(stateDir, sessionId);
+	try {
+		return {
+			epoch: readEpoch(database),
+			claims: readClaimRows(database),
+		};
+	} finally {
+		database.close();
+	}
+}