@gajae-code/coding-agent 0.8.2 → 0.9.1

package/src/extensibility/gjc-plugins/runtime-adapters.ts

@@ -1,14 +1,161 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { loadCustomTools } from "../custom-tools/loader";
 import type { CustomTool } from "../custom-tools/types";
-import { loadEffectiveGjcPluginRegistry } from "./registry";
-import { type SessionQuarantine, validateSessionBundles, verifyEntryHashes } from "./session-validation";
+import { loadEffectiveGjcPluginRegistry, registryPathForScope } from "./registry";
+import { type SessionQuarantine, type SessionValidationResult, validateSessionBundles } from "./session-validation";
+import type { GjcPluginRegistryEntry, GjcPluginScope } from "./types";
 
 export interface AlwaysOnPluginTools {
 	tools: CustomTool[];
 	quarantine: SessionQuarantine[];
 }
 
+interface FileSnapshot {
+	path: string;
+	mtimeMs: number;
+	ctimeMs: number;
+	size: number;
+	ino: number;
+}
+
+interface ValidatedPluginRegistry {
+	effective: GjcPluginRegistryEntry[];
+	active: GjcPluginRegistryEntry[];
+	quarantine: SessionQuarantine[];
+	validation: SessionValidationResult;
+	registryFiles: FileSnapshot[];
+	pluginFiles: FileSnapshot[];
+}
+
+interface CachedValidatedPluginRegistry extends ValidatedPluginRegistry {
+	registryKey: string;
+	pluginKey: string;
+}
+
+const validatedRegistryCache = new Map<string, CachedValidatedPluginRegistry>();
+const hashCache = new Map<string, string>();
+// Bound the digest memo so long sessions with plugin churn cannot grow it
+// unboundedly; entries are re-derivable from disk at the cost of one read.
+const HASH_CACHE_MAX_ENTRIES = 512;
+const registryScopes: GjcPluginScope[] = ["user", "project"];
+
+async function snapshotExistingFile(filePath: string): Promise<FileSnapshot | null> {
+	try {
+		const stat = await fs.stat(filePath);
+		return { path: filePath, mtimeMs: stat.mtimeMs, ctimeMs: stat.ctimeMs, size: stat.size, ino: stat.ino };
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException)?.code === "ENOENT") return null;
+		throw error;
+	}
+}
+
+function snapshotsKey(snapshots: readonly FileSnapshot[]): string {
+	return snapshots.map(s => `${s.path}:${s.mtimeMs}:${s.ctimeMs}:${s.size}:${s.ino}`).join("|");
+}
+
+async function snapshotRegistryFiles(cwd: string): Promise<FileSnapshot[]> {
+	const snapshots = await Promise.all(
+		registryScopes.map(scope => snapshotExistingFile(registryPathForScope(scope, cwd))),
+	);
+	return snapshots.filter((s): s is FileSnapshot => s !== null);
+}
+
+async function snapshotPluginFiles(entries: readonly GjcPluginRegistryEntry[]): Promise<FileSnapshot[]> {
+	const snapshots: FileSnapshot[] = [];
+	for (const entry of entries) {
+		if (!entry.enabled) continue;
+		for (const file of entry.copiedFiles) {
+			const abs = path.join(entry.pluginRoot, file.relativePath);
+			const snapshot = await snapshotExistingFile(abs);
+			if (!snapshot) {
+				snapshots.push({ path: abs, mtimeMs: Number.NaN, ctimeMs: Number.NaN, size: Number.NaN, ino: Number.NaN });
+			} else {
+				snapshots.push(snapshot);
+			}
+		}
+	}
+	return snapshots;
+}
+
+function sha256(buf: Buffer): string {
+	return createHash("sha256").update(buf).digest("hex");
+}
+
+async function hashFile(snapshot: FileSnapshot): Promise<string> {
+	const key = `${snapshot.path}:${snapshot.mtimeMs}:${snapshot.ctimeMs}:${snapshot.size}:${snapshot.ino}`;
+	const cached = hashCache.get(key);
+	if (cached) return cached;
+	const digest = sha256(await fs.readFile(snapshot.path));
+	if (hashCache.size >= HASH_CACHE_MAX_ENTRIES) {
+		// FIFO eviction is sufficient: the memo only avoids re-reads within a
+		// session; correctness never depends on a hit.
+		const oldest = hashCache.keys().next().value;
+		if (oldest !== undefined) hashCache.delete(oldest);
+	}
+	hashCache.set(key, digest);
+	return digest;
+}
+
+async function verifyEntryHashesCached(entry: GjcPluginRegistryEntry): Promise<SessionQuarantine | null> {
+	for (const file of entry.copiedFiles) {
+		const abs = path.join(entry.pluginRoot, file.relativePath);
+		const snapshot = await snapshotExistingFile(abs);
+		if (!snapshot) {
+			return {
+				plugin: entry.name,
+				surfaceId: `plugin:${entry.name}`,
+				code: "runtime_mismatch",
+				message: `Installed file missing: ${file.relativePath}`,
+			};
+		}
+		if ((await hashFile(snapshot)) !== file.sha256) {
+			return {
+				plugin: entry.name,
+				surfaceId: `plugin:${entry.name}`,
+				code: "runtime_mismatch",
+				message: `Installed file hash drift: ${file.relativePath}`,
+			};
+		}
+	}
+	return null;
+}
+
+async function loadValidatedPluginRegistry(cwd: string): Promise<ValidatedPluginRegistry> {
+	const registryFiles = await snapshotRegistryFiles(cwd);
+	const registryKey = snapshotsKey(registryFiles);
+	const cached = validatedRegistryCache.get(cwd);
+	if (cached && cached.registryKey === registryKey) {
+		const pluginFiles = await snapshotPluginFiles(cached.effective);
+		const pluginKey = snapshotsKey(pluginFiles);
+		if (cached.pluginKey === pluginKey) return cached;
+	}
+
+	const effective = await loadEffectiveGjcPluginRegistry(cwd);
+	const currentRegistryFiles = await snapshotRegistryFiles(cwd);
+	const preQuarantine: SessionQuarantine[] = [];
+	for (const entry of effective) {
+		if (!entry.enabled) continue;
+		const drift = await verifyEntryHashesCached(entry);
+		if (drift) preQuarantine.push(drift);
+	}
+	const validation = validateSessionBundles(effective, {}, preQuarantine);
+	const pluginFiles = await snapshotPluginFiles(effective);
+	const next: CachedValidatedPluginRegistry = {
+		effective,
+		active: validation.active,
+		quarantine: validation.quarantine,
+		validation,
+		registryFiles: currentRegistryFiles,
+		pluginFiles,
+		registryKey: snapshotsKey(currentRegistryFiles),
+		pluginKey: snapshotsKey(pluginFiles),
+	};
+	validatedRegistryCache.set(cwd, next);
+	return next;
+}
+
 /**
  * Load the always-on plugin tool surfaces for the effective registry at `cwd`.
  *
@@ -26,22 +173,15 @@ export async function loadAlwaysOnPluginTools(input: {
 	cwd: string;
 	reservedToolNames: string[];
 }): Promise<AlwaysOnPluginTools> {
-	const effective = await loadEffectiveGjcPluginRegistry(input.cwd);
+	const validated = await loadValidatedPluginRegistry(input.cwd);
+	const { effective } = validated;
 	if (effective.length === 0) return { tools: [], quarantine: [] };
 
-	// Hash-drift quarantine before importing any plugin code.
-	const preQuarantine: SessionQuarantine[] = [];
-	for (const entry of effective) {
-		if (!entry.enabled) continue;
-		const drift = await verifyEntryHashes(entry);
-		if (drift) preQuarantine.push(drift);
-	}
-
 	const reserved = new Set(input.reservedToolNames);
 	const { active, quarantine } = validateSessionBundles(
 		effective,
 		{ toolNames: input.reservedToolNames },
-		preQuarantine,
+		validated.quarantine,
 	);
 
 	// Map declared (path -> name) for every active always-on tool surface.
@@ -109,15 +249,8 @@ export async function loadAlwaysOnPluginTools(input: {
  * plugins are installed/enabled. Safe to call unconditionally at session start.
  */
 export async function renderAlwaysOnSystemAppendices(input: { cwd: string }): Promise<string> {
-	const effective = await loadEffectiveGjcPluginRegistry(input.cwd);
+	const { effective, active } = await loadValidatedPluginRegistry(input.cwd);
 	if (effective.length === 0) return "";
-	const preQuarantine: SessionQuarantine[] = [];
-	for (const entry of effective) {
-		if (!entry.enabled) continue;
-		const drift = await verifyEntryHashes(entry);
-		if (drift) preQuarantine.push(drift);
-	}
-	const { active } = validateSessionBundles(effective, {}, preQuarantine);
 	const { renderPluginAppendices } = await import("./prompt-appendix");
 	return (await renderPluginAppendices(active)).system;
 }
