model-compare-opencode-plugin 0.1.1 → 0.3.0

package/src/index.ts

@@ -4,9 +4,10 @@
 // warn-and-default, never throws), seeds state from storage (§8's startup
 // chain: pin → fallback → disabled) without ever blocking on fresh data,
 // registers the alias transform — after seeding, so the registration-time
-// application sees the seeded picks — then the guard hook and the two
-// commands, kicks off the first refresh in the background, schedules the
-// 30-minute refresh tick, and returns a cleanup that clears the timer.
+// application sees the seeded picks — then the guard hook, the steering
+// injection hook and the two commands, kicks off the first refresh in the
+// background, schedules the 30-minute refresh tick, and returns a cleanup
+// that clears the timer.
 //
 // `wire` is the testable core — the same setup with injected seams (acquire,
 // timer, clock). The default export hands OpenCode the real context; it is
@@ -17,11 +18,12 @@ import { Plugin } from "@opencode/plugin"
 import { parseConfig } from "./config"
 import { pinKey, type Pin } from "./core/pins"
 import { effectiveWeights, rankModels } from "./core/rank"
-import type { Catalog, ModelEntry, Priority, Sourced } from "./core/types"
-import { formatReport, humanizeAge, reportEntries } from "./opencode/commands"
+import type { Catalog, EndpointCapture, ModelEntry, Priority, Sourced } from "./core/types"
+import { captureEndpoint, injectSteering, steeringFor } from "./core/steering"
+import { formatReport, humanizeAge, reportEntries, steeringNote } from "./opencode/commands"
 import { ModelCompare } from "./rpc"
 import { planAlias, type AliasTarget } from "./opencode/aliases"
