effect-agent 0.1.0-beta.12 → 0.1.0-beta.121

package/dist/RunJournal-BXrq0VIK.mjs

@@ -0,0 +1,931 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { RunId, ThreadId, ToolCallId, TurnId } from "./core/Identifiers.mjs";
+import { IdempotencyKey } from "./core/Receipt.mjs";
+import { ModelCallUsage, summarizeModelUsage } from "./core/Usage.mjs";
+import { f as contextWindowId, n as COMPACTION_SUMMARY_PREFIX, p as contextWindowMessage, t as CLEARED_TOOL_RESULT } from "./compaction-C2OTceKw.mjs";
+import { RunPolicyUsage } from "./core/RunPolicyUsage.mjs";
+import { BatchId, CanonicalBatch, CompactionCreated, ModelResponseRecorded, PersistedJson, RecordEnvelope, RecordId, RunCompleted, ToolCallSettled } from "./durable/Records.mjs";
+import { digestJson } from "./durable/Digest.mjs";
+import { Prompt } from "effect/unstable/ai";
+import { Effect, Schema, Stream } from "effect";
+//#region src/durable/internal/journal-metadata.ts
+const toolExecutionKey = (call) => JSON.stringify([
+	call.runId,
+	call.turn,
+	call.toolCallId
+]);
+/**
+* Attempt-local metadata collector. Feed every validated record exactly once, in canonical order,
+* including records omitted from the control view. A snapshot is independent of later suffix
+* additions and may only accompany a replay stream bounded at that same captured tail.
+*/
+const makeJournalMetadata = (ownerRunId, seed) => {
+	const firstSequenceByRun = /* @__PURE__ */ new Map();
+	if (seed?.firstSequence !== void 0) firstSequenceByRun.set(seed.runId, seed.firstSequence);
+	const lastResponseSequenceByRun = /* @__PURE__ */ new Map();
+	const terminalSequenceByRun = /* @__PURE__ */ new Map();
+	const settledSpans = [];
+	const toolExecutionEvidence = /* @__PURE__ */ new Set();
+	const settledToolCallRecordIds = /* @__PURE__ */ new Set();
+	const settledById = /* @__PURE__ */ new Map();
+	const compactions = [];
+	return {
+		add: (envelope) => {
+			const payload = envelope.record.payload;
+			if ((payload._tag === "RunCompleted" || payload._tag === "RunFailed" || payload._tag === "SubmissionSettled") && payload.runId !== void 0 && !terminalSequenceByRun.has(payload.runId)) terminalSequenceByRun.set(payload.runId, envelope.sequence);
+			if (payload._tag === "CompactionCreated") {
+				compactions.push({
+					payload,
+					sequence: envelope.sequence
+				});
+				return;
+			}
+			if ("runId" in payload && typeof payload.runId === "string" && !firstSequenceByRun.has(payload.runId)) firstSequenceByRun.set(payload.runId, envelope.sequence);
+			if (payload._tag === "ModelResponseRecorded") lastResponseSequenceByRun.set(payload.runId, envelope.sequence);
+			else if (payload._tag === "ToolCallPrepared" || payload._tag === "ToolCallUnknown") toolExecutionEvidence.add(toolExecutionKey(payload));
+			else if (payload._tag === "ToolCallSettled") {
+				settledToolCallRecordIds.add(envelope.record.recordId);
+				if (payload.runId === ownerRunId) settledById.set(envelope.record.recordId, {
+					isFailure: payload.isFailure,
+					...payload.toolSelection === void 0 ? {} : { toolSelection: payload.toolSelection },
+					...payload.budgetRejected === void 0 ? {} : { budgetRejected: payload.budgetRejected }
+				});
+				const from = lastResponseSequenceByRun.get(payload.runId);
+				if (from !== void 0 && from < envelope.sequence) settledSpans.push({
+					from,
+					to: envelope.sequence
+				});
+			}
+		},
+		snapshot: () => ({
+			ownerRunId,
+			seed,
+			firstSequenceByRun: new Map(firstSequenceByRun),
+			lastResponseSequenceByRun: new Map(lastResponseSequenceByRun),
+			terminalSequenceByRun: new Map(terminalSequenceByRun),
+			settledSpans: [...settledSpans],
+			toolExecutionEvidence: new Set(toolExecutionEvidence),
+			settledToolCallRecordIds: new Set(settledToolCallRecordIds),
+			settledById: new Map(settledById),
+			compactions: [...compactions]
+		})
+	};
+};
+//#endregion
+//#region src/durable/RunJournal.ts
+var RunJournal_exports = /* @__PURE__ */ __exportAll({
+	RunJournalError: () => RunJournalError,
+	agentUpdateRecordId: () => agentUpdateRecordId,
+	approvalDecisionBatchId: () => approvalDecisionBatchId,
+	childIdempotencyKeyFor: () => childIdempotencyKeyFor,
+	childThreadIdFor: () => childThreadIdFor,
+	compactionBatchId: () => compactionBatchId,
+	compactionRecordId: () => compactionRecordId,
+	firstWorkerInputRecordId: () => firstWorkerInputRecordId,
+	markUnknownBatchId: () => markUnknownBatchId,
+	modelResponseInterruptedBatchId: () => modelResponseInterruptedBatchId,
+	modelResponseInterruptedRecordId: () => modelResponseInterruptedRecordId,
+	modelResponseRecordId: () => modelResponseRecordId,
+	peerMessageRecordId: () => peerMessageRecordId,
+	projectRunJournal: () => projectRunJournal,
+	projectRunJournalStream: () => projectRunJournalStream,
+	promptFromCanonicalRecords: () => promptFromCanonicalRecords,
+	runCompletedRecordId: () => runCompletedRecordId,
+	runCompletionDigest: () => runCompletionDigest,
+	runDurationBatchId: () => runDurationBatchId,
+	runDurationRecordId: () => runDurationRecordId,
+	runIdForSubmission: () => runIdForSubmission,
+	runStartedBatchId: () => runStartedBatchId,
+	runStartedRecordId: () => runStartedRecordId,
+	subagentJoinBatchId: () => subagentJoinBatchId,
+	subagentJoinedRecordId: () => subagentJoinedRecordId,
+	subagentLineageBatchId: () => subagentLineageBatchId,
+	subagentLineageRecordId: () => subagentLineageRecordId,
+	subagentRequestedBatchId: () => subagentRequestedBatchId,
+	subagentRequestedRecordId: () => subagentRequestedRecordId,
+	subagentStartedBatchId: () => subagentStartedBatchId,
+	subagentStartedRecordId: () => subagentStartedRecordId,
+	toolApprovalDecisionRecordId: () => toolApprovalDecisionRecordId,
+	toolApprovalRequestRecordId: () => toolApprovalRequestRecordId,
+	toolCallPreparedRecordId: () => toolCallPreparedRecordId,
+	toolCallResolutionBatchId: () => toolCallResolutionBatchId,
+	toolCallResolvedRecordId: () => toolCallResolvedRecordId,
+	toolCallResultBatchId: () => toolCallResultBatchId,
+	toolCallSettledRecordId: () => toolCallSettledRecordId,
+	toolCallUnknownRecordId: () => toolCallUnknownRecordId,
+	toolStepSettledBatchId: () => toolStepSettledBatchId,
+	toolStepSettledRecordId: () => toolStepSettledRecordId,
+	turnApprovalsBatchId: () => turnApprovalsBatchId,
+	turnBatchId: () => turnBatchId,
+	turnCanonicalBatch: () => turnCanonicalBatch,
+	turnIdForRun: () => turnIdForRun,
+	turnPreparedBatchId: () => turnPreparedBatchId,
+	turnResponseBatch: () => turnResponseBatch,
+	turnResponseBatchId: () => turnResponseBatchId,
+	turnResultsBatch: () => turnResultsBatch,
+	turnResultsBatchId: () => turnResultsBatchId,
+	workerInputRecordId: () => workerInputRecordId,
+	workerOriginRecordId: () => workerOriginRecordId,
+	workerReportRecordId: () => workerReportRecordId
+});
+/** A canonical record could not be projected into Run/Prompt state. */
+var RunJournalError = class extends Schema.TaggedError()("RunJournalError", {
+	message: Schema.String,
+	cause: Schema.optionalKey(Schema.Defect())
+}) {};
+const journalError = (message, cause) => cause === void 0 ? RunJournalError.make({ message }) : RunJournalError.make({
+	message,
+	cause
+});
+const decodeRunId = Schema.decodeSync(RunId);
+const decodeTurnId = Schema.decodeSync(TurnId);
+const decodeBatchId = Schema.decodeSync(BatchId);
+const decodeRecordId = Schema.decodeSync(RecordId);
+/**
+* Deterministic Run identity pinned per Submission (plan §Coordinator flow). Every Attempt of one
+* Submission shares this Run identity, so canonical per-Turn records from different Attempts
+* belong to one logical Run.
+*/
+const runIdForSubmission = (submissionId) => decodeRunId(`run:${submissionId}`);
+/** Stable canonical clock identity shared by every Attempt of one Run. */
+const runStartedRecordId = (runId) => decodeRecordId(`run-start:${runId}`);
+const runStartedBatchId = (runId) => decodeBatchId(`run-start:${runId}`);
+const runDurationRecordId = (runId) => decodeRecordId(`run-duration:${runId}`);
+const runDurationBatchId = (runId) => decodeBatchId(`run-duration:${runId}`);
+/** Deterministic Turn identity: Attempt-independent for one (Run, canonical turn) pair. */
+const turnIdForRun = (runId, turn) => decodeTurnId(`turn:${runId}:${turn}`);
+/** Deterministic batch identity of one committed canonical no-tool Turn (P4 single-batch shape). */
+const turnBatchId = (runId, turn) => decodeBatchId(`turn:${runId}:${turn}`);
+/**
+* Deterministic batch identity of a tool-declaring Turn's RESPONSE commit (plan §2.1 commit 1):
+* the assistant response plus pending steering becomes canonical BEFORE approval preflight and
+* tool preparation, creating the durability §15 "resume tool scheduling" window.
+*/
+const turnResponseBatchId = (runId, turn) => decodeBatchId(`turn-response:${runId}:${turn}`);
+/**
+* Deterministic batch identity of a tool-declaring Turn's RESULTS commit (plan §2.1 commit 5):
+* every `ToolCallSettled` record of the Turn, in declaration order, model-visible atomically.
+*/
+const turnResultsBatchId = (runId, turn) => decodeBatchId(`turn-results:${runId}:${turn}`);
+/**
+* Deterministic per-call late-settle batch identity used by the resolution path when one
+* recovered/resolved call settles outside its Turn's results batch. Record identity
+* (`tool-settled:{runId}:{turn}:{toolCallId}`) dedupes double-settles across both paths.
+*/
+const toolCallResultBatchId = (runId, turn, toolCallId) => decodeBatchId(`turn-results:${runId}:${turn}:${toolCallId}`);
+/** Deterministic batch identity of one Turn's `ToolCallPrepared` commit (plan §2.1 commit 3). */
+const turnPreparedBatchId = (runId, turn) => decodeBatchId(`turn-prepared:${runId}:${turn}`);
+/**
+* Deterministic identity of one pre-Turn compaction record (RUN-026,
+* RUN-026). Keyed by Run, Turn, and kind — the engine performs at most one
+* threshold compaction per Turn plus at most one overflow-forced summarize,
+* so a superseding Attempt that re-decides the same compaction replays the
+* batch identity instead of duplicating the record.
+*/
+const compactionRecordId = (runId, turn, kind) => decodeRecordId(`compaction:${runId}:${turn}:${kind}`);
+/** Deterministic batch identity of one compaction append (same string as its record id). */
+const compactionBatchId = (runId, turn, kind) => decodeBatchId(`compaction:${runId}:${turn}:${kind}`);
+/** Deterministic canonical record identity of one Turn's `ModelResponseRecorded` record. */
+const modelResponseRecordId = (runId, turn) => decodeRecordId(`model-response:${runId}:${turn}`);
+/** Terminal Tool completion marker committed atomically with its settled Tool result. */
+const runCompletedRecordId = (runId) => decodeRecordId(`run-completed:${runId}`);
+/** Native source reservation locator, including the first admission of a continuing worker. */
+const workerInputRecordId = (messageId) => decodeRecordId(`worker-input:${messageId}`);
+/** Source-owned first reservation; native worker identity is minted from its first message. */
+const firstWorkerInputRecordId = (worker) => decodeRecordId(`worker-input:${worker.threadId}`);
+const workerOriginRecordId = (threadId) => decodeRecordId(`worker-origin:${threadId}`);
+const workerReportRecordId = (messageId) => decodeRecordId(`worker-report:${messageId}`);
+const peerMessageRecordId = (messageId) => decodeRecordId(messageId);
+/** Same immutable tuple used by native update admission; callers never parse its hash. */
+const agentUpdateRecordId = Effect.fn("RunJournal.agentUpdateRecordId")(function* (threadId, runId, updateId) {
+	return decodeRecordId(`agent-update:${yield* digestJson([
+		threadId,
+		runId,
+		updateId
+	])}`);
+});
+/** Deterministic canonical record identity of one Turn's `ToolCallSettled` record. */
+const toolCallSettledRecordId = (runId, turn, toolCallId) => decodeRecordId(`tool-settled:${runId}:${turn}:${toolCallId}`);
+/** Deterministic canonical record identity of one Tool Call's `ToolCallPrepared` record. */
+const toolCallPreparedRecordId = (runId, turn, toolCallId) => decodeRecordId(`tool-prepared:${runId}:${turn}:${toolCallId}`);
+/** Deterministic batch identity of one Turn's `ToolCallUnknown` marking append. */
+const markUnknownBatchId = (submissionId, turn) => decodeBatchId(`mark-unknown:${submissionId}:${turn}`);
+/** Deterministic canonical record identity of one Tool Call's `ToolCallUnknown` record. */
+const toolCallUnknownRecordId = (runId, turn, toolCallId) => decodeRecordId(`tool-unknown:${runId}:${turn}:${toolCallId}`);
+/** Deterministic batch identity of one Tool Call's resolution append (DUR-017). */
+const toolCallResolutionBatchId = (submissionId, toolCallId) => decodeBatchId(`resolve:${submissionId}:${toolCallId}`);
+/** Deterministic canonical record identity of one Tool Call's `ToolCallResolved` record. */
+const toolCallResolvedRecordId = (runId, turn, toolCallId) => decodeRecordId(`tool-resolved:${runId}:${turn}:${toolCallId}`);
+/**
+* Deterministic identity of one accepted Durable Step result. The one-record batch reuses the
+* SAME string, so batch idempotency plus the epoch fence realize the durability §11
+* racing-writers rule: only the fenced winner's record commits; the loser replays it.
+* A versioned JSON tuple keeps separator characters in each identity component distinct.
+* Replay derives this key from the structured payload, including records with legacy IDs.
+*/
+const toolStepSettledRecordId = (runId, toolCallId, stepName) => decodeRecordId(JSON.stringify([
+	"step@2",
+	runId,
+	toolCallId,
+	stepName
+]));
+/** Deterministic batch identity of one Durable Step commit (same string as its record id). */
+const toolStepSettledBatchId = (runId, toolCallId, stepName) => decodeBatchId(toolStepSettledRecordId(runId, toolCallId, stepName));
+/** Deterministic batch identity of one Turn's canonical approval-request append (plan §2.6). */
+const turnApprovalsBatchId = (runId, turn) => decodeBatchId(`turn-approvals:${runId}:${turn}`);
+/** Deterministic canonical record identity of one Tool Call's `ToolApprovalRequested` record. */
+const toolApprovalRequestRecordId = (runId, turn, toolCallId) => decodeRecordId(`approval-request:${runId}:${turn}:${toolCallId}`);
+/** Deterministic batch identity of one Tool Call's canonical approval-decision append. */
+const approvalDecisionBatchId = (submissionId, toolCallId) => decodeBatchId(`approval-decision:${submissionId}:${toolCallId}`);
+/** Deterministic canonical record identity of one Tool Call's `ToolApprovalDecided` record. */
+const toolApprovalDecisionRecordId = (runId, turn, toolCallId) => decodeRecordId(`approval-decision:${runId}:${turn}:${toolCallId}`);
+/**
+* Deterministic identity of one superseded Attempt's `ModelResponseInterrupted` audit record
+* (durability §9). Keyed by the superseded epoch, so each interrupted ownership period is
+* recorded at most once; the one-record batch reuses the same string.
+*/
+const modelResponseInterruptedRecordId = (runId, supersededEpoch) => decodeRecordId(`interrupted:${runId}:${supersededEpoch}`);
+/** Deterministic batch identity of one `ModelResponseInterrupted` append (same string). */
+const modelResponseInterruptedBatchId = (runId, supersededEpoch) => decodeBatchId(`interrupted:${runId}:${supersededEpoch}`);
+const decodeThreadId = Schema.decodeSync(ThreadId);
+const decodeIdempotencyKey = Schema.decodeSync(IdempotencyKey);
+/**
+* Deterministic canonical record identity of one parent Tool Call's `SubagentRequested` record.
+* The one-record batch reuses the same string, so batch
+* idempotency plus the parent epoch fence make the request append exactly-once-canonical.
+*/
+const subagentRequestedRecordId = (runId, toolCallId) => decodeRecordId(`subagent-requested:${runId}:${toolCallId}`);
+/** Deterministic batch identity of one `SubagentRequested` append (same string). */
+const subagentRequestedBatchId = (runId, toolCallId) => decodeBatchId(`subagent-requested:${runId}:${toolCallId}`);
+/**
+* Deterministic canonical record identity of one parent Tool Call's `SubagentStarted` record.
+* Recovery's start-link repair appends the EXACT same record
+* under this identity, so a raced repair replays instead of duplicating (SUB-016/SUB-017).
+*/
+const subagentStartedRecordId = (runId, toolCallId) => decodeRecordId(`subagent-started:${runId}:${toolCallId}`);
+/** Deterministic batch identity of one `SubagentStarted` append (same string). */
+const subagentStartedBatchId = (runId, toolCallId) => decodeBatchId(`subagent-started:${runId}:${toolCallId}`);
+/**
+* Deterministic batch identity of one parent Tool Call's atomic settlement join: the
+* `SubagentJoined` record plus the parent's `ToolCallSettled` record (its existing
+* `tool-settled:{runId}:{turn}:{toolCallId}` identity) commit as ONE canonical batch (SUB-019).
+*/
+const subagentJoinBatchId = (runId, toolCallId) => decodeBatchId(`subagent-join:${runId}:${toolCallId}`);
+/** Deterministic canonical record identity of one parent Tool Call's `SubagentJoined` record. */
+const subagentJoinedRecordId = (runId, toolCallId) => decodeRecordId(`subagent-joined:${runId}:${toolCallId}`);
+/**
+* Deterministic identity of one child Thread's `SubagentLineageRecorded` record.
+* Its own single-record batch reuses the same string so the generic
+* `thread-created:{cid}` batch identity is never contradicted.
+*/
+const subagentLineageRecordId = (threadId) => decodeRecordId(`subagent-lineage:${threadId}`);
+/** Deterministic batch identity of one `SubagentLineageRecorded` append (same string). */
+const subagentLineageBatchId = (threadId) => decodeBatchId(`subagent-lineage:${threadId}`);
+/**
+* Deterministic intended child Thread identity: the
+* parent Submission and Tool Call pair addresses exactly one child Thread, so a replayed
+* establishment converges on the one existing child (SUB-016).
+*/
+const childThreadIdFor = (parentSubmissionId, toolCallId) => decodeThreadId(`subagent:${parentSubmissionId}:${toolCallId}`);
+/**
+* Deterministic child admission idempotency key: scoped to
+* the parent Run and Tool Call identity, so duplicate admission attempts resolve through the
+* ledger's idempotency contract to one child Receipt (SUB-016, SUB-031). The ledger key is
+* bounded (256); coordinator-minted Run and Tool Call identities stay far below that bound.
+*/
+const childIdempotencyKeyFor = (parentRunId, toolCallId) => decodeIdempotencyKey(`subagent:${parentRunId}:${toolCallId}`);
+const decodePromptMessages = Effect.fn("RunJournal.decodePromptMessages")((messages) => Schema.decodeUnknownEffect(Prompt.Prompt)(messages).pipe(Effect.mapError((cause) => journalError("Canonical messages are not Schema-encoded Prompt messages", cause))));
+const toolMessageFromSettled = Effect.fn("RunJournal.toolMessageFromSettled")((settled) => Effect.try({
+	try: () => Prompt.makeMessage("tool", { content: settled.map(({ record, cleared }) => Prompt.makePart("tool-result", {
+		id: record.toolCallId,
+		name: record.toolName,
+		result: cleared ? CLEARED_TOOL_RESULT : record.result,
+		isFailure: record.isFailure,
+		providerExecuted: false
+	})) }),
+	catch: (cause) => journalError("Unable to rebuild Tool message from ToolCallSettled", cause)
+}));
+const projectedResponseUsage = (response) => Effect.gen(function* () {
+	const calls = response.modelUsage;
+	if (calls === void 0) return {
+		modelCalls: 1,
+		inputTokens: response.inputTokens ?? 0,
+		outputTokens: response.outputTokens ?? 0,
+		costMicrousd: response.costMicrousd ?? 0,
+		modelUsage: []
+	};
+	if (calls.length === 0) return yield* journalError("A canonical modelUsage list must not be empty");
+	const summary = yield* summarizeModelUsage(calls).pipe(Effect.mapError((cause) => journalError("Canonical model usage exceeds accounting bounds", cause)));
+	if (response.inputTokens !== void 0 && response.inputTokens !== summary.inputTokens.total || response.outputTokens !== void 0 && response.outputTokens !== summary.outputTokens.total || response.costMicrousd !== void 0 && response.costMicrousd !== summary.costMicrousd) return yield* journalError("Canonical detailed and aggregate model usage disagree");
+	return {
+		modelCalls: summary.modelCalls,
+		inputTokens: summary.inputTokens.total,
+		outputTokens: summary.outputTokens.total,
+		costMicrousd: summary.costMicrousd,
+		modelUsage: calls
+	};
+});
+const addProjectedUsage = (field, left, right) => Schema.decodeEffect(Schema.Natural)(left + right).pipe(Effect.mapError((cause) => journalError(`Canonical projected usage exceeds safe-integer bounds at ${field}`, cause)));
+const decodeToolCallId = Schema.decodeSync(ToolCallId);
+const declaredApplicationToolCallIds = (prompt) => {
+	const ids = [];
+	for (const message of prompt.content) {
+		if (message.role !== "assistant") continue;
+		for (const part of message.content) if (part.type === "tool-call" && !part.providerExecuted) ids.push(part.id);
+	}
+	return ids;
+};
+/**
+* Phase 5 audit tags that are prompt-transparent: they carry durability evidence (preparation,
+* unknown marking, resolution, Step results, approvals, interruption) but contribute nothing to
+* the model-visible Prompt, and — unlike the P4 tags — they do NOT split a contiguous
+* `ToolCallSettled` group into separate Tool messages, so a late-settled call's audit records
+* cannot change the replayed prompt shape.
+*
+* The four S2 Subagent lifecycle tags are prompt-transparent for the same reason (spec §5/§11):
+* the parent prompt never carries child transcript or establishment evidence — the joined child
+* result reaches the model exclusively through the paired `ToolCallSettled` record, and the
+* child-log lineage record is not model input.
+*/
+const PROMPT_TRANSPARENT_TAGS = /* @__PURE__ */ new Set([
+	"RunPolicyUsageReserved",
+	"RunStarted",
+	"RunDurationExhausted",
+	"ToolCallPrepared",
+	"ToolCallUnknown",
+	"ToolCallResolved",
+	"ToolStepSettled",
+	"ToolApprovalRequested",
+	"ToolApprovalDecided",
+	"ModelResponseInterrupted",
+	"SubagentRequested",
+	"SubagentStarted",
+	"SubagentJoined",
+	"SubagentLineageRecorded",
+	"WorkerInputRequested",
+	"WorkerOriginRecorded",
+	"WorkerInputCompleted",
+	"WorkerReportPrepared",
+	"AgentUpdateEmitted",
+	"WorkerReportRefused",
+	"PeerMessagePrepared",
+	"SubtreeBudgetReserved"
+]);
+/**
+* Reconstruct a fixed canonical prefix from a re-readable stream. The caller must keep the same
+* records visible on every traversal. The first collects compaction and settlement metadata;
+* rollovers additionally validate covered Tool batches before rebuilding Prompt and usage. Metadata and the
+* live Prompt remain resident; covered historical message/tool payloads do not. An uncompacted Prompt still grows
+* with its conversation, so hosts must configure an appropriate context compaction policy.
+* Prepared metadata must describe exactly this stream and seed through the same fixed tail;
+* it skips only the metadata scan, never covered-Tool validation or the canonical fold.
+* @internal
+*/
+const projectRunJournalStream = Effect.fn("RunJournal.projectRunJournalStream")(function* (records, ownerRunId, onBoundary, seed, preparedMetadata) {
+	if (seed !== void 0 && seed.runId !== ownerRunId) return yield* journalError("Recovery checkpoint belongs to another Run");
+	let state = {
+		all: [],
+		before: [],
+		pendingTools: [],
+		pendingToolsForRun: false,
+		committedTurns: seed?.committedTurns ?? 0
+	};
+	if (preparedMetadata !== void 0 && (preparedMetadata.ownerRunId !== ownerRunId || preparedMetadata.seed !== seed)) return yield* journalError("Prepared journal metadata belongs to another replay");
+	let metadata = preparedMetadata;
+	if (metadata === void 0) {
+		const collected = makeJournalMetadata(ownerRunId, seed);
+		yield* Stream.runForEach(records, (envelope) => Effect.sync(() => collected.add(envelope)));
+		metadata = collected.snapshot();
+	}
+	const { firstSequenceByRun, lastResponseSequenceByRun, terminalSequenceByRun, settledSpans, toolExecutionEvidence, settledToolCallRecordIds, settledById, compactions } = metadata;
+	const settledCoverage = compactions.reduce((through, { payload }) => payload.kind !== "summarize" ? Math.max(through, payload.coversThrough) : through, 0);
+	const isTerminalPriorRun = (candidateRunId, compactionRunId, beforeSequence) => {
+		const terminal = terminalSequenceByRun.get(candidateRunId);
+		return candidateRunId !== compactionRunId && terminal !== void 0 && terminal < beforeSequence && terminal > (lastResponseSequenceByRun.get(candidateRunId) ?? 0);
+	};
+	const incompleteResponseSequences = [];
+	let ownerPrefixSequence = seed?.firstSequence ?? Number.POSITIVE_INFINITY;
+	let protectedContext = seed?.protectedContext === void 0 ? void 0 : yield* decodePromptMessages(seed.protectedContext);
+	if (settledCoverage > 0) yield* Stream.runForEach(records, (envelope) => Effect.gen(function* () {
+		const payload = envelope.record.payload;
+		if (payload._tag !== "ModelResponseRecorded" || envelope.sequence > settledCoverage) return;
+		const messages = yield* decodePromptMessages(payload.messages);
+		const declared = declaredApplicationToolCallIds(messages);
+		for (const id of declared) {
+			const callId = yield* Schema.decodeEffect(ToolCallId)(id).pipe(Effect.mapError((cause) => journalError("Failed to decode a declared Tool Call ID", cause)));
+			if (!settledToolCallRecordIds.has(toolCallSettledRecordId(payload.runId, payload.turn, callId))) {
+				incompleteResponseSequences.push({
+					sequence: envelope.sequence,
+					runId: payload.runId
+				});
+				break;
+			}
+		}
+		if (payload.runId === ownerRunId && payload.turn === 1 && payload.runScopedPrefixLength !== void 0) {
+			ownerPrefixSequence = envelope.sequence;
+			protectedContext = Prompt.fromMessages(messages.content.slice(0, payload.runScopedPrefixLength));
+		}
+	}));
+	const boundIsValid = (payload, ownSequence) => {
+		const { runId, coversThrough } = payload;
+		if (coversThrough <= 0 || coversThrough >= ownSequence) return false;
+		if (seed !== void 0 && ownSequence === seed.compaction.sequence) return seed.compaction.record.payload._tag === "CompactionCreated" && Schema.toEquivalence(CompactionCreated)(payload, seed.compaction.record.payload);
+		const ownerFirst = firstSequenceByRun.get(runId);
+		if (payload.kind === "summarize" && ownerFirst !== void 0 && coversThrough >= ownerFirst) return false;
+		if (payload.kind !== "summarize" && incompleteResponseSequences.some((response) => response.sequence <= coversThrough && !isTerminalPriorRun(response.runId, runId, ownSequence))) return false;
+		for (const span of settledSpans) if (span.from <= coversThrough && coversThrough < span.to) return false;
+		return true;
+	};
+	let summarizeBound = 0;
+	let replacement;
+	let summarizeSequence = -1;
+	let clearBound = 0;
+	let latestWindowId = seed?.contextWindowId;
+	let latestWindowSequence = seed?.throughSequence ?? -1;
+	let rolloverCoveredThrough = 0;
+	for (const { payload, sequence } of compactions) {
+		if (!boundIsValid(payload, sequence)) continue;
+		if (payload.kind === "rollover" && sequence > latestWindowSequence) {
+			latestWindowId = contextWindowId(payload.runId, payload.turn);
+			latestWindowSequence = sequence;
+		}
+		if (payload.kind === "rollover") rolloverCoveredThrough = Math.max(rolloverCoveredThrough, payload.coversThrough);
+		if (payload.kind === "summarize" || payload.kind === "rollover") {
+			if (payload.kind === "summarize" && payload.summary === void 0) continue;
+			if (payload.coversThrough > summarizeBound || payload.coversThrough === summarizeBound && sequence > summarizeSequence) {
+				summarizeBound = payload.coversThrough;
+				summarizeSequence = sequence;
+				replacement = payload;
+			}
+		} else if (payload.coversThrough > clearBound) clearBound = payload.coversThrough;
+	}
+	let summaryEmitted = false;
+	const retainedPrefix = replacement?.kind === "rollover" && replacement.runId === ownerRunId && ownerPrefixSequence <= summarizeBound ? protectedContext?.content ?? [] : [];
+	const replacementLength = replacement === void 0 ? 0 : retainedPrefix.length + 1;
+	if (seed?.frontier !== void 0) onBoundary?.({
+		...seed.frontier,
+		promptLength: replacementLength
+	});
+	const emitSummary = () => {
+		if (summaryEmitted || replacement === void 0) return;
+		summaryEmitted = true;
+		const message = replacement.kind === "rollover" ? contextWindowMessage(contextWindowId(replacement.runId, replacement.turn), replacement.handoff) : Prompt.makeMessage("user", { content: [Prompt.makePart("text", { text: `${COMPACTION_SUMMARY_PREFIX}${replacement.summary}` })] });
+		state.all.push(...retainedPrefix, message);
+		if (replacement.kind !== "rollover" || replacement.runId !== ownerRunId) state.before.push(message);
+	};
+	const modelUsage = [];
+	let unobservedModelCalls = seed?.unobservedModelCalls ?? 0;
+	const usage = {
+		modelCalls: seed?.modelCalls ?? 0,
+		inputTokens: seed?.inputTokens ?? 0,
+		outputTokens: seed?.outputTokens ?? 0,
+		lastInputTokens: seed?.lastInputTokens ?? 0,
+		lastOutputTokens: seed?.lastOutputTokens ?? 0,
+		costMicrousd: seed?.costMicrousd ?? 0,
+		modelUsage,
+		...seed === void 0 ? {} : { summarizedModelUsage: seed.summarizedModelUsage }
+	};
+	let toolSelection = seed?.toolSelection;
+	let usageTurn = seed?.committedTurns ?? 0;
+	const incompleteToolTurns = /* @__PURE__ */ new Set();
+	const incompleteToolCalls = /* @__PURE__ */ new Set();
+	let pendingContextToolCallId;
+	let ownerTerminated = false;
+	const policyUsage = {
+		committedTurns: seed?.policyUsage.committedTurns ?? 0,
+		toolCalls: seed?.policyUsage.toolCalls ?? 0,
+		programmaticToolCalls: seed?.policyUsage.programmaticToolCalls ?? 0,
+		consecutiveToolFailures: seed?.policyUsage.consecutiveToolFailures ?? 0,
+		finalizationUsed: seed?.policyUsage.finalizationUsed ?? false
+	};
+	const accountResponse = Effect.fn("RunJournal.accountResponse")(function* (envelope, payload, messages) {
+		const record = envelope.record;
+		const declared = declaredApplicationToolCallIds(messages);
+		const declaredRecordIds = [];
+		for (const id of declared) {
+			const toolCallId = yield* Effect.try({
+				try: () => decodeToolCallId(id),
+				catch: (cause) => journalError("Failed to decode a declared Tool Call ID", cause)
+			});
+			declaredRecordIds.push(toolCallSettledRecordId(payload.runId, payload.turn, toolCallId));
+		}
+		if (declaredRecordIds.some((recordId) => !settledToolCallRecordIds.has(recordId))) {
+			incompleteToolTurns.add(envelope.record.recordId);
+			for (const recordId of declaredRecordIds) incompleteToolCalls.add(recordId);
+		}
+		if (payload.runId !== ownerRunId) return;
+		if (seed !== void 0 && envelope.sequence <= seed.throughSequence) return;
+		if (payload.turn === 1 && payload.runScopedPrefixLength !== void 0) protectedContext = Prompt.fromMessages(messages.content.slice(0, payload.runScopedPrefixLength));
+		const responseUsage = yield* projectedResponseUsage(payload);
+		unobservedModelCalls = yield* addProjectedUsage("unobservedModelCalls", unobservedModelCalls, payload.unobservedModelCalls ?? 0);
+		usage.modelCalls = yield* addProjectedUsage("modelCalls", usage.modelCalls, responseUsage.modelCalls);
+		usage.inputTokens = yield* addProjectedUsage("inputTokens", usage.inputTokens, responseUsage.inputTokens);
+		usage.outputTokens = yield* addProjectedUsage("outputTokens", usage.outputTokens, responseUsage.outputTokens);
+		usage.costMicrousd = yield* addProjectedUsage("costMicrousd", usage.costMicrousd, responseUsage.costMicrousd);
+		usage.modelUsage.push(...responseUsage.modelUsage);
+		if (payload.turn > usageTurn) {
+			usageTurn = payload.turn;
+			usage.lastInputTokens = responseUsage.inputTokens;
+			usage.lastOutputTokens = responseUsage.outputTokens;
+		}
+		policyUsage.committedTurns = Math.max(policyUsage.committedTurns, payload.turn);
+		const calls = messages.content.flatMap((message) => message.role === "assistant" ? message.content.filter((part) => part.type === "tool-call") : []);
+		const candidate = calls.length === 1 ? calls[0] : void 0;
+		const candidateResult = candidate === void 0 ? void 0 : settledById.get(`tool-settled:${ownerRunId}:${payload.turn}:${candidate.id}`);
+		pendingContextToolCallId = candidate !== void 0 && !candidate.providerExecuted && candidateResult?.isFailure === false && candidateResult.budgetRejected !== true && envelope.sequence > rolloverCoveredThrough ? candidate.id : void 0;
+		policyUsage.toolCalls += calls.length;
+		if (payload.toolExposure !== void 0) toolSelection = payload.toolExposure.selection;
+		if (incompleteToolTurns.has(record.recordId)) return;
+		for (const call of calls) {
+			const result = call.providerExecuted ? messages.content.flatMap((message) => message.role === "assistant" ? message.content : []).find((part) => part.type === "tool-result" && part.providerExecuted && part.id === call.id) : settledById.get(`tool-settled:${ownerRunId}:${payload.turn}:${call.id}`);
+			if (result === void 0 || "budgetRejected" in result && result.budgetRejected === true) continue;
+			if (!("isFailure" in result)) continue;
+			if (!result.isFailure && "toolSelection" in result && result.toolSelection !== void 0) toolSelection = result.toolSelection;
+			policyUsage.consecutiveToolFailures = result.isFailure ? policyUsage.consecutiveToolFailures + 1 : 0;
+		}
+	});
+	const historicalResults = /* @__PURE__ */ new Map();
+	let pendingToolOrder = /* @__PURE__ */ new Map();
+	const flushTools = Effect.fn("RunJournal.flushTools")(function* (current) {
+		if (current.pendingTools.length === 0) return current;
+		const ordered = current.pendingTools.toSorted((left, right) => (pendingToolOrder.get(left.record.toolCallId) ?? Number.MAX_SAFE_INTEGER) - (pendingToolOrder.get(right.record.toolCallId) ?? Number.MAX_SAFE_INTEGER));
+		const toolMessage = yield* toolMessageFromSettled(ordered);
+		current.all.push(toolMessage);
+		if (!current.pendingToolsForRun) current.before.push(toolMessage);
+		return {
+			...current,
+			pendingTools: [],
+			pendingToolsForRun: false
+		};
+	});
+	yield* Stream.runForEach(records, (envelope) => Effect.gen(function* () {
+		const payload = envelope.record.payload;
+		if ((payload._tag === "RunCompleted" || payload._tag === "RunFailed") && payload.runId === ownerRunId || payload._tag === "SubmissionSettled" && runIdForSubmission(payload.submissionId) === ownerRunId) ownerTerminated = true;
+		if (payload._tag === "RunPolicyUsageReserved" && payload.runId === ownerRunId) {
+			if (seed !== void 0 && envelope.sequence <= seed.throughSequence) return;
+			if (payload.programmaticToolCalls < policyUsage.programmaticToolCalls || policyUsage.finalizationUsed && !payload.finalizationUsed) return yield* journalError("Run policy reservations must be monotonic");
+			policyUsage.programmaticToolCalls = payload.programmaticToolCalls;
+			policyUsage.finalizationUsed = payload.finalizationUsed;
+		}
+		if (PROMPT_TRANSPARENT_TAGS.has(payload._tag)) return;
+		if (payload._tag === "CompactionCreated") return;
+		if (seed !== void 0 && envelope.sequence <= seed.throughSequence && (payload._tag === "ModelResponseRecorded" || payload._tag === "ToolCallSettled")) return;
+		if (envelope.sequence <= summarizeBound) {
+			if (payload._tag === "ModelResponseRecorded" && payload.runId === ownerRunId) {
+				const messages = yield* decodePromptMessages(payload.messages);
+				yield* accountResponse(envelope, payload, messages);
+				state = {
+					...state,
+					committedTurns: Math.max(state.committedTurns, payload.turn)
+				};
+			}
+			if (payload._tag === "ModelResponseRecorded" || payload._tag === "ToolCallSettled") onBoundary?.({
+				sequence: envelope.sequence,
+				tag: payload._tag,
+				promptLength: replacementLength,
+				...isTerminalPriorRun(payload.runId, ownerRunId, Number.POSITIVE_INFINITY) ? { terminalPriorRun: true } : {},
+				...incompleteToolTurns.has(envelope.record.recordId) || incompleteToolCalls.has(envelope.record.recordId) ? { incomplete: true } : {}
+			});
+			return;
+		}
+		emitSummary();
+		if (payload._tag === "ToolCallSettled") {
+			if (payload.runId !== ownerRunId) {
+				const slot = historicalResults.get(envelope.record.recordId);
+				if (slot === void 0) return yield* journalError("Historical Tool result has no matching declaration");
+				const declared = slot.parts[slot.partIndex];
+				if (declared?.id !== payload.toolCallId || declared.name !== payload.toolName) return yield* journalError("Historical Tool result differs from its declaration");
+				slot.parts[slot.partIndex] = Prompt.makePart("tool-result", {
+					id: payload.toolCallId,
+					name: payload.toolName,
+					result: envelope.sequence <= clearBound ? CLEARED_TOOL_RESULT : payload.result,
+					isFailure: payload.isFailure,
+					providerExecuted: false
+				});
+				const message = Prompt.makeMessage("tool", { content: [...slot.parts] });
+				state.all[slot.allIndex] = message;
+				state.before[slot.beforeIndex] = message;
+				historicalResults.delete(envelope.record.recordId);
+				onBoundary?.({
+					sequence: envelope.sequence,
+					tag: payload._tag,
+					promptLength: state.all.length,
+					...incompleteToolCalls.has(envelope.record.recordId) ? { incomplete: true } : {},
+					...isTerminalPriorRun(payload.runId, ownerRunId, Number.POSITIVE_INFINITY) ? { terminalPriorRun: true } : {}
+				});
+				return;
+			}
+			if (state.pendingTools.length > 0 && state.pendingToolsForRun !== (payload.runId === ownerRunId)) state = yield* flushTools(state);
+			state.pendingTools.push({
+				record: payload,
+				cleared: envelope.sequence <= clearBound
+			});
+			state = {
+				...state,
+				pendingToolsForRun: payload.runId === ownerRunId
+			};
+			onBoundary?.({
+				sequence: envelope.sequence,
+				tag: payload._tag,
+				promptLength: state.all.length + 1,
+				...isTerminalPriorRun(payload.runId, ownerRunId, Number.POSITIVE_INFINITY) ? { terminalPriorRun: true } : {},
+				...incompleteToolCalls.has(envelope.record.recordId) ? { incomplete: true } : {}
+			});
+			return;
+		}
+		state = yield* flushTools(state);
+		if (payload._tag === "ModelCompleted" && payload.messages !== void 0) {
+			const messages = yield* decodePromptMessages(payload.messages);
+			for (const message of messages.content) {
+				state.all.push(message);
+				if (payload.runId !== ownerRunId) state.before.push(message);
+			}
+			return;
+		}
+		if (payload._tag !== "ModelResponseRecorded") return;
+		const messages = yield* decodePromptMessages(payload.messages);
+		const forRun = payload.runId === ownerRunId;
+		pendingToolOrder = new Map(declaredApplicationToolCallIds(messages).map((id, index) => [id, index]));
+		yield* accountResponse(envelope, payload, messages);
+		const visibleMessages = forRun ? messages.content : messages.content.filter((message) => message.role !== "system");
+		for (const message of visibleMessages) {
+			state.all.push(message);
+			if (!forRun) state.before.push(message);
+		}
+		if (!forRun) {
+			const calls = messages.content.flatMap((message) => message.role === "assistant" ? message.content.filter((part) => part.type === "tool-call" && !part.providerExecuted) : []);
+			if (calls.length > 0) {
+				const parts = yield* Effect.forEach(calls, (call) => Effect.gen(function* () {
+					const callId = yield* Schema.decodeEffect(ToolCallId)(call.id).pipe(Effect.mapError((cause) => journalError("Invalid historical Tool Call ID", cause)));
+					const operation = payload.toolOperations?.find((operation) => operation.toolCallId === callId && operation.toolName === call.name);
+					const notExecuted = operation !== void 0 && (operation.executionClass !== "readonly" || operation.executionKind !== "ordinary") && !toolExecutionEvidence.has(toolExecutionKey({
+						runId: payload.runId,
+						turn: payload.turn,
+						toolCallId: callId
+					}));
+					return Prompt.makePart("tool-result", {
+						id: call.id,
+						name: call.name,
+						result: notExecuted ? {
+							_tag: "ToolUnavailable",
+							toolName: call.name,
+							execution: "not-executed",
+							message: "This earlier call never reached durable preparation and was not executed."
+						} : {
+							_tag: "ToolOutcomeUnknown",
+							message: "This earlier operation has no recorded outcome. It may have executed. Do not assume success or retry it; its original operation remains unresolved."
+						},
+						isFailure: true,
+						providerExecuted: false
+					});
+				}));
+				const allIndex = state.all.length;
+				const beforeIndex = state.before.length;
+				const message = Prompt.makeMessage("tool", { content: parts });
+				state.all.push(message);
+				state.before.push(message);
+				for (const [partIndex, call] of calls.entries()) {
+					const callId = yield* Schema.decodeEffect(ToolCallId)(call.id).pipe(Effect.mapError((cause) => journalError("Invalid historical Tool Call ID", cause)));
+					historicalResults.set(toolCallSettledRecordId(payload.runId, payload.turn, callId), {
+						allIndex,
+						beforeIndex,
+						parts,
+						partIndex
+					});
+				}
+			}
+		}
+		state = {
+			...state,
+			committedTurns: forRun ? Math.max(state.committedTurns, payload.turn) : state.committedTurns
+		};
+		onBoundary?.({
+			sequence: envelope.sequence,
+			tag: payload._tag,
+			promptLength: state.all.length,
+			...isTerminalPriorRun(payload.runId, ownerRunId, Number.POSITIVE_INFINITY) ? { terminalPriorRun: true } : {},
+			...incompleteToolTurns.has(envelope.record.recordId) ? { incomplete: true } : {}
+		});
+	}));
+	emitSummary();
+	state = yield* flushTools(state);
+	const validatedPolicyUsage = yield* Schema.decodeEffect(RunPolicyUsage)(policyUsage).pipe(Effect.mapError((cause) => journalError("Run policy accounting exceeds its Schema bounds", cause)));
+	return {
+		...toolSelection === void 0 ? {} : { toolSelection },
+		policyUsage: validatedPolicyUsage,
+		prompt: Prompt.fromMessages(state.all),
+		historyBefore: Prompt.fromMessages(state.before),
+		committedTurns: state.committedTurns,
+		usage: unobservedModelCalls === 0 ? usage : {
+			...usage,
+			unobservedModelCalls
+		},
+		...latestWindowId === void 0 ? {} : { contextWindowId: latestWindowId },
+		...protectedContext === void 0 ? {} : { protectedContext },
+		...ownerTerminated || pendingContextToolCallId === void 0 ? {} : { pendingContextToolCallId }
+	};
+});
+/** Pure projection of one Run's durable recovery state from canonical records. */
+const projectRunJournal = Effect.fn("RunJournal.projectRunJournal")((records, runId) => projectRunJournalStream(Stream.fromIterable(records), runId));
+/**
+* Pure valid-prompt projection from canonical records: `UserInputRecorded` +
+* `ModelResponseRecorded` + complete `ToolCallSettled` batches → the deterministic model-visible
+* Prompt (plan §Coordinator flow step 3).
+*/
+const promptFromCanonicalRecords = Effect.fn("RunJournal.promptFromCanonicalRecords")((records) => projectRunJournalStream(Stream.fromIterable(records), void 0).pipe(Effect.map((projection) => projection.prompt)));
+/** Everything one committed Turn contributes to its canonical batch. */
+/**
+* Staged usage is validated, never repaired: clamping negatives or truncating
+* fractions would under-record canonical usage, and NaN/Infinity must fail
+* typed instead of escaping as a record-construction defect (RUN-023).
+*/
+const validStagedUsage = (label, value) => Number.isSafeInteger(value) && value >= 0 ? Effect.succeed(value) : Effect.fail(journalError(`Staged ${label} must be a non-negative safe integer, got ${String(value)}`));
+const decodePersistedJson = Schema.decodeUnknownEffect(PersistedJson);
+const encodePrompt = Schema.encodeEffect(Prompt.Prompt);
+const decodeModelUsage = Schema.decodeUnknownEffect(Schema.Array(ModelCallUsage));
+const requireCanonicalTurn = (turn) => !Number.isInteger(turn) || turn <= 0 ? Effect.fail(journalError(`Canonical turn number must be a positive integer: ${turn}`)) : Effect.void;
+const splitTurnMessages = (appended) => {
+	const promptMessages = [];
+	const toolParts = [];
+	for (const message of appended) {
+		if (message.role !== "tool") {
+			promptMessages.push(message);
+			continue;
+		}
+		for (const part of message.content) {
+			if (part.type !== "tool-result") continue;
+			toolParts.push(part);
+		}
+	}
+	return {
+		promptMessages,
+		toolParts
+	};
+};
+const modelResponseRecord = Effect.fn("RunJournal.modelResponseRecord")(function* (input, promptMessages) {
+	if (promptMessages.length === 0) return yield* journalError(`Turn ${input.turn} appended no model-visible Prompt messages`);
+	const runScopedPrefixLength = input.runScopedPrefixLength;
+	if (runScopedPrefixLength !== void 0 && (input.turn !== 1 || !Number.isSafeInteger(runScopedPrefixLength) || runScopedPrefixLength <= 0 || runScopedPrefixLength >= promptMessages.length || promptMessages.slice(0, runScopedPrefixLength).some((message) => message.role !== "system" && message.role !== "user"))) return yield* journalError("Run-scoped Prompt provenance must identify a non-empty system/user prefix of Turn 1 before its assistant response");
+	const encodedMessages = yield* encodePrompt(Prompt.fromMessages([...promptMessages])).pipe(Effect.mapError((cause) => journalError("Turn Prompt messages failed to encode", cause)));
+	const messages = yield* decodePersistedJson(encodedMessages).pipe(Effect.mapError((cause) => journalError("Turn Prompt messages exceed canonical persistence bounds", cause)));
+	const messagesDigest = yield* digestJson(messages);
+	const modelUsage = input.usage?.modelUsage === void 0 ? void 0 : yield* decodeModelUsage(input.usage.modelUsage).pipe(Effect.mapError((cause) => journalError("Turn model usage failed to decode", cause)));
+	if (modelUsage !== void 0) {
+		if (modelUsage.length === 0) return yield* journalError("Turn model usage must contain at least one completed call");
+		const summary = yield* summarizeModelUsage(modelUsage).pipe(Effect.mapError((cause) => journalError("Turn model usage exceeds accounting bounds", cause)));
+		if (input.usage === void 0 || input.usage.inputTokens !== summary.inputTokens.total || input.usage.outputTokens !== summary.outputTokens.total || (input.usage.costMicrousd ?? 0) !== summary.costMicrousd) return yield* journalError("Turn detailed and aggregate model usage disagree");
+	}
+	return RecordEnvelope.make({
+		recordId: modelResponseRecordId(input.runId, input.turn),
+		family: "thread",
+		schemaVersion: 1,
+		createdAt: input.createdAt,
+		deploymentId: input.deploymentId,
+		payload: ModelResponseRecorded.make({
+			...input.toolOperations === void 0 ? {} : { toolOperations: input.toolOperations },
+			...input.toolParameterRejections === void 0 || input.toolParameterRejections.length === 0 ? {} : { toolParameterRejections: input.toolParameterRejections },
+			...input.toolExposure === void 0 ? {} : { toolExposure: input.toolExposure },
+			runId: input.runId,
+			turnId: input.turnId,
+			turn: input.turn,
+			messages,
+			messagesDigest,
+			...runScopedPrefixLength === void 0 ? {} : { runScopedPrefixLength },
+			...modelUsage === void 0 ? {} : { modelUsage },
+			...input.unobservedModelCalls === void 0 || input.unobservedModelCalls === 0 ? {} : { unobservedModelCalls: yield* validStagedUsage("unobservedModelCalls", input.unobservedModelCalls) },
+			...input.usage === void 0 ? {} : {
+				inputTokens: yield* validStagedUsage("inputTokens", input.usage.inputTokens),
+				outputTokens: yield* validStagedUsage("outputTokens", input.usage.outputTokens),
+				...input.usage.costMicrousd === void 0 || input.usage.costMicrousd === 0 ? {} : { costMicrousd: yield* validStagedUsage("costMicrousd", input.usage.costMicrousd) }
+			}
+		})
+	});
+});
+const toolSettledRecords = Effect.fn("RunJournal.toolSettledRecords")(function* (input, toolParts) {
+	const toolRecords = [];
+	for (const part of toolParts) {
+		const result = yield* decodePersistedJson(part.result).pipe(Effect.mapError((cause) => journalError(`Tool result ${part.id} exceeds canonical persistence bounds`, cause)));
+		const toolCallId = yield* Effect.try({
+			try: () => decodeToolCallId(part.id),
+			catch: (cause) => journalError(`Invalid Tool Call ID ${part.id}`, cause)
+		});
+		toolRecords.push(RecordEnvelope.make({
+			recordId: toolCallSettledRecordId(input.runId, input.turn, toolCallId),
+			family: "thread",
+			schemaVersion: 1,
+			createdAt: input.createdAt,
+			deploymentId: input.deploymentId,
+			payload: ToolCallSettled.make({
+				...input.toolSelections?.get(part.id) === void 0 ? {} : { toolSelection: input.toolSelections.get(part.id) },
+				runId: input.runId,
+				toolCallId,
+				toolName: part.name,
+				result,
+				isFailure: part.isFailure,
+				...input.budgetRejectedCalls?.has(part.id) === true ? { budgetRejected: true } : {}
+			})
+		}));
+	}
+	return toolRecords;
+});
+/** Integrity of the original validated terminal values; never a current-code projection. */
+const runCompletionDigest = (completion) => digestJson({
+	runId: completion.runId,
+	output: completion.output,
+	runDisposition: completion.runDisposition ?? null,
+	finishReason: completion.finishReason ?? null,
+	exhausted: completion.exhausted ?? null
+});
+const runCompletionRecord = Effect.fn("RunJournal.runCompletionRecord")(function* (input) {
+	if (input.runCompletion === void 0) return void 0;
+	const completion = {
+		runId: input.runId,
+		...input.runCompletion
+	};
+	return RecordEnvelope.make({
+		recordId: runCompletedRecordId(input.runId),
+		family: "thread",
+		schemaVersion: 1,
+		createdAt: input.createdAt,
+		deploymentId: input.deploymentId,
+		payload: RunCompleted.make({
+			...completion,
+			resultDigest: yield* runCompletionDigest(completion)
+		})
+	});
+});
+/**
+* Pure per-Turn canonical batch builder (TurnCompleted seam fold, D6/D8): one
+* `ModelResponseRecorded` record plus one `ToolCallSettled` record per terminal Tool result, all
+* under the WP0-style deterministic identities, committed as ONE atomic batch. The same input
+* always yields byte-identical content, so an in-Attempt append retry is an honest batch replay.
+*
+* Phase 5 keeps this shape for Turns that declare no application Tool calls; their terminal
+* `RunCompleted` marker joins the response in this same atomic batch. Tool-declaring Turns split
+* into `turnResponseBatch` + `turnResultsBatch`.
+*/
+const turnCanonicalBatch = Effect.fn("RunJournal.turnCanonicalBatch")(function* (input) {
+	yield* requireCanonicalTurn(input.turn);
+	const { promptMessages, toolParts } = splitTurnMessages(input.appended);
+	const modelResponse = yield* modelResponseRecord(input, promptMessages);
+	const toolRecords = yield* toolSettledRecords(input, toolParts);
+	const completionRecord = yield* runCompletionRecord(input);
+	return CanonicalBatch.make({
+		batchId: turnBatchId(input.runId, input.turn),
+		producerId: input.producerId,
+		records: completionRecord === void 0 ? [modelResponse, ...toolRecords] : [
+			modelResponse,
+			...toolRecords,
+			completionRecord
+		]
+	});
+});
+/**
+* Commit 1 of a tool-declaring Turn: the Turn's `ModelResponseRecorded` record, including
+* provider results retained in assistant content before application Tools execute.
+* — pending steering plus the assistant response with its declared tool calls — under batch
+* identity `turn-response:{runId}:{turn}`. Committing the response before preparation creates
+* the provably-safe durability §15 window ("after model item commit, before tool preparation →
+* resume tool scheduling"): a crash there resumes the declared batch with no model re-invocation
+* and no Unknown. Tool messages in `appended` are ignored; the record identity is the same
+* `model-response:{runId}:{turn}` as the single-batch shape, so record-id assertions and the
+* prompt projection are unchanged.
+*/
+const turnResponseBatch = Effect.fn("RunJournal.turnResponseBatch")(function* (input) {
+	yield* requireCanonicalTurn(input.turn);
+	const { promptMessages } = splitTurnMessages(input.appended);
+	const modelResponse = yield* modelResponseRecord(input, promptMessages);
+	return CanonicalBatch.make({
+		batchId: turnResponseBatchId(input.runId, input.turn),
+		producerId: input.producerId,
+		records: [modelResponse]
+	});
+});
+/**
+* Commit 5 of a tool-declaring Turn (plan §2.1): the Turn's `ToolCallSettled` records in
+* declaration order under batch identity `turn-results:{runId}:{turn}` — the batch becomes
+* model-visible atomically. Non-tool messages in `appended` are ignored; a Turn without any
+* terminal Tool result has no results batch and fails typed.
+*/
+const turnResultsBatch = Effect.fn("RunJournal.turnResultsBatch")(function* (input) {
+	yield* requireCanonicalTurn(input.turn);
+	const { toolParts } = splitTurnMessages(input.appended);
+	const toolRecords = yield* toolSettledRecords(input, toolParts);
+	const first = toolRecords[0];
+	if (first === void 0) return yield* journalError(`Turn ${input.turn} has no terminal Tool results to commit`);
+	if (input.runCompletion !== void 0 && toolRecords.length !== 1) return yield* journalError("A terminal Tool completion requires exactly one settled result");
+	const completionRecord = yield* runCompletionRecord(input);
+	return CanonicalBatch.make({
+		batchId: turnResultsBatchId(input.runId, input.turn),
+		producerId: input.producerId,
+		records: completionRecord === void 0 ? [first, ...toolRecords.slice(1)] : [
+			first,
+			...toolRecords.slice(1),
+			completionRecord
+		]
+	});
+});
+//#endregion
+export { workerOriginRecordId as $, subagentRequestedRecordId as A, toolCallUnknownRecordId as B, runStartedBatchId as C, subagentLineageBatchId as D, subagentJoinedRecordId as E, toolCallPreparedRecordId as F, turnCanonicalBatch as G, toolStepSettledRecordId as H, toolCallResolutionBatchId as I, turnResponseBatch as J, turnIdForRun as K, toolCallResolvedRecordId as L, subagentStartedRecordId as M, toolApprovalDecisionRecordId as N, subagentLineageRecordId as O, toolApprovalRequestRecordId as P, workerInputRecordId as Q, toolCallResultBatchId as R, runIdForSubmission as S, subagentJoinBatchId as T, turnApprovalsBatchId as U, toolStepSettledBatchId as V, turnBatchId as W, turnResultsBatch as X, turnResponseBatchId as Y, turnResultsBatchId as Z, promptFromCanonicalRecords as _, childIdempotencyKeyFor as a, runDurationBatchId as b, compactionRecordId as c, modelResponseInterruptedBatchId as d, workerReportRecordId as et, modelResponseInterruptedRecordId as f, projectRunJournalStream as g, projectRunJournal as h, approvalDecisionBatchId as i, subagentStartedBatchId as j, subagentRequestedBatchId as k, firstWorkerInputRecordId as l, peerMessageRecordId as m, RunJournal_exports as n, childThreadIdFor as o, modelResponseRecordId as p, turnPreparedBatchId as q, agentUpdateRecordId as r, compactionBatchId as s, RunJournalError as t, makeJournalMetadata as tt, markUnknownBatchId as u, runCompletedRecordId as v, runStartedRecordId as w, runDurationRecordId as x, runCompletionDigest as y, toolCallSettledRecordId as z };
+
+//# sourceMappingURL=RunJournal-BXrq0VIK.mjs.map