@@ -131,15 +264,8 @@ export async function renderAgentPromptAdditions(input: {
 	cwd: string;
 	agentName: string;
 }): Promise<{ appendix: string; advertisement: string }> {
-	const effective = await loadEffectiveGjcPluginRegistry(input.cwd);
+	const { effective, active } = await loadValidatedPluginRegistry(input.cwd);
 	if (effective.length === 0) return { appendix: "", advertisement: "" };
-	const preQuarantine: SessionQuarantine[] = [];
-	for (const entry of effective) {
-		if (!entry.enabled) continue;
-		const drift = await verifyEntryHashes(entry);
-		if (drift) preQuarantine.push(drift);
-	}
-	const { active } = validateSessionBundles(effective, {}, preQuarantine);
 	const { renderPluginAppendices } = await import("./prompt-appendix");
 	const { buildAgentSubskillAdvertisement } = await import("./injection");
 	const rendered = await renderPluginAppendices(active);
@@ -158,15 +284,8 @@ export async function renderSkillAdvertisement(input: {
 	skillName: string;
 	phase?: string;
 }): Promise<string> {
-	const effective = await loadEffectiveGjcPluginRegistry(input.cwd);
+	const { effective, active } = await loadValidatedPluginRegistry(input.cwd);
 	if (effective.length === 0) return "";
-	const preQuarantine: SessionQuarantine[] = [];
-	for (const entry of effective) {
-		if (!entry.enabled) continue;
-		const drift = await verifyEntryHashes(entry);
-		if (drift) preQuarantine.push(drift);
-	}
-	const { active } = validateSessionBundles(effective, {}, preQuarantine);
 	const { buildSubskillAdvertisement } = await import("./injection");
 	return buildSubskillAdvertisement(active, input.skillName, input.phase);
 }
@@ -181,15 +300,8 @@ export async function buildPluginMcpConfigs(input: { cwd: string }): Promise<{
 	configs: Record<string, any>;
 	quarantine: SessionQuarantine[];
 }> {
-	const effective = await loadEffectiveGjcPluginRegistry(input.cwd);
+	const { effective, active, quarantine } = await loadValidatedPluginRegistry(input.cwd);
 	if (effective.length === 0) return { configs: {}, quarantine: [] };
-	const preQuarantine: SessionQuarantine[] = [];
-	for (const entry of effective) {
-		if (!entry.enabled) continue;
-		const drift = await verifyEntryHashes(entry);
-		if (drift) preQuarantine.push(drift);
-	}
-	const { active, quarantine } = validateSessionBundles(effective, {}, preQuarantine);
 	const { assertMcpInstallPolicy, assertDnsResolvesPublic, assertUrlAllowed } = await import("./mcp-policy");
 	const nodePath = await import("node:path");
 

package/src/gjc-runtime/deep-interview-state.ts

@@ -163,13 +163,39 @@ const HOISTED_STATE_FIELDS = [
 	"threshold_source",
 ] as const;
 
+/**
+ * Envelope-reserved keys that are never legitimate interview `state` fields.
+ *
+ * A malformed write that wraps a whole envelope under `state`
+ * (`gjc state deep-interview write --input '{"state": <envelope>}'`) leaks these
+ * into the nested state. Because normalization otherwise preserves unknown
+ * nested fields, they would accrete a recursive `state.state` chain (plus stale
+ * `receipt`/`skill`/`version`/... duplicates) that no later merge or write ever
+ * removes, permanently corrupting the shape. They are stripped from `state` on
+ * normalize so the canonical envelope self-heals on the next write.
+ */
+const ENVELOPE_RESERVED_STATE_KEYS = [
+	"state",
+	"receipt",
+	"skill",
+	"version",
+	"updated_at",
+	"active",
+	"current_phase",
+	"state_revision",
+	"session_id",
+] as const;
+
 /**
  * Canonicalize a deep-interview envelope: interview data nested under `state`,
  * legacy flattened fields hoisted in losslessly, transcript duplicates removed
  * from the top level, and `rounds`/`established_facts` guaranteed to be arrays.
  *
- * Idempotent: a canonical envelope is returned unchanged in shape. Never deletes
- * unknown envelope or nested fields, and never mutates the input.
+ * Idempotent: a canonical envelope is returned unchanged in shape. Preserves all
+ * unknown envelope and nested fields except the envelope-reserved keys that leak
+ * into `state` (see `ENVELOPE_RESERVED_STATE_KEYS`), which are stripped so a
+ * malformed envelope-in-state write cannot permanently nest state. Never mutates
+ * the input.
  */
 export function normalizeDeepInterviewEnvelope(value: unknown): DeepInterviewStateEnvelope {
 	const envelope: DeepInterviewStateEnvelope = isPlainObject(value) ? { ...value } : {};
@@ -182,6 +208,9 @@ export function normalizeDeepInterviewEnvelope(value: unknown): DeepInterviewSta
 	for (const field of HOISTED_STATE_FIELDS) {
 		if (inner[field] === undefined && envelope[field] !== undefined) inner[field] = envelope[field];
 	}
+	for (const field of ENVELOPE_RESERVED_STATE_KEYS) {
+		if (field in inner) delete inner[field];
+	}
 
 	if (!Array.isArray(inner.rounds)) inner.rounds = [];
 	if (!Array.isArray(inner.established_facts)) inner.established_facts = [];

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

@@ -13,6 +13,7 @@ import {
 	buildGjcTmuxSessionName,
 	buildGjcTmuxSessionSlug,
 	GJC_DEFAULT_TMUX_SESSION,
+	GJC_TMUX_ACTIVE_SESSION_ENV,
 	GJC_TMUX_COMMAND_ENV,
 	GJC_TMUX_MOUSE_ENV,
 	GJC_TMUX_PROFILE_ENV,
@@ -688,6 +689,11 @@ export function buildDefaultTmuxLaunchPlan(context: TmuxLaunchContext): TmuxLaun
 			extraEnv: {
 				[GJC_COORDINATOR_SESSION_ID_ENV]: sessionId,
 				[GJC_COORDINATOR_SESSION_STATE_FILE_ENV]: sessionStateFile,
+				// Carry the GJC-managed session name into the child so `gjc team`
+				// can target the correct leader session by name. Under psmux on
+				// Windows the inherited TMUX_PANE can resolve to the wrong/default
+				// session, which would split/send workers into the wrong session.
+				[GJC_TMUX_ACTIVE_SESSION_ENV]: sessionName,
 			},
 			platform,
 		},

package/src/gjc-runtime/session-state-sidecar.ts

@@ -8,11 +8,27 @@ import { sessionRuntimeDir } from "./session-layout";
 export const GJC_COORDINATOR_SESSION_STATE_FILE_ENV = "GJC_COORDINATOR_SESSION_STATE_FILE";
 export const GJC_COORDINATOR_SESSION_ID_ENV = "GJC_COORDINATOR_SESSION_ID";
 export const GJC_COORDINATOR_SESSION_BRANCH_ENV = "GJC_COORDINATOR_SESSION_BRANCH";
+const GJC_SESSION_PROMPT_ACCEPTED_JSON_ENV = "GJC_SESSION_PROMPT_ACCEPTED_JSON";
+const GJC_SESSION_WORKTREE_BASELINE_DIRTY_ENV = "GJC_SESSION_WORKTREE_BASELINE_DIRTY";
 
 export type RuntimeState = "ready_for_input" | "running" | "needs_user_input" | "completed" | "errored";
 
 type FinalResponseSource = "agent_end" | "launch_error";
 const MAX_PUBLIC_ERROR_MESSAGE_LENGTH = 2000;
+const HEARTBEAT_MS = 1000;
+
+type LastPayloadCacheEntry = { mtimeMs: number; size: number; payload: Record<string, unknown> };
+const lastPayloadByStateFile = new Map<string, LastPayloadCacheEntry>();
+
+/** Test-only counters for runtime sidecar hot-path assertions. */
+export const __sessionStateSidecarPerfCounters = {
+	persistFromEventCalls: 0,
+	reset(): void {
+		this.persistFromEventCalls = 0;
+	},
+};
+
+const lastWrittenPayloadByStateFile = new Map<string, Record<string, unknown>>();
 
 interface RuntimeStateEvent {
 	type: string;
@@ -32,6 +48,7 @@ interface RuntimeStateSidecarPayload {
 	state?: unknown;
 	ready_for_input?: unknown;
 	cwd?: unknown;
+	workdir?: unknown;
 	session_file?: unknown;
 	final_response?: { source?: unknown };
 }
@@ -53,6 +70,11 @@ function sameResolvedPath(left: string, right: string): boolean {
 	return path.resolve(left) === path.resolve(right);
 }
 
+function isCoordinatorOwnedStateFile(stateFile: string): boolean {
+	const coordinatorStateFile = process.env[GJC_COORDINATOR_SESSION_STATE_FILE_ENV]?.trim();
+	return !!coordinatorStateFile && sameResolvedPath(coordinatorStateFile, stateFile);
+}
+
 export async function readTerminalRuntimeStateMarker(input: {
 	stateFile?: string | null;
 	sessionId?: string | null;
@@ -125,7 +147,7 @@ function finalResponseForEvent(event: RuntimeStateEvent): {
 	};
 }
 
-function stateForEvent(event: RuntimeStateEvent): RuntimeState | null {
+export function stateForEvent(event: RuntimeStateEvent): RuntimeState | null {
 	if (event.type === "agent_start" || event.type === "turn_start") return "running";
 	if (event.type === "agent_end") {
 		const assistant = lastAssistant(event.messages);
@@ -135,6 +157,10 @@ function stateForEvent(event: RuntimeStateEvent): RuntimeState | null {
 	return null;
 }
 
+export function eventAffectsCoordinatorRuntimeState(event: RuntimeStateEvent): boolean {
+	return stateForEvent(event) !== null;
+}
+
 function readPreviousPayload(stateFile: string): Record<string, unknown> {
 	try {
 		return JSON.parse(fsSync.readFileSync(stateFile, "utf8")) as Record<string, unknown>;
@@ -143,10 +169,84 @@ function readPreviousPayload(stateFile: string): Record<string, unknown> {
 	}
 }
 
-function shouldPreserveTerminalPayload(previous: RuntimeStateSidecarPayload): boolean {
+async function readPreviousPayloadForEvent(stateFile: string): Promise<Record<string, unknown>> {
+	if (!isCoordinatorOwnedStateFile(stateFile)) {
+		const cachedWritten = lastWrittenPayloadByStateFile.get(stateFile);
+		if (cachedWritten) return cachedWritten;
+	}
+	let stat: Awaited<ReturnType<typeof fs.stat>>;
+	try {
+		stat = await fs.stat(stateFile);
+	} catch {
+		lastPayloadByStateFile.delete(stateFile);
+		return {};
+	}
+	const cached = lastPayloadByStateFile.get(stateFile);
+	if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) return cached.payload;
+	try {
+		const payload = JSON.parse(await Bun.file(stateFile).text()) as Record<string, unknown>;
+		lastPayloadByStateFile.set(stateFile, { mtimeMs: stat.mtimeMs, size: stat.size, payload });
+		return payload;
+	} catch {
+		lastPayloadByStateFile.delete(stateFile);
+		return {};
+	}
+}
+
+function withoutUpdatedAt(payload: Record<string, unknown>): Record<string, unknown> {
+	const { updated_at: _updatedAt, ...rest } = payload;
+	return rest;
+}
+
+function shouldSkipRuntimeStateWrite(
+	previous: Record<string, unknown>,
+	payload: Record<string, unknown>,
+	nowMs: number,
+): boolean {
+	if (payload.state === "completed" || payload.state === "errored") return false;
+	if (previous.state !== payload.state) return false;
+	if (previous.state !== "running" || payload.state !== "running") return false;
+	if (JSON.stringify(withoutUpdatedAt(previous)) !== JSON.stringify(withoutUpdatedAt(payload))) return false;
+	const previousUpdatedAt = typeof previous.updated_at === "string" ? Date.parse(previous.updated_at) : NaN;
+	if (!Number.isFinite(previousUpdatedAt)) return false;
+	return nowMs - previousUpdatedAt < HEARTBEAT_MS;
+}
+
+function rememberWrittenPayload(stateFile: string, payload: Record<string, unknown>): void {
+	lastWrittenPayloadByStateFile.set(stateFile, payload);
+	try {
+		const stat = fsSync.statSync(stateFile);
+		lastPayloadByStateFile.set(stateFile, { mtimeMs: stat.mtimeMs, size: stat.size, payload });
+	} catch {
+		lastPayloadByStateFile.delete(stateFile);
+	}
+}
+function shouldPreserveTerminalPayload(
+	previous: RuntimeStateSidecarPayload,
+	input: { sessionId: string; cwd: string; sessionFile?: string | null },
+): boolean {
 	if (previous.state !== "completed" && previous.state !== "errored") return false;
 	const source = previous.final_response?.source;
-	return source === "agent_end" || source === "launch_error";
+	if (source !== "agent_end" && source !== "launch_error") return false;
+	if (typeof previous.session_id === "string" && previous.session_id !== input.sessionId) return false;
+	if (typeof previous.cwd === "string" && !sameResolvedPath(previous.cwd, input.cwd)) return false;
+	if (typeof previous.workdir === "string" && !sameResolvedPath(previous.workdir, input.cwd)) return false;
+	if (
+		input.sessionFile &&
+		typeof previous.session_file === "string" &&
+		!sameResolvedPath(previous.session_file, input.sessionFile)
+	) {
+		return false;
+	}
+	return true;
+}
+
+function cachedTerminalPayload(
+	stateFile: string,
+	input: { sessionId: string; cwd: string; sessionFile?: string | null },
+): RuntimeStateSidecarPayload | null {
+	const cached = lastWrittenPayloadByStateFile.get(stateFile) as RuntimeStateSidecarPayload | undefined;
+	return cached && shouldPreserveTerminalPayload(cached, input) ? cached : null;
 }
 
 function runtimeStateFileForContext(context: RuntimeStateContext): string | null {
@@ -187,6 +287,56 @@ function basePayload(input: {
 		session_file: input.context.sessionFile ?? null,
 	};
 }
+function booleanFromUnknown(value: unknown): boolean | null {
+	if (typeof value === "boolean") return value;
+	if (typeof value === "string") {
+		const normalized = value.trim().toLowerCase();
+		if (normalized === "true") return true;
+		if (normalized === "false") return false;
+	}
+	return null;
+}
+
+function promptAcceptedFromEnv(): boolean {
+	const promptAcceptedJson = process.env[GJC_SESSION_PROMPT_ACCEPTED_JSON_ENV]?.trim();
+	if (!promptAcceptedJson) return false;
+	try {
+		return fsSync.statSync(promptAcceptedJson).size > 0;
+	} catch {
+		return false;
+	}
+}
+
+function readJsonFileSync(file: string): Record<string, unknown> | null {
+	try {
+		return JSON.parse(fsSync.readFileSync(file, "utf8")) as Record<string, unknown>;
+	} catch {
+		return null;
+	}
+}
+
+function worktreeBaselineDirtyFromEnvOrMarker(): boolean | null {
+	const promptAcceptedJson = process.env[GJC_SESSION_PROMPT_ACCEPTED_JSON_ENV]?.trim();
+	if (promptAcceptedJson) {
+		const promptAccepted = readJsonFileSync(promptAcceptedJson);
+		const promptBaseline = booleanFromUnknown(promptAccepted?.worktreeBaselineDirty);
+		if (promptBaseline !== null) return promptBaseline;
+	}
+	const envValue = booleanFromUnknown(process.env[GJC_SESSION_WORKTREE_BASELINE_DIRTY_ENV]);
+	if (envValue !== null) return envValue;
+	return null;
+}
+
+function observedRecoverableWorktreeChanges(cwd: string): boolean {
+	if (!cwd.trim()) return false;
+	try {
+		const proc = Bun.spawnSync(["git", "status", "--porcelain"], { cwd, stdout: "pipe", stderr: "pipe" });
+		return proc.exitCode === 0 && proc.stdout.byteLength > 0;
+	} catch {
+		return false;
+	}
+}
+
 function publicSafeErrorMessage(message: string): string {
 	const normalized = message.replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, " ").trim();
 	if (normalized.length <= MAX_PUBLIC_ERROR_MESSAGE_LENGTH) return normalized;
@@ -204,6 +354,7 @@ function numericProcessExitCode(defaultCode: number | null): number | null {
 function postmortemExitDetails(
 	reason: postmortem.Reason,
 	previous: RuntimeStateSidecarPayload,
+	cwd: string,
 ): {
 	state: RuntimeState;
 	reason: string;
@@ -212,7 +363,15 @@ function postmortemExitDetails(
 	signal: string | null;
 	error?: { code: string; message: string; recoverable: true };
 	recovery?: { action: string; reason: string };
+	promptAccepted: boolean;
+	observedRecoverableWorktreeChanges: boolean;
+	worktreeBaselineDirty: boolean | null;
+	worktreeChangedSinceBaseline: boolean;
 } {
+	const promptAccepted = promptAcceptedFromEnv();
+	const observedChanges = observedRecoverableWorktreeChanges(typeof previous.cwd === "string" ? previous.cwd : cwd);
+	const worktreeBaselineDirty = worktreeBaselineDirtyFromEnvOrMarker();
+	const worktreeChangedSinceBaseline = worktreeBaselineDirty === false && observedChanges;
 	if (reason === postmortem.Reason.EXIT || reason === postmortem.Reason.MANUAL) {
 		const exitCode = numericProcessExitCode(0) ?? 0;
 		const exitedBeforeTerminalState =
@@ -223,16 +382,25 @@ function postmortemExitDetails(
 			: reason === postmortem.Reason.EXIT
 				? "process_exit"
 				: "manual_cleanup";
+		let classifiedReason = exitReason;
+		if (exitedBeforeTerminalState) {
+			if (!promptAccepted) classifiedReason = "process_exit_before_prompt_acceptance";
+			else if (worktreeChangedSinceBaseline)
+				classifiedReason = "accepted_prompt_observed_recoverable_worktree_changes";
+			else if (observedChanges)
+				classifiedReason = "accepted_prompt_dirty_worktree_observed_without_new_change_proof";
+			else classifiedReason = "accepted_prompt_no_useful_output";
+		}
 		return {
 			state,
-			reason: exitReason,
+			reason: classifiedReason,
 			exitKind: reason,
 			exitCode,
 			signal: null,
 			...(state === "errored"
 				? {
 						error: {
-							code: exitReason,
+							code: classifiedReason,
 							message: publicSafeErrorMessage(
 								exitedBeforeTerminalState
 									? "GJC process exited before emitting terminal agent state"
@@ -248,6 +416,10 @@ function postmortemExitDetails(
 						},
 					}
 				: {}),
+			promptAccepted,
+			observedRecoverableWorktreeChanges: observedChanges,
+			worktreeBaselineDirty,
+			worktreeChangedSinceBaseline,
 		};
 	}
 	const signalByReason: Partial<Record<postmortem.Reason, string>> = {
@@ -263,29 +435,37 @@ function postmortemExitDetails(
 		signal: signalByReason[reason] ?? null,
 		error: { code: reason, message: errorMessageForPostmortem(reason), recoverable: true },
 		recovery: { action: "recover_or_resume_session", reason: "process cleanup ran before terminal agent state" },
+		promptAccepted,
+		observedRecoverableWorktreeChanges: observedChanges,
+		worktreeBaselineDirty,
+		worktreeChangedSinceBaseline,
 	};
 }
 
 function writeStateFileSync(stateFile: string, payload: Record<string, unknown>): void {
 	fsSync.mkdirSync(path.dirname(stateFile), { recursive: true });
-	fsSync.writeFileSync(stateFile, `${JSON.stringify(payload, null, 2)}\n`);
+	fsSync.writeFileSync(stateFile, `${JSON.stringify(payload)}\n`);
+	rememberWrittenPayload(stateFile, payload);
 }
 
 async function writeStateFile(stateFile: string, payload: Record<string, unknown>): Promise<void> {
 	await fs.mkdir(path.dirname(stateFile), { recursive: true });
-	await Bun.write(stateFile, `${JSON.stringify(payload, null, 2)}\n`);
+	await Bun.write(stateFile, `${JSON.stringify(payload)}\n`);
+	rememberWrittenPayload(stateFile, payload);
 }
 
 export async function persistCoordinatorRuntimeStateFromEvent(
 	event: RuntimeStateEvent,
 	context: RuntimeStateContext,
 ): Promise<void> {
+	__sessionStateSidecarPerfCounters.persistFromEventCalls += 1;
 	const stateFile = runtimeStateFileForContext(context);
 	if (!stateFile) return;
 	const state = stateForEvent(event);
 	if (!state) return;
-	const now = new Date().toISOString();
-	const previous = readPreviousPayload(stateFile);
+	const nowMs = Date.now();
+	const now = new Date(nowMs).toISOString();
+	const previous = await readPreviousPayloadForEvent(stateFile);
 	const finalResponse = finalResponseForEvent(event);
 	const sessionId = process.env[GJC_COORDINATOR_SESSION_STATE_FILE_ENV]?.trim()
 		? process.env[GJC_COORDINATOR_SESSION_ID_ENV]?.trim() || context.sessionId
@@ -313,7 +493,9 @@ export async function persistCoordinatorRuntimeStateFromEvent(
 				}
 			: {}),
 	};
+	if (state === "completed" || state === "errored") rememberWrittenPayload(stateFile, payload);
 	try {
+		if (shouldSkipRuntimeStateWrite(previous, payload, nowMs)) return;
 		await writeStateFile(stateFile, payload);
 	} catch (error) {
 		logger.warn("Failed to persist coordinator runtime state", { error: String(error), stateFile });
@@ -326,13 +508,22 @@ export function persistCoordinatorRuntimeStateFromPostmortem(
 ): void {
 	const stateFile = runtimeStateFileForContext(context);
 	if (!stateFile) return;
-	const previous = readPreviousPayload(stateFile);
-	if (shouldPreserveTerminalPayload(previous as RuntimeStateSidecarPayload)) return;
-	const now = new Date().toISOString();
-	const details = postmortemExitDetails(reason, previous as RuntimeStateSidecarPayload);
 	const sessionId = process.env[GJC_COORDINATOR_SESSION_STATE_FILE_ENV]?.trim()
 		? process.env[GJC_COORDINATOR_SESSION_ID_ENV]?.trim() || context.sessionId
 		: context.sessionId;
+	const preserveInput = { sessionId, cwd: context.cwd, sessionFile: context.sessionFile };
+	const cachedTerminal = cachedTerminalPayload(stateFile, preserveInput);
+	const previous: Record<string, unknown> = cachedTerminal
+		? (cachedTerminal as unknown as Record<string, unknown>)
+		: readPreviousPayload(stateFile);
+	if (cachedTerminal || shouldPreserveTerminalPayload(previous as RuntimeStateSidecarPayload, preserveInput)) return;
+	const previousForDetails: RuntimeStateSidecarPayload =
+		(previous as RuntimeStateSidecarPayload).state === "completed" ||
+		(previous as RuntimeStateSidecarPayload).state === "errored"
+			? { ...(previous as RuntimeStateSidecarPayload), state: "running" }
+			: (previous as RuntimeStateSidecarPayload);
+	const now = new Date().toISOString();
+	const details = postmortemExitDetails(reason, previousForDetails, context.cwd);
 	const payload = {
 		...basePayload({
 			context,
@@ -352,6 +543,10 @@ export function persistCoordinatorRuntimeStateFromPostmortem(
 		...(details.error ? { error: details.error } : {}),
 		...(details.recovery ? { recovery: details.recovery } : {}),
 		previous_runtime_state: typeof previous.state === "string" ? previous.state : null,
+		prompt_accepted: details.promptAccepted,
+		observed_recoverable_worktree_changes: details.observedRecoverableWorktreeChanges,
+		worktree_baseline_dirty: details.worktreeBaselineDirty,
+		worktree_changed_since_baseline: details.worktreeChangedSinceBaseline,
 	};
 	try {
 		writeStateFileSync(stateFile, payload);