-import { guardDecision, type ModelRef } from "./opencode/guard"
+import { guardDecision, parseAliasRef, type ModelRef } from "./opencode/guard"
 import { readNewestCachedDoc, readRecord, type Storage } from "./opencode/storage"
 import { acquire, cacheIdentities } from "./sources"
 import {
@@ -51,6 +53,89 @@ function bareModelId(configValue: string): string {
     : configValue
 }
 
+// The request body's `model` field when it is a string, else undefined — the
+// gate steeringFor checks against the pick's id (the live alias-bound body
+// carries the pick id verbatim, spike fact 1). Any non-object body reads as
+// undefined; injectSteering rejects those on its own.
+function bodyModelOf(body: unknown): string | undefined {
+  if (typeof body !== "object" || body === null) return undefined
+  const model = (body as Record<string, unknown>).model
+  return typeof model === "string" ? model : undefined
+}
+
+// ---- response capture helpers ----------------------------------------------
+
+// The bounded peek (global constraint: never buffer or consume a response
+// stream to inspect it — only a bounded first-chunk peek through a
+// pass-through transform, the rest forwarding byte-for-byte). At most this
+// many BYTES of a response stream are decoded for inspection; everything past
+// the bound is untouched. Sized so a first SSE data chunk (a comment line
+// plus one data event in the spike's observations) always fits.
+const PEEK_MAX_BYTES = 4096
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+// A response field that must be a string, else null (a numeric/absent
+// `provider` or `model` is nothing to capture).
+function stringField(obj: Record<string, unknown>, key: string): string | null {
+  const value = obj[key]
+  return typeof value === "string" ? value : null
+}
+
+// The served `provider`/`model` pair carried by a response's first bytes, or
+// null while the prefix is not yet conclusive (the peek keeps going). Two
+// shapes the spike observed:
+//   - SSE (streaming): data lines — the first one carrying a NON-null
+//     `provider` decides, and `data: [DONE]` concludes without a capture. A
+//     parseable line that carries no provider must NOT conclude anything:
+//     the provider may arrive in a later data line within the byte bound.
+//     Leading comment or blank lines (`: OPENROUTER PROCESSING`, spike fact
+//     5/warmup-B) carry neither, so the peek simply continues to the next
+//     chunk rather than concluding anything from them.
+//   - plain JSON (non-streaming): the whole prefix parses to an object. A
+//     prefix whose JSON is still truncated (e.g. the `provider` key beyond
+//     the peek window) stays inconclusive — the body passes through
+//     uncaptured rather than being buffered.
+function extractServedFields(
+  prefix: string,
+): { provider: string | null; model: string | null } | null {
+  let sawData = false
+  for (const line of prefix.split("\n")) {
+    const trimmed = line.trim()
+    if (!trimmed.startsWith("data:")) continue
+    sawData = true
+    const payload = trimmed.slice("data:".length).trim()
+    if (payload === "[DONE]") return { provider: null, model: null }
+    try {
+      const parsed = JSON.parse(payload) as unknown
+      if (isPlainObject(parsed)) {
+        // Only a NON-null provider concludes the peek: a parseable line
+        // without one must not end the search — the provider may arrive in a
+        // later data line within the byte bound. `data: [DONE]` (above) is
+        // the one line that concludes without a capture.
+        const provider = stringField(parsed, "provider")
+        if (provider !== null) {
+          return { provider, model: stringField(parsed, "model") }
+        }
+      }
+    } catch {
+      // A line split across a chunk boundary — keep peeking.
+    }
+  }
+  if (sawData) return null
+  try {
+    const parsed = JSON.parse(prefix) as unknown
+    if (isPlainObject(parsed)) {
+      return { provider: stringField(parsed, "provider"), model: stringField(parsed, "model") }
+    }
+  } catch {
+    // Not (yet) JSON — keep peeking.
+  }
+  return null
+}
+
 // ---- the slice of the OpenCode v2 plugin context the plugin touches --------
 
 type Registration = { dispose: () => Promise<void> }
@@ -89,14 +174,19 @@ export type CommandDefinition = {
   execute: (input: { sessionID: string; prompt: { text: string } }) => Promise<void>
 }
 
-// The `http.request` event (§9): the guard keys on the requesting agent, not
-// on event.model, which already shows the effective (fallback) reference.
+// The `http.request` / `http.response` event (§9): the guard keys on the
+// requesting agent, not on event.model, which already shows the effective
+// (fallback) reference. `response` is present only on http.response events
+// (the real SDK carries both hook events' shapes; only the response's hook
+// receives one) — and it must stay MUTABLE: the capture hook re-creates the
+// Response around a pass-through stream and writes it back.
 export type HttpEvent = {
   sessionID: string
   agent: string
   model: ModelRef
   kind: "primary" | "compaction" | "title" | "generate"
   request: unknown
+  response?: Response
 }
 
 export type ModelListEntry = { id: string; providerID: string; enabled: boolean }
@@ -120,7 +210,7 @@ export type PluginCtx = {
   }
   session: {
     hook(
-      name: "http.request",
+      name: "http.request" | "http.response",
       callback: (event: HttpEvent) => Promise<void> | void,
     ): Promise<Registration>
     switchModel(input: { sessionID: string; model: ModelRef }): Promise<void>
@@ -146,6 +236,11 @@ export type WireDeps = {
   now?: () => number
   // Per-tick hard deadline (F-01); tests shrink it.
   deadlineMs?: number
+  // State-observation seam (tests): hands the LIVE WireState object to the
+  // caller once setup finishes wiring it — every later mutation (steering
+  // records, endpoint captures) lands on the same object, so the holder sees
+  // the updates in real time. Nothing in production passes it.
+  onState?: (state: WireState) => void
 }
 
 // ---- captured state and small helpers --------------------------------------
@@ -166,6 +261,34 @@ export type AliasPlan = {
 // `registryDisabled[p]` records that the transform wanted alias p enabled but
 // its concrete model was missing from the editor; the applied view then says
 // disabled, whatever the plan wanted.
+//
+// `appliedSteering[sessionID]` records the steering order the request hook
+// ACTUALLY injected into that session's most recent request: the order array
+// when it injected (catalog-projected blocks always carry a non-empty order),
+// null when it did not (non-alias ref, no steering data, a pre-existing body
+// `provider`, or any failure — fail open). The response hook consumes it as
+// captureEndpoint's `order`, so the `!` downgrade flag fires only when a
+// non-empty order was really applied. Last request per session wins.
+//
+// `lastEndpoints[sessionID]` records the served-endpoint capture for that
+// session's most recent primary response: the served `provider` string
+// verbatim, the response's concrete `model` id, the downgrade verdict, and
+// the wall-clock moment of the capture. Last-writer-wins WITHIN a session
+// (hook invocations interleave concurrently — every write is per-event, from
+// the event's own sessionID); stale entries for ended sessions are
+// acceptable (no session-removal hook exists to prune them).
+//
+// `cannotSteerToasted[sessionID]` records that the Q2 fallback's cannot-steer
+// event was already successfully emitted for that session: when a steerable
+// alias request (alias ref + a current pick) finds NO steering data — no
+// catalog source, `sourced === null` — the injection hook emits the event
+// exactly ONCE PER SESSION (never once per request), leaving the request body
+// untouched. A body that already carries a `provider` key binds the
+// exclusion: the emit is skipped (user-configured routing makes the "default
+// routing applies" copy false) without consuming the flag, so a later
+// provider-free request still toasts. The flag is set only AFTER a successful
+// emit (a failed one leaves it unset so a later request retries) and is never
+// re-armed: a session that has seen the toast keeps it for its lifetime.
 export type WireState = {
   sourced: Sourced | null
   pins: Partial<Record<Priority, Pin>>
@@ -173,6 +296,9 @@ export type WireState = {
   enabled: Partial<Record<Priority, boolean>>
   plan: AliasPlan
   registryDisabled: Partial<Record<Priority, boolean>>
+  appliedSteering: Record<string, string[] | null>
+  lastEndpoints: Record<string, EndpointCapture>
+  cannotSteerToasted: Record<string, boolean>
 }
 
 // readRecord only guarantees a v=1 object; the pin fields are checked so a
@@ -251,7 +377,18 @@ export async function wire(ctx: PluginCtx, deps: WireDeps = {}): Promise<() => v
     enabled: {},
     plan: { picks: {}, enabled: {} },
     registryDisabled: {},
+    // The three per-session records are keyed by ids that reach them from
+    // OUTSIDE (hook events, RPC input): null-prototype objects so a key like
+    // "constructor"/"toString"/"__proto__" can never resolve through — or
+    // mutate — the prototype chain (a plain-object lookup would return
+    // Object.prototype junk and poison the report footer).
+    appliedSteering: Object.create(null) as Record<string, string[] | null>,
+    lastEndpoints: Object.create(null) as Record<string, EndpointCapture>,
+    cannotSteerToasted: Object.create(null) as Record<string, boolean>,
   }
+  // Test seam: hand the live state object out BEFORE any registration can
+  // mutate it — the reference never changes, only its contents do.
+  deps.onState?.(state)
 
   // Seed state from storage (§8 startup) BEFORE registering the transform:
   // OpenCode applies transforms at registration time (design-spike-verified),
@@ -318,6 +455,13 @@ export async function wire(ctx: PluginCtx, deps: WireDeps = {}): Promise<() => v
   // transform from the captured state, so any replay applies the current pick.
   await ctx.model.transform((editor) => applyAliases(state, editor))
 
+  // The RPC registration (below, before the commands) is the event bridge
+  // the steering hook emits the cannot-steer fallback through; the binding is
+  // hoisted here so the hook's closure sees it declared. No request can
+  // arrive before setup completes, and the emit site guards on the
+  // registration being ready anyway (fail open).
+  let rpcRegistration: RpcRegistration | undefined
+
   // The guard (§9): a primary request whose agent is configured with a
   // DISABLED alias aborts with the exact error; everything else passes. The
   // agent lookup is wrapped — a missing agent must not break the request path.
@@ -333,20 +477,311 @@ export async function wire(ctx: PluginCtx, deps: WireDeps = {}): Promise<() => v
     if (decision.error !== undefined) throw new Error(decision.error)
   })
 
+  // The steering injection (design §Steering injection; spike fact 2):
+  // alias-scoped requests whose pick's catalog entry carries a steering block
+  // get the block's provider sub-object injected into the JSON body and the
+  // Request re-created. No kind filter — alias-bound refs arrive for primary
+  // AND compaction (spike scoping), and a directly-picked ref is never an
+  // alias ref, so it falls through untouched (the anti-goal). Every path
+  // that does not inject leaves the original request untouched (fail open,
+  // spec anti-goal) and nulls the session's appliedSteering record.
+  await ctx.session.hook("http.request", async (event) => {
+    try {
+      // Cheap gate before any body read (the guard's parseAliasRef rule;
+      // steeringFor re-checks variant-blind): concrete refs — title kinds,
+      // direct picks, fallback-bound sessions — skip the body entirely.
+      const p = parseAliasRef(event.model)
+      if (p === null) {
+        state.appliedSteering[event.sessionID] = null
+        return
+      }
+      // The Q2 fallback (Task 6): a steerable alias request (alias ref + a
+      // current pick) with NO steering data — no catalog source,
+      // `sourced === null` — proceeds untouched, but the TUI is told so it
+      // can toast the fallback: exactly ONCE PER SESSION (the
+      // cannotSteerToasted flag), never once per request. A disabled alias
+      // (no pick) stays silent — that is the guard's domain, not a toast.
+      // The body is never reassigned — the request proceeds untouched.
+      if (state.sourced === null) {
+        state.appliedSteering[event.sessionID] = null
+        const pick = state.picks[p]
+        // The whole toast block needs the RPC registration (the emit's event
+        // bridge): while it is still undefined the block is skipped ENTIRELY —
+        // no body read, no flag write, no emit — so nothing is consumed while
+        // there is nowhere to emit to (a later request retries).
+        const registration = rpcRegistration
+        if (
+          registration !== undefined &&
+          pick !== undefined &&
+          pick.id !== null &&
+          state.cannotSteerToasted[event.sessionID] !== true
+        ) {
+          // The one-off body read (fix round 1): gated behind the once-flag
+          // so steady-state requests are never parsed. A body that already
+          // carries a `provider` key binds the exclusion — user-configured
+          // routing makes the "default routing applies" toast false copy —
+          // so the emit is skipped WITHOUT consuming the flag: a later
+          // provider-free request for the session still toasts. The read is
+          // a cheap clone-parse; the original Request is never reassigned.
+          let bodyHasProvider = false
+          try {
+            const body: unknown = JSON.parse(await (event.request as Request).clone().text())
+            bodyHasProvider =
+              typeof body === "object" && body !== null && Object.hasOwn(body, "provider")
+          } catch {
+            // Unreadable or missing body: no provider key is knowable —
+            // fall back to the plain emit (fail open).
+          }
+          if (!bodyHasProvider) {
+            // Fire-and-forget: the emit must never block the request path.
+            // The once-flag is set only AFTER a successful emit; a failed
+            // emit leaves it unset so a later request for the session
+            // retries — never a permanently lost toast.
+            void registration.events
+              .emit("cannotSteer", { sessionID: event.sessionID })
+              .then(() => {
+                state.cannotSteerToasted[event.sessionID] = true
+              })
+              .catch(() => {
+                // Leave the once-flag unset: a later request retries.
+              })
+          }
+        }
+        return
+      }
+      const request = event.request as Request
+      let body: unknown
+      try {
+        body = JSON.parse(await request.clone().text())
+      } catch {
+        // No JSON body (or unreadable): untouched, fail open.
+        state.appliedSteering[event.sessionID] = null
+        return
+      }
+      const steering = steeringFor(
+        event.model,
+        bodyModelOf(body),
+        state.picks,
+        new Map(state.sourced.doc.models.map((entry): [string, ModelEntry] => [entry.id, entry])),
+      )
+      if (steering === null) {
+        // No steering data for the pick: untouched, fail open.
+        state.appliedSteering[event.sessionID] = null
+        return
+      }
+      const modified = injectSteering(body, steering)
+      if (modified === body) {
+        // The body already carries a `provider` key (or is not an object):
+        // never clobber routing the user or a provider configured.
+        state.appliedSteering[event.sessionID] = null
+        return
+      }
+      // Spike fact 2's verified recipe: re-create the Request around the
+      // modified body, dropping the stale length/encoding headers (the
+      // runtime re-derives content-length for the new body). The original's
+      // `signal` is forwarded so abort/interrupt handling stays wired to the
+      // request the chain handed us.
+      const headers = new Headers(request.headers)
+      headers.delete("content-length")
+      headers.delete("content-encoding")
+      event.request = new Request(request.url, {
+        method: request.method,
+        headers,
+        body: JSON.stringify(modified),
+        signal: request.signal,
+      })
+      // Record the order actually applied — the response hook reads it as
+      // captureEndpoint's order (the `!` flag fires only on a non-empty one).
+      state.appliedSteering[event.sessionID] = steering.order
+    } catch {
+      // Fail open: any error leaves the original request proceeding
+      // untouched, and records that nothing was injected.
+      state.appliedSteering[event.sessionID] = null
+    }
+  })
+
+  // The response capture (design §Steering visibility): a primary response's
+  // first few bytes are peeked THROUGH a pass-through transform (never
+  // buffered or consumed — the peeked chunks are forwarded untouched, so the
+  // rest of the body flows byte-for-byte) to read the served `provider` and
+  // `model`, and the session's lastEndpoints record is written per-event from
+  // the event's OWN sessionID (hook invocations interleave concurrently —
+  // never write from a shared "current session"). Only primary responses of
+  // alias-bound sessions update the capture — a non-alias model ref returns
+  // before any wrap (zero modification, the anti-goal); any body the peek
+  // cannot parse passes through unmodified, uncaptured; every error is
+  // swallowed — the capture is best-effort and must never break the response
+  // itself.
+  await ctx.session.hook("http.response", async (event) => {
+    try {
+      if (event.kind !== "primary") return
+      // Alias-scoped (the spec's binding constraint): capture fires only when
+      // the session's model is one of the three alias refs. A non-alias
+      // session — a direct pick, another agent, any provider — gets ZERO
+      // modification: no wrap, no peek, no capture. The request-side half of
+      // the binding (the request's model equals that alias's current pick) is
+      // inherited via appliedSteering, which only the injection hook's
+      // injecting paths set to a non-empty order; a disabled alias's session
+      // carries its concrete fallback ref here and captures nothing.
+      if (parseAliasRef(event.model) === null) return
+      const response = event.response
+      if (response === undefined) return
+      const body = response.body
+      if (body === null) return
+
+      // Read ONCE, per-event, from the event's own sessionID. The record
+      // holds the session's most recent REQUEST's order — best-effort ONLY:
+      // with concurrent same-session requests (compaction/title alongside
+      // primary) the verdict can be wrong in EITHER direction. A newer
+      // non-injecting request nulls the record and this response's downgrade
+      // then reads `false` even if its own request did inject (false
+      // negative); a newer injecting request leaves ITS order here, and a
+      // response produced under the older order may be flagged `!` against
+      // the wrong order (false positive). Display-only impact — the alt+e
+      // toast and the report footer; nothing about the sent request depends
+      // on this read.
+      const order = state.appliedSteering[event.sessionID] ?? null
+
+      const decoder = new TextDecoder()
+      let captured = ""
+      let peekedBytes = 0
+      let done = false
+      const record = (provider: string | null, model: string | null) => {
+        done = true
+        // Nothing to show (no provider at all, or a name with no provider
+        // part): treat as no capture — captureEndpoint's endpoint === null
+        // means exactly that.
+        if (provider === null) return
+        const verdict = captureEndpoint(provider, order)
+        if (verdict.endpoint === null) return
+        state.lastEndpoints[event.sessionID] = {
+          sessionID: event.sessionID,
+          endpoint: verdict.endpoint,
+          // The spike established OpenRouter responses always carry `model`;
+          // an outlier without one still records the endpoint (the capture's
+          // point), with an empty id standing in for the missing field.
+          model: model ?? "",
+          downgrade: verdict.downgrade,
+          at: now(),
+        }
+      }
+      const inspect = () => {
+        const peek = extractServedFields(captured)
+        if (peek !== null) record(peek.provider, peek.model)
+      }
+      const transform = new TransformStream<Uint8Array, Uint8Array>({
+        transform: (chunk, controller) => {
+          try {
+            if (!done) {
+              // The peek is byte-bounded: only the first PEEK_MAX_BYTES
+              // bytes of the stream are ever decoded for inspection — a
+              // chunk that crosses the bound contributes only its head, and
+              // the rest is never decoded (it still passes through
+              // untouched, below).
+              const take = Math.min(chunk.byteLength, PEEK_MAX_BYTES - peekedBytes)
+              if (take > 0) captured += decoder.decode(chunk.subarray(0, take), { stream: true })
+              peekedBytes += take
+              // Extraction runs on every peeked chunk: a first chunk that is
+              // only a comment line must not conclude anything — the data
+              // line may arrive in a later chunk (spike fact 5).
+              inspect()
+              if (peekedBytes >= PEEK_MAX_BYTES) done = true
+            }
+          } catch {
+            // Inspection never breaks the stream: give up on the peek, keep
+            // forwarding.
+            done = true
+          }
+          controller.enqueue(chunk)
+        },
+        flush: () => {
+          try {
+            if (!done) {
+              // The stream ended before the bound: flush any held-back
+              // multi-byte tail and make one final extraction attempt.
+              captured += decoder.decode()
+              inspect()
+            }
+          } catch {
+            done = true
+          }
+        },
+      })
+      // Re-create the Response around the pass-through stream (mirror of the
+      // request hook's re-creation): the original body is owned by the chain
+      // and never consumed by the plugin. Deliberate deviation from the spike
+      // recipe: the spike DELETED content-length/content-encoding on BOTH the
+      // request and the response re-creation, while here the body passes
+      // through unchanged, so the response's exact headers are kept verbatim
+      // for byte-identical passthrough. Known cost of the re-creation: the
+      // new Response cannot carry `url`, `type` or `redirected` (they reset
+      // to ""/"default"/false) — no consumer of those fields is known in this
+      // plugin; flagged for any downstream hook that reads them.
+      event.response = new Response(body.pipeThrough(transform), {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+      })
+    } catch {
+      // Fail open: any error leaves the response untouched and uncaptured.
+    }
+  })
+
   // The RPC (V2 plugins RPC): the report method serves the SAME text the
   // /model-compare command synthesizes (one builder — the two can never
   // drift), and the registration carries the report EVENT the command emits
   // so the TUI half can open the report as an instant selectable dialog.
   // Registered BEFORE the commands: the command's execute emits through it.
-  const rpcRegistration = await ctx.rpc.register(ModelCompare, {
-    report: async () => {
+  // One registration per rpcID: the host resolves duplicates last-one-wins,
+  // so a second register() would silently rebind the events bridge.
+  //
+  // The report footer (design §Steering visibility): the payload carries the
+  // session's last-endpoint capture and the steering note. One derivation
+  // (reportFooter, below) serves the RPC method, the event emit and
+  // formatReport, so the dialog's footer and the transcript text agree.
+  const reportFooter = (sessionID: string | null) => {
+    // The capture is keyed by sessionID (Task 5's per-session map): a null
+    // session (the opening screen) has nothing to look up. The record's
+    // display fields are projected — the toast needs `downgrade` too, so all
+    // three travel.
+    const record = sessionID === null ? undefined : state.lastEndpoints[sessionID]
+    const capture =
+      record === undefined
+        ? null
+        : { endpoint: record.endpoint, model: record.model, downgrade: record.downgrade }
+    // The steering note needs the catalog: without a source there is no data
+    // to derive it from, and the note does not render.
+    const steeringNoteFor =
+      state.sourced === null ? null : steeringNote(state.sourced.doc, state.picks, state.enabled)
+    return { capture, steeringNote: steeringNoteFor }
+  }
+
+  rpcRegistration = await ctx.rpc.register(ModelCompare, {
+    report: async (rawInput: unknown) => {
+      const input = rawInput as { sessionID?: string | null } | undefined
+      const sessionID = input?.sessionID ?? null
       const ranks = reportRanks()
+      // ONE derivation per call: the same footer fields feed formatReport's
+      // context and the returned payload, so the transcript text and the
+      // dialog footer can never disagree.
+      const footer = reportFooter(sessionID)
       if (state.sourced === null || ranks === null) {
-        return { text: "model-compare: no ranking data available yet", age: null, entries: [] }
+        return {
+          text: "model-compare: no ranking data available yet",
+          age: null,
+          ...footer,
+          entries: [],
+        }
       }
       return {
-        text: formatReport(state.sourced, ranks, { picks: state.picks, overrides: config.weights }),
+        text: formatReport(state.sourced, ranks, {
+          picks: state.picks,
+          overrides: config.weights,
+          enabled: state.enabled,
+          capture: footer.capture,
+        }),
         age: humanizeAge(Date.now() - state.sourced.acquiredAt),
+        ...footer,
         entries: reportEntries(state.sourced, ranks, { picks: state.picks, overrides: config.weights }),
       }
     },
@@ -415,7 +850,12 @@ export async function wire(ctx: PluginCtx, deps: WireDeps = {}): Promise<() => v
         // transcript notice is the durable copy, not the fast path).
         if (sourced === null || ranks === null) {
           try {
-            await rpcRegistration.events.emit("report", { sessionID, age: null, entries: [] })
+            await rpcRegistration.events.emit("report", {
+              sessionID,
+              age: null,
+              ...reportFooter(sessionID),
+              entries: [],
+            })
           } catch {
             // Emission failures must not fail the command.
           }
@@ -426,11 +866,19 @@ export async function wire(ctx: PluginCtx, deps: WireDeps = {}): Promise<() => v
           })
           return
         }
-        const context = { picks: state.picks, overrides: config.weights }
+        const footer = reportFooter(sessionID)
+        const context = {
+          picks: state.picks,
+          overrides: config.weights,
+          enabled: state.enabled,
+          capture: footer.capture,
+        }
         try {
           await rpcRegistration.events.emit("report", {
             sessionID,
             age: humanizeAge(Date.now() - sourced.acquiredAt),
+            capture: footer.capture,
+            steeringNote: footer.steeringNote,
             entries: reportEntries(sourced, ranks, context),
           })
         } catch {