@namzu/sdk 43.0.0 → 44.0.0

package/src/agents/ReactiveAgent.ts

@@ -6,7 +6,7 @@ import type {
 	ReactiveAgentResult,
 } from '../types/agent/index.js'
 import type { AssistantMessage } from '../types/message/index.js'
-import type { RunEventListener } from '../types/run/index.js'
+import type { SessionEventListener } from '../types/session/events.js'
 import type { Logger } from '../utils/logger.js'
 import { AbstractAgent } from './AbstractAgent.js'
 
@@ -30,18 +30,18 @@ export class ReactiveAgent extends AbstractAgent<ReactiveAgentConfig, ReactiveAg
 	}
 
 	/**
-	 * One run at a time per instance.
+	 * One turn at a time per instance.
 	 *
-	 * `abortController` and `currentRunId` are instance state, so two
-	 * overlapping runs share one abort controller — cancelling either kills
-	 * both — and the second clobbers the first's run id, so a later
-	 * `cancel()` cancels the wrong run. Neither failure announces itself.
+	 * `abortController` and `currentSessionId` are instance state, so two
+	 * overlapping turns share one abort controller — cancelling either kills
+	 * both — and the second clobbers the first's session, so a later
+	 * `cancel()` cancels the wrong children. Neither failure announces itself.
 	 * A host that wants parallelism constructs a second instance.
 	 */
 	async run(
 		input: AgentInput,
 		config: ReactiveAgentConfig,
-		listener?: RunEventListener,
+		listener?: SessionEventListener,
 	): Promise<ReactiveAgentResult> {
 		return await this.underIdempotencyKey(config.idempotencyKey, () =>
 			this.underInvocationLock(() => this.runExclusive(input, config, listener)),
@@ -51,19 +51,18 @@ export class ReactiveAgent extends AbstractAgent<ReactiveAgentConfig, ReactiveAg
 	private async runExclusive(
 		input: AgentInput,
 		config: ReactiveAgentConfig,
-		listener?: RunEventListener,
+		listener?: SessionEventListener,
 	): Promise<ReactiveAgentResult> {
 		const startTime = Date.now()
-		const runId = this.createRunId()
-		this.bindRun(runId, config.logger)
-
 		if (!config.sessionId || !config.topicId || !config.projectId || !config.tenantId) {
 			throw new Error(
 				'ReactiveAgent requires sessionId, topicId, projectId, and tenantId in config (session-hierarchy.md §12.1).',
 			)
 		}
+		const turnId = this.createTurnId()
+		this.bindTurn(config.sessionId, turnId, config.logger)
 
-		const run = await drainQuery(
+		const turn = await drainQuery(
 			{
 				systemPrompt: config.systemPrompt,
 				persona: config.persona,
@@ -81,6 +80,8 @@ export class ReactiveAgent extends AbstractAgent<ReactiveAgentConfig, ReactiveAg
 				...(config.sandboxTeardownTimeoutMs !== undefined
 					? { sandboxTeardownTimeoutMs: config.sandboxTeardownTimeoutMs }
 					: {}),
+				...(config.outsideRootAccess ? { outsideRootAccess: config.outsideRootAccess } : {}),
+				...(config.sandboxEscape ? { sandboxEscape: config.sandboxEscape } : {}),
 				// Working-memory / compaction seam (optional; absent => unchanged run path).
 				...(config.compactionConfig ? { compactionConfig: config.compactionConfig } : {}),
 				...(config.workingMemoryProvider
@@ -94,7 +95,6 @@ export class ReactiveAgent extends AbstractAgent<ReactiveAgentConfig, ReactiveAg
 				// feature that does not exist for them.
 				...(config.resumeHandler ? { resumeHandler: config.resumeHandler } : {}),
 				...(config.retry !== undefined ? { retry: config.retry } : {}),
-				...(config.emergencySave !== undefined ? { emergencySave: config.emergencySave } : {}),
 				...(config.toolTimeoutMs !== undefined ? { toolTimeoutMs: config.toolTimeoutMs } : {}),
 				...(config.toolRetryBackoff !== undefined
 					? { toolRetryBackoff: config.toolRetryBackoff }
@@ -130,9 +130,12 @@ export class ReactiveAgent extends AbstractAgent<ReactiveAgentConfig, ReactiveAg
 				...(config.inputGuardrails ? { inputGuardrails: config.inputGuardrails } : {}),
 				...(config.outputGuardrails ? { outputGuardrails: config.outputGuardrails } : {}),
 				...(config.checkpointStore ? { checkpointStore: config.checkpointStore } : {}),
-				...(config.pathBuilder ? { pathBuilder: config.pathBuilder } : {}),
+				...(config.paths ? { paths: config.paths } : {}),
+				// Forwarded so a session log in memory keeps the whole session
+				// there; dropped here, the turn would build a disk log instead.
+				...(config.sessionLog ? { sessionLog: config.sessionLog } : {}),
 				...(config.parentSpan ? { parentSpan: config.parentSpan } : {}),
-				runConfig: {
+				turnConfig: {
 					model: config.model,
 					...(config.webSearch ? { webSearch: config.webSearch } : {}),
 					tokenBudget: config.tokenBudget,
@@ -147,6 +150,7 @@ export class ReactiveAgent extends AbstractAgent<ReactiveAgentConfig, ReactiveAg
 					maxIterations: config.maxIterations,
 					temperature: config.temperature,
 					maxResponseTokens: config.maxResponseTokens,
+					...(config.pruneKeepLast !== undefined ? { pruneKeepLast: config.pruneKeepLast } : {}),
 					costLimitUsd: config.costLimitUsd,
 					permissionMode: config.permissionMode,
 					env: config.env,
@@ -164,8 +168,9 @@ export class ReactiveAgent extends AbstractAgent<ReactiveAgentConfig, ReactiveAg
 				topicId: config.topicId,
 				projectId: config.projectId,
 				tenantId: config.tenantId,
-				runId,
-				parentRunId: config.parentRunId,
+				turnId,
+				...(config.parentSessionId ? { parentSessionId: config.parentSessionId } : {}),
+				...(config.parentTurnId ? { parentTurnId: config.parentTurnId } : {}),
 				depth: config.depth,
 				contextLevel: config.contextLevel,
 				messages: input.messages,
@@ -180,7 +185,7 @@ export class ReactiveAgent extends AbstractAgent<ReactiveAgentConfig, ReactiveAg
 		)
 
 		let toolCallCount = 0
-		for (const msg of run.messages) {
+		for (const msg of turn.messages) {
 			if (msg.role === 'assistant') {
 				const assistantMsg = msg as AssistantMessage
 				if (assistantMsg.toolCalls) {
@@ -190,18 +195,19 @@ export class ReactiveAgent extends AbstractAgent<ReactiveAgentConfig, ReactiveAg
 		}
 
 		return {
-			runId: run.id,
-			status: run.status,
-			stopReason: run.stopReason,
-			usage: run.tokenUsage,
-			...(run.budget ? { budget: run.budget } : {}),
-			cost: run.costInfo,
-			iterations: run.currentIteration,
+			sessionId: turn.sessionId,
+			turnId: turn.id,
+			status: turn.status,
+			stopReason: turn.stopReason,
+			usage: turn.tokenUsage,
+			...(turn.budget ? { budget: turn.budget } : {}),
+			cost: turn.costInfo,
+			iterations: turn.currentIteration,
 			durationMs: Date.now() - startTime,
-			messages: run.messages,
-			result: run.result,
-			structuredOutput: run.structuredOutput,
-			lastError: run.lastError,
+			messages: turn.messages,
+			result: turn.result,
+			structuredOutput: turn.structuredOutput,
+			lastError: turn.lastError,
 			toolCallCount,
 		}
 	}

package/src/agents/RouterAgent.ts

@@ -15,7 +15,7 @@ import { type TokenUsage, accumulateTokenUsage } from '../types/common/index.js'
 import type { FallbackStrategy } from '../types/decision/index.js'
 import { deriveChildState } from '../types/invocation/index.js'
 import { createSystemMessage, createUserMessage } from '../types/message/index.js'
-import type { RunEventListener } from '../types/run/index.js'
+import type { SessionEventListener } from '../types/session/events.js'
 import { ZERO_COST } from '../utils/cost.js'
 import type { Logger } from '../utils/logger.js'
 import { AbstractAgent } from './AbstractAgent.js'
@@ -41,18 +41,18 @@ export class RouterAgent extends AbstractAgent<RouterAgentConfig, RouterAgentRes
 	}
 
 	/**
-	 * One run at a time per instance.
+	 * One turn at a time per instance.
 	 *
-	 * `abortController` and `currentRunId` are instance state, so two
-	 * overlapping runs share one abort controller — cancelling either kills
-	 * both — and the second clobbers the first's run id, so a later
-	 * `cancel()` cancels the wrong run. Neither failure announces itself.
+	 * `abortController` and `currentSessionId` are instance state, so two
+	 * overlapping turns share one abort controller — cancelling either kills
+	 * both — and the second clobbers the first's session, so a later
+	 * `cancel()` cancels the wrong children. Neither failure announces itself.
 	 * A host that wants parallelism constructs a second instance.
 	 */
 	async run(
 		input: AgentInput,
 		config: RouterAgentConfig,
-		listener?: RunEventListener,
+		listener?: SessionEventListener,
 	): Promise<RouterAgentResult> {
 		return await this.underIdempotencyKey(config.idempotencyKey, () =>
 			this.underInvocationLock(() => this.runExclusive(input, config, listener)),
@@ -62,22 +62,25 @@ export class RouterAgent extends AbstractAgent<RouterAgentConfig, RouterAgentRes
 	private async runExclusive(
 		input: AgentInput,
 		config: RouterAgentConfig,
-		listener?: RunEventListener,
+		listener?: SessionEventListener,
 	): Promise<RouterAgentResult> {
-		// Resolve before a run id/event exists, matching query(): malformed
-		// liveness policy is a caller config error, not a failed model run.
+		// Resolve before a turn id/event exists, matching query(): malformed
+		// liveness policy is a caller config error, not a failed model turn.
 		const streamIdleTimeoutMs = resolveStreamIdleTimeoutMs(config.streamIdleTimeoutMs)
 		const signal = input.signal
 			? AbortSignal.any([input.signal, this.abortController.signal])
 			: this.abortController.signal
 		const startTime = Date.now()
-		const runId = this.createRunId()
-		this.bindRun(runId, config.logger)
-		const budget = await resolveAgentBudget(input, config, runId)
+		const sessionId = this.resolveSessionId(config.sessionId)
+		const turnId = this.createTurnId()
+		this.bindTurn(sessionId, turnId, config.logger)
+		const budget = await resolveAgentBudget(input, config, { sessionId, turnId })
 		const budgetConfig = { ...config, budget }
+		// No lifecycle events of its own. A `turn_*` event names a turn in a
+		// session log, and routing writes none: the delegate below runs the
+		// session's turn and emits its lifecycle, and the listener receives
+		// exactly that turn rather than a synthetic one wrapped around it.
 		try {
-			await this.emitEvent({ type: 'run_started', runId }, listener)
-
 			const decision = await this.route(input, budgetConfig, streamIdleTimeoutMs, signal)
 
 			let targetRoute = config.routes.find((r) => r.agentId === decision.agentId)
@@ -90,18 +93,9 @@ export class RouterAgent extends AbstractAgent<RouterAgentConfig, RouterAgentRes
 				if (!fallback) {
 					const errorMsg = `No route found for "${decision.agentId}"`
 
-					await this.emitEvent(
-						{
-							type: 'run_failed',
-							runId,
-							error: errorMsg,
-							budget: budget.summary(),
-						},
-						listener,
-					)
-
 					return {
-						runId,
+						sessionId,
+						turnId,
 						status: 'failed',
 						stopReason: 'error',
 						usage: budget.ownUsage,
@@ -114,7 +108,8 @@ export class RouterAgent extends AbstractAgent<RouterAgentConfig, RouterAgentRes
 						selectedRoute: decision.agentId,
 						routingDecision: decision,
 						delegateResult: {
-							runId,
+							sessionId,
+							turnId,
 							status: 'failed',
 							usage: { ...EMPTY_TOKEN_USAGE },
 							cost: { ...ZERO_COST },
@@ -148,13 +143,15 @@ export class RouterAgent extends AbstractAgent<RouterAgentConfig, RouterAgentRes
 						...config,
 						budget: childBudget,
 						tokenBudget: allocation,
-						parentRunId: runId,
+						// The same session: the delegate runs this session's turn,
+						// it is not a child session of it.
+						sessionId,
 						depth: (config.depth ?? 0) + 1,
 						invocationState: childInvocationState,
 					},
 					listener,
 				)
-				childBudget.bindRun(delegateResult.runId)
+				childBudget.bindTurn(delegateResult.sessionId, delegateResult.turnId)
 				childBudget.settle(delegateResult.usage.totalTokens)
 			} finally {
 				// A thrown custom delegate supplies no final usage receipt.
@@ -162,18 +159,9 @@ export class RouterAgent extends AbstractAgent<RouterAgentConfig, RouterAgentRes
 				await childBudget.flush()
 			}
 
-			await this.emitEvent(
-				{
-					type: 'run_completed',
-					budget: budget.summary(),
-					runId,
-					result: delegateResult.result ?? '',
-				},
-				listener,
-			)
-
 			return {
-				runId,
+				sessionId,
+				turnId: delegateResult.turnId,
 				status: delegateResult.status,
 				stopReason: delegateResult.stopReason,
 				usage: budget.ownUsage,
@@ -200,11 +188,11 @@ export class RouterAgent extends AbstractAgent<RouterAgentConfig, RouterAgentRes
 		streamIdleTimeoutMs: number,
 		signal: AbortSignal,
 	): Promise<RoutingDecision> {
-		// `this.log`, not a fresh `getRootLogger()` child — bound by `bindRun` in
-		// `runExclusive` before this is called, so a routing warning below
-		// carries the SAME `namzu.run.id` as the run it is routing. The old
+		// `this.log`, not a fresh `getRootLogger()` child — bound by `bindTurn`
+		// in `runExclusive` before this is called, so a routing warning below
+		// carries the SAME `namzu.turn.id` as the turn it is routing. The old
 		// independent construction here is the exact bug LOG-10's acceptance
-		// criterion names: a route() log line with no run id at all.
+		// criterion names: a route() log line with no id at all.
 		const log = this.log
 
 		const validAgentIds = config.routes.map((r) => r.agentId)

package/src/agents/SupervisorAgent.ts

@@ -14,14 +14,15 @@ import type {
 } from '../types/agent/index.js'
 import type { TaskHandle, TaskScheduler } from '../types/agent/scheduler.js'
 import type { AgentTaskContext } from '../types/agent/task.js'
-import type { RunId } from '../types/ids/index.js'
+import type { SessionId, TurnId } from '../types/ids/index.js'
 import { deriveChildState } from '../types/invocation/index.js'
-import type { RunEventListener } from '../types/run/index.js'
 import type { ActorRef } from '../types/session/actor.js'
+import type { SessionEventListener } from '../types/session/events.js'
 import { ZERO_COST } from '../utils/cost.js'
 import type { Logger } from '../utils/logger.js'
 import { AbstractAgent } from './AbstractAgent.js'
 import { resolveAgentBudget } from './budget.js'
+import { childSessionStorage } from './storage.js'
 
 /**
  * Build the authoritative per-task ledger from the gateway's task handles.
@@ -35,19 +36,20 @@ import { resolveAgentBudget } from './budget.js'
  * The earlier implementation cast `handle.state` onto the synthesized result's
  * status, letting a worker that ended without a result count toward
  * `completedTasks`. That produced fabricated "done" workers with empty outputs
- * (observed in a live supervised run): the supervisor reported "3 workers done, 40KB
+ * (observed in a live supervised session): the supervisor reported "3 workers done, 40KB
  * reports" when the workers never started. Real workers (those with a present
  * `result`) are unaffected — their `result` is preserved verbatim.
  */
 export function synthesizeTaskResults(
 	taskHandles: readonly TaskHandle[],
-	runId: RunId,
+	turn: { readonly sessionId: SessionId; readonly turnId: TurnId },
 	now: number = Date.now(),
 ): AgentTaskResult[] {
 	return taskHandles.map((handle, index) => ({
 		agentId: handle.agentId,
 		result: handle.result ?? {
-			runId,
+			sessionId: turn.sessionId,
+			turnId: turn.turnId,
 			status: 'failed' as const,
 			usage: { ...EMPTY_TOKEN_USAGE },
 			cost: { ...ZERO_COST },
@@ -84,18 +86,18 @@ export class SupervisorAgent extends AbstractAgent<SupervisorAgentConfig, Superv
 	}
 
 	/**
-	 * One run at a time per instance.
+	 * One turn at a time per instance.
 	 *
-	 * `abortController` and `currentRunId` are instance state, so two
-	 * overlapping runs share one abort controller — cancelling either kills
-	 * both — and the second clobbers the first's run id, so a later
-	 * `cancel()` cancels the wrong run. Neither failure announces itself.
+	 * `abortController` and `currentSessionId` are instance state, so two
+	 * overlapping turns share one abort controller — cancelling either kills
+	 * both — and the second clobbers the first's session, so a later
+	 * `cancel()` cancels the wrong children. Neither failure announces itself.
 	 * A host that wants parallelism constructs a second instance.
 	 */
 	async run(
 		input: AgentInput,
 		config: SupervisorAgentConfig,
-		listener?: RunEventListener,
+		listener?: SessionEventListener,
 	): Promise<SupervisorAgentResult> {
 		return await this.underIdempotencyKey(config.idempotencyKey, () =>
 			this.underInvocationLock(() => this.runExclusive(input, config, listener)),
@@ -105,18 +107,17 @@ export class SupervisorAgent extends AbstractAgent<SupervisorAgentConfig, Superv
 	private async runExclusive(
 		input: AgentInput,
 		config: SupervisorAgentConfig,
-		listener?: RunEventListener,
+		listener?: SessionEventListener,
 	): Promise<SupervisorAgentResult> {
 		const startTime = Date.now()
-		const runId = this.createRunId()
-		this.bindRun(runId, config.logger)
-
 		if (!config.sessionId || !config.topicId || !config.projectId || !config.tenantId) {
 			throw new Error(
 				'SupervisorAgent requires sessionId, topicId, projectId, and tenantId in config (session-hierarchy.md §12.1).',
 			)
 		}
 		const sessionId = config.sessionId
+		const turnId = this.createTurnId()
+		this.bindTurn(sessionId, turnId, config.logger)
 		const topicId = config.topicId
 		const projectId = config.projectId
 		const tenantId = config.tenantId
@@ -135,12 +136,14 @@ export class SupervisorAgent extends AbstractAgent<SupervisorAgentConfig, Superv
 		const budget = await resolveAgentBudget(
 			input,
 			{ ...config, budget: config.budget ?? configuredScheduler?.budget },
-			runId,
+			{ sessionId, turnId },
 		)
 		if (configuredScheduler && configuredScheduler.budget !== budget) {
 			throw new Error('Injected task scheduler must share the supervisor token budget authority')
 		}
 
+		const childStorage = await childSessionStorage(config, input.workingDirectory)
+
 		let gateway: TaskScheduler
 		if (configuredScheduler) {
 			gateway = configuredScheduler
@@ -157,7 +160,8 @@ export class SupervisorAgent extends AbstractAgent<SupervisorAgentConfig, Superv
 					: undefined
 
 			const taskContext: AgentTaskContext = {
-				parentRunId: runId,
+				parentSessionId: sessionId,
+				parentTurnId: turnId,
 				parentAgentId: this.metadata.id,
 				parentAbortController: this.abortController,
 				// This context describes the CURRENT supervisor. AgentManager owns
@@ -166,12 +170,12 @@ export class SupervisorAgent extends AbstractAgent<SupervisorAgentConfig, Superv
 				depth: config.depth ?? 0,
 				budget,
 				factoryOptions: mergedFactoryOptions,
-				// The supervisor already hands this to its OWN run. Handing it to
+				// The supervisor already hands this to its OWN turn. Handing it to
 				// the spawn context makes a worker's REVIEW-tier calls reach the
 				// same person. It does not grant the root-only question tool.
 				// Without the handler, workers silently auto-approved themselves.
 				...(config.resumeHandler ? { resumeHandler: config.resumeHandler } : {}),
-				// Handed down for the same reason: a worker is a fresh run whose
+				// Handed down for the same reason: a worker is a fresh turn whose
 				// executor installs the shipped screens unless the spawn says
 				// otherwise, so the supervisor's own choice — including an
 				// empty list, which `config.toolResultGuardrails` distinguishes
@@ -184,6 +188,10 @@ export class SupervisorAgent extends AbstractAgent<SupervisorAgentConfig, Superv
 				sessionId,
 				projectId,
 				parentActor,
+				// A supervisor held in memory delegates to workers held in
+				// memory; without this each worker wrote a disk log under
+				// `NAMZU_HOME` its supervisor never asked for.
+				...(childStorage ? { childStorage } : {}),
 			}
 			// The only hop between the config and the gateway's policy. Omit it
 			// and the field is settable, documented, and read by nothing —
@@ -204,7 +212,7 @@ export class SupervisorAgent extends AbstractAgent<SupervisorAgentConfig, Superv
 		let planManagerRef: import('../manager/plan/lifecycle.js').PlanManager | undefined
 
 		// Created here because the TOOLS are created here: the durability
-		// channel has to reach the tool instance, and the run that supplies
+		// channel has to reach the tool instance, and the turn that supplies
 		// it does not exist yet. `query` binds them once it does.
 		const questionParks = new QuestionParkBinding()
 		const pendingAnswers = new PendingAnswers()
@@ -223,7 +231,7 @@ export class SupervisorAgent extends AbstractAgent<SupervisorAgentConfig, Superv
 		// From here to the return in a try/finally, so the listener is released
 		// on every way out. The registration loop below can throw
 		// ToolNameCollisionError, and a host that hits that fixes its config and
-		// runs again — which is how a leak of one listener per run becomes a leak
+		// runs again — which is how a leak of one listener per turn becomes a leak
 		// of one per ATTEMPT.
 		try {
 			const isRootAgent = (config.depth ?? 0) === 0
@@ -239,7 +247,8 @@ export class SupervisorAgent extends AbstractAgent<SupervisorAgentConfig, Superv
 				// has had to go and delete before.
 				allowDelegation: config.allowDelegation,
 				taskStore: input.taskStore,
-				runId,
+				sessionId,
+				turnId,
 				getPlanManager: () => planManagerRef,
 				// A human-question tool belongs only to the root agent. The handler
 				// itself still reaches `drainQuery` below: delegated REVIEW-tier
@@ -271,7 +280,7 @@ export class SupervisorAgent extends AbstractAgent<SupervisorAgentConfig, Superv
 			// tools — but the coordinator tools were registered before that and
 			// unconditionally, so `{ create_task: 'disabled' }` was honoured
 			// everywhere except the one surface a host would most want to decline.
-			// A run that must not delegate had prompt text and a gateway refusal as
+			// A turn that must not delegate had prompt text and a gateway refusal as
 			// its only defences.
 			//
 			// Collision REFUSES rather than overwrites, and the principle is
@@ -284,7 +293,7 @@ export class SupervisorAgent extends AbstractAgent<SupervisorAgentConfig, Superv
 			// decision made about the old binding stale.
 			//
 			// The counter-argument is that today the host's tool merely loses
-			// quietly and the run still works, so six reserved names is a real cost
+			// quietly and the turn still works, so six reserved names is a real cost
 			// on a name a consumer may have chosen long ago. It does not hold,
 			// because "loses quietly" is not what happens. `registerOne` ends with
 			// `availability.set(id, state)` and this call passes no state, so a tool
@@ -319,7 +328,7 @@ export class SupervisorAgent extends AbstractAgent<SupervisorAgentConfig, Superv
 				this.metadata.id,
 			)
 
-			const run = await drainQuery(
+			const turn = await drainQuery(
 				{
 					systemPrompt: config.systemPrompt,
 					skills: config.skills,
@@ -332,7 +341,7 @@ export class SupervisorAgent extends AbstractAgent<SupervisorAgentConfig, Superv
 					...(config.attachmentResolveTimeoutMs !== undefined
 						? { attachmentResolveTimeoutMs: config.attachmentResolveTimeoutMs }
 						: {}),
-					runConfig: {
+					turnConfig: {
 						model: config.model,
 						tokenBudget: config.tokenBudget,
 						timeoutMs: config.timeoutMs,
@@ -348,6 +357,7 @@ export class SupervisorAgent extends AbstractAgent<SupervisorAgentConfig, Superv
 						maxIterations: config.maxIterations,
 						temperature: config.temperature,
 						env: config.env,
+						...(config.pruneKeepLast !== undefined ? { pruneKeepLast: config.pruneKeepLast } : {}),
 						logger: this.log,
 						// See ReactiveAgent: a hand-listed literal drops what nobody
 						// remembered to add, and reports nothing when it does.
@@ -371,8 +381,9 @@ export class SupervisorAgent extends AbstractAgent<SupervisorAgentConfig, Superv
 					topicId,
 					projectId,
 					tenantId,
-					runId,
-					parentRunId: config.parentRunId,
+					turnId,
+					...(config.parentSessionId ? { parentSessionId: config.parentSessionId } : {}),
+					...(config.parentTurnId ? { parentTurnId: config.parentTurnId } : {}),
 					depth: config.depth,
 					contextLevel: 'full',
 					onContextCreated: ({ planManager }) => {
@@ -417,35 +428,38 @@ export class SupervisorAgent extends AbstractAgent<SupervisorAgentConfig, Superv
 					...(config.workingMemoryProvider
 						? { workingMemoryProvider: config.workingMemoryProvider }
 						: {}),
-					...(config.pathBuilder ? { pathBuilder: config.pathBuilder } : {}),
+					...(config.paths ? { paths: config.paths } : {}),
+					...(config.sessionLog ? { sessionLog: config.sessionLog } : {}),
+					...(config.checkpointStore ? { checkpointStore: config.checkpointStore } : {}),
 				},
 				listener,
 			)
 
 			const taskHandles = gateway.listTasks()
-			const taskResults = synthesizeTaskResults(taskHandles, runId)
+			const taskResults = synthesizeTaskResults(taskHandles, { sessionId, turnId })
 
 			const completedTasks = countCompletedTasks(taskResults)
 
 			return {
-				runId: run.id,
-				status: run.status === 'completed' ? 'completed' : 'failed',
-				stopReason: run.stopReason,
-				usage: run.tokenUsage,
+				sessionId,
+				turnId: turn.id,
+				status: turn.status === 'completed' ? 'completed' : 'failed',
+				stopReason: turn.stopReason,
+				usage: turn.tokenUsage,
 				budget: budget.summary(),
-				cost: run.costInfo,
-				iterations: run.currentIteration,
+				cost: turn.costInfo,
+				iterations: turn.currentIteration,
 				durationMs: Date.now() - startTime,
-				messages: run.messages,
-				result: run.result,
+				messages: turn.messages,
+				result: turn.result,
 				// `BaseAgentResult.structuredOutput` names "an archetype's result
 				// literal did not copy it" as a defect it was written to close.
 				// This literal still did not copy it, so the same defect was live
 				// in the one archetype nobody checked: the value would have been
-				// produced, recorded on the run, serialized into `result`, and
+				// produced, recorded on the turn, serialized into `result`, and
 				// absent from the type a supervisor host actually reads.
-				structuredOutput: run.structuredOutput,
-				lastError: run.lastError,
+				structuredOutput: turn.structuredOutput,
+				lastError: turn.lastError,
 				taskResults,
 				completedTasks,
 				totalTasks: taskResults.length,