@namzu/sdk 43.0.0 → 44.0.0

package/src/runtime/query/release-run.ts

@@ -1,168 +0,0 @@
-import type { Span } from '@opentelemetry/api'
-import type { WorkingStateManager } from '../../compaction/manager.js'
-import { NAMZU } from '../../constants/telemetry/index.js'
-import type { EmergencySaveManager } from '../../manager/run/emergency.js'
-import { recordRunDuration } from '../../telemetry/metrics.js'
-import type { RunEvent } from '../../types/run/index.js'
-import { type PromoteMemory, memoryCandidateFor } from '../../types/run/memory-promotion.js'
-import type { Sandbox } from '../../types/sandbox/index.js'
-import { errorAttributes } from '../../utils/log/exception.js'
-import type { AwaitedJobs } from '../jobs/awaited-jobs.js'
-import type { BackgroundJobRegistry } from '../jobs/registry.js'
-import type { RunContext } from './context.js'
-import type { EventTranslator } from './events.js'
-import type { QuestionParkBinding } from './question-park.js'
-import { teardownSandbox } from './sandbox-lifecycle.js'
-
-/**
- * Everything a run borrows, handed back when it ends.
- *
- * A run attaches to process-wide things it does not own — crash handlers, a
- * shared background-job registry, a question channel a tool outlived, a task
- * store's listener, a sandbox — and every one of them has to be released on
- * the way out, including the exits a `try` never reaches. So this is the body
- * of `query()`'s `finally`: the keyword stays where it is, which is what makes
- * abandonment run this just as settlement does.
- *
- * The order is the contract, and the awaits are in it: detach the emergency
- * handlers, unsubscribe from job exits, close the wait-intent recorder, kill
- * only this run's jobs, unbind the question channel, promote what the run
- * learned, tear the sandbox down, unsubscribe from the task store, record the
- * duration under the status the run actually settled with, and end the root
- * span last.
- */
-export interface RunResources {
-	readonly ctx: RunContext
-	readonly eventTranslator: EventTranslator
-	readonly emergencyManager: EmergencySaveManager | undefined
-	readonly unsubscribeJobExits: (() => void) | undefined
-	readonly unsubscribeTaskStore: (() => void) | undefined
-	readonly awaitedJobs: AwaitedJobs | undefined
-	/** Jobs a host bound to its session are the host's to stop, not this run's. */
-	readonly backgroundJobs: BackgroundJobRegistry | undefined
-	readonly backgroundJobOwner: string | undefined
-	readonly questionParks: QuestionParkBinding
-	readonly workingStateManager: WorkingStateManager | undefined
-	readonly promoteMemory: PromoteMemory | undefined
-	readonly sandbox: Sandbox | undefined
-	readonly sandboxTeardownTimeoutMs: number
-	readonly runStartedAt: number
-	readonly rootSpan: Span
-}
-
-/**
- * Release them, in that order.
- *
- * A generator rather than a plain async function because the sandbox teardown
- * reports `sandbox_destroyed`, and that event has to reach the host at the
- * position it always did — `yield*` from the caller's `finally` keeps it
- * exactly there.
- */
-export async function* releaseRunResources(
-	resources: RunResources,
-): AsyncGenerator<RunEvent, void> {
-	const {
-		ctx,
-		eventTranslator,
-		emergencyManager,
-		unsubscribeJobExits,
-		unsubscribeTaskStore,
-		awaitedJobs,
-		backgroundJobs,
-		backgroundJobOwner,
-		questionParks,
-		workingStateManager,
-		promoteMemory,
-		sandbox,
-		sandboxTeardownTimeoutMs,
-		runStartedAt,
-		rootSpan,
-	} = resources
-
-	// Release the process's termination path as soon as this run is
-	// done with it. Leaving the handlers installed would keep a
-	// WeakRef'd, settled run as the crash target for the rest of the
-	// process's life.
-	emergencyManager?.detach()
-
-	// A background job outlives the tool call that started it — that
-	// is what it is for — so nothing but this stops it outliving the
-	// RUN. Scoped to this run's id: a shared registry serving several
-	// runs must not have one of them tear down another's work.
-	//
-	// Awaited, and its failure swallowed. A job that would not die is
-	// worth a log line, and is not worth retracting a run's answer.
-	unsubscribeJobExits?.()
-	// The wait-intent recorder listens on the same shared registry and
-	// leaks the same way if it is left attached.
-	awaitedJobs?.close()
-	// Only jobs bound to this run. Jobs a host bound to its session are
-	// the host's to stop, when the session ends.
-	if (backgroundJobs && (backgroundJobOwner ?? ctx.runId) === ctx.runId) {
-		try {
-			const stopped = await backgroundJobs.killOwner(ctx.runId)
-			if (stopped.length > 0) {
-				ctx.log.info('Background jobs stopped with the run', {
-					[NAMZU.RUN_ID]: ctx.runId,
-					'namzu.jobs.stopped': stopped.length,
-				})
-			}
-		} catch (jobErr) {
-			ctx.log.error('A background job did not stop cleanly', {
-				[NAMZU.RUN_ID]: ctx.runId,
-				...errorAttributes(jobErr),
-			})
-		}
-	}
-
-	// Same reasoning for the question channel: the tools outlive the
-	// run that bound them, so leaving it attached would have a later
-	// run's question written into this run's checkpoint store.
-	questionParks.unbind()
-
-	// Offer what the run learned to whoever decides what is worth
-	// keeping. In `finally` and awaited: a run that failed still
-	// discovered things, and a fire-and-forget write would race the
-	// process exiting on a one-shot CLI run. A throw here is
-	// swallowed — a memory that failed to form must not retract an
-	// answer that was already produced.
-	const candidate = memoryCandidateFor(ctx.runId, workingStateManager)
-	if (promoteMemory && candidate) {
-		try {
-			await promoteMemory(candidate)
-		} catch (promoteErr) {
-			ctx.log.error('Memory promotion threw — the run is unaffected', {
-				[NAMZU.RUN_ID]: ctx.runId,
-				'exception.message': promoteErr instanceof Error ? promoteErr.message : String(promoteErr),
-			})
-		}
-	}
-
-	// --- Sandbox lifecycle: destroy after run ---
-	if (sandbox) {
-		const sandboxId = sandbox.id
-		const teardown = await teardownSandbox(sandbox, sandboxTeardownTimeoutMs)
-		if (teardown.kind === 'destroyed') {
-			await eventTranslator.emitEvent({
-				type: 'sandbox_destroyed',
-				runId: ctx.runId,
-				sandboxId,
-			})
-			yield* eventTranslator.drainPending()
-			ctx.log.info('Sandbox destroyed', { 'namzu.sandbox.id': sandboxId })
-		} else {
-			ctx.log.error('Sandbox destroy failed', {
-				'namzu.sandbox.id': sandboxId,
-				...errorAttributes(teardown.error),
-			})
-		}
-	}
-
-	unsubscribeTaskStore?.()
-	// Keyed by HOW it settled, not just that it did: a run that was
-	// cancelled and a run that hit its budget have very different
-	// duration distributions, and averaging them together describes
-	// neither.
-	recordRunDuration(ctx.runMgr.getRun().status ?? 'unknown', Date.now() - runStartedAt)
-	rootSpan.end()
-}

