@gajae-code/coding-agent 0.13.0 → 0.13.2

package/src/eval/py/runtime.ts

@@ -7,7 +7,8 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { $env, $which, getPythonEnvDir } from "@gajae-code/utils";
+import { $env, $which, getPythonEnvDir, WhichCachePolicy } from "@gajae-code/utils";
+import { withFileLock } from "../../config/file-lock";
 
 export const RLM_MANAGED_PYTHON_PACKAGES: readonly string[] = ["numpy", "pandas", "matplotlib", "polars"];
 
@@ -18,6 +19,14 @@ export interface PythonRuntimeOptions {
 	seedPackages?: readonly string[];
 }
 
+export interface PythonRuntimeLifecycleOptions {
+	signal?: AbortSignal;
+	deadlineMs?: number;
+}
+
+const RUNTIME_CANCEL_GRACE_MS = 1_000;
+const RUNTIME_PROCESS_TREE_EXIT_TIMEOUT_MS = 5_000;
+
 const DEFAULT_ENV_ALLOWLIST = new Set([
 	"PATH",
 	"HOME",
@@ -195,11 +204,56 @@ export function resolveVenvPath(cwd: string): string | undefined {
 	return undefined;
 }
 
+function createRuntimeCancellationError(timedOut: boolean): Error {
+	const error = new Error(timedOut ? "Python runtime startup timed out" : "Python runtime startup aborted");
+	error.name = timedOut ? "TimeoutError" : "AbortError";
+	return error;
+}
+
+async function waitForRuntimeLifecycle<T>(
+	value: Promise<T>,
+	lifecycle: PythonRuntimeLifecycleOptions | undefined,
+	settleAfterCancellation?: () => boolean,
+): Promise<T> {
+	const { promise, resolve, reject } = Promise.withResolvers<T>();
+	const cleanups: Array<() => void> = [];
+	const finish = (callback: () => void): void => {
+		while (cleanups.length > 0) cleanups.pop()?.();
+		callback();
+	};
+	const cancel = (timedOut: boolean): void => {
+		if (settleAfterCancellation?.()) return;
+		finish(() => reject(createRuntimeCancellationError(timedOut)));
+	};
+	if (lifecycle?.signal?.aborted) {
+		if (!settleAfterCancellation?.()) throw lifecycle.signal.reason ?? createRuntimeCancellationError(false);
+	} else if (lifecycle?.signal) {
+		const onAbort = (): void => cancel(false);
+		lifecycle.signal.addEventListener("abort", onAbort, { once: true });
+		cleanups.push(() => lifecycle.signal?.removeEventListener("abort", onAbort));
+	}
+	const remainingMs = lifecycle?.deadlineMs === undefined ? undefined : lifecycle.deadlineMs - Date.now();
+	if (remainingMs !== undefined) {
+		if (remainingMs <= 0) cancel(true);
+		else {
+			const timer = setTimeout(() => cancel(true), remainingMs);
+			timer.unref();
+			cleanups.push(() => clearTimeout(timer));
+		}
+	}
+	void value.then(
+		result => finish(() => resolve(result)),
+		error => finish(() => reject(error)),
+	);
+	return await promise;
+}
+
 async function runRuntimeCommand(
 	cmd: string[],
 	cwd: string,
 	env: Record<string, string | undefined>,
 	description: string,
+	lifecycle?: PythonRuntimeLifecycleOptions,
 ): Promise<void> {
 	const spawnEnv: Record<string, string> = {};
 	for (const [key, value] of Object.entries(env)) {
@@ -211,15 +265,106 @@ async function runRuntimeCommand(
 		stdout: "pipe",
 		stderr: "pipe",
 		windowsHide: true,
+		detached: process.platform !== "win32",
 	});
-	const [stdout, stderr, exitCode] = await Promise.all([
-		new Response(proc.stdout).text(),
-		new Response(proc.stderr).text(),
-		proc.exited,
-	]);
+	const output = Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text(), proc.exited]);
+	const { promise, resolve, reject } = Promise.withResolvers<number>();
+	const cleanups: Array<() => void> = [];
+	const finish = (callback: () => void): void => {
+		while (cleanups.length > 0) cleanups.pop()?.();
+		callback();
+	};
+	let cancellation: { timedOut: boolean } | undefined;
+	let windowsTermination: Promise<void> | undefined;
+	const terminateWindowsProcessTree = (): void => {
+		if (windowsTermination) return;
+		const taskkill = Bun.spawn(["taskkill", "/pid", String(proc.pid), "/t", "/f"], {
+			stdout: "ignore",
+			stderr: "ignore",
+			windowsHide: true,
+		});
+		windowsTermination = taskkill.exited.then(
+			() => undefined,
+			() => undefined,
+		);
+	};
+	const waitForProcessTreeExit = async (): Promise<boolean> => {
+		if (process.platform === "win32") {
+			await windowsTermination;
+			return true;
+		}
+		const deadline = Date.now() + RUNTIME_PROCESS_TREE_EXIT_TIMEOUT_MS;
+		while (Date.now() < deadline) {
+			try {
+				process.kill(-proc.pid, 0);
+				await Bun.sleep(10);
+			} catch {
+				return true;
+			}
+		}
+		return false;
+	};
+	const cancel = (timedOut: boolean): void => {
+		if (cancellation) return;
+		cancellation = { timedOut };
+		const signalProcessTree = (signal: NodeJS.Signals): void => {
+			try {
+				if (process.platform === "win32") {
+					terminateWindowsProcessTree();
+				} else {
+					process.kill(-proc.pid, signal);
+				}
+			} catch {
+				// The process may have exited between the cancellation check and signal.
+			}
+		};
+		signalProcessTree("SIGTERM");
+		const escalation = setTimeout(() => signalProcessTree("SIGKILL"), RUNTIME_CANCEL_GRACE_MS);
+		escalation.unref();
+		cleanups.push(() => clearTimeout(escalation));
+	};
+	if (lifecycle?.signal?.aborted) {
+		cancel(false);
+	} else if (lifecycle?.signal) {
+		const onAbort = (): void => cancel(false);
+		lifecycle.signal.addEventListener("abort", onAbort, { once: true });
+		cleanups.push(() => lifecycle.signal?.removeEventListener("abort", onAbort));
+	}
+	const remainingMs = lifecycle?.deadlineMs === undefined ? undefined : lifecycle.deadlineMs - Date.now();
+	if (remainingMs !== undefined) {
+		if (remainingMs <= 0) {
+			cancel(true);
+		} else {
+			const timer = setTimeout(() => cancel(true), remainingMs);
+			timer.unref();
+			cleanups.push(() => clearTimeout(timer));
+		}
+	}
+	void proc.exited.then(async code => {
+		const cancelled = cancellation;
+		if (cancelled) {
+			const processTreeExited = await waitForProcessTreeExit();
+			finish(() => {
+				const error = createRuntimeCancellationError(cancelled.timedOut);
+				if (!processTreeExited)
+					error.message += "; Python provisioner process tree did not exit after cancellation";
+				reject(error);
+			});
+			return;
+		}
+		finish(() => resolve(code));
+	});
+	let exitCode: number;
+	try {
+		exitCode = await promise;
+	} catch (error) {
+		void output.catch(() => undefined);
+		throw error;
+	}
+	const [stdout, stderr] = await output;
 	if (exitCode !== 0) {
-		const output = [stdout.trim(), stderr.trim()].filter(Boolean).join("\n");
-		throw new Error(`${description} failed with exit code ${exitCode}${output ? `: ${output}` : ""}`);
+		const text = [stdout.trim(), stderr.trim()].filter(Boolean).join("\n");
+		throw new Error(`${description} failed with exit code ${exitCode}${text ? `: ${text}` : ""}`);
 	}
 }
 
