@sayknow-cli/coding-agent 0.4.6 → 0.5.0

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

@@ -483,20 +483,23 @@ export function assertDeepInterviewEnvelopeInputLimits(envelope: Record<string,
 		typeof envelope.state === "object" && envelope.state !== null && !Array.isArray(envelope.state)
 			? (envelope.state as Record<string, unknown>)
 			: {};
+	// `null` is legal everywhere prose is optional: the skill template seeds
+	// `initial_context_summary: null` and the merge treats `null` as a deletion
+	// marker, so only present non-null values are bounded.
 	for (const field of ["initial_idea", "initial_context", "initial_context_summary"] as const) {
 		const nestedValue = state[field];
-		if (nestedValue !== undefined)
+		if (nestedValue !== undefined && nestedValue !== null)
 			assertDeepInterviewInputWithinLimit(nestedValue as string, MAX_INITIAL_CONTEXT_LENGTH, `state.${field}`);
 		const topLevelValue = envelope[field];
-		if (topLevelValue !== undefined)
+		if (topLevelValue !== undefined && topLevelValue !== null)
 			assertDeepInterviewInputWithinLimit(topLevelValue as string, MAX_INITIAL_CONTEXT_LENGTH, field);
 	}
 	for (const field of ["user_response", "answer"] as const) {
 		const nestedValue = state[field];
-		if (nestedValue !== undefined)
+		if (nestedValue !== undefined && nestedValue !== null)
 			assertDeepInterviewInputWithinLimit(nestedValue as string, MAX_USER_RESPONSE_LENGTH, `state.${field}`);
 		const topLevelValue = envelope[field];
-		if (topLevelValue !== undefined)
+		if (topLevelValue !== undefined && topLevelValue !== null)
 			assertDeepInterviewInputWithinLimit(topLevelValue as string, MAX_USER_RESPONSE_LENGTH, field);
 	}
 	if (!Array.isArray(state.rounds)) return;
@@ -507,7 +510,7 @@ export function assertDeepInterviewEnvelopeInputLimits(envelope: Record<string,
 			const value = record[field];
 			// A structured scorer may use an unrelated object-valued `answer`; only prose
 			// values in a legacy answer slot are user input subject to this cap.
-			if (value === undefined || (field === "answer" && typeof value !== "string")) continue;
+			if (value === undefined || value === null || (field === "answer" && typeof value !== "string")) continue;
 			assertDeepInterviewInputWithinLimit(
 				value as string,
 				MAX_USER_RESPONSE_LENGTH,

package/src/skc-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/skc-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/skc-runtime/linux-proc.ts

@@ -1,26 +1,30 @@
 /**
- * Shared helpers for reading Linux `/proc/<pid>/stat` process start time.
+ * Shared helpers for reading Linux `/proc/<pid>/stat` process identity fields.
  *
  * The `comm` field (field 2, wrapped in parentheses) may itself contain spaces
  * and parentheses, so the only robust anchor is the *last* `)` in the stat
  * string. Field 22 (the process start time in clock ticks since boot) is the
- * 20th whitespace-separated token after that closing paren (index 19).
- *
- * Every caller previously parsed this format independently, with subtly
- * different failure handling. This module fails closed: any malformed input
- * (missing `)`, non-numeric field 22, unreadable `/proc` file, non-Linux
- * platform) yields `null` rather than an inconsistent sentinel.
+ * 20th whitespace-separated token after that closing paren (index 19). Field 7
+ * (`tty_nr`) is the 5th token after the closing paren (index 4).
  */
 
 import * as nodeFsSync from "node:fs";
 import * as nodeFs from "node:fs/promises";
 
-/**
- * Parse field 22 (process start time, in clock ticks since boot) from one
- * `/proc/<pid>/stat` record. Returns the raw numeric token, or `null` when the
- * record shape is malformed or field 22 is absent/non-numeric.
- */
-export function parseLinuxProcStartTime(stat: string | null | undefined): string | null {
+export interface LinuxProcStatIdentity {
+	startTime: string;
+	ttyDevice: string;
+}
+
+export type LinuxProcPidProbeResult =
+	| ({ kind: "live" } & LinuxProcStatIdentity)
+	| { kind: "absent" }
+	| {
+			kind: "unverifiable";
+			reason: "unsupported_platform" | "invalid_pid" | "permission_denied" | "read_error" | "malformed_stat";
+	  };
+
+function parseLinuxProcIdentity(stat: string | null | undefined): LinuxProcStatIdentity | null {
 	if (!stat || stat.includes("\0") || stat.includes("\r")) return null;
 	const record = stat.endsWith("\n") ? stat.slice(0, -1) : stat;
 	if (!record || record.includes("\n")) return null;
@@ -32,40 +36,70 @@ export function parseLinuxProcStartTime(stat: string | null | undefined): string
 	const suffix = record.slice(close + 1);
 	if (!/^[ \t]+/.test(suffix)) return null;
 	const fields = suffix.trim().split(/[ \t]+/);
-	if (fields.length < 20 || !/^[RSDTtXZPI]$/.test(fields[0])) return null;
-
+	if (fields.length < 20 || !/^[A-Za-z]$/.test(fields[0])) return null;
+	const ttyDevice = fields[4];
 	const startTime = fields[19];
-	return /^\d+$/.test(startTime) ? startTime : null;
+	if (!ttyDevice || !/^-?\d+$/.test(ttyDevice) || !/^\d+$/.test(startTime)) return null;
+	return { startTime, ttyDevice };
 }
 
-/**
- * Read `/proc/<pid>/stat` synchronously and return the parsed start time.
- * Returns `null` on non-Linux platforms, unreadable files, or malformed input.
- */
-export function readLinuxProcStartTimeSync(pid: number): string | null {
-	if (process.platform !== "linux") return null;
-	if (!Number.isSafeInteger(pid) || pid <= 0) return null;
+function classifyProcReadError(error: unknown): Extract<LinuxProcPidProbeResult, { kind: "absent" | "unverifiable" }> {
+	const code = (error as NodeJS.ErrnoException | undefined)?.code;
+	if (code === "ENOENT" || code === "ESRCH") return { kind: "absent" };
+	if (code === "EACCES" || code === "EPERM") return { kind: "unverifiable", reason: "permission_denied" };
+	return { kind: "unverifiable", reason: "read_error" };
+}
+
+/** Parse field 22 (start time) from a `/proc/<pid>/stat` record. */
+export function parseLinuxProcStartTime(stat: string | null | undefined): string | null {
+	return parseLinuxProcIdentity(stat)?.startTime ?? null;
+}
+
+/** Parse field 7 (`tty_nr`) from a `/proc/<pid>/stat` record. */
+export function parseLinuxProcTtyDevice(stat: string | null | undefined): string | null {
+	return parseLinuxProcIdentity(stat)?.ttyDevice ?? null;
+}
+
+export function probeLinuxProcPidSync(pid: number): LinuxProcPidProbeResult {
+	if (!Number.isSafeInteger(pid) || pid <= 0) return { kind: "unverifiable", reason: "invalid_pid" };
+	if (process.platform !== "linux") return { kind: "unverifiable", reason: "unsupported_platform" };
 	let stat: string;
 	try {
 		stat = nodeFsSync.readFileSync(`/proc/${pid}/stat`, "utf8");
-	} catch {
-		return null;
+	} catch (error) {
+		return classifyProcReadError(error);
 	}
-	return parseLinuxProcStartTime(stat);
+	const identity = parseLinuxProcIdentity(stat);
+	return identity ? { kind: "live", ...identity } : { kind: "unverifiable", reason: "malformed_stat" };
 }
 
-/**
- * Read `/proc/<pid>/stat` asynchronously and return the parsed start time.
- * Returns `null` on non-Linux platforms, unreadable files, or malformed input.
- */
-export async function readLinuxProcStartTime(pid: number): Promise<string | null> {
-	if (process.platform !== "linux") return null;
-	if (!Number.isSafeInteger(pid) || pid <= 0) return null;
+export async function probeLinuxProcPid(pid: number): Promise<LinuxProcPidProbeResult> {
+	if (!Number.isSafeInteger(pid) || pid <= 0) return { kind: "unverifiable", reason: "invalid_pid" };
+	if (process.platform !== "linux") return { kind: "unverifiable", reason: "unsupported_platform" };
 	let stat: string;
 	try {
 		stat = await nodeFs.readFile(`/proc/${pid}/stat`, "utf8");
-	} catch {
-		return null;
+	} catch (error) {
+		return classifyProcReadError(error);
 	}
-	return parseLinuxProcStartTime(stat);
+	const identity = parseLinuxProcIdentity(stat);
+	return identity ? { kind: "live", ...identity } : { kind: "unverifiable", reason: "malformed_stat" };
+}
+
+/**
+ * Read `/proc/<pid>/stat` synchronously and return the parsed start time.
+ * Returns `null` when the probe is absent or unverifiable.
+ */
+export function readLinuxProcStartTimeSync(pid: number): string | null {
+	const probe = probeLinuxProcPidSync(pid);
+	return probe.kind === "live" ? probe.startTime : null;
+}
+
+/**
+ * Read `/proc/<pid>/stat` asynchronously and return the parsed start time.
+ * Returns `null` when the probe is absent or unverifiable.
+ */
+export async function readLinuxProcStartTime(pid: number): Promise<string | null> {
+	const probe = await probeLinuxProcPid(pid);
+	return probe.kind === "live" ? probe.startTime : null;
 }

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

@@ -1,9 +1,11 @@
 import * as crypto from "node:crypto";
+import * as fsSync from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import { Process } from "@sayknow-cli/natives";
 import { readLinuxProcStartTime } from "./linux-proc";
 import { assertSafePathComponent } from "./session-layout";
-import { lifecyclePaths } from "./tmux-owner-isolation";
+import { lifecyclePaths, type OwnerIntent, observeOwnerTerminal } from "./tmux-owner-isolation";
 
 export const MANAGED_OWNER_SUPERVISOR_ARG = "--internal-managed-owner-supervisor";
 export const MANAGED_OWNER_CHILD_TOKEN_ENV = "SKC_MANAGED_OWNER_CHILD_TOKEN";
@@ -14,6 +16,15 @@ export const MANAGED_OWNER_STATE_DIR_ENV = "SKC_TMUX_OWNER_STATE_DIR";
 export const MANAGED_OWNER_RUN_ID_ENV = "SKC_MANAGED_OWNER_RUN_ID";
 export const MANAGED_OWNER_INCARNATION_ENV = "SKC_MANAGED_OWNER_INCARNATION";
 
+let bootstrapSigtermPending = false;
+const captureBootstrapSigterm = () => {
+	bootstrapSigtermPending = true;
+};
+if (process.argv.includes(MANAGED_OWNER_SUPERVISOR_ARG)) {
+	process.removeAllListeners("SIGTERM");
+	process.on("SIGTERM", captureBootstrapSigterm);
+}
+
 export interface ManagedOwnerBinding {
 	schema_version: 2;
 	generation: string;
@@ -52,7 +63,14 @@ function requiredEnvironment(name: string): string {
 	return value;
 }
 
-function lifecycleRoot(): { root: string; generation: string; sessionId: string; runId: string; incarnation: string } {
+function lifecycleRoot(): {
+	root: string;
+	stateDir: string;
+	generation: string;
+	sessionId: string;
+	runId: string;
+	incarnation: string;
+} {
 	const stateDir = requiredEnvironment(MANAGED_OWNER_STATE_DIR_ENV);
 	const sessionId = requiredEnvironment(MANAGED_OWNER_SESSION_ID_ENV);
 	const generation = requiredEnvironment(MANAGED_OWNER_GENERATION_ENV);
@@ -68,7 +86,7 @@ function lifecycleRoot(): { root: string; generation: string; sessionId: string;
 	if (!path.isAbsolute(stateDir)) throw new Error("managed_owner_lifecycle_path_unsafe");
 	const root = lifecyclePaths(stateDir, sessionId, generation).root;
 	if (!root.startsWith(`${path.resolve(stateDir)}${path.sep}`)) throw new Error("managed_owner_lifecycle_path_unsafe");
-	return { root, generation, sessionId, runId, incarnation };
+	return { root, stateDir, generation, sessionId, runId, incarnation };
 }
 
 function commandDigest(command: readonly string[]): string {
@@ -106,8 +124,14 @@ export function isManagedOwnerSupervisorArgv(args: readonly string[]): boolean {
 
 /** Runs one exact child and publishes authority only for a directly observed Linux signal 6. */
 export async function runManagedOwnerSupervisor(): Promise<void> {
-	const { root, generation, sessionId, runId, incarnation } = lifecycleRoot();
+	const { root, stateDir, generation, sessionId, runId, incarnation } = lifecycleRoot();
 	const command = childCommand();
+	let sigtermPending = bootstrapSigtermPending;
+	const captureEarlySigterm = () => {
+		sigtermPending = true;
+	};
+	process.removeAllListeners("SIGTERM");
+	process.on("SIGTERM", captureEarlySigterm);
 	const supervisorStartTime = await readLinuxProcStartTime(process.pid);
 	if (!supervisorStartTime) throw new Error("managed_owner_supervisor_start_time_unavailable");
 	await fs.mkdir(root, { recursive: true, mode: 0o700 });
@@ -135,7 +159,62 @@ export async function runManagedOwnerSupervisor(): Promise<void> {
 	});
 	const childStartTime = await readLinuxProcStartTime(child.pid);
 	if (!childStartTime) throw new Error("managed_owner_child_start_time_unavailable");
+	const childProcess = Process.fromPid(child.pid);
+	if (!childProcess) throw new Error("managed_owner_child_reference_unavailable");
+	if (process.platform === "linux" && childProcess.incarnation !== `linux:${childStartTime}`)
+		throw new Error("managed_owner_child_incarnation_mismatch");
+	let childExited = false;
+	let sigtermRelayed = false;
+	let relayedIntent: OwnerIntent | null = null;
+	let relayedAt: string | null = null;
+	const relaySigterm = () => {
+		if (childExited || sigtermRelayed) return;
+		let candidateIntent: OwnerIntent | null = null;
+		try {
+			const candidate = JSON.parse(
+				fsSync.readFileSync(lifecyclePaths(stateDir, sessionId, generation).intentFile, "utf8"),
+			) as Partial<OwnerIntent>;
+			candidateIntent = typeof candidate.dispatch_id === "string" ? (candidate as OwnerIntent) : null;
+		} catch {
+			candidateIntent = null;
+		}
+		try {
+			if (!childProcess.signalRoot(15)) return;
+		} catch {
+			// The child exited between intent capture and delivery.
+			return;
+		}
+		sigtermRelayed = true;
+		relayedAt = new Date().toISOString();
+		relayedIntent = candidateIntent;
+	};
+	sigtermPending ||= bootstrapSigtermPending;
+	process.removeListener("SIGTERM", captureBootstrapSigterm);
+	process.removeListener("SIGTERM", captureEarlySigterm);
+	process.on("SIGTERM", relaySigterm);
+	if (sigtermPending) relaySigterm();
 	const exitCode = await child.exited;
+	childExited = true;
+	process.removeListener("SIGTERM", relaySigterm);
+	const terminalIntent = relayedIntent as OwnerIntent | null;
+	const terminalObservedAt = relayedAt as string | null;
+	if (sigtermRelayed && terminalObservedAt && terminalIntent) {
+		await observeOwnerTerminal({
+			schema_version: 1,
+			op: "observe_terminal",
+			session_id: sessionId,
+			owner_generation: generation,
+			state_dir: stateDir,
+			socket_key: process.env.SKC_TMUX_OWNER_SERVER_KEY ?? "",
+			observer: "raw_monitor",
+			observed_at: terminalObservedAt,
+			signal: "SIGTERM",
+			exit_code: exitCode,
+			exit_kind: "supervisor_child_exit",
+			reason: "managed_owner_supervisor_exit",
+			operator_dispatch_id: terminalIntent.dispatch_id,
+		});
+	}
 	if (child.signalCode === "SIGABRT") {
 		const receipt: ManagedOwnerSigabrtReceipt = {
 			schema_version: 2,