package/src/runtime/query/replay/list.ts

@@ -1,66 +0,0 @@
-import { RunDiskStore } from '../../../store/run/disk.js'
-import type { RunId } from '../../../types/ids/index.js'
-import type { CheckpointRunScope, CheckpointStore } from '../../../types/run/checkpoint-store.js'
-import type { CheckpointListEntry } from '../../../types/run/replay.js'
-import type { Logger } from '../../../utils/logger.js'
-import { toCheckpointListEntry } from '../checkpoint.js'
-
-export interface ListCheckpointsInput {
-	/** Directory that contains `<runId>/` for the target run. */
-	baseDir: string
-	/** Run whose checkpoints should be listed. */
-	runId: RunId
-	logger?: Logger
-	/**
-	 * Optional store override (host-injected, e.g. Postgres). When set,
-	 * `scope` is required — a scope-keyed backend cannot be addressed by
-	 * `baseDir` — and `baseDir` is ignored. Absent ⇒ the disk layout under
-	 * `baseDir` is read, exactly as before.
-	 */
-	checkpointStore?: CheckpointStore
-	/** Run scope for `checkpointStore`. Required when it is set. */
-	scope?: CheckpointRunScope
-}
-
-/**
- * Read-only listing of a run's checkpoints for use with {@link
- * import('./prepare.js').prepareReplayState}. Returns the public
- * {@link CheckpointListEntry} projection — just enough for a caller to
- * pick a fork point — not the full `IterationCheckpoint` payload.
- *
- * Entries are returned in the order the underlying store returns them
- * (stores sort by `createdAt` ascending). Callers that want a
- * specific order should sort client-side.
- *
- * See ses_005-deterministic-replay/design.md §3.1.
- */
-export async function listCheckpoints(input: ListCheckpointsInput): Promise<CheckpointListEntry[]> {
-	const checkpoints = await listRawCheckpoints(input)
-	return checkpoints.map(toCheckpointListEntry)
-}
-
-async function listRawCheckpoints(input: ListCheckpointsInput) {
-	if (input.checkpointStore) {
-		return input.checkpointStore.listCheckpoints(requireScope(input.scope, 'listCheckpoints'))
-	}
-	const store = new RunDiskStore({ baseDir: input.baseDir, logger: input.logger })
-	await store.initRun(input.runId)
-	return store.listCheckpoints()
-}
-
-/**
- * Guard shared by the replay entry points: an injected {@link
- * CheckpointStore} is scope-keyed, so the caller must say which run —
- * across the full five-layer attribution — it is asking about.
- */
-export function requireScope(
-	scope: CheckpointRunScope | undefined,
-	caller: string,
-): CheckpointRunScope {
-	if (!scope) {
-		throw new Error(
-			`${caller}: \`checkpointStore\` was provided without \`scope\` — an injected store is keyed by tenantId/projectId/sessionId/runId, not by baseDir.`,
-		)
-	}
-	return scope
-}