@@ -227,18 +372,54 @@ async function ensureWorkspaceManagedVenv(
 	cwd: string,
 	baseEnv: Record<string, string | undefined>,
 	seedPackages: readonly string[],
+	lifecycle?: PythonRuntimeLifecycleOptions,
+): Promise<void> {
+	const venvPath = resolveWorkspaceManagedPythonCandidate(cwd).venvPath;
+	const lockSignal =
+		lifecycle?.deadlineMs === undefined
+			? lifecycle?.signal
+			: lifecycle.signal
+				? AbortSignal.any([lifecycle.signal, AbortSignal.timeout(Math.max(0, lifecycle.deadlineMs - Date.now()))])
+				: AbortSignal.timeout(Math.max(0, lifecycle.deadlineMs - Date.now()));
+	let lockAcquired = false;
+	const provisioning = withFileLock(
+		venvPath,
+		async () => {
+			if (lifecycle?.signal?.aborted) throw lifecycle.signal.reason ?? createRuntimeCancellationError(false);
+			if (lifecycle?.deadlineMs !== undefined && lifecycle.deadlineMs <= Date.now())
+				throw createRuntimeCancellationError(true);
+			await ensureWorkspaceManagedVenvInner(cwd, baseEnv, seedPackages, lifecycle);
+		},
+		{ retries: Number.POSITIVE_INFINITY, signal: lockSignal, onAcquired: () => (lockAcquired = true) },
+	);
+	return await waitForRuntimeLifecycle(provisioning, lifecycle, () => lockAcquired);
+}
+
+async function ensureWorkspaceManagedVenvInner(
+	cwd: string,
+	baseEnv: Record<string, string | undefined>,
+	seedPackages: readonly string[],
+	lifecycle?: PythonRuntimeLifecycleOptions,
 ): Promise<void> {
 	const managed = resolveWorkspaceManagedPythonCandidate(cwd);
 	if (!fs.existsSync(managed.pythonPath)) {
-		const basePython = $which("python3") ?? $which("python");
+		const basePython =
+			$which("python3", { PATH: baseEnv.PATH, cache: WhichCachePolicy.Bypass }) ??
+			$which("python", { PATH: baseEnv.PATH, cache: WhichCachePolicy.Bypass });
 		if (!basePython) throw new Error("Python executable not found on PATH");
 		await fs.promises.mkdir(path.dirname(managed.venvPath), { recursive: true });
-		await runRuntimeCommand(
-			[basePython, "-m", "venv", managed.venvPath],
-			cwd,
-			baseEnv,
-			"Managed Python venv creation",
-		);
+		try {
+			await runRuntimeCommand(
+				[basePython, "-m", "venv", managed.venvPath],
+				cwd,
+				baseEnv,
+				"Managed Python venv creation",
+				lifecycle,
+			);
+		} catch (error) {
+			await fs.promises.rm(managed.venvPath, { recursive: true, force: true });
+			throw error;
+		}
 	}
 	if (seedPackages.length === 0) return;
 	const markerPath = path.join(managed.venvPath, ".gjc-seeded.json");
@@ -257,12 +438,14 @@ async function ensureWorkspaceManagedVenv(
 		cwd,
 		runtimeEnv,
 		"Managed Python pip bootstrap",
+		lifecycle,
 	);
 	await runRuntimeCommand(
 		[managed.pythonPath, "-m", "pip", "install", ...seedPackages],
 		cwd,
 		runtimeEnv,
 		"Managed Python package seed",
+		lifecycle,
 	);
 	await fs.promises.writeFile(
 		markerPath,
@@ -315,6 +498,7 @@ export async function ensurePythonRuntime(
 	cwd: string,
 	baseEnv: Record<string, string | undefined>,
 	options: PythonRuntimeOptions = {},
+	lifecycle?: PythonRuntimeLifecycleOptions,
 ): Promise<PythonRuntime> {
 	if (options.managedWorkspaceVenv) {
 		const env = { ...baseEnv };
@@ -325,7 +509,7 @@ export async function ensurePythonRuntime(
 				return runtimeFromVenv(candidate.venvPath, candidate.pythonPath, candidate.binDir, env);
 			}
 		}
-		await ensureWorkspaceManagedVenv(cwd, baseEnv, options.seedPackages ?? RLM_MANAGED_PYTHON_PACKAGES);
+		await ensureWorkspaceManagedVenv(cwd, baseEnv, options.seedPackages ?? RLM_MANAGED_PYTHON_PACKAGES, lifecycle);
 	}
 	return resolvePythonRuntime(cwd, baseEnv, options);
 }

package/src/exec/bash-executor.ts

@@ -19,7 +19,7 @@ import { formatArtifactReference, resolveOutputMaxColumns, resolveOutputSinkHead
 import { getOrCreateSnapshot } from "../utils/shell-snapshot";
 import { NON_INTERACTIVE_ENV } from "./non-interactive-env";
 
-type NativeShellBindings = Pick<typeof import("@gajae-code/natives"), "Shell" | "executeShell">;
+type NativeShellBindings = Pick<typeof import("@gajae-code/natives"), "Shell">;
 let nativeShellBindingsLoad: Promise<NativeShellBindings> | undefined;
 
 async function shellNatives(): Promise<NativeShellBindings> {
@@ -288,7 +288,7 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 			...(await sink.dump("Command cancelled")),
 		};
 	}
-	const { Shell, executeShell } = await shellNatives();
+	const { Shell } = await shellNatives();
 
 	const usePersistentShell = options?.oneShot !== true;
 	const sessionKey = buildSessionKey(shell, configuredPrefix, snapshotPath, shellEnv, options?.sessionKey, minimizer);
@@ -303,14 +303,26 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 		});
 		shellSessions.set(sessionKey, shellSession);
 	}
