@namzu/sdk 42.0.2 → 44.0.0

package/src/runtime/query/iteration/outstanding-work.ts

@@ -2,22 +2,22 @@ import { NAMZU } from '../../../constants/telemetry/index.js'
 import { formatCompletionNotification } from '../../../scheduler/completion-inbox.js'
 import { DELEGATION_TIMEOUT_MS } from '../../../tools/coordinator/index.js'
 import { createRuntimeContextMessage } from '../../../types/message/index.js'
-import type { RunEvent } from '../../../types/run/index.js'
+import type { SessionEvent } from '../../../types/session/index.js'
 import { readPositiveIntEnv } from '../../../utils/env.js'
 import { formatJobNote } from '../steering.js'
 import type { IterationContext } from './phases/index.js'
 
 /**
- * The run's settle points: holding open for work that has not finished, and
+ * The turn's settle points: holding open for work that has not finished, and
  * delivering what arrived.
  *
  * Two kinds of work qualify — a delegated task the `CompletionInbox` is still
  * expecting, and a background job the model told `wait_for_job` it is waiting
- * on — and both are raced together, because a run has one settle point and one
+ * on — and both are raced together, because a turn has one settle point and one
  * grace period to spend at it.
  *
  * Everything here reads the iteration context rather than capturing it, and
- * the one thing it cannot read off that context — how this run drains its
+ * the one thing it cannot read off that context — how this turn drains its
  * inbound queue — arrives as an explicit `deliverInbound` input, because the
  * recording of operator intent that goes with it belongs to the orchestrator.
  * `holdForOutstandingWork` is a generator and is reached with `yield*`: its
@@ -25,7 +25,7 @@ import type { IterationContext } from './phases/index.js'
  */
 
 /**
- * The share of a run's REMAINING time a settle-hold may take.
+ * The share of a turn's REMAINING time a settle-hold may take.
  *
  * The rule is borrowed from `AGENT_MANAGER_DEFAULTS.maxBudgetFraction`, which
  * gives a spawned child at most half of what its parent has left: one
@@ -34,10 +34,10 @@ import type { IterationContext } from './phases/index.js'
  * host-tunable knob about TOKEN allocation and coupling the two would let a
  * host lowering one silently change the other.
  *
- * Half, specifically, because the hold is not the last thing the run does.
+ * Half, specifically, because the hold is not the last thing the turn does.
  * Its whole purpose is to put a worker's result where the model can read it,
  * and reading it costs a turn. A hold that spent everything remaining would
- * deliver a notification into a run with no turn left to act on it — the same
+ * deliver a notification into a turn with no turn left to act on it — the same
  * "the result exists and the model is never told" failure this mechanism was
  * built to close, wearing a different costume.
  */