package/src/runtime/query/replay/mutate.ts

@@ -1,82 +0,0 @@
-import type { ToolCallId } from '../../../types/ids/index.js'
-import {
-	type AssistantMessage,
-	type Message,
-	type ToolCall,
-	createToolMessage,
-} from '../../../types/message/index.js'
-import { type Mutation, MutationNotApplicableError } from '../../../types/run/replay.js'
-
-/**
- * Returns the tool calls on the most recent assistant message that do not
- * yet have a matching {@link import('../../../types/message/index.js').ToolMessage}
- * response further down the message list. These are the fork-point "pending"
- * tool calls that mutations may target.
- */
-function findPendingToolCalls(messages: readonly Message[]): ToolCall[] {
-	let lastAssistantIdx = -1
-	for (let i = messages.length - 1; i >= 0; i--) {
-		const msg = messages[i]
-		if (msg && msg.role === 'assistant' && (msg.toolCalls?.length ?? 0) > 0) {
-			lastAssistantIdx = i
-			break
-		}
-	}
-	if (lastAssistantIdx === -1) return []
-
-	const assistant = messages[lastAssistantIdx] as AssistantMessage
-	const satisfied = new Set<string>()
-	for (let i = lastAssistantIdx + 1; i < messages.length; i++) {
-		const msg = messages[i]
-		if (msg && msg.role === 'tool') {
-			satisfied.add(msg.toolCallId)
-		}
-	}
-	return (assistant.toolCalls ?? []).filter((tc) => !satisfied.has(tc.id))
-}
-
-/**
- * Apply an ordered list of {@link Mutation} to a checkpoint's message
- * history at the fork point, producing a new message array that the
- * resumed iteration loop consumes. Pure function; does not touch the run
- * store, does not emit events.
- *
- * Throws {@link MutationNotApplicableError} when an `injectToolResponse`
- * mutation targets a tool call id that is not pending at the fork point —
- * the error payload carries the list of ids that *are* pending so the
- * caller can recover without guessing.
- *
- * See ses_005-deterministic-replay design §3.3.
- */
-export function applyMutations(
-	messages: readonly Message[],
-	mutations: readonly Mutation[],
-): Message[] {
-	let current: Message[] = [...messages]
-	for (const m of mutations) {
-		current = applyOne(current, m)
-	}
-	return current
-}
-
-function applyOne(messages: Message[], mutation: Mutation): Message[] {
-	switch (mutation.type) {
-		case 'injectToolResponse': {
-			const pending = findPendingToolCalls(messages)
-			const match = pending.find((tc) => tc.id === mutation.toolCallId)
-			if (!match) {
-				throw new MutationNotApplicableError(
-					`No pending tool call ${mutation.toolCallId} at fork point`,
-					// `ToolCall.id` is a bare `string` — a provider chooses its own
-					// shape, which is what `ToolUseId` exists to say. This assertion
-					// satisfies `MutationNotApplicableError`'s parameter and is only
-					// ever read back as text in that message; it never becomes a
-					// key. Left as a cast because the honest fix is that parameter
-					// type, not this line.
-					pending.map((tc) => tc.id as ToolCallId),
-				)
-			}
-			return [...messages, createToolMessage(mutation.response.output, mutation.toolCallId)]
-		}
-	}
-}