+	// Non-persistent invocations still need an owned native Shell so its lifetime
+	// can be ended explicitly. executeShell creates a native shell outside the
+	// persistent registry, leaving its cleanup untrackable by the host process.
+	const oneShotShell =
+		!usePersistentShell || persistentSessionBroken
+			? new Shell({
+					sessionEnv: shellEnv,
+					snapshotPath: snapshotPath ?? undefined,
+					minimizer,
+				})
+			: undefined;
+	const activeShell = shellSession ?? oneShotShell;
 	const userSignal = options?.signal;
 	const runAbortController = new AbortController();
 	const abortCurrentExecution = () => {
 		if (!runAbortController.signal.aborted) {
 			runAbortController.abort();
 		}
-		if (shellSession && !abortPromise) {
-			abortPromise = shellSession.abort();
+		if (activeShell && !abortPromise) {
+			abortPromise = activeShell.abort();
 		}
 	};
 	const abortDeferred = Promise.withResolvers<"abort">();
@@ -351,38 +363,20 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 	let runSettled = false;
 
 	try {
-		const runPromise = shellSession
-			? shellSession.run(
-					{
-						command: finalCommand,
-						cwd: commandCwd,
-						env: commandEnv,
-						timeoutMs: executionTimeoutMs,
-						signal: runAbortController.signal,
-					},
-					(err, chunk) => {
-						if (!err) {
-							enqueueChunk(chunk);
-						}
-					},
-				)
-			: executeShell(
-					{
-						command: finalCommand,
-						cwd: commandCwd,
-						env: commandEnv,
-						sessionEnv: shellEnv,
-						snapshotPath: snapshotPath ?? undefined,
-						minimizer,
-						timeoutMs: executionTimeoutMs,
-						signal: runAbortController.signal,
-					},
-					(err, chunk) => {
-						if (!err) {
-							enqueueChunk(chunk);
-						}
-					},
-				);
+		const runPromise = activeShell!.run(
+			{
+				command: finalCommand,
+				cwd: commandCwd,
+				env: commandEnv,
+				timeoutMs: executionTimeoutMs,
+				signal: runAbortController.signal,
+			},
+			(err, chunk) => {
+				if (!err) {
+					enqueueChunk(chunk);
+				}
+			},
+		);
 
 		const winner = await Promise.race([
 			runPromise.then(result => ({ kind: "result" as const, result })),
@@ -413,7 +407,8 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 						.catch(() => undefined);
 				}
 			} else {
-				void runPromise.catch(() => undefined);
+				runSettled = await awaitAbortCleanup(runPromise);
+				if (!runSettled) void runPromise.catch(() => undefined);
 			}
 			return {
 				exitCode: undefined,
@@ -512,6 +507,10 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 		if (resetSession && runSettled && shellSessions.get(sessionKey) === shellSession) {
 			shellSessions.delete(sessionKey);
 		}
+		if (oneShotShell) {
+			const disposePromise = abortPromise ?? oneShotShell.abort();
+			await Promise.race([disposePromise.catch(() => undefined), Bun.sleep(CANCEL_CLEANUP_WAIT_MS)]);
+		}
 	}
 }
 

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

@@ -1194,6 +1194,9 @@ async function markGcDiskBlobReferences(transcriptPath: string, into: Set<string
 interface GcDiskMarkedTranscript {
 	size: number;
 	mtimeMs: number;
+	ctimeMs: number;
+	dev: number;
+	ino: number;
 }
 
 /**
@@ -1233,14 +1236,26 @@ async function markGcDiskTranscript(
 		errors.push({ surface: "blobs", scope: transcriptPath, message: gcDiskErrorText(error) });
 		return;
 	}
-	if (before.size !== after.size || before.mtimeMs !== after.mtimeMs) {
+	if (
+		before.size !== after.size ||
+		before.mtimeMs !== after.mtimeMs ||
+		before.ctimeMs !== after.ctimeMs ||
+		before.dev !== after.dev ||
+		before.ino !== after.ino
+	) {
 		// The transcript changed while its references were being read: the
 		// reference set is not bound to a stable snapshot, so it cannot vouch
 		// for any blob. Same posture as the drift rounds exhausting below.
 		markGcDiskEvidenceIncomplete(evidence, "sessions_changed_during_mark");
 		return;
 	}
-	marked.set(transcriptPath, { size: after.size, mtimeMs: after.mtimeMs });
+	marked.set(transcriptPath, {
+		size: after.size,
+		mtimeMs: after.mtimeMs,
+		ctimeMs: after.ctimeMs,
+		dev: after.dev,
+		ino: after.ino,
+	});
 }
 
 /**
@@ -1269,7 +1284,14 @@ async function findGcDiskMarkDrift(input: {
 		visit: (transcriptPath, _directory, stat) => {
 			const mark = input.marked.get(transcriptPath);
 			if (mark) {
-				if (mark.size !== stat.size || mark.mtimeMs !== stat.mtimeMs) drifted.push(transcriptPath);
+				if (
+					mark.size !== stat.size ||
+					mark.mtimeMs !== stat.mtimeMs ||
+					mark.ctimeMs !== stat.ctimeMs ||
+					mark.dev !== stat.dev ||
+					mark.ino !== stat.ino
+				)
+					drifted.push(transcriptPath);
 				return;
 			}
 			if (!input.accounted.has(transcriptPath)) drifted.push(transcriptPath);

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

@@ -164,7 +164,33 @@ export async function runManagedOwnerSupervisor(): Promise<void> {
 	const childStartTime = await managedOwnerProcessProvenance(child.pid);
 	if (!childStartTime) throw new Error("managed_owner_child_start_time_unavailable");
 	const childProcess = nativeProcessBindings().Process.fromPid(child.pid);
-	if (!childProcess) throw new Error("managed_owner_child_reference_unavailable");
+	if (!childProcess) {
+		const exitCode = await child.exited;
+		if (child.signalCode === "SIGABRT") {
+			const receipt: ManagedOwnerSigabrtReceipt = {
+				schema_version: 2,
+				generation,
+				session_id: sessionId,
+				run_id: runId,
+				endpoint_incarnation: incarnation,
+				child_token: childToken,
+				command_sha256: binding.command_sha256,
+				supervisor_pid: process.pid,
+				supervisor_start_time: supervisorStartTime,
+				child_pid: child.pid,
+				child_start_time: childStartTime,
+				signal: "SIGABRT",
+				signal_number: 6,
+				exit_code: exitCode,
+				received_at: new Date().toISOString(),
+			};
+			await writeDurableExclusive(path.join(root, `sigabrt-${childToken}.receipt.json`), receipt);
+			process.exitCode = 134;
+			return;
+		}
+		process.exitCode = exitCode;
+		return;
+	}
 	if (process.platform === "linux" && childProcess.incarnation !== `linux:${childStartTime}`)
 		throw new Error("managed_owner_child_incarnation_mismatch");
 	let childExited = false;

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

@@ -1,4 +1,4 @@
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import * as fsSync from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
@@ -45,6 +45,8 @@ export type RuntimeState = "ready_for_input" | "running" | "needs_user_input" |
 type FinalResponseSource = "agent_end" | "launch_error";
 const MAX_PUBLIC_ERROR_MESSAGE_LENGTH = 2000;
 const HEARTBEAT_MS = 1000;
+const MAX_PUBLIC_ACTIVE_TOOLS = 8;
+const SAFE_TOOL_NAME = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
 
 type LastPayloadCacheEntry = { mtimeMs: number; size: number; payload: Record<string, unknown> };
 const lastPayloadByStateFile = new Map<string, LastPayloadCacheEntry>();
@@ -61,6 +63,9 @@ export const __sessionStateSidecarPerfCounters = {
 interface RuntimeStateEvent {
 	type: string;
 	messages?: unknown[];
+	toolCallId?: unknown;
+	toolName?: unknown;
+	isError?: unknown;
 }
 
 export interface OwnerTerminalContext {
@@ -369,7 +374,95 @@ export function stateForEvent(event: RuntimeStateEvent): RuntimeState | null {
 }
 
 export function eventAffectsCoordinatorRuntimeState(event: RuntimeStateEvent): boolean {
-	return stateForEvent(event) !== null;
+	return stateForEvent(event) !== null || toolActivityForEvent(event) !== null;
+}
+
+function safeToolName(value: unknown): string {
+	return typeof value === "string" && SAFE_TOOL_NAME.test(value) ? value : "custom";
+}
+
+function toolActivityForEvent(
+	event: RuntimeStateEvent,
+):
+	| { phase: "started"; toolCallKey: string; toolName: string }
+	| { phase: "finished"; toolCallKey: string; toolName: string; outcome: "succeeded" | "failed" }
+	| null {
+	if (event.type !== "tool_execution_start" && event.type !== "tool_execution_end") return null;
+	if (typeof event.toolCallId !== "string") return null;
+	const toolCallKey = createHash("sha256").update(event.toolCallId).digest("hex");
+	if (event.type === "tool_execution_start")
+		return { phase: "started", toolCallKey, toolName: safeToolName(event.toolName) };
+	return {
+		phase: "finished",
+		toolCallKey,
+		toolName: safeToolName(event.toolName),
+		outcome: event.isError === true ? "failed" : "succeeded",
+	};
+}
+
+function runtimeStateFromPrevious(value: unknown): RuntimeState {
+	return value === "ready_for_input" ||
+		value === "running" ||
+		value === "needs_user_input" ||
+		value === "completed" ||
+		value === "errored"
+		? value
+		: "running";
+}
+
+function activityFieldsForEvent(
+	previous: Record<string, unknown>,
+	activityEvent: NonNullable<ReturnType<typeof toolActivityForEvent>>,
+	now: string,
+	nowMs: number,
+): Record<string, unknown> {
+	const activeToolCalls: Record<string, { tool_name: string; started_at: string }> = {};
+	const existing = previous.active_tool_calls;
+	if (existing && typeof existing === "object" && !Array.isArray(existing)) {
+		for (const [key, value] of Object.entries(existing)) {
+			if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+			const entry = value as Record<string, unknown>;
+			if (typeof entry.tool_name !== "string" || typeof entry.started_at !== "string") continue;
+			if (!Number.isFinite(Date.parse(entry.started_at))) continue;
+			activeToolCalls[key] = { tool_name: safeToolName(entry.tool_name), started_at: entry.started_at };
+		}
+	}
+	const prior = activeToolCalls[activityEvent.toolCallKey];
+	if (activityEvent.phase === "started")
+		activeToolCalls[activityEvent.toolCallKey] = { tool_name: activityEvent.toolName, started_at: now };
+	else delete activeToolCalls[activityEvent.toolCallKey];
+	const previousActivity =
+		previous.activity && typeof previous.activity === "object" && !Array.isArray(previous.activity)
+			? (previous.activity as Record<string, unknown>)
+			: null;
+	const sequence =
+		previousActivity &&
+		typeof previousActivity.sequence === "number" &&
+		Number.isSafeInteger(previousActivity.sequence) &&
+		previousActivity.sequence >= 0
+			? Math.min(Number.MAX_SAFE_INTEGER, previousActivity.sequence + 1)
+			: 1;
+	const activeTools = Object.values(activeToolCalls)
+		.sort((left, right) => left.started_at.localeCompare(right.started_at))
+		.slice(0, MAX_PUBLIC_ACTIVE_TOOLS);
+	const startedAt = activityEvent.phase === "started" ? now : prior?.started_at;
+	const elapsedMs = startedAt ? Math.max(0, nowMs - Date.parse(startedAt)) : undefined;
+	return {
+		last_activity_at: now,
+		activity: {
+			sequence,
+			kind: "tool_execution",
+			phase: activityEvent.phase,
+			tool_name: activityEvent.toolName,
+			observed_at: now,
+			...(startedAt ? { started_at: startedAt } : {}),
+			...(elapsedMs === undefined ? {} : { elapsed_ms: elapsedMs }),
+			...(activityEvent.phase === "finished" ? { outcome: activityEvent.outcome } : {}),
+			active_tool_count: Object.keys(activeToolCalls).length,
+		},
+		active_tools: activeTools,
+		active_tool_calls: activeToolCalls,
+	};
 }
 
 class PreviousRuntimeStateReadError extends Error {
@@ -584,6 +677,16 @@ function basePayload(input: {
 		workdir: identity.workdir,
 		branch: branchForContext(input.context),
 		session_file: identity.sessionFile,
+		...(typeof input.previous.last_activity_at === "string"
+			? { last_activity_at: input.previous.last_activity_at }
+			: {}),
+		...(input.previous.activity && typeof input.previous.activity === "object"
+			? { activity: input.previous.activity }
+			: {}),
+		...(Array.isArray(input.previous.active_tools) ? { active_tools: input.previous.active_tools } : {}),
+		...(input.previous.active_tool_calls && typeof input.previous.active_tool_calls === "object"
+			? { active_tool_calls: input.previous.active_tool_calls }
+			: {}),
 		...(input.context.ownerTerminal ? { owner_generation: input.context.ownerTerminal.generation } : {}),
 	};
 }
@@ -784,8 +887,9 @@ export async function persistCoordinatorRuntimeStateFromEvent(
 ): Promise<void> {
 	__sessionStateSidecarPerfCounters.persistFromEventCalls += 1;
 	const stateFile = runtimeStateFileForContext(context);
-	const state = stateForEvent(event);
-	if (!stateFile || !state) return;
+	const eventState = stateForEvent(event);
+	const activityEvent = toolActivityForEvent(event);
+	if (!stateFile || (!eventState && !activityEvent)) return;
 	context = contextWithManagedOwnerGeneration(context);
 	const identity = normalizedIdentity(context);
 	await serializeStateFileWrite(
@@ -799,6 +903,7 @@ export async function persistCoordinatorRuntimeStateFromEvent(
 						const now = new Date(nowMs).toISOString();
 						const previous = await readPreviousPayloadForEvent(stateFile);
 						assertPreviousRuntimeStateIdentity(previous, identity);
+						const state = eventState ?? runtimeStateFromPrevious(previous.state);
 						const payload = {
 							...basePayload({
 								context,
@@ -815,6 +920,7 @@ export async function persistCoordinatorRuntimeStateFromEvent(
 							...(state === "errored"
 								? { error: { code: "agent_error", message: "GJC agent reported an error", recoverable: true } }
 								: {}),
+							...(activityEvent ? activityFieldsForEvent(previous, activityEvent, now, nowMs) : {}),
 						};
 						if (shouldSkipRuntimeStateWrite(previous, payload, nowMs)) return;
 						await writeStateFile(stateFile, payload);