@defrex/autobuild 0.8.0 → 0.9.0

package/packages/core/src/store/remote/index.ts

@@ -1,7 +1,8 @@
+// Client half + shared wire vocabulary for the remote BuildStore (SPEC §7.2).
+// The HTTP server half ships in `@defrex/autobuild-hosted-store-service`;
+// this barrel is what a local CLI and the hosted package both build against.
 export { AuthError, RemoteBuildStore } from './client'
 export type { RemoteBuildStoreOptions, RemoteStoreIdentity } from './client'
-export { createStoreServer, startStoreServer } from './server'
-export type { StartStoreServerOptions, StoreServer, StoreServerOptions } from './server'
 export { mintToken, tokenResource, verifyToken } from './token'
 export type { OperatorTokenScope, TokenScope } from './token'
 export {
@@ -10,3 +11,12 @@ export {
   REMOTE_STORE_PROTOCOL_VERSION,
   REMOTE_STORE_PROTOCOL_VERSION_HEADER,
 } from './version'
+// The whole wire protocol: schemas, error vocabulary, and the placeholder-ref
+// deposit convention. The protocol servers (hosted package) compose these;
+// clients parse them for feedback.
+export * from './protocol'
+// Event vocabulary the wire envelopes and the server's D6 mapping rely on.
+export { EventValidationError } from '../../events/catalog'
+export type { Via } from '../../events/envelope'
+export type { SessionEvent, SessionEventWrite } from '../../events/sessions'
+export type { RepositoryEvent, RepositoryEventWrite } from '../../events/repository'

package/packages/core/src/store/remote/protocol.ts

@@ -40,6 +40,18 @@ export const errorBodySchema = z.object({
 })
 export type ErrorBody = z.infer<typeof errorBodySchema>
 
+/**
+ * Deliberately loose: the ontology is enforced by `validateEventWrite` in
+ * the *backing store* (§8), so its precise EventValidationError message —
+ * the agent feedback D6 exists for — survives the wire instead of being
+ * shadowed by a duplicate wire-schema error.
+ */
+export const eventWriteWireSchema = z.object({
+  actor: z.unknown(),
+  type: z.string().min(1),
+  payload: z.unknown(),
+})
+
 // ── Builds ───────────────────────────────────────────────────────────────────
 
 export const newBuildBodySchema = z.object({
@@ -51,6 +63,9 @@ export const newBuildBodySchema = z.object({
   repoOrigin: z.string().optional(),
   ticket: ticketRefSchema.optional(),
   branch: z.string().min(1).optional(),
+  // Additive optional initial `build.created` event, appended atomically with
+  // the record. Loose like every event wire schema: the backing store validates.
+  created: eventWriteWireSchema.optional(),
 })
 
 export const buildRecordWireSchema = z.object({
@@ -68,18 +83,6 @@ export const buildRecordListSchema = z.array(buildRecordWireSchema)
 
 // ── Events ───────────────────────────────────────────────────────────────────
 
-/**
- * Deliberately loose: the ontology is enforced by `validateEventWrite` in
- * the *backing store* (§8), so its precise EventValidationError message —
- * the agent feedback D6 exists for — survives the wire instead of being
- * shadowed by a duplicate wire-schema error.
- */
-export const eventWriteWireSchema = z.object({
-  actor: z.unknown(),
-  type: z.string().min(1),
-  payload: z.unknown(),
-})
-
 export const eventEnvelopeWireSchema = z.object({
   build: z.string(),
   seq: z.number().int().positive(),
@@ -138,6 +141,68 @@ export const repoDepositsResponseSchema = z.object({
   artifacts: repositoryArtifactMetaListSchema,
 })
 
+// ── Ticket assets (SPEC §7.1) ────────────────────────────────────────────────
+
+export const ticketAssetLayoutSchema = z.enum(['file', 'tree'])
+/** An entry on the put request: `{type:'file',path,contentBase64}` or `{type:'dir',path}`. */
+export const ticketAssetEntryWireInputSchema = z.discriminatedUnion('type', [
+  z.object({ type: z.literal('file'), path: z.string(), contentBase64: z.string() }),
+  z.object({ type: z.literal('dir'), path: z.string() }),
+])
+export const putTicketAssetBodySchema = z.object({
+  kind: z.string(),
+  name: z.string(),
+  layout: ticketAssetLayoutSchema,
+  entries: z.array(ticketAssetEntryWireInputSchema),
+})
+/** A manifest entry: `dir` entries carry no size or blobRef. */
+export const ticketAssetEntryWireSchema = z.discriminatedUnion('type', [
+  z.object({
+    type: z.literal('file'),
+    path: z.string(),
+    size: z.number().int().nonnegative(),
+    blobRef: z.string(),
+  }),
+  z.object({ type: z.literal('dir'), path: z.string() }),
+])
+export const ticketAssetMetaWireSchema = z.object({
+  repo: z.string(),
+  ticketId: z.string(),
+  kind: z.string(),
+  name: z.string(),
+  revision: z.number().int().nonnegative(),
+  layout: ticketAssetLayoutSchema,
+  size: z.number().int().nonnegative(),
+  entries: z.array(ticketAssetEntryWireSchema),
+  createdAt: z.string(),
+})
+export const ticketAssetSummaryWireSchema = z.object({
+  repo: z.string(),
+  ticketId: z.string(),
+  kind: z.string(),
+  name: z.string(),
+  revision: z.number().int().nonnegative(),
+  layout: ticketAssetLayoutSchema,
+  size: z.number().int().nonnegative(),
+  fileCount: z.number().int().nonnegative(),
+  dirCount: z.number().int().nonnegative(),
+  createdAt: z.string(),
+})
+export const ticketAssetSummaryListSchema = z.array(ticketAssetSummaryWireSchema)
+/** `GET …/assets` answers the manifest only (no bytes); null when absent or removed. */
+export const ticketAssetManifestResponseSchema = ticketAssetMetaWireSchema.nullable()
+/** `GET …/assets/file` answers one file's bytes; null when absent. */
+export const ticketAssetFileResponseSchema = z.object({ contentBase64: z.string() }).nullable()
+export const removeTicketAssetBodySchema = z.object({ kind: z.string(), name: z.string() })
+export const removeTicketAssetResponseSchema = ticketAssetMetaWireSchema.nullable()
+export const ticketAssetLimitsWireSchema = z.object({
+  maxBytes: z.number().int().nonnegative(),
+  maxEntries: z.number().int().positive(),
+  /** Largest request or response body the deployment can carry. Absent: no ceiling. */
+  maxRequestBytes: z.number().int().positive().optional(),
+})
+export type TicketAssetLimitsWire = z.infer<typeof ticketAssetLimitsWireSchema>
+
 // ── Operator sessions (SPEC §7.1.1) ─────────────────────────────────────────
 
 export const newSessionBodySchema = z.object({
@@ -166,6 +231,12 @@ export const sessionEventEnvelopeWireSchema = z.object({
 })
 export const sessionEventListSchema = z.array(sessionEventEnvelopeWireSchema)
 
+export const conditionalSessionEventBodySchema = z.object({
+  expectedSeq: z.number().int().nonnegative(),
+  event: eventWriteWireSchema,
+})
+export const conditionalSessionEventResponseSchema = sessionEventEnvelopeWireSchema.nullable()
+
 export const sessionArtifactMetaWireSchema = z.object({
   session: z.string(),
   kind: z.string(),
@@ -187,6 +258,23 @@ export const sessionDepositsResponseSchema = z.object({
   artifacts: sessionArtifactMetaListSchema,
 })
 
+// ── Build digests (repo-scoped batch read, AUT-487) ────────────────────────
+// The wire form of `BuildDigest` (store/types.ts). `terminal` is omitted when
+// the build's log carries no terminal fact, per the protocol's omission
+// convention for optional members.
+export const buildDigestWireSchema = z.object({
+  slug: z.string().min(1),
+  terminal: z.enum(['done', 'aborted']).optional(),
+  observations: z.array(
+    z.object({
+      seq: z.number().int().positive(),
+      ts: z.string().min(1),
+    }),
+  ),
+  merged: z.string().min(1).optional(),
+})
+export const buildDigestListSchema = z.array(buildDigestWireSchema)
+
 // ── Artifacts ────────────────────────────────────────────────────────────────
 
 export const artifactMetaWireSchema = z.object({

package/packages/core/src/store/remote/version.ts

@@ -3,8 +3,12 @@ import manifest from '../../../../../package.json'
 /** Release-synchronized identity sent by every remote-store client. */
 export const AUTOBUILD_VERSION = manifest.version
 
-/** Wire compatibility version for the remote BuildStore protocol. */
-export const REMOTE_STORE_PROTOCOL_VERSION = '2'
+/** Wire compatibility version for the remote BuildStore protocol.
+ * Version 3 (AUT-521): the build-digest wire shape gains per-occurrence
+ * observation timestamps and the `merged` fact — a breaking shape change,
+ * so stale peers are rejected at handshake instead of failing mid-request
+ * at schema parse. */
+export const REMOTE_STORE_PROTOCOL_VERSION = '3'
 
 export const AUTOBUILD_VERSION_HEADER = 'x-autobuild-version'
 export const REMOTE_STORE_PROTOCOL_VERSION_HEADER = 'x-autobuild-protocol-version'

package/packages/core/src/store/repo-state-events.ts

@@ -0,0 +1,140 @@
+/**
+ * The bounded repository-journal read (AUT-489): a pure subset derivation
+ * that stateless full-state readers can fetch instead of the whole journal
+ * without changing what their reducers report.
+ *
+ * The hosted dispatcher appends ~4 journal events per invocation (run-started,
+ * tick-started, tick-completed/tick-yielded, run-stopped) whether or not it
+ * did anything, so the journal grows forever with wall-clock time while the
+ * durable signal stays small. Every repository-state consumer reduces the
+ * journal through one of four pure reducers whose event-type dependencies
+ * partition the catalog:
+ *
+ * - `reduceDispatchSettings` — only the three dispatcher setting types
+ *   (latest-wins by seq).
+ * - `reduceDispatchStatus(events, latestRun)` — only run-correlated
+ *   dispatcher facts, and it skips every event whose `payload.run` is not the
+ *   latest run. A run's facts are appended under its own run id, which is
+ *   minted at `dispatcher.run-started`, so all facts the reducer keeps live at
+ *   or after the latest run-started.
+ * - `reduceHarvest` (and everything built on it) — only `harvest.*` events
+ *   plus the three setting types, which it explicitly ignores.
+ * - `sandboxStates` — only `orchestrator.sandbox.*` events.
+ *
+ * So the bounded subset is: **every event of a durable (slow-growing) type —
+ * all `harvest.*`, all `orchestrator.sandbox.*`, and the three dispatcher
+ * setting types — plus, when the journal contains at least one
+ * `dispatcher.run-started`, the tail from that latest run-started to the end
+ * of the journal.** For a hosted repository with N no-op invocations this
+ * subset's size is a constant (one invocation's ~4 facts plus the durable
+ * signal), independent of N.
+ *
+ * INVARIANT FOR AUTHORS OF NEW REPOSITORY EVENT TYPES: a new type must either
+ * (a) join `REPOSITORY_STATE_EVENT_TYPES` — it is durable, slow-growing state
+ * some reducer depends on at full replay depth — or (b) join
+ * `REPOSITORY_RUN_SCOPED_EVENT_TYPES` — it is run-correlated and its only
+ * consumers reduce it for the latest run, so the tail from the latest
+ * `dispatcher.run-started` covers it. `tests/store/repo-state-events.test.ts`
+ * asserts the two sets exactly partition `REPOSITORY_EVENT_TYPES`; adding a
+ * type to neither fails the build until the author makes the call. A type in
+ * neither set would be silently dropped from bounded reads.
+ *
+ * Reducing this subset with the state readers yields exactly what a full
+ * replay yields: `reduceDispatchSettings`, `reduceHarvest`, `sandboxStates`
+ * see identical event lists, and `reduceDispatchStatus` sees every event it
+ * keeps (the rest are skipped by the `payload.run !== latestRun` guard). The
+ * journal itself stays append-only; no event is deleted, rewritten, or
+ * re-ordered, and a replay from the start is untouched.
+ */
+import type { RepositoryEvent, RepositoryEventType } from '../events/repository'
+import {
+  dispatcherSettingEventPayloadSchemas,
+  dispatcherStatusEventPayloadSchemas,
+  harvestEventPayloadSchemas,
+  orchestratorSandboxEventPayloadSchemas,
+} from '../events/repository'
+
+/** The anchor fact a bounded read's tail hangs from. */
+const RUN_STARTED = 'dispatcher.run-started'
+
+/** Durable, slow-growing repository event types: every fact a state reducer
+ * may consult at full replay depth. Derived from the catalog groups so a new
+ * harvest or sandbox event type joins automatically; the three dispatcher
+ * setting types are enumerated because they share one schema group with the
+ * run-correlated `dispatcher.config-reloaded`. */
+export const REPOSITORY_STATE_EVENT_TYPES: readonly RepositoryEventType[] = [
+  ...Object.keys(harvestEventPayloadSchemas),
+  ...Object.keys(orchestratorSandboxEventPayloadSchemas),
+  ...Object.keys(dispatcherSettingEventPayloadSchemas).filter(
+    (type) => type !== 'dispatcher.config-reloaded',
+  ),
+] as RepositoryEventType[]
+
+/** Run-correlated repository event types: facts whose only state consumers
+ * reduce them for the latest dispatcher run, so the tail from the latest
+ * `dispatcher.run-started` contains everything those consumers keep. */
+export const REPOSITORY_RUN_SCOPED_EVENT_TYPES: readonly RepositoryEventType[] = [
+  ...Object.keys(dispatcherStatusEventPayloadSchemas),
+  'dispatcher.config-reloaded',
+] as RepositoryEventType[]
+
+const STATE_TYPES = new Set<string>(REPOSITORY_STATE_EVENT_TYPES)
+
+/**
+ * The race-closed read shape every SQL adapter delegates `getRepoStateEvents`
+ * to (AUT-551). Both adapters issue the anchor probe and the selection as two
+ * separate statements, so a concurrent append of the journal's first
+ * `dispatcher.run-started` between them is invisible to the probe, absent
+ * from the durable-only selection, yet present in the journal by the time the
+ * method returns — a stateless reader can transiently throw
+ * `effective-config-unavailable` where a moment-later full replay would
+ * succeed.
+ *
+ * The fix is a **one-shot anchor re-check on the durable-only outcome**:
+ * after a selection that took the durable-only branch (the probe saw no
+ * anchor), re-probe the anchor once; if an anchor now exists, re-run the
+ * anchored selection against it. The invariant this achieves: a durable-only
+ * result is returned only when the journal was anchor-free as of the final
+ * probe — so a run-started appended between the original probe and the
+ * selection can never be missed while present. When the first probe *did*
+ * find an anchor, no re-check is needed: the anchored select's
+ * `seq >= anchor` arm is monotone-inclusive, so any later run-started (higher
+ * seq) is picked up by that same select. A run-started appended after the
+ * final re-probe is an ordinary post-read concurrent append — outside this
+ * read's snapshot, exactly as if it had landed after the method returned —
+ * and is not this race; that bound is why the re-check is one-shot and never
+ * a loop.
+ *
+ * Non-concurrent behavior is byte-identical: the same two statements run in
+ * the same order; only the durable-only outcome may trigger one extra
+ * probe+select pair.
+ */
+export async function readRepoStateEventsWithAnchorRecheck(
+  probeAnchor: () => Promise<number | undefined>,
+  select: (anchor: number | undefined) => Promise<RepositoryEvent[]>,
+): Promise<RepositoryEvent[]> {
+  const anchor = await probeAnchor()
+  const events = await select(anchor)
+  if (anchor !== undefined) return events
+  const rechecked = await probeAnchor()
+  return rechecked === undefined ? events : select(rechecked)
+}
+
+/** The normative subset derivation every adapter implements and the contract
+ * tests use as the oracle: durable types across the whole journal, plus —
+ * only when the journal has one — every event from the latest
+ * `dispatcher.run-started` onward, ordered by seq. A journal with no
+ * run-started has **no tail at all** (durable types only); the anchor is
+ * never defaulted to 0, which would make a `seq >= anchor` clause select the
+ * whole journal and defeat the bound. */
+export function projectRepositoryStateEvents(
+  events: readonly RepositoryEvent[],
+): RepositoryEvent[] {
+  let anchor: number | undefined
+  for (const event of events) {
+    if (event.type === RUN_STARTED) anchor = event.seq
+  }
+  return events.filter(
+    (event) => STATE_TYPES.has(event.type) || (anchor !== undefined && event.seq >= anchor),
+  )
+}

package/packages/core/src/store/retention.ts

@@ -38,6 +38,13 @@
  */
 export const OPERATOR_NOTES_REPO_KIND = 'operator-notes'
 
+/** The repository artifact carrying the schema-validated composed Config one
+ * dispatch run used. The embedded orchestrator's hosted wiring resolves its
+ * per-repository configuration from the latest revision of this kind
+ * (AUT-342). Defined here — the store must not import from the CLI — and
+ * re-exported by `cli/dispatch.ts`, which deposits it. */
+export const DISPATCHER_EFFECTIVE_CONFIG_ARTIFACT = 'dispatcher-effective-config'
+
 /**
  * Repository-scoped artifact kinds subject to retention. Values mirror the
  * kind constants in `cli/dispatch.ts` (DISPATCHER_EFFECTIVE_CONFIG_ARTIFACT)

package/packages/core/src/store/session-handle.ts

@@ -13,6 +13,7 @@ import type {
   Artifact,
   ArtifactInput,
   ArtifactMeta,
+  BuildDigest,
   BuildRecord,
   BuildStore,
   NewBuildInput,
@@ -26,6 +27,13 @@ import type {
   SubscribeOptions,
   Unsubscribe,
 } from './types'
+import type {
+  TicketAsset,
+  TicketAssetInput,
+  TicketAssetLimits,
+  TicketAssetMeta,
+  TicketAssetSummary,
+} from './ticket-assets'
 import type {
   StreamChunk,
   StreamOutcome,
@@ -160,6 +168,12 @@ export function createSessionScopedStore(store: BuildStore, scope: string): Sess
     getRepoEvents(repo: string, _sinceSeq?: number): Promise<RepositoryEvent[]> {
       return Promise.reject(new SessionScopeError(scope, 'getRepoEvents', repo))
     },
+    getRepoStateEvents(repo: string): Promise<RepositoryEvent[]> {
+      return Promise.reject(new SessionScopeError(scope, 'getRepoStateEvents', repo))
+    },
+    getRepoBuildDigests(repo: string): Promise<Map<string, BuildDigest>> {
+      return Promise.reject(new SessionScopeError(scope, 'getRepoBuildDigests', repo))
+    },
     putRepoArtifact(repo: string, _artifact: ArtifactInput): Promise<RepositoryArtifactMeta> {
       return Promise.reject(new SessionScopeError(scope, 'putRepoArtifact', repo))
     },
@@ -173,6 +187,48 @@ export function createSessionScopedStore(store: BuildStore, scope: string): Sess
     listRepoArtifacts(repo: string, _kind?: string): Promise<RepositoryArtifactMeta[]> {
       return Promise.reject(new SessionScopeError(scope, 'listRepoArtifacts', repo))
     },
+    ticketAssetLimits(repo: string): Promise<TicketAssetLimits> {
+      return Promise.reject(new SessionScopeError(scope, 'ticketAssetLimits', repo))
+    },
+    putTicketAsset(
+      repo: string,
+      _ticketId: string,
+      _asset: TicketAssetInput,
+    ): Promise<TicketAssetMeta> {
+      return Promise.reject(new SessionScopeError(scope, 'putTicketAsset', repo))
+    },
+    getTicketAsset(
+      repo: string,
+      _ticketId: string,
+      _kind: string,
+      _name: string,
+      _rev?: number,
+    ): Promise<TicketAsset | null> {
+      return Promise.reject(new SessionScopeError(scope, 'getTicketAsset', repo))
+    },
+    getPinnedTicketAsset(
+      slug: string,
+      _kind: string,
+      _name: string,
+      _rev?: number,
+    ): Promise<TicketAsset | null> {
+      return Promise.reject(new SessionScopeError(scope, 'getPinnedTicketAsset', slug))
+    },
+    listTicketAssets(
+      repo: string,
+      _ticketId: string,
+      _opts?: { revisions?: boolean },
+    ): Promise<TicketAssetSummary[]> {
+      return Promise.reject(new SessionScopeError(scope, 'listTicketAssets', repo))
+    },
+    removeTicketAsset(
+      repo: string,
+      _ticketId: string,
+      _kind: string,
+      _name: string,
+    ): Promise<TicketAssetMeta | null> {
+      return Promise.reject(new SessionScopeError(scope, 'removeTicketAsset', repo))
+    },
     claimRepoLease(repo: string, _holder: string, _ttlMs: number): Promise<boolean> {
       return Promise.reject(new SessionScopeError(scope, 'claimRepoLease', repo))
     },
@@ -199,6 +255,14 @@ export function createSessionScopedStore(store: BuildStore, scope: string): Sess
       own('appendSessionEvent', id)
       return store.appendSessionEvent(id, event)
     },
+    async appendSessionEventIfCurrent<T extends SessionEventType>(
+      id: string,
+      expectedSeq: number,
+      event: SessionEventWrite<T>,
+    ): Promise<SessionEventEnvelope<T> | null> {
+      own('appendSessionEventIfCurrent', id)
+      return store.appendSessionEventIfCurrent(id, expectedSeq, event)
+    },
     async getSessionEvents(
       id: string,
       sinceSeq?: number,

package/packages/core/src/{sessions/reducer.ts → store/session-reducer.ts}

@@ -13,7 +13,7 @@ export type TurnOutcomeState = 'open' | 'suspended' | 'completed' | 'failed'
 
 export type SessionTurnTrigger =
   | { kind: 'message'; messageSeq: number }
-  | { kind: 'wake'; build: string; seq: number; type: string }
+  | { kind: 'wake'; build?: string; journal?: true; seq: number; type: string }
 
 export interface SessionTurn {
   turn: string
@@ -21,8 +21,11 @@ export interface SessionTurn {
   startedSeq: number
   trigger: SessionTurnTrigger
   state: TurnOutcomeState
-  usage?: { inputTokens: number; outputTokens: number; turns?: number }
+  usage?: { inputTokens: number; outputTokens: number; steps: number; turns?: number }
   error?: string
+  /** The typed failure class of a failed turn (provider-unavailable,
+   * exhausted, credentials, configuration, or internal). */
+  kind?: 'provider-unavailable' | 'exhausted' | 'credentials' | 'configuration' | 'internal'
 }
 
 export interface SessionState {
@@ -43,6 +46,10 @@ export interface SessionState {
   wakeGlobs: string[]
   /** Per build, the highest build event seq a wake trigger has consumed. */
   wakeCursors: Record<string, number>
+  /** The highest repository-journal seq a wake trigger has consumed (0 when
+   * no journal wake has been consumed). The journal has an independent seq
+   * space with no build slug, so it gets its own cursor. */
+  journalWakeCursor: number
   /** Every turn in start order, with its stream id and outcome. */
   turns: SessionTurn[]
 }
@@ -63,6 +70,7 @@ export function reduceSession(events: SessionEvent[]): SessionState {
   let pendingApproval: SessionState['pendingApproval']
   let wakeGlobs: string[] = []
   const wakeCursors: Record<string, number> = {}
+  let journalWakeCursor = 0
 
   const open = (): TurnEntry | undefined => turns.findLast((turn) => !isTerminal(turn.state))
 
@@ -85,8 +93,15 @@ export function reduceSession(events: SessionEvent[]): SessionState {
         }
         turns.push(entry)
         if (event.payload.trigger.kind === 'wake') {
-          const build = event.payload.trigger.build
-          wakeCursors[build] = Math.max(wakeCursors[build] ?? 0, event.payload.trigger.seq)
+          if (event.payload.trigger.journal === true) {
+            journalWakeCursor = Math.max(journalWakeCursor, event.payload.trigger.seq)
+          } else {
+            // The catalog's `.check()` guarantees `build` when `journal` is
+            // absent — a stored trigger can never be a journal wake without
+            // the flag or a build wake without the slug.
+            const build = event.payload.trigger.build!
+            wakeCursors[build] = Math.max(wakeCursors[build] ?? 0, event.payload.trigger.seq)
+          }
         }
         break
       }
@@ -118,11 +133,13 @@ export function reduceSession(events: SessionEvent[]): SessionState {
           pendingApproval.toolCallId === event.payload.toolCallId
         ) {
           pendingApproval = undefined
-          // The answer resumes the turn; `turn.resumed` is the runner's
-          // acknowledgement of the same fact, so between answer and resume
-          // the status is already `running` when a turn is open.
-          const entry = turns.findLast((candidate) => candidate.turn === event.payload.turn)
-          if (entry && entry.state === 'suspended') entry.state = 'open'
+          // The answer only clears the pending approval — `turn.resumed` is
+          // the sole resume fact, recorded by the runner when it actually
+          // picks the turn up. Flipping the turn state here (the earlier
+          // behavior) made a session look `running` while no runner existed:
+          // an answered approval whose resuming invocation died would be
+          // unrecoverable. The status sequence after an answer is therefore
+          // awaiting-approval → suspended(approval) → running.
         }
         break
       }
@@ -139,6 +156,7 @@ export function reduceSession(events: SessionEvent[]): SessionState {
         if (entry && !isTerminal(entry.state)) {
           entry.state = 'failed'
           entry.error = event.payload.error
+          entry.kind = event.payload.kind
         }
         break
       }
@@ -180,6 +198,7 @@ export function reduceSession(events: SessionEvent[]): SessionState {
     ...(pendingApproval !== undefined ? { pendingApproval } : {}),
     wakeGlobs,
     wakeCursors,
+    journalWakeCursor,
     turns: turns.map(({ suspensionCause: _suspensionCause, ...turn }) => turn),
   }
 }

package/packages/core/src/store/streams/session-writer.ts

@@ -23,7 +23,6 @@
  * never reorder), retries re-queue at the front under the same discipline,
  * and `close` waits out any in-flight drain before closing the stream.
  */
-import type { SessionStreamSink } from '../../ports/types'
 import { STREAM_PART_MAX_BYTES, truncationPart } from '../../ports/runner/stream-parts'
 import type { JsonRecord } from '../../ports/runner/json-record'
 import {
@@ -52,6 +51,22 @@ export interface SessionStreamSinkOptions {
   schedule?: (flush: () => void, ms: number) => () => void
 }
 
+/** The sink's concrete surface. Structurally a superset of the
+ * `SessionStreamSink` port (ports/types.ts): `open` keeps its port-declared
+ * shape for the build-runner's `openSessionStreamLabel` caller, while the
+ * orchestrator turn runner additionally uses `resume` (bind to an
+ * already-open stream — a resumed invocation must append to the turn's
+ * existing stream, never create a second one) and `flush` (await the drain,
+ * so a step-boundary checkpoint is durable before the next step starts). */
+export type SessionStreamWriter = {
+  open(label: string): Promise<string>
+  append(parts: StreamPart[]): void
+  close(outcome: StreamOutcome): Promise<void>
+} & {
+  resume(streamId: string): Promise<string>
+  flush(): Promise<void>
+}
+
 /** Consecutive failed flushes before the writer stops streaming a session. */
 const MAX_FLUSH_FAILURES = 3
 
@@ -131,8 +146,10 @@ function boundPart(part: StreamPart, maxBytes: number): StreamPart[] {
 /**
  * Create the bracket-scoped sink. `open` creates the store stream and
  * returns its id; appends buffer until then and flush on the cadence.
+ * `resume` binds to an already-open stream instead of creating one;
+ * `flush` awaits the drain without closing.
  */
-export function createSessionStreamSink(options: SessionStreamSinkOptions): SessionStreamSink {
+export function createSessionStreamSink(options: SessionStreamSinkOptions): SessionStreamWriter {
   const { store, scope } = options
   const flushMs = options.flushMs ?? 250
   const maxPartBytes = STREAM_PART_MAX_BYTES
@@ -288,6 +305,29 @@ export function createSessionStreamSink(options: SessionStreamSinkOptions): Sess
       }
     },
 
+    /** Bind to an already-open stream — the resume path. Never calls
+     * `createStream`, so a fresh invocation appends to the turn's existing
+     * stream instead of creating a second one nothing reads. Appends made
+     * before the bind stay buffered and flush right after. */
+    async resume(boundStreamId) {
+      if (streamId !== undefined) {
+        throw new Error(`session stream sink already bound to "${streamId}"`)
+      }
+      streamId = boundStreamId
+      ensureTimer()
+      await requestFlush()
+      return streamId
+    },
+
+    /** Await the drain of everything appended so far (joining the in-flight
+     * drain under the single-flight rule), so a caller can make a checkpoint
+     * durable without closing. Best-effort like `append`: a defunct writer
+     * resolves without throwing, and the diagnostic hook already fired. */
+    async flush() {
+      if (streamId === undefined) return
+      await requestFlush()
+    },
+
     append(parts) {
       // Never throws: after defunct/close or before a successful open,
       // parts are dropped or buffered without surfacing an error.

package/packages/core/src/store/streams/wait.ts

@@ -10,7 +10,7 @@
  * synchronous (SQLite) and asynchronous (PostgreSQL) backends is worth more
  * than wake-on-write precision. The loop serves two cadences: held *stream*
  * reads are presentation content and poll at the ~25 ms `STREAM_WAIT_POLL_MS`;
- * held *event* reads (build, repository, session — AUT-334/381/383) take the
+ * held *event* reads (build, repository, session — AUT-334/381/383/394) take the
  * one-second `EVENT_WAIT_POLL_MS` budget when the adapter passes it per call
  * (see `EVENT_WAIT_POLL_MS` for which adapters do). Closed streams never wait.
  *
@@ -28,15 +28,14 @@ export const STREAM_WAIT_POLL_MS = 25
 
 /**
  * The one-second held-event poll budget (the hosted per-query budget,
- * AUT-334/381/383): held event reads — build, repository, and session —
+ * AUT-334/381/383/394): held event reads — build, repository, and session —
  * re-query at most once per second, so an append is observed at the next
  * poll, typically within about one second. Held *stream* reads are excluded:
  * they are presentation content and stay at the ~25 ms `STREAM_WAIT_POLL_MS`
  * cadence. This deliberately diverges from `STREAM_WAIT_POLL_MS`; adapters
  * pass it as `pollMs` on their event-family calls to `readEventsWithWait` —
- * the PostgreSQL and memory stores do on all three families (AUT-334/381/383).
- * The SQLite store has not adopted the budget (out of scope for AUT-383), so
- * its held event reads fall back to the stream default until it does.
+ * the PostgreSQL, memory, and SQLite stores do on all three families
+ * (AUT-334/381/383/394).
  *
  * The PostgreSQL adapter treats the bound as nominal, not hard: a worst-case
  * ≤1 s guarantee would need Postgres LISTEN/NOTIFY wake-on-append — one