package/src/runtime/query/replay/prepare.ts

@@ -1,147 +0,0 @@
-import { join } from 'node:path'
-import { EmergencySaveManager } from '../../../manager/run/emergency.js'
-import { RunDiskStore } from '../../../store/run/disk.js'
-import type { CheckpointId, IterationCheckpoint } from '../../../types/hitl/index.js'
-import type { RunId } from '../../../types/ids/index.js'
-import type { Message } from '../../../types/message/index.js'
-import type { CheckpointRunScope, CheckpointStore } from '../../../types/run/checkpoint-store.js'
-import type { Mutation, ReplayAttribution } from '../../../types/run/replay.js'
-import type { Logger } from '../../../utils/logger.js'
-import { projectEmergencyToCheckpoint } from '../checkpoint.js'
-import { requireScope } from './list.js'
-import { applyMutations } from './mutate.js'
-
-export type CheckpointSelector = CheckpointId | 'latest' | 'emergency'
-
-export interface PrepareReplayInput {
-	/** Directory that contains `<runId>/` for the source run. */
-	baseDir: string
-	/** Source run to fork from. */
-	runId: RunId
-	/** Which checkpoint to fork at. */
-	fromCheckpoint: CheckpointSelector
-	/** Optional mutations applied at the fork point before the caller hands state to `query()`. */
-	mutate?: Mutation[]
-	/**
-	 * Directory that holds emergency dumps. Required only when `fromCheckpoint`
-	 * is `'emergency'`; conventionally sibling of `baseDir` (the `.namzu/emergency`
-	 * folder), but left explicit so callers with non-default layouts can redirect.
-	 */
-	emergencyDir?: string
-	logger?: Logger
-	/**
-	 * Optional store override (host-injected, e.g. Postgres). When set,
-	 * `scope` is required and `baseDir` is ignored for checkpoint reads.
-	 * The `'emergency'` selector still reads the on-disk dump under
-	 * `emergencyDir` — emergency saves are process-local by nature.
-	 */
-	checkpointStore?: CheckpointStore
-	/** Run scope for `checkpointStore`. Required when it is set. */
-	scope?: CheckpointRunScope
-}
-
-export interface PreparedReplayState {
-	/**
-	 * Message history at the fork point, with mutations applied. Seed this
-	 * as the new run's initial messages and pass `sourceCheckpoint.id` as
-	 * `resumeFromCheckpoint` when you call `query()`.
-	 */
-	messages: Message[]
-	/** The checkpoint the replay forks from (already projected if emergency). */
-	sourceCheckpoint: IterationCheckpoint
-	/**
-	 * Attribution to stamp on the replay run once it is created. The caller
-	 * sets `Run.replayOf = buildAttribution(prepared, replayedAt)` on the
-	 * new `RunPersistence` before persisting the first time.
-	 */
-	attribution: ReplayAttribution
-}
-
-/**
- * Produce the state materials needed to execute a replay run — the mutated
- * message history, the resolved source checkpoint, and the replay
- * attribution record. Pure read; does not touch the run store beyond
- * reading the source run's checkpoint files.
- *
- * This is the state-preparation half of the replay primitive. The
- * caller is expected to thread the returned `messages` +
- * `sourceCheckpoint.id` into `query({ resumeFromCheckpoint, messages,
- * ... })` and stamp `Run.replayOf = prepared.attribution` on the resulting
- * run. The end-to-end `replay()` entry that does all of this in one call
- * is a follow-up session (`ReplayEnvironment` shape).
- *
- * See `ses_005-deterministic-replay/design.md` §3.1.
- */
-export async function prepareReplayState(input: PrepareReplayInput): Promise<PreparedReplayState> {
-	const sourceCheckpoint = await resolveCheckpoint(input)
-	const mutations = input.mutate ?? []
-	const messages = applyMutations(sourceCheckpoint.messages, mutations)
-
-	const attribution: ReplayAttribution = {
-		sourceRunId: input.runId,
-		fromCheckpointId: sourceCheckpoint.id,
-		mutations,
-		replayedAt: Date.now(),
-	}
-
-	return { messages, sourceCheckpoint, attribution }
-}
-
-async function resolveCheckpoint(input: PrepareReplayInput): Promise<IterationCheckpoint> {
-	if (input.fromCheckpoint === 'emergency') {
-		return resolveEmergency(input)
-	}
-
-	const reader = await bindCheckpointReader(input)
-
-	if (input.fromCheckpoint === 'latest') {
-		const all = await reader.list()
-		if (all.length === 0) {
-			throw new Error(`No checkpoints found for run ${input.runId} in ${input.baseDir}`)
-		}
-		return [...all].sort((a, b) => b.iteration - a.iteration)[0] as IterationCheckpoint
-	}
-
-	const checkpoint = await reader.read(input.fromCheckpoint)
-	if (!checkpoint) {
-		throw new Error(`Checkpoint ${input.fromCheckpoint} not found for run ${input.runId}`)
-	}
-	return checkpoint
-}
-
-interface CheckpointReader {
-	list(): Promise<IterationCheckpoint[]>
-	read(id: CheckpointId): Promise<IterationCheckpoint | null>
-}
-
-async function bindCheckpointReader(input: PrepareReplayInput): Promise<CheckpointReader> {
-	if (input.checkpointStore) {
-		const store = input.checkpointStore
-		const scope = requireScope(input.scope, 'prepareReplayState')
-		return {
-			list: () => store.listCheckpoints(scope),
-			read: (id) => store.readCheckpoint(scope, id),
-		}
-	}
-	const store = new RunDiskStore({ baseDir: input.baseDir, logger: input.logger })
-	await store.initRun(input.runId)
-	return {
-		list: () => store.listCheckpoints(),
-		read: (id) => store.readCheckpoint(id),
-	}
-}
-
-async function resolveEmergency(input: PrepareReplayInput): Promise<IterationCheckpoint> {
-	if (!input.emergencyDir) {
-		throw new Error(
-			"fromCheckpoint: 'emergency' requires an `emergencyDir` — conventionally sibling of baseDir",
-		)
-	}
-	const path = join(input.emergencyDir, `${input.runId}.json`)
-	try {
-		const dump = EmergencySaveManager.loadSave(path)
-		return projectEmergencyToCheckpoint(dump)
-	} catch (err) {
-		throw new Error(`No emergency dump found for run ${input.runId} at ${path}`, { cause: err })
-	}
-}

