@gajae-code/coding-agent 0.5.0 → 0.5.1

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

@@ -4,6 +4,7 @@ import type { WorkflowHudSummary } from "../skill-state/active-state";
 import { buildUltragoalHudSummary as buildWorkflowUltragoalHudSummary } from "../skill-state/workflow-hud";
 import { renderCliWriteReceipt } from "./cli-write-receipt";
 import { DEFAULT_ULTRAGOAL_OBJECTIVE } from "./goal-mode-request";
+import { latestUltragoalLedgerEventFromText } from "./ledger-event-renderer";
 import { renderUltragoalStatusMarkdown } from "./state-renderer";
 import { reconcileWorkflowSkillState } from "./state-runtime";
 import { appendJsonl, writeArtifact, writeJsonAtomic } from "./state-writer";
@@ -2127,6 +2128,17 @@ async function reconcileUltragoalState(cwd: string): Promise<void> {
 			goals_path: summary.paths.goalsPath,
 		};
 		if (summary.gjcObjective) payload.gjc_objective = summary.gjcObjective;
+		const ledgerText = await Bun.file(summary.paths.ledgerPath)
+			.text()
+			.catch(() => "");
+		const latestLedger = latestUltragoalLedgerEventFromText(ledgerText);
+		if (latestLedger) {
+			payload.latestLedgerEvent = {
+				event: latestLedger.event,
+				...(latestLedger.goalId ? { goalId: latestLedger.goalId } : {}),
+				...(latestLedger.timestamp ? { timestamp: latestLedger.timestamp } : {}),
+			};
+		}
 		await reconcileWorkflowSkillState({ cwd, mode: "ultragoal", sessionId, active, phase: status, payload });
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);

package/src/harness-control-plane/gc-adapter.ts

