Dashboard › opencode › Distillation
f63fc265-3f3b-4dbf-ad76-e80b66a2465c["lore_tm_v1_rhdUSRzbaGaX6E1ov6f_lw2nIfpAMa9WPkbaYV1K2TA","lore_tm_v1_NdvZyA2c0bdt8Su2q2QIe-Cfia2aM0FpsRMLyXSnPSw","lore_tm_v1_mb1rjjZr4bVzKdayseJiNcxrQStJ-UOq8YV6GJlNohs","lore_tm_v1_geMpxPce8n0DJbx8-96jelydm26xmsDCEMpLEw6IkmA"]
Date: Sep 17, 2026
packages/core/src/session/projector.ts, the SessionEvent.Step.Recovered projector requires event.durable; absence dies with "Durable Session event is missing aggregate sequence". It derives continuationMessageID via continuation(event.data.executionID).SessionEvent.Step.Recovered projection is idempotent only when an existing SessionRecoveryTable row exactly matches sessionID, assistantMessageID (or null), derived continuationMessageID, and phase; any mismatch dies with Recovery execution identity conflict: ${event.data.executionID}.SessionEvent.Step.Recovered specifies assistantMessageID, packages/core/src/session/projector.ts requires it to be the latest assistant message by descending SessionMessageTable.seq. A missing or non-latest target dies with Recovery target is not the latest assistant: ${event.data.assistantMessageID}; a decoded non-assistant target dies with Recovery target is not an assistant: ${event.data.assistantMessageID}.SessionEvent.Step.Recovered through run(db, event), the projector admits a synthetic continuation input with ID continuationMessageID, prompt Prompt.make({ text: "continue" }), delivery "queue", requestExecution: false, admittedSeq: event.durable.seq, and the recovery event timestamp.SessionRecoveryTable with session_id, execution_id, nullable assistant_message_id, continuation_message_id, phase, wake_pending: true, and epoch-millisecond time_created. It uses .onConflictDoNothing(); failure to insert dies with Recovery execution identity conflict: ${event.data.executionID}.packages/core/src/session/projector.ts, SessionEvent.RevertEvent.Committed requires the boundary message identified by sessionID and messageID; absence dies with Revert boundary message not found: ${event.data.messageID}. It deletes later SessionMessageTable rows where seq > boundary.seq, deletes SessionInputTable rows where either admitted_seq > boundary.seq or promoted_seq > boundary.seq, then clears SessionTable.revert and updates time_updated.packages/core/src/session/execution/local.ts creates a per-process ownerID, computes leaseDuration from SESSION_EXECUTION_LEASE_MS, and tracks activeClaims plus in-progress interruptions by SessionSchema.ID.executionID, finds the latest assistant seq, and performs an immediate transaction inserting SessionExecutionTable with phase: "ready", assistant_seq: latest?.seq ?? -1, owner_id, time_created, and expires_at: now + leaseDuration. .onConflictDoNothing() means an unsuccessful claim returns without running.SessionRecoveryTable, filtering wake_pending=true and recovery_error IS NULL, ordered by ascending time_created then execution_id; its continuation_message_id is passed to input.run(claim, force, recoveryInputID).SessionExecutionClaim.renew(db, claim) calls spaced at leaseDuration / 3. Non-interrupt-only failures log "Failed to drain Session" with sessionID."cancelling" or "cancelled"; preserves an interrupted claim unless its phase is "safe"; and otherwise clears a current claim whose phase is neither "unknown" nor "continue".settleCancellation() in packages/core/src/session/execution/local.ts renews the claim first. Phase "cancelled" clears the claim; any phase other than "cancelling" dies with Interrupted Session settlement failed: ${claim.sessionID}; a null assistant message ID also clears the claim.data.time.completed, cancellation is settled to { phase: "cancelled", assistant_message_id: null } and the claim is cleared. Otherwise the code requires EventV2.Service, publishes SessionEvent.Step.Interrupted with error { type: "unknown", message: "Provider Step outcome unknown after interruption" }, settles cancellation in the event commit hook, and then clears the claim.interrupt(sessionID) coalesces duplicate interruption requests through a shared Deferred. For an active claim it first updates the phase to "cancelling", races coordinator interruption/settlement against lease renewal every leaseDuration / 3, and removes/completes the interruption entry on exit.SessionExecutionClaim.Lost is suppressed only when no current SessionExecutionTable row remains for the session; if a row still exists, the defect is rethrown.packages/core/src/session/run-coordinator.ts implements per-key serialization while allowing different keys to run concurrently. Each entry contains done, optional interruption, optional owner fiber, optional exit, pendingWake, and stopping.SessionRunCoordinator.run(key) joins the active execution when one exists. If that entry is stopping, it waits for entry.done and recursively retries; otherwise it waits for the existing result. When idle, it starts drain(key, true) and waits for completion.SessionRunCoordinator.wake(key) coalesces follow-up work by setting pendingWake=true on an active entry. When idle, it creates an entry and starts drain(key, false) without waiting for completion.force=false after a successful run with pendingWake=true. Otherwise, a pending wake is transferred to a fresh successor entry; without one, the key is removed. The original entry’s done deferred receives the original exit.SessionRunCoordinator.interrupt(key, cleanup) runs cleanup directly when there is no active owner and coalesces concurrent interruptions through entry.interruption. For an active owner it sets stopping=true, clears the preexisting pendingWake, interrupts the owner, captures the cleanup exit, verifies the interrupted execution settled, and then either removes the key or starts one successor for work that arrived while stopping.entry.exit, it throws "Interrupted Session execution did not settle"; cleanup failure is propagated after coordinator state and the original entry’s done deferred are settled.