package/src/runtime/query/resume-run.ts

@@ -1,202 +0,0 @@
-import { NamzuError } from '../../types/errors/index.js'
-import type { PendingDecision } from '../../types/hitl/index.js'
-import type { CheckpointStore, FencingToken } from '../../types/run/checkpoint-store.js'
-import type { Run } from '../../types/run/entity.js'
-import type { RunEventReplay } from '../../types/run/event-cursor.js'
-import type { RunEventListener } from '../../types/run/events.js'
-import type { RunState } from '../../types/run/state.js'
-import { type QueryParams, drainQueryWithSelectedResumeState } from './index.js'
-import { type RunStateScope, loadSelectedRunState } from './run-state.js'
-
-/**
- * What a resume attempt found.
- *
- * Three outcomes rather than a nullable `Run`, because the two failures
- * mean opposite things to a caller. "No checkpoint" is a dead end — there
- * is nothing to continue and starting fresh would be a different run
- * wearing the same id. "Awaiting decision" is the run working as designed:
- * it parked on a question, and continuing means answering it first.
- */
-export type ResumeOutcome =
-	| { readonly resumed: false; readonly reason: 'no-checkpoint' }
-	| {
-			readonly resumed: false
-			readonly reason: 'awaiting-decision'
-			/** What to put in front of a human. */
-			readonly pending: PendingDecision
-			readonly state: RunState
-	  }
-	| {
-			readonly resumed: true
-			readonly run: Run
-			readonly state: RunState
-			/**
-			 * What became of {@link ResumeRunParams.eventCursor}. Absent when no
-			 * cursor was supplied.
-			 *
-			 * Reported rather than thrown: a stale cursor is the client's
-			 * problem and the run still had to be resumed. A caller that sees
-			 * `unavailable` re-derives its view from the run's transcript
-			 * instead of folding a hole into it.
-			 */
-			readonly replay?: RunEventReplay
-	  }
-
-/**
- * The half of a run that cannot be serialized, plus where to look.
- *
- * `messages` is deliberately absent. On resume the history comes from the
- * checkpoint and any passed messages would be discarded, so accepting them
- * would invite a caller to hand over a transcript that is silently ignored.
- */
-export interface ResumeRunParams
-	extends Omit<QueryParams, 'messages' | 'runId' | 'resumeFromCheckpoint'> {
-	/** Identifies the run inside the checkpoint store. */
-	readonly scope: RunStateScope
-	/** Required to find the checkpoint; also threaded into the resumed run. */
-	readonly checkpointStore: CheckpointStore
-
-	/**
-	 * The fence of the claim this worker took on the run before resuming.
-	 *
-	 * A resume is the one moment two workers are most likely to collide — it
-	 * is what a queue reader does with a parked run — so this is the call that
-	 * most needs to carry one.
-	 */
-	readonly claimFence?: FencingToken
-	/**
-	 * Resume a specific checkpoint instead of the one the store would pick.
-	 * Absent means the parked checkpoint if there is one, else the newest.
-	 */
-	readonly checkpointId?: RunState['checkpointId']
-
-	/**
-	 * Where to send the resumed run's events.
-	 *
-	 * This call had none, and the consequence was total: it drains the run to
-	 * completion and every event the run emits — every tool call, every park,
-	 * every token update — was discarded, because `drainQuery` forwards to a
-	 * listener and none was ever passed. So the one API for continuing a run
-	 * another process started could not show anybody what the run was doing.
-	 *
-	 * It is also what makes {@link ResumeRunParams.eventCursor} mean anything:
-	 * a catch-up delivered into a stream nobody receives is not a catch-up.
-	 */
-	readonly listener?: RunEventListener
-}
-
-/**
- * Continue a run that a different process started.
- *
- * Everything this needs already existed — `CheckpointManager` writes the
- * history, budgets, working state, trace context and any park;
- * `loadRunState` reads them back; `query` accepts `runId` +
- * `resumeFromCheckpoint` and restores all of it. What was missing was the
- * few lines that join them, so every host wrote their own — and in this
- * repo nothing outside the SDK ever did, which means the whole path shipped
- * untravelled.
- *
- * The division of labour is the one the mechanism already implies: the
- * CALLER brings what cannot be serialized — the provider client, the tool
- * registry, the sandbox, the working directory — and the STORE brings the
- * state. A snapshot deliberately holds no socket, no client and no open
- * file, so it could never have carried the first half.
- *
- * Refusing beats guessing at both failure points. A missing checkpoint does
- * not silently become a fresh run under a recycled id, and a park is not
- * resumed past without the answer it is waiting for.
- */
-export async function resumeRun(params: ResumeRunParams): Promise<ResumeOutcome> {
-	const {
-		scope,
-		checkpointStore,
-		checkpointId,
-		pendingDecision,
-		claimFence,
-		listener,
-		onEventReplay,
-		...rest
-	} = params
-
-	const selected = await loadSelectedRunState(checkpointStore, scope, checkpointId)
-	const state = selected?.state
-	if (!state?.checkpointId || !selected) return { resumed: false, reason: 'no-checkpoint' }
-	assertResumeRequestAttribution(params, state)
-
-	// A park is outstanding until it is answered. `resolvedAt` is what marks
-	// an answered one, so a checkpoint that carries a resolved decision is an
-	// ordinary resume, not a question waiting on anybody.
-	const outstanding = state.pending && !state.pending.resolvedAt ? state.pending : undefined
-	if (outstanding && !pendingDecision) {
-		return {
-			resumed: false,
-			reason: 'awaiting-decision',
-			pending: outstanding,
-			state,
-		}
-	}
-
-	let replay: RunEventReplay | undefined
-
-	const run = await drainQueryWithSelectedResumeState(
-		{
-			...rest,
-			messages: [],
-			runId: state.runId,
-			sessionId: state.sessionId,
-			topicId: state.topicId,
-			projectId: state.projectId,
-			tenantId: state.tenantId,
-			// Forwarded, and it is not cosmetic: the run store nests a sub-run's
-			// evidence under `<parent>/children/<run>`, so resuming a sub-run
-			// without this binds `<base>/<run>` instead — a second, empty
-			// transcript under a run id that already has one, a sequence that
-			// restarts at 1, and a catch-up that reports a live run as having
-			// produced nothing.
-			...(state.parentRunId !== undefined ? { parentRunId: state.parentRunId } : {}),
-			resumeFromCheckpoint: state.checkpointId,
-			checkpointStore,
-			...(claimFence !== undefined ? { claimFence } : {}),
-			...(pendingDecision ? { pendingDecision } : {}),
-			onEventReplay: (verdict: RunEventReplay) => {
-				replay = verdict
-				return onEventReplay?.(verdict)
-			},
-		} as QueryParams,
-		{
-			...state,
-			checkpointId: state.checkpointId,
-			...(selected.checkpoint.traceContext
-				? { traceContext: selected.checkpoint.traceContext }
-				: {}),
-		},
-		listener,
-	)
-
-	return {
-		resumed: true,
-		run,
-		state,
-		...(replay !== undefined ? { replay } : {}),
-	}
-}
-
-function assertResumeRequestAttribution(params: ResumeRunParams, state: RunState): void {
-	const mismatchedFields: string[] = []
-	if (params.scope.runId !== state.runId) mismatchedFields.push('runId')
-	if (params.sessionId !== state.sessionId) mismatchedFields.push('sessionId')
-	if (params.topicId !== state.topicId) mismatchedFields.push('topicId')
-	if (params.projectId !== state.projectId) mismatchedFields.push('projectId')
-	if (params.tenantId !== state.tenantId) mismatchedFields.push('tenantId')
-	if (params.parentRunId !== undefined && params.parentRunId !== state.parentRunId) {
-		mismatchedFields.push('parentRunId')
-	}
-	if (mismatchedFields.length === 0) return
-
-	throw new NamzuError({
-		code: 'invalid_config',
-		message:
-			'The resume request attribution does not match the checkpoint scope selected for this run.',
-		details: { fields: mismatchedFields },
-	})
-}