@@ -0,0 +1,184 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import {
+	type GcCollectResult,
+	type GcContext,
+	type GcError,
+	type GcPruneOutcome,
+	type GcRecord,
+	type GcStoreAdapter,
+	gcPidStatusLabel,
+	gcProbeToLeasePidStatus,
+} from "../gjc-runtime/gc-runtime";
+import { classifyLeaseStatus, readLease, reapDeadOwnerArtifacts } from "./session-lease";
+import {
+	type HarnessRootRegistryForGc,
+	type HarnessRootRegistryListingForGc,
+	listHarnessRootRegistriesForGc,
+	removeHarnessRootRegistryFileForGc,
+	rewriteHarnessRootRegistryForGc,
+	sessionPaths,
+} from "./storage";
+
+function errorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+async function exists(file: string): Promise<boolean> {
+	try {
+		await fs.access(file);
+		return true;
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
+		throw error;
+	}
+}
+
+function registryErrors(registries: HarnessRootRegistryListingForGc[]): GcError[] {
+	return registries
+		.filter(registry => registry.error)
+		.map(registry => ({
+			store: "registry_entries",
+			scope: registry.file,
+			message: registry.error ?? "registry_error",
+		}));
+}
+
+async function collectRegistries(ctx: GcContext): Promise<HarnessRootRegistryListingForGc[]> {
+	return listHarnessRootRegistriesForGc(ctx.env);
+}
+
+export const harnessLeasesGcAdapter: GcStoreAdapter = {
+	store: "harness_leases",
+	async collect(ctx: GcContext): Promise<GcCollectResult> {
+		const records: GcRecord[] = [];
+		const errors: GcError[] = [];
+		const registries = await collectRegistries(ctx);
+		errors.push(...registryErrors(registries).map(error => ({ ...error, store: "harness_leases" as const })));
+
+		const roots = new Set<string>();
+		for (const registry of registries) {
+			if (registry.error) continue;
+			for (const entry of registry.roots) roots.add(path.resolve(entry.root));
+		}
+
+		for (const root of roots) {
+			const sessionsDir = path.join(root, "sessions");
+			let sessionEntries: string[];
+			try {
+				sessionEntries = await fs.readdir(sessionsDir);
+			} catch (error) {
+				const code = (error as NodeJS.ErrnoException).code;
+				if (code === "ENOENT") continue;
+				errors.push({ store: "harness_leases", scope: sessionsDir, message: errorMessage(error) });
+				continue;
+			}
+
+			for (const sessionId of sessionEntries) {
+				const sessionDir = sessionPaths(root, sessionId).dir;
+				try {
+					const stat = await fs.stat(sessionDir);
+					if (!stat.isDirectory()) continue;
+					const lease = await readLease(root, sessionId);
+					if (!lease) continue;
+					const status = classifyLeaseStatus(lease, { probe: gcProbeToLeasePidStatus(ctx.probe) });
+					const pidProbe = ctx.probe(lease.pid);
+					const pidStatus = gcPidStatusLabel(pidProbe);
+					const removable = status === "dead" && pidProbe.status === "dead";
+					records.push({
+						store: "harness_leases",
+						id: sessionId,
+						root,
+						path: sessionPaths(root, sessionId).lease,
+						pid: lease.pid,
+						pid_status: pidStatus,
+						status,
+						stale: status === "dead",
+						removable,
+						action: "none",
+						reason: removable
+							? `lease owner pid ${lease.pid} is dead`
+							: `lease owner pid ${lease.pid} is ${pidStatus}; keeping`,
+					});
+				} catch (error) {
+					errors.push({ store: "harness_leases", scope: sessionDir, message: errorMessage(error) });
+				}
+			}
+		}
+
+		return { records, errors };
+	},
+	async prune(record: GcRecord, ctx: GcContext): Promise<GcPruneOutcome> {
+		if (!record.root) return { removed: false, skipped: "missing_root" };
+		const lease = await readLease(record.root, record.id);
+		if (!lease) return { removed: false, skipped: "lease_not_dead_or_missing" };
+		const status = classifyLeaseStatus(lease, { probe: gcProbeToLeasePidStatus(ctx.probe) });
+		if (status !== "dead") return { removed: false, skipped: "lease_not_dead_or_missing" };
+		const removed = await reapDeadOwnerArtifacts(record.root, record.id, lease.ownerId, lease.leaseEpoch, {
+			probe: gcProbeToLeasePidStatus(ctx.probe),
+		});
+		return removed ? { removed: true } : { removed: false, skipped: "reaper_guard_rejected" };
+	},
+};
+
+async function splitRegistryRoots(registry: HarnessRootRegistryForGc): Promise<{
+	liveRoots: HarnessRootRegistryForGc["roots"];
+	danglingRoots: HarnessRootRegistryForGc["roots"];
+}> {
+	const liveRoots: HarnessRootRegistryForGc["roots"] = [];
+	const danglingRoots: HarnessRootRegistryForGc["roots"] = [];
+	for (const entry of registry.roots) {
+		const sessionDir = sessionPaths(entry.root, registry.sessionId).dir;
+		if (await exists(sessionDir)) liveRoots.push(entry);
+		else danglingRoots.push(entry);
+	}
+	return { liveRoots, danglingRoots };
+}
+
+export const registryEntriesGcAdapter: GcStoreAdapter = {
+	store: "registry_entries",
+	async collect(ctx: GcContext): Promise<GcCollectResult> {
+		const records: GcRecord[] = [];
+		const errors: GcError[] = [];
+		const registries = await collectRegistries(ctx);
+		errors.push(...registryErrors(registries));
+
+		for (const registry of registries) {
+			if (registry.error) continue;
+			try {
+				const { liveRoots, danglingRoots } = await splitRegistryRoots(registry);
+				if (danglingRoots.length === 0) continue;
+				records.push({
+					store: "registry_entries",
+					id: registry.sessionId,
+					path: registry.file,
+					pid_status: "none",
+					status: "dangling",
+					stale: true,
+					removable: true,
+					action: "none",
+					reason: `dangling roots: ${danglingRoots.map(entry => entry.root).join(", ")}`,
+					detail: `${danglingRoots.length} dangling, ${liveRoots.length} live`,
+				});
+			} catch (error) {
+				errors.push({ store: "registry_entries", scope: registry.file, message: errorMessage(error) });
+			}
+		}
+
+		return { records, errors };
+	},
+	async prune(record: GcRecord, ctx: GcContext): Promise<GcPruneOutcome> {
+		if (!record.path) return { removed: false, skipped: "missing_registry_path" };
+		const registries = await collectRegistries(ctx);
+		const registry = registries.find(entry => entry.file === record.path);
+		if (!registry || registry.error) return { removed: false, skipped: "registry_not_readable" };
+		const { liveRoots, danglingRoots } = await splitRegistryRoots(registry);
+		if (danglingRoots.length === 0) return { removed: false, skipped: "no_dangling_roots" };
+		if (liveRoots.length === 0) {
+			await removeHarnessRootRegistryFileForGc(record.path);
+		} else {
+			await rewriteHarnessRootRegistryForGc(record.path, { sessionId: registry.sessionId, roots: liveRoots });
+		}
+		return { removed: true };
+	},
+};

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

@@ -670,3 +670,14 @@ export async function resolveOwner(root: string, sessionId: string): Promise<Res
 	const live = status === "live" || status === "expiredAlive" || status === "epermAlive";
 	return { live, socketPath: lease.endpoint?.path ?? null, lease };
 }
+
+/**
+ * Owner liveness for verbs that do not route to the owner (e.g. `classify`): a routable owner
+ * has a live lease and a socket endpoint. This is the same lease/socket probe `observe` uses to
+ * decide routing, so non-routing verbs derive `ownerLive` consistently instead of assuming the
+ * owner is gone (which would misclassify a live owner as vanished/restart-clean).
+ */
+export async function resolveOwnerLive(root: string, sessionId: string): Promise<boolean> {
+	const owner = await resolveOwner(root, sessionId);
+	return owner.live && owner.socketPath !== null;
+}

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

@@ -32,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;
 }
@@ -101,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;