@@ -46,8 +46,8 @@ const SETTLE_GRACE_FRACTION = 0.5
 /**
  * How long a finishing run waits for a background worker it launched.
  *
- * Derived from the run rather than fixed, because a constant is wrong in both
- * directions at once. The 120 seconds this replaces held a run configured for
+ * Derived from the turn rather than fixed, because a constant is wrong in both
+ * directions at once. The 120 seconds this replaces held a turn configured for
  * a twenty-second timeout open for 120,267 ms — six times its own budget, and
  * unreachable by the guard, which only checks between iterations — while on an
  * hour-long run it abandoned workers measured at 4m21s, 5m58s and 8m04s, all
@@ -59,24 +59,24 @@ const SETTLE_GRACE_FRACTION = 0.5
  * the first attempt and it was wrong in a way that looked safe: a hold cannot
  * outlive the deadline either way, but half of the time-to-deadline started
  * just under the warning threshold ends at 95% of the budget — so the slice
- * that exists for the run to produce a closing answer is half spent waiting
+ * that exists for the turn to produce a closing answer is half spent waiting
  * for the result that answer was supposed to use. Against the finalize point
  * the hold cannot reach the reserve at all, which is what makes the guard's
  * inability to interrupt a hold a non-issue rather than a smaller issue.
  *
- * **The floor of zero is a decision, not a clamp artefact.** A run with no
+ * **The floor of zero is a decision, not a clamp artefact.** A turn with no
  * time left before it must start finishing has no turn in which to read a
  * notification, so waiting could only delay a stop that is already due.
  * Nothing is lost by it: `CompletionInbox.waitForArrival` returns before it
  * looks at its timer when a completion is already in hand, so a zero grace
  * still delivers everything that has arrived. No minimum is invented on top,
- * because zero is exactly what a run past the threshold should wait — and
+ * because zero is exactly what a turn past the threshold should wait — and
  * reading the remainder at hold time rather than trusting `forceFinalize`,
  * which is sampled at the top of the iteration, is what makes a long iteration
  * that crossed the line in between compute it.
  *
  * **The ceiling is the longest anything in this subsystem waits for a
- * delegated worker.** It binds only for a host whose run timeout exceeds
+ * delegated worker.** It binds only for a host whose turn timeout exceeds
  * roughly two and a quarter hours; below that the fraction is smaller.
  */
 export function settleGraceMs(remainingBeforeFinalizeMs: number): number {
@@ -90,8 +90,8 @@ export function settleGraceMs(remainingBeforeFinalizeMs: number): number {
  * The ceiling on the job half of that grace, in milliseconds.
  *
  * `DELEGATION_TIMEOUT_MS` is the wrong ceiling for a shell job, and the gap
- * only opens where it matters most: a run with no `timeoutMs` — the CLI's
- * shipping default, `No run deadline by default` — has infinite time before
+ * only opens where it matters most: a turn with no `timeoutMs` — the CLI's
+ * shipping default, `No turn deadline by default` — has infinite time before
  * it must start finishing, so `settleGraceMs` returns the ceiling flat. For a
  * delegated task that is sound, because the hour is the longest the task
  * itself may live: the hold cannot outlast the work. A background job has no
@@ -102,21 +102,21 @@ export function settleGraceMs(remainingBeforeFinalizeMs: number): number {
  * So the job leg gets its own bound, and it is sized to what the wait buys
  * rather than to how long a job may live: a turn in which to use the exit.
  * A model that already waited its `wait_for_job` bound out and saw nothing is
- * not usually two minutes from an exit, and the run ending is not the news
- * being lost — with no run in flight the session announces the exit itself
+ * not usually two minutes from an exit, and the turn ending is not the news
+ * being lost — with no turn in flight the session announces the exit itself
  * (`docs/cli/background-jobs.md`, *Learning that it ended*), which is the
  * cheaper of the two places to hear it.
  */
 const DEFAULT_JOB_HOLD_MAX_MS = 2 * 60 * 1000
 
 /**
- * The same share of the run, under {@link DEFAULT_JOB_HOLD_MAX_MS}.
+ * The same share of the turn, under {@link DEFAULT_JOB_HOLD_MAX_MS}.
  *
  * `NAMZU_JOB_HOLD_MAX_MS` overrides the ceiling for a host that wants a
  * longer or shorter park, the way `NAMZU_JOB_WAIT_TIMEOUT_MS` overrides
  * `wait_for_job`'s own bound — and it is the same parse, so a value that is
  * not a positive whole number of milliseconds leaves the default standing
- * rather than holding a run for `NaN`. Called here rather than at module
+ * rather than holding a turn for `NaN`. Called here rather than at module
  * load, because a host that sets it after import is not ignored.
  */
 export function awaitedJobGraceMs(remainingBeforeFinalizeMs: number): number {
@@ -125,14 +125,14 @@ export function awaitedJobGraceMs(remainingBeforeFinalizeMs: number): number {
 }
 
 /**
- * Hold the run open for work that has not finished, and deliver it.
+ * Hold the turn open for work that has not finished, and deliver it.
  *
  * Returns whether a completion, a job exit or an operator message entered
  * the transcript — the caller continues on `true`, so the model gets a turn
  * to respond. That turn is the entire justification for waiting, which
  * is why only the exits that can still take one call this.
  *
- * Two kinds of work qualify and they are raced together, because a run has
+ * Two kinds of work qualify and they are raced together, because a turn has
  * one settle point and one grace period to spend at it:
  *
  *  - a delegated task the `CompletionInbox` is still expecting;
@@ -148,10 +148,10 @@ export function awaitedJobGraceMs(remainingBeforeFinalizeMs: number): number {
  * is idle, so racing an idle one would end the hold before it began.
  *
  * Bounded by `settleGraceMs` and by `maxIterations`, so work that never
- * finishes cannot keep the run open. On a run with a deadline the grace is
+ * finishes cannot keep the turn open. On a turn with a deadline the grace is
  * a share of what is LEFT of it rather than a fresh allowance, so a
  * `wait_for_job` call that already spent minutes has shortened this hold
- * by the same minutes. On a run without one — the CLI's default — there is
+ * by the same minutes. On a turn without one — the CLI's default — there is
  * no remainder to take a share of, and the job leg's own ceiling
  * (`awaitedJobGraceMs`) is what keeps a timed-out wait from being followed
  * by an hour of silence.
@@ -161,7 +161,7 @@ export async function* holdForOutstandingWork(
 	iterationNum: number,
 	hasToolCalls: boolean,
 	deliverInbound: () => number,
-): AsyncGenerator<RunEvent, boolean> {
+): AsyncGenerator<SessionEvent, boolean> {
 	const inbox = ctx.completionInbox?.hasPendingWork ? ctx.completionInbox : undefined
 	const jobs = ctx.awaitedJobs?.hasPendingWork ? ctx.awaitedJobs : undefined
 	if (!inbox && !jobs) return false
@@ -173,14 +173,14 @@ export async function* holdForOutstandingWork(
 	// One deadline for the race, and it is the LONGEST ceiling any pending
 	// leg justifies. A leg resolving on its own timer ends the whole race,
 	// so handing the job leg its shorter ceiling while a task was also
-	// outstanding would cut the task's hold down to the job's — a run
+	// outstanding would cut the task's hold down to the job's — a turn
 	// walking away from a worker it had time for, because a job happened
 	// to be running. A job therefore never shortens a wait, and it never
 	// lengthens one either: where a task is outstanding too, that is how
-	// long this run was waiting anyway.
+	// long this turn was waiting anyway.
 	const graceMs = inbox ? settleGraceMs(remainingMs) : awaitedJobGraceMs(remainingMs)
-	ctx.log.info('Holding the run open for outstanding work', {
-		[NAMZU.RUN_ID]: ctx.runMgr.id,
+	ctx.log.info('Holding the turn open for outstanding work', {
+		[NAMZU.TURN_ID]: ctx.recorder.turnId,
 		[NAMZU.ITERATION]: iterationNum,
 		'namzu.runtime.grace_ms': graceMs,
 		'namzu.runtime.awaited_jobs': jobs?.outstandingJobIds ?? [],
@@ -208,7 +208,7 @@ export async function* holdForOutstandingWork(
 
 	const arrived = ctx.completionInbox?.drain() ?? []
 	if (arrived.length > 0) {
-		ctx.runMgr.pushMessage(
+		ctx.recorder.pushMessage(
 			createRuntimeContextMessage(formatCompletionNotification(arrived), 'task-completion'),
 		)
 	}
@@ -217,7 +217,7 @@ export async function* holdForOutstandingWork(
 	if (arrived.length === 0 && !exited && inbound === 0) return false
 	await ctx.emitEvent({
 		type: 'iteration_completed',
-		runId: ctx.runMgr.id,
+		turnId: ctx.recorder.turnId,
 		iteration: iterationNum,
 		hasToolCalls,
 	})
@@ -255,11 +255,11 @@ export function deliverAwaitedJobExits(ctx: IterationContext): boolean {
 	const delivered = ctx.awaitedJobs?.takeDelivery(() => ctx.jobNotices?.drain())
 	if (!delivered) return false
 
-	ctx.log.info('Delivering a background job exit the run held open for', {
-		[NAMZU.RUN_ID]: ctx.runMgr.id,
+	ctx.log.info('Delivering a background job exit the turn held open for', {
+		[NAMZU.TURN_ID]: ctx.recorder.turnId,
 		'namzu.runtime.jobs': delivered.exits.map((job) => job.id),
 	})
-	ctx.runMgr.pushMessage(createRuntimeContextMessage(formatJobNote(delivered.text), 'job-exit'))
+	ctx.recorder.pushMessage(createRuntimeContextMessage(formatJobNote(delivered.text), 'job-exit'))
 	return true
 }
 
@@ -267,17 +267,17 @@ export function deliverAwaitedJobExits(ctx: IterationContext): boolean {
  * Account for outstanding work on the way out: deliver what arrived, and
  * say what did not.
  *
- * A run that ends with a worker outstanding must not leave the impression
+ * A turn that ends with a worker outstanding must not leave the impression
  * that the worker's result was delivered. There are exactly two honest
  * outcomes and this does both:
  *
  *  - **What has already arrived is delivered.** It makes no false claim,
  *    and dropping it is pure loss — the message rides out on
- *    `Run.messages`, so a host reads it and the next turn of a continued
+ *    `Turn.messages`, so a host reads it and the next turn of a continued
  *    thread starts with it. This does NOT wait: a hold buys the model a
  *    turn in which to USE a result, and on an exit whose answer is already
  *    decided there is no such turn, so waiting would delay a settled answer
- *    to append text this run will not read. The bounded hold stays where it
+ *    to append text this turn will not read. The bounded hold stays where it
  *    was, on the exits that do have a turn left.
  *  - **What is still running is NAMED, not cancelled.** Giving up on a wait
  *    is a statement about the waiter, not about the work — the rule
@@ -285,7 +285,7 @@ export function deliverAwaitedJobExits(ctx: IterationContext): boolean {
  *    "the parent answered early" is a weaker warrant for killing a child
  *    than "the clock ran out", not a stronger one. Killing a worker that
  *    may be mid-write is a policy only the host can judge, and it has
- *    `cancel_task` and the run controller to judge it with.
+ *    `cancel_task` and the turn controller to judge it with.
  */
 export function settleOutstandingWork(ctx: IterationContext): void {
 	deliverArrivedCompletions(ctx)
@@ -293,44 +293,44 @@ export function settleOutstandingWork(ctx: IterationContext): void {
 	recordAbandonedWork(ctx)
 }
 
-/** Work this run walked away from. See {@link settleOutstandingWork}. */
+/** Work this turn walked away from. See {@link settleOutstandingWork}. */
 export function recordAbandonedWork(ctx: IterationContext): void {
 	const abandoned = ctx.completionInbox?.outstandingTaskIds ?? []
 	if (abandoned.length > 0) {
-		ctx.log.warn('Run ended with delegated work still running', {
-			[NAMZU.RUN_ID]: ctx.runMgr.id,
+		ctx.log.warn('Turn ended with delegated work still running', {
+			[NAMZU.TURN_ID]: ctx.recorder.turnId,
 			'namzu.runtime.tasks': abandoned,
 		})
-		ctx.runMgr.setAbandonedTaskIds(abandoned)
+		ctx.recorder.setAbandonedTaskIds(abandoned)
 	}
 
 	// The same statement for a job the model was waiting on when the grace
 	// ran out. Only awaited ones: a job nobody waited for was never work
-	// this run was holding, so naming it would report an abandonment that
+	// this turn was holding, so naming it would report an abandonment that
 	// did not happen.
 	const abandonedJobs = ctx.awaitedJobs?.outstandingJobIds ?? []
 	if (abandonedJobs.length === 0) return
 
-	ctx.log.warn('Run ended with an awaited background job still running', {
-		[NAMZU.RUN_ID]: ctx.runMgr.id,
+	ctx.log.warn('Turn ended with an awaited background job still running', {
+		[NAMZU.TURN_ID]: ctx.recorder.turnId,
 		'namzu.runtime.jobs': abandonedJobs,
 	})
-	ctx.runMgr.setAbandonedJobIds(abandonedJobs)
+	ctx.recorder.setAbandonedJobIds(abandonedJobs)
 }
 
 export function deliverArrivedCompletions(ctx: IterationContext): void {
 	const unheard = ctx.completionInbox?.drain() ?? []
 	if (unheard.length === 0) return
 
-	// Fix the run's answer BEFORE appending anything after it.
+	// Fix the turn's answer BEFORE appending anything after it.
 	//
-	// `RunPersistence.resolveResult` walks the message tail backwards and
+	// `TurnRecorder.resolveResult` walks the message tail backwards and
 	// stops at the first non-assistant message, and it runs at
 	// `markCompleted` — which is AFTER this. So a notification appended
-	// after the final assistant turn makes the run's own answer
-	// unreachable. Measured, on a run whose model had just said "THIS IS
-	// THE RUN ANSWER.": `run.result` came back `undefined`. That trades a
-	// lost worker result for a lost RUN result, which is strictly worse
+	// after the final assistant turn makes the turn's own answer
+	// unreachable. Measured, on a turn whose model had just said "THIS IS
+	// THE TURN ANSWER.": the turn's `result` came back `undefined`. That trades a
+	// lost worker result for a lost TURN result, which is strictly worse
 	// than the defect this delivery exists to fix.
 	//
 	// Materialising resolves it while the tail is still the assistant's;
@@ -338,14 +338,14 @@ export function deliverArrivedCompletions(ctx: IterationContext): void {
 	// when there is something to pin: on the cancelled and thrown paths
 	// there may be no answer, and pinning an empty string there would
 	// suppress whatever the error path assembles.
-	const answer = ctx.runMgr.materializeResult()
-	if (answer.length > 0) ctx.runMgr.setResult(answer)
+	const answer = ctx.recorder.materializeResult()
+	if (answer.length > 0) ctx.recorder.setResult(answer, 'outstanding_work')
 
-	ctx.log.info('Delivering task completions the run would have settled over', {
-		[NAMZU.RUN_ID]: ctx.runMgr.id,
+	ctx.log.info('Delivering task completions the turn would have settled over', {
+		[NAMZU.TURN_ID]: ctx.recorder.turnId,
 		'namzu.runtime.tasks': unheard.map((h) => h.taskId),
 	})
-	ctx.runMgr.pushMessage(
+	ctx.recorder.pushMessage(
 		createRuntimeContextMessage(formatCompletionNotification(unheard), 'task-completion'),
 	)
 }
@@ -355,13 +355,13 @@ export function deliverArrivedCompletions(ctx: IterationContext): void {
  * too late to earn a turn is still delivered on the way out.
  *
  * The window this closes is one tick wide and it is nobody else's. An
- * awaited job that exits between the hold's grace expiring and the run
+ * awaited job that exits between the hold's grace expiring and the turn
  * settling was never delivered — the hold had already looked — and is no
  * longer named either, because the exit took it off the outstanding list
  * on its way past, so `abandonedJobIds` would be lying to claim it. The
  * host's own listener is no help: the CLI queues an exit for the next
- * turn only when no run is in flight, and this one is still in flight.
- * Delivered here it reaches `Run.messages`, so the transcript has it and
+ * turn only when no turn is in flight, and this one is still in flight.
+ * Delivered here it reaches `Turn.messages`, so the transcript has it and
  * a continued thread opens with it.
  *
  * Before `recordAbandonedWork`, which then reports only what is still
@@ -372,15 +372,15 @@ export function deliverArrivedJobExits(ctx: IterationContext): void {
 	const delivered = ctx.awaitedJobs?.takeDelivery(() => ctx.jobNotices?.drain())
 	if (!delivered) return
 
-	// Fix the run's answer BEFORE appending anything after it — the same
+	// Fix the turn's answer BEFORE appending anything after it — the same
 	// `resolveResult` tail walk `deliverArrivedCompletions` explains just
 	// above, and the same guard against pinning an empty one.
-	const answer = ctx.runMgr.materializeResult()
-	if (answer.length > 0) ctx.runMgr.setResult(answer)
+	const answer = ctx.recorder.materializeResult()
+	if (answer.length > 0) ctx.recorder.setResult(answer, 'outstanding_work')
 
-	ctx.log.info('Delivering a background job exit the run would have settled over', {
-		[NAMZU.RUN_ID]: ctx.runMgr.id,
+	ctx.log.info('Delivering a background job exit the turn would have settled over', {
+		[NAMZU.TURN_ID]: ctx.recorder.turnId,
 		'namzu.runtime.jobs': delivered.exits.map((job) => job.id),
 	})
-	ctx.runMgr.pushMessage(createRuntimeContextMessage(formatJobNote(delivered.text), 'job-exit'))
+	ctx.recorder.pushMessage(createRuntimeContextMessage(formatJobNote(delivered.text), 'job-exit'))
 }

package/src/runtime/query/iteration/phases/advisory.ts

@@ -11,7 +11,7 @@ import type { IterationContext } from './context.js'
 
 function countToolCalls(ctx: IterationContext): number {
 	let count = 0
-	for (const msg of ctx.runMgr.messages) {
+	for (const msg of ctx.recorder.messages) {
 		if (msg.role === 'assistant' && msg.toolCalls) {
 			count += msg.toolCalls.length
 		}
@@ -25,9 +25,9 @@ function estimateContextWindowPercent(ctx: IterationContext): number {
 }
 
 function computeCostBudgetPercent(ctx: IterationContext): number | undefined {
-	const limit = ctx.runConfig.costLimitUsd
+	const limit = ctx.turnConfig.costLimitUsd
 	if (limit === undefined || limit <= 0) return undefined
-	return (ctx.runMgr.costInfo.totalCost / limit) * 100
+	return (ctx.recorder.costInfo.totalCost / limit) * 100
 }
 
 function extractLastToolCategory(
@@ -56,7 +56,7 @@ export async function runAdvisoryPhase(
 	const budgetCheck = advisoryCtx.checkBudget()
 	if (!budgetCheck.allowed) {
 		ctx.log.debug('Advisory budget exhausted, skipping advisory phase', {
-			[NAMZU.RUN_ID]: ctx.runMgr.id,
+			[NAMZU.TURN_ID]: ctx.recorder.turnId,
 			'namzu.runtime.reason': budgetCheck.reason,
 		})
 		return
@@ -65,9 +65,9 @@ export async function runAdvisoryPhase(
 	const evalState: TriggerEvaluationState = {
 		iteration: iterationNum,
 		totalToolCalls: countToolCalls(ctx),
-		totalTokens: ctx.runMgr.tokenUsage.totalTokens,
+		totalTokens: ctx.recorder.tokenUsage.totalTokens,
 		contextWindowPercent: estimateContextWindowPercent(ctx),
-		totalCostUsd: ctx.runMgr.costInfo.totalCost,
+		totalCostUsd: ctx.recorder.costInfo.totalCost,
 		costBudgetPercent: computeCostBudgetPercent(ctx),
 		lastError: extractCurrentToolErrors(ctx, response),
 		lastToolCategory: extractLastToolCategory(ctx, response),
@@ -83,7 +83,7 @@ export async function runAdvisoryPhase(
 	const advisor = advisoryCtx.registry.resolve(trigger.advisorId)
 	if (!advisor) {
 		ctx.log.warn('Advisory trigger fired but advisor not found', {
-			[NAMZU.RUN_ID]: ctx.runMgr.id,
+			[NAMZU.TURN_ID]: ctx.recorder.turnId,
 			'namzu.runtime.trigger_id': trigger.id,
 			'namzu.advisory.id': trigger.advisorId,
 		})
@@ -106,7 +106,7 @@ export async function runAdvisoryPhase(
 
 	try {
 		const executionResult = await advisoryCtx.executor.consult(advisor, request, {
-			messages: ctx.runMgr.messages,
+			messages: ctx.recorder.messages,
 			...(turn ? { turn } : {}),
 			workingStateSummary,
 			toolCatalog: ctx.tools.toLLMTools(ctx.allowedTools),
@@ -115,18 +115,18 @@ export async function runAdvisoryPhase(
 
 		advisoryCtx.evaluator.recordFiring(trigger.id, iterationNum)
 
-		// An advisory call is a real model call on the run's dime. It was
+		// An advisory call is a real model call on the turn's dime. It was
 		// recorded into `callHistory` for reporting but never reached
-		// `runMgr.tokenUsage`, so the guard could not see it: a run with
+		// `recorder.tokenUsage`, so the guard could not see it: a turn with
 		// `tokenBudget: 200_000` and an `on_error` trigger could send well
 		// past 200k and never trip `token_budget`. The usage is already in
 		// hand — this just tells the accountant about it.
-		// Priced against the ADVISOR's own driver and model, not the run's. An
+		// Priced against the ADVISOR's own driver and model, not the turn's. An
 		// advisor carries its own `provider`, so attributing its tokens to
 		// whoever is serving the main loop would price one vendor's work at
 		// another's card — which is the class of quiet wrongness the whole
 		// catalogue exists to remove, and it would be invisible here.
-		ctx.runMgr.accumulateUsage(executionResult.usage, {
+		ctx.recorder.accumulateUsage(executionResult.usage, {
 			providerId: advisor.provider.id,
 			model: advisor.model,
 		})
@@ -172,10 +172,10 @@ export async function runAdvisoryPhase(
 
 		sections.push('</advisory-result>')
 
-		ctx.runMgr.pushMessage(createRuntimeContextMessage(sections.join('\n'), 'advisory'))
+		ctx.recorder.pushMessage(createRuntimeContextMessage(sections.join('\n'), 'advisory'))
 
 		ctx.log.info('Advisory phase completed', {
-			[NAMZU.RUN_ID]: ctx.runMgr.id,
+			[NAMZU.TURN_ID]: ctx.recorder.turnId,
 			[NAMZU.ITERATION]: iterationNum,
 			'namzu.runtime.trigger_id': trigger.id,
 			'namzu.advisory.id': advisor.id,
@@ -184,7 +184,7 @@ export async function runAdvisoryPhase(
 		})
 	} catch (err) {
 		ctx.log.warn('Advisory phase failed', {
-			[NAMZU.RUN_ID]: ctx.runMgr.id,
+			[NAMZU.TURN_ID]: ctx.recorder.turnId,
 			[NAMZU.ITERATION]: iterationNum,
 			'namzu.runtime.trigger_id': trigger.id,
 			'namzu.advisory.id': advisor.id,
@@ -199,7 +199,7 @@ function extractCurrentToolErrors(
 ): string | undefined {
 	const calls = new Map(response.message.toolCalls?.map((call) => [call.id, call.function.name]))
 	if (calls.size === 0) return undefined
-	const messages = ctx.runMgr.messages
+	const messages = ctx.recorder.messages
 	const errors: string[] = []
 	for (let i = messages.length - 1; i >= 0; i--) {
 		const msg = messages[i]

package/src/runtime/query/iteration/phases/checkpoint.ts

@@ -1,4 +1,6 @@
-import type { RunEvent } from '../../../../types/run/index.js'
+import { NAMZU } from '../../../../constants/telemetry/index.js'
+import type { SessionEvent } from '../../../../types/session/index.js'
+import { toErrorMessage } from '../../../../utils/error.js'
 import { CheckpointManager } from '../../checkpoint.js'
 import {
 	type IterationContext,
@@ -8,7 +10,7 @@ import {
 } from './context.js'
 
 /**
- * Cadence gate for the per-iteration checkpoint (`runConfig.checkpointEvery`,
+ * Cadence gate for the per-iteration checkpoint (`turnConfig.checkpointEvery`,
  * default 1 = every iteration). Off-cadence iterations skip the whole phase —
  * no checkpoint, no `checkpoint_created` event, and no HITL
  * `iteration_checkpoint` park (there is no checkpoint id to park on).
@@ -24,32 +26,46 @@ function isOnCheckpointCadence(iterationNum: number, checkpointEvery: number | u
 export async function* runIterationCheckpoint(
 	ctx: IterationContext,
 	iterationNum: number,
-): AsyncGenerator<RunEvent, PhaseSignal> {
-	if (!isOnCheckpointCadence(iterationNum, ctx.runConfig.checkpointEvery)) {
+): AsyncGenerator<SessionEvent, PhaseSignal> {
+	if (!isOnCheckpointCadence(iterationNum, ctx.turnConfig.checkpointEvery)) {
 		return 'continue'
 	}
 
-	const iterCheckpoint = await ctx.checkpointMgr.create(ctx.runMgr, iterationNum)
+	const iterCheckpoint = await ctx.checkpointMgr.create(ctx.recorder, iterationNum)
 
 	// Growth control: keep only the newest N checkpoints when the host asked
 	// for pruning. Default undefined ⇒ never prune (today's behavior).
-	const pruneKeepLast = ctx.runConfig.pruneKeepLast
+	//
+	// A failed prune is logged, not thrown. The checkpoint this iteration
+	// needs was written above; failing to delete OLD ones costs disk, and
+	// ending a live turn over disk that can be reclaimed at its next
+	// iteration trades the user's work for housekeeping.
+	const pruneKeepLast = ctx.turnConfig.pruneKeepLast
 	if (pruneKeepLast !== undefined && pruneKeepLast >= 1) {
-		await ctx.checkpointMgr.prune(Math.floor(pruneKeepLast))
+		try {
+			await ctx.checkpointMgr.prune(Math.floor(pruneKeepLast))
+		} catch (err) {
+			ctx.log.warn('Checkpoint retention failed; older checkpoints are kept for now', {
+				[NAMZU.TURN_ID]: ctx.recorder.turnId,
+				[NAMZU.ITERATION]: iterationNum,
+				'exception.message': toErrorMessage(err),
+			})
+		}
 	}
 
 	await ctx.emitEvent({
 		type: 'checkpoint_created',
-		runId: ctx.runMgr.id,
+		turnId: ctx.recorder.turnId,
 		checkpointId: iterCheckpoint.id,
 		iteration: iterationNum,
 	})
 	yield* ctx.drainPending()
 
-	const summary = CheckpointManager.buildSummary(ctx.runMgr, iterationNum)
+	const summary = CheckpointManager.buildSummary(ctx.recorder, iterationNum)
 	const iterDecision = await awaitDecisionDurably(ctx, iterCheckpoint, {
 		type: 'iteration_checkpoint',
-		runId: ctx.runMgr.id,
+		sessionId: ctx.recorder.sessionId,
+		turnId: ctx.recorder.turnId,
 		checkpointId: iterCheckpoint.id,
 		summary,
 	})