feat(coding-agent): persist subagent lifecycle state

packages/coding-agent/src/core/sdk.ts

@@ -23,9 +23,10 @@ import { ModelRuntime } from "./model-runtime.ts";
 import { mergeProviderAttributionHeaders } from "./provider-attribution.ts";
 import type { ResourceLoader } from "./resource-loader.ts";
 import { DefaultResourceLoader } from "./resource-loader.ts";
-import { getDefaultSessionDir, SessionManager } from "./session-manager.ts";
+import { getDefaultSessionDir, persistSessionState, SessionManager } from "./session-manager.ts";
 import { SettingsManager } from "./settings-manager.ts";
 import { SubagentController } from "./subagents/controller.ts";
+import { encodeSubagentRosterSnapshot, SUBAGENT_ROSTER_CUSTOM_TYPE } from "./subagents/persistence.ts";
 import { captureSubagentSessionConfig, createSubagentSession } from "./subagents/services.ts";
 import { RootLocalEphemeralSubagentSessionManagerFactory } from "./subagents/session-manager-factory.ts";
 import { time } from "./timings.ts";
@@ -198,21 +199,56 @@ function createRootSubagentController(
 	maxConcurrent: number,
 	agentDir: string,
 	telemetryContext: TelemetryContext,
+	parentSessionManager: SessionManager,
 ): SubagentController {
 	const sessionManagerFactory = new RootLocalEphemeralSubagentSessionManagerFactory();
 	return new SubagentController({
 		maxConcurrent,
 		telemetryContext,
 		captureSession: (parent, childName, origin) => {
 			const config = captureSubagentSessionConfig(parent, agentDir);
-			return (signal) =>
-				createSubagentSession(config, {
-					signal,
+			const sessionManager = sessionManagerFactory.create(
+				Object.freeze({
 					childName,
+					sourceSessionManager: config.sourceSessionManager,
+					cwd: config.cwd,
+					parentSessionId: config.parentSession,
 					origin,
-					sessionManagerFactory,
-				});
+				}),
+			);
+			return Object.freeze({
+				sessionManager,
+				config: Object.freeze({
+					model: Object.freeze({ provider: config.model.provider, id: config.model.id }),
+					thinkingLevel: config.thinkingLevel,
+					tools: config.tools,
+					harnessRevision: config.harnessVersionBundle?.manifest.version ?? null,
+				}),
+				createSession: (signal: AbortSignal) =>
+					createSubagentSession(config, {
+						signal,
+						childName,
+						origin,
+						sessionManager,
+					}),
+			});
 		},
+		persistRoster: parentSessionManager.isPersisted()
+			? (agents, admission) => {
+					const previousLeafId = parentSessionManager.getLeafId();
+					try {
+						parentSessionManager.appendCustomEntry(
+							SUBAGENT_ROSTER_CUSTOM_TYPE,
+							encodeSubagentRosterSnapshot(agents),
+						);
+						if (admission) persistSessionState(parentSessionManager);
+					} catch (error) {
+						if (previousLeafId === null) parentSessionManager.resetLeaf();
+						else parentSessionManager.branch(previousLeafId);
+						throw error;
+					}
+				}
+			: undefined,
 	});
 }
 
@@ -260,11 +296,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const subagentOptions = normalizeSubagentOptions(options.subagents);
 	const telemetryContext = options.telemetryContext ?? NOOP_TELEMETRY_CONTEXT;
 	assertNoReservedSubagentTools(options.customTools);
-	const subagentController =
-		subagentOptions === false
-			? undefined
-			: createRootSubagentController(subagentOptions.maxConcurrent, agentDir, telemetryContext);
-	const customTools = [...(options.customTools ?? []), ...(subagentController?.createToolDefinitions() ?? [])];
 	let resourceLoader = options.resourceLoader;
 
 	const authPath = options.agentDir ? join(agentDir, "auth.json") : undefined;
@@ -273,6 +304,11 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 	const settingsManager = options.settingsManager ?? SettingsManager.create(cwd, agentDir);
 	const sessionManager = options.sessionManager ?? SessionManager.create(cwd, getDefaultSessionDir(cwd, agentDir));
+	const subagentController =
+		subagentOptions === false
+			? undefined
+			: createRootSubagentController(subagentOptions.maxConcurrent, agentDir, telemetryContext, sessionManager);
+	const customTools = [...(options.customTools ?? []), ...(subagentController?.createToolDefinitions() ?? [])];
 
 	if (!resourceLoader) {
 		resourceLoader = new DefaultResourceLoader({ cwd, agentDir, settingsManager });

packages/coding-agent/src/core/session-manager.ts

@@ -229,6 +229,7 @@ function createSessionId(): string {
 }
 
 const PERSIST_SESSION_HEADER = Symbol("persistSessionHeader");
+const PERSIST_SESSION_STATE = Symbol("persistSessionState");
 
 export function assertValidSessionId(id: string): void {
 	if (!/^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/.test(id)) {
@@ -1056,6 +1057,34 @@ export class SessionManager {
 		this.flushed = true;
 	}
 
+	/** Flush the complete admitted session state before accepting dependent work. */
+	[PERSIST_SESSION_STATE](): void {
+		if (!this.persist || !this.sessionFile) {
+			throw new Error("Cannot persist an in-memory session");
+		}
+
+		if (!this.flushed) {
+			const fd = openSync(this.sessionFile, "wx");
+			try {
+				for (const entry of this.fileEntries) {
+					writeFileSync(fd, `${JSON.stringify(entry)}\n`);
+				}
+				fsyncSync(fd);
+			} finally {
+				closeSync(fd);
+			}
+			this.flushed = true;
+			return;
+		}
+
+		const fd = openSync(this.sessionFile, "r+");
+		try {
+			fsyncSync(fd);
+		} finally {
+			closeSync(fd);
+		}
+	}
+
 	_persist(entry: SessionEntry): void {
 		if (!this.persist || !this.sessionFile) return;
 
@@ -1814,3 +1843,8 @@ export class SessionManager {
 export function persistSessionHeader(sessionManager: SessionManager): void {
 	sessionManager[PERSIST_SESSION_HEADER]();
 }
+
+/** Internal seam for durably admitting state that normal creation may still buffer. */
+export function persistSessionState(sessionManager: SessionManager): void {
+	sessionManager[PERSIST_SESSION_STATE]();
+}