@openparachute/agent 0.2.2 → 0.2.3-rc.11

package/src/backends/registry.ts

@@ -44,7 +44,7 @@
 
 import type { AgentSpec, AgentMode } from "../sandbox/types.ts";
 import { normalizeChannel } from "../sandbox/types.ts";
-import type { AgentBackend, AgentHandle, InterimTurnEvent, TurnSession } from "./types.ts";
+import type { AgentBackend, AgentHandle, InterimTurnEvent, RunContext, TurnSession } from "./types.ts";
 import type { InboundAttachment } from "../transport.ts";
 
 /**
@@ -90,12 +90,15 @@ export type WriteOutbound = (
   reply: string,
   inReplyTo?: string,
   /**
-   * The per-turn thread id this reply belongs to — the explicit definition→thread→message
-   * link the outbound note carries (stamped into `metadata.thread`). For multi-threaded it
-   * IS the per-fire thread note's leaf (an exact link); for single-threaded it's a per-turn
-   * correlation id (the note's stable deterministic leaf is the def name — single-threaded
-   * outbound→note linkage by the stable path is a follow-up). INBOUND-note stamping is
-   * deferred (those notes are externally written; see the PR notes).
+   * The RESOLVABLE, MODE-CORRECT thread id this reply belongs to — the explicit
+   * definition→thread→message link the outbound note carries (stamped into `metadata.thread`),
+   * mirroring the callback `source_thread` fix (agent#124/#163). For multi-threaded it IS the
+   * per-fire thread note's leaf (`Threads/<channel>/<id>`); for single-threaded it is the
+   * DETERMINISTIC thread-NOTE id (`Threads/<channel>/<name>`), STABLE across turns — so an
+   * observer reading the outbound note's `metadata.thread` resolves the agent's ONE thread
+   * with `query-notes { id }`, instead of the per-turn correlation UUID that changed every
+   * run (the pre-#163 bug that looked like a fresh session each time). INBOUND-note stamping
+   * is deferred (those notes are externally written; see the PR notes).
    */
   threadId?: string,
 ) => Promise<{ id?: string } | void>;
@@ -174,8 +177,16 @@ export interface ThreadNote {
  * per channel, multi-threaded writes one per fire. A write failure is the implementation's
  * to surface (the registry logs whatever it throws); it never re-runs the turn. Optional on
  * the registry — when unwired (no vault-backed channel), a turn still runs, just no note.
+ *
+ * RETURNS the WRITTEN thread-note's id (`{ id }`) so the drain can use it as a RESOLVABLE
+ * `source_thread` on the agent-to-agent callback (agent#124) — for BOTH modes, this is the
+ * actual note an orchestrator can pull with `query-notes { id }` (single-threaded: the
+ * deterministic `Threads/<safeChannel>/<safeName>` note; multi-threaded: the per-fire
+ * `Threads/<safeChannel>/<uuid>` note). `void` is in the union (back-compat) — a transport
+ * with no durable store, or one that can't surface an id, returns it and the drain falls
+ * back to the per-turn id.
  */
-export type WriteThread = (thread: ThreadNote) => Promise<void>;
+export type WriteThread = (thread: ThreadNote) => Promise<{ id?: string } | void>;
 
 /**
  * A callback delivered back to a SENDER's channel when a turn it requested finishes —
@@ -216,15 +227,16 @@ export interface CallbackMeta {
   /** The channel/def whose turn just finished (the recipient) — provenance for the sender. */
   source_channel: string;
   /**
-   * The per-turn thread id the drain minted. RESOLVABILITY DIFFERS BY MODE:
-   *  - multi-threaded: this IS the per-fire note's leaf — the orchestrator can pull the
-   *    thread note at `Threads/<channel>/<source_thread>`.
-   *  - single-threaded: this is a per-turn CORRELATION id, NOT the note leaf (the
-   *    single-threaded note lives at the deterministic `Threads/<channel>/<name>`), so it
-   *    is NOT directly resolvable. Use `source_message` as the reliable pull-link for a
-   *    single-threaded recipient. Making this a resolvable thread id for both modes
-   *    (widen the writeThread seam to return the written note id) is tracked as a
-   *    follow-up (parachute-agent#124).
+   * The WRITTEN thread-note id — RESOLVABLE for BOTH modes (agent#124): an orchestrator can
+   * always pull the recipient's full thread record with `query-notes { id: source_thread }`,
+   * even on an error/empty/tool-only turn (the thread note is written BEFORE the outbound
+   * reply, so its id exists when there's no `source_message`).
+   *  - multi-threaded: the per-fire note id (`Threads/<safeChannel>/<uuid>`).
+   *  - single-threaded: the deterministic note id (`Threads/<safeChannel>/<safeName>`) — NOT
+   *    the per-turn correlation id (the pre-#124 bug: that correlation id wasn't the note leaf
+   *    for single-threaded, so it couldn't be resolved).
+   * The drain sources this from {@link WriteThread}'s returned id; if the seam can't surface
+   * one (no durable store) it falls back to the per-turn id (still a stable provenance token).
    */
   source_thread: string;
   /**
@@ -293,6 +305,46 @@ function delay(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+/**
+ * The thread id to stamp into an OUTBOUND note's `metadata.thread` (agent#163) — the
+ * MODE-CORRECT, RESOLVABLE definition→thread→message link, mirroring the callback
+ * `source_thread` fix (agent#124):
+ *
+ *  - SINGLE-THREADED — the resolvable thread-NOTE id (the deterministic
+ *    `Threads/<safeChannel>/<safeName>` note), so an observer reading the outbound note's
+ *    `metadata.thread` resolves the agent's ONE stable thread with `query-notes { id }`.
+ *    The pre-#163 bug stamped the per-turn correlation UUID here, which changed every turn
+ *    and resolved to nothing — misleading an observer into "a fresh session each run" when
+ *    the single-threaded session is actually stable + resumed across turns.
+ *  - MULTI-THREADED — the per-fire id (`turnThreadId`), which IS that fire's thread-note leaf
+ *    (`Threads/<safeChannel>/<turnThreadId>`) — correct as-is: each fire is its own thread.
+ *
+ * Falls back to `turnThreadId` when no resolvable note id surfaced (no durable thread store
+ * wired, or the thread-note write failed) — never undefined, so the link is always stamped.
+ */
+export function outboundThreadId(
+  multiThreaded: boolean,
+  turnThreadId: string,
+  threadNoteId: string | undefined,
+): string {
+  if (multiThreaded) return turnThreadId;
+  return threadNoteId ?? turnThreadId;
+}
+
+/**
+ * Derive the run-context `fired-by` provenance (agent#162) from an inbound message's
+ * `sender` (the note's `metadata.sender`). A SCHEDULED job fire stamps `runner:<jobId>`
+ * (the runner's sender provenance) → reported as the job id so the agent knows it's a cron
+ * fire; anything else (a human / a delegated agent message) → `interactive`. Absent sender →
+ * undefined (the run context omits `fired-by`).
+ */
+export function runFiredBy(sender: string | undefined): string | undefined {
+  if (!sender) return undefined;
+  const m = /^runner:(.+)$/.exec(sender);
+  if (m) return `scheduled-job:${m[1]}`;
+  return "interactive";
+}
+
 /** A queued inbound message awaiting its serial turn. */
 export interface QueuedMessage {
   /** The inbound text handed to the `claude -p` turn as the prompt. */
@@ -334,6 +386,13 @@ export interface QueuedMessage {
    * `Read` it. Absent/empty → no attachments (today's behavior unchanged).
    */
   attachments?: InboundAttachment[];
+  /**
+   * WHO/WHAT sent this inbound (the note's `metadata.sender`) — used ONLY to derive the
+   * run-context `fired-by` provenance the daemon injects into the turn (agent#162): a
+   * SCHEDULED job fire stamps `runner:<jobId>`, an interactive/delegated message stamps
+   * something else. Absent → the run context omits `fired-by`. Carries no routing meaning.
+   */
+  sender?: string;
 }
 
 /** A registered programmatic agent's live status (surfaced in /health + the list). */
@@ -797,7 +856,11 @@ export class ProgrammaticAgentRegistry {
       // start+end never double-count. Best-effort: a start-ensure write failure is logged
       // (inside recordThread) and the turn STILL runs — a missing/stale working note must
       // never strand the queue or skip the turn.
-      await this.recordThread(handle, msg, "working", "", startedAt, undefined, {
+      // Capture the start-ensure's WRITTEN thread-note id. For single-threaded this is the
+      // DETERMINISTIC `Threads/<safeChannel>/<safeName>` note (the same every turn) — so a
+      // resolvable thread id is available BEFORE the turn runs, for the failure-note +
+      // outbound `metadata.thread` stamping (agent#163), even on a turn that fails early.
+      const startThreadNoteId = await this.recordThread(handle, msg, "working", "", startedAt, undefined, {
         threadId: turnThreadId,
         phase: "start",
         // NO session on the start-ensure: it runs BEFORE claude, so claude may never
@@ -807,6 +870,26 @@ export class ProgrammaticAgentRegistry {
         // the `end` record, and ONLY the id claude actually echoed (FIX 2). For a
         // single-threaded resume turn the prior session is preserved by writeThread anyway.
       });
+      // The MODE-CORRECT, RESOLVABLE thread id stamped into outbound + failure notes
+      // (agent#163): single-threaded → the deterministic thread-NOTE id (stable across turns);
+      // multi-threaded → the per-fire `turnThreadId`. Computed once from the start-ensure id so
+      // every path (early failure, ok, outbound-failure) stamps the same resolvable link.
+      const outThreadId = outboundThreadId(multiThreaded, turnThreadId, startThreadNoteId);
+
+      // RUN CONTEXT (agent#162): assemble the runtime facts a headless `claude -p` turn can't
+      // know — the REAL wall-clock (`startedAt`), whether this run CONTINUES a prior session
+      // (`turnSession.resume`) or starts fresh, and WHY it fired (a scheduled job vs an
+      // interactive/delegated message, from the inbound sender). The backend prepends these as
+      // a labeled preamble so the agent stamps ACCURATE times instead of fabricating them.
+      // (DEFERRED: `priorTurnCount` — the rolling turn_count lives in the transport's thread
+      // note and isn't surfaced back to the drain; wiring it is a follow-up. Until then the
+      // preamble omits the `turn=N` line — the `now`/session/fired-by trio is the floor.)
+      const firedBy = runFiredBy(msg.sender);
+      const runContext: RunContext = {
+        now: startedAt,
+        session: turnSession.resume ? "resumed" : "new",
+        ...(firedBy ? { firedBy } : {}),
+      };
 
       let result;
       try {
@@ -821,6 +904,8 @@ export class ProgrammaticAgentRegistry {
           // Phase 1: inbound attachments → the programmatic backend stages them into the
           // agent's private workspace so the turn can Read them. Absent/empty → no staging.
           msg.attachments,
+          // agent#162: the daemon-known runtime context (real clock, new/resumed, fired-by).
+          runContext,
         );
       } catch (err) {
         // The backend contract is failure-as-VALUE, never a throw — but defend so a
@@ -835,7 +920,7 @@ export class ProgrammaticAgentRegistry {
         // thread note captures the turn outcome, so a failed turn is still a queryable
         // `status:error` (single-threaded upserts the rolling thread; multi-threaded writes
         // a per-fire note).
-        await this.recordThread(handle, msg, "error", reason, startedAt, undefined, {
+        const threadNoteId = await this.recordThread(handle, msg, "error", reason, startedAt, undefined, {
           threadId: turnThreadId,
           phase: "end",
           // No `result` (the backend threw) → NO session to persist. We never write a
@@ -845,11 +930,13 @@ export class ProgrammaticAgentRegistry {
         });
         this.emitTurnEvent(channel, { kind: "error", error: reason });
         // Post a user-facing failure note so the channel shows SOMETHING (not a silent
-        // no-reply) — best-effort.
-        await this.postFailureNote(channel, msg.inReplyTo, turnThreadId, reason);
+        // no-reply) — best-effort. Stamp the MODE-CORRECT resolvable thread id (agent#163).
+        await this.postFailureNote(channel, msg.inReplyTo, outThreadId, reason);
         // CALLBACK on the failure too — an orchestrator MUST learn its sub-task failed, not
-        // hang waiting forever. No outbound note was produced, so no `source_message`.
-        await this.maybeDeliverCallback(handle, msg, turnThreadId, "error");
+        // hang waiting forever. No outbound note was produced, so no `source_message`; the
+        // RESOLVABLE thread-note id (written above) is `source_thread` so the orchestrator can
+        // still pull the recipient's thread on a no-reply turn (agent#124).
+        await this.maybeDeliverCallback(handle, msg, turnThreadId, "error", undefined, threadNoteId);
         continue;
       }
 
@@ -863,7 +950,7 @@ export class ProgrammaticAgentRegistry {
         // BOTH modes record the failed turn (status:error) on the thread note so a failure
         // always leaves a queryable trace (single-threaded upserts the rolling thread,
         // marking it errored; multi-threaded writes a per-fire status:error note).
-        await this.recordThread(handle, msg, "error", result.error, startedAt, undefined, {
+        const threadNoteId = await this.recordThread(handle, msg, "error", result.error, startedAt, undefined, {
           threadId: turnThreadId,
           phase: "end",
           // Persist ONLY the session claude ECHOED (FIX 2). A turn can fail AFTER
@@ -875,11 +962,12 @@ export class ProgrammaticAgentRegistry {
         });
         this.emitTurnEvent(channel, { kind: "error", error: result.error });
         // Post a user-facing failure note so the channel shows SOMETHING (not a silent
-        // no-reply) — best-effort.
-        await this.postFailureNote(channel, msg.inReplyTo, turnThreadId, result.error);
+        // no-reply) — best-effort. Stamp the MODE-CORRECT resolvable thread id (agent#163).
+        await this.postFailureNote(channel, msg.inReplyTo, outThreadId, result.error);
         // CALLBACK on the failure-as-value too (status:error) — the orchestrator learns the
-        // sub-task failed and can react. No delivered reply, so no `source_message`.
-        await this.maybeDeliverCallback(handle, msg, turnThreadId, "error");
+        // sub-task failed and can react. No delivered reply, so no `source_message`; the
+        // RESOLVABLE thread-note id (written above) is `source_thread` (agent#124).
+        await this.maybeDeliverCallback(handle, msg, turnThreadId, "error", undefined, threadNoteId);
         continue;
       }
 
@@ -891,7 +979,11 @@ export class ProgrammaticAgentRegistry {
       // multi-threaded writes the per-fire note. Best-effort: a thread-note failure is
       // logged + the turn still resolves (we never re-run a `claude -p` turn — that would
       // burn quota for a duplicate).
-      await this.recordThread(handle, msg, "ok", result.reply ?? "", startedAt, result.usage, {
+      // Capture the WRITTEN thread-note id — the RESOLVABLE `source_thread` for the callback
+      // (agent#124). The same note id is reused for the outbound-failure re-record below
+      // (sameTurn → same note), so a callback on either terminal path points at a pullable
+      // thread record.
+      let threadNoteId = await this.recordThread(handle, msg, "ok", result.reply ?? "", startedAt, result.usage, {
         threadId: turnThreadId,
         phase: "end",
         // Persist the session claude ECHOED (FIX 2) so the next turn `--resume`s this
@@ -915,7 +1007,12 @@ export class ProgrammaticAgentRegistry {
           channel,
           result.reply,
           msg.inReplyTo,
-          turnThreadId,
+          // agent#163: stamp the MODE-CORRECT, RESOLVABLE thread id into the outbound note's
+          // `metadata.thread` — single-threaded → the deterministic thread-NOTE id (stable
+          // across turns; an observer resolves the ONE thread), multi-threaded → the per-fire
+          // id. NOT the per-turn correlation UUID (the pre-#163 bug that looked like a fresh
+          // session every run).
+          outThreadId,
         );
         if (delivered.ok) sourceMessage = delivered.noteId;
         if (!delivered.ok) {
@@ -938,7 +1035,9 @@ export class ProgrammaticAgentRegistry {
           // `sameTurn` so this updates the note the `ok` record above just wrote (one
           // note, no turn_count double-count) rather than minting a duplicate / advancing
           // the count (the FIX-1 re-record bug the reviewer caught).
-          await this.recordThread(
+          // Re-record returns the SAME note's id (sameTurn upsert / same per-fire note) — use
+          // it as the callback `source_thread` (agent#124), falling back to the ok-record id.
+          threadNoteId = (await this.recordThread(
             handle,
             msg,
             "error",
@@ -955,7 +1054,7 @@ export class ProgrammaticAgentRegistry {
               // write failed. Only claude's echoed id (FIX 2), never the passed uuid.
               ...(result.sessionId ? { session: result.sessionId } : {}),
             },
-          );
+          )) ?? threadNoteId;
           this.emitTurnEvent(channel, {
             kind: "error",
             error: `reply produced but not saved: ${delivered.error}`,
@@ -963,8 +1062,8 @@ export class ProgrammaticAgentRegistry {
           // CALLBACK as status:error — the reply was produced but NOT delivered, so the
           // turn did not truly succeed; the orchestrator must learn that. No `source_message`
           // (the outbound note never landed); the undelivered text lives in the error thread
-          // note for an operator to recover.
-          await this.maybeDeliverCallback(handle, msg, turnThreadId, "error");
+          // note for an operator to recover — pull it via the RESOLVABLE `source_thread`.
+          await this.maybeDeliverCallback(handle, msg, turnThreadId, "error", undefined, threadNoteId);
           continue;
         }
       }
@@ -976,8 +1075,10 @@ export class ProgrammaticAgentRegistry {
       // (empty/tool-only turn → clean resolve, no note expected).
       this.emitTurnEvent(channel, { kind: "done", reply: result.reply ?? "" });
       // CALLBACK on success — the turn finished cleanly (status:ok). `sourceMessage` is the
-      // delivered reply note (when there was one) the orchestrator pulls the full result from.
-      await this.maybeDeliverCallback(handle, msg, turnThreadId, "ok", sourceMessage);
+      // delivered reply note (when there was one) the orchestrator pulls the full result from;
+      // `source_thread` (the WRITTEN thread-note id, agent#124) is the RESOLVABLE pull-link in
+      // both modes, including an empty/tool-only turn where there's no `sourceMessage`.
+      await this.maybeDeliverCallback(handle, msg, turnThreadId, "ok", sourceMessage, threadNoteId);
     }
   }
 
@@ -1013,6 +1114,7 @@ export class ProgrammaticAgentRegistry {
     turnThreadId: string,
     status: "ok" | "error",
     sourceMessage?: string,
+    sourceThreadId?: string,
   ): Promise<void> {
     // Guard 1 + 2: no sink, or this wasn't a delegated request → nothing to call back.
     if (!this.writeCallback) return;
@@ -1041,11 +1143,17 @@ export class ProgrammaticAgentRegistry {
     // source_message are echoed/included only when present. The daemon's WriteCallback
     // wiring writes this as a `#agent/message/inbound` note to `msg.replyTo` and — CRUCIALLY
     // — does NOT stamp a `reply_to` on it (the terminal-callback loop guard).
+    //
+    // `source_thread` is the WRITTEN thread-note id (agent#124) — RESOLVABLE for BOTH modes
+    // (`query-notes { id: source_thread }`), available even on an error/empty/tool-only turn
+    // (the thread note is written before the outbound). Fall back to the per-turn id only when
+    // the thread seam surfaced none (no durable store / a write failure) — still a stable
+    // provenance token, just not a pullable note.
     const meta: CallbackMeta = {
       callback: "true",
       status,
       source_channel: handle.channel,
-      source_thread: turnThreadId,
+      source_thread: sourceThreadId ?? turnThreadId,
       ...(sourceMessage ? { source_message: sourceMessage } : {}),
       ...(msg.correlationId ? { correlation_id: msg.correlationId } : {}),
       delegation_depth: String(incomingDepth + 1),
@@ -1071,6 +1179,11 @@ export class ProgrammaticAgentRegistry {
    * agent name (single-threaded's thread is "named after the definition"). Best-effort: a
    * write failure is LOGGED, never thrown out — a missing thread note must not strand the
    * queue, and the turn is never re-run (it would burn quota for a duplicate `claude -p`).
+   *
+   * RETURNS the WRITTEN thread-note id so the drain can use it as a RESOLVABLE
+   * `source_thread` on the agent-to-agent callback (agent#124), for BOTH modes. `undefined`
+   * when no sink is wired, the write failed, or the seam surfaced no id — the drain then
+   * falls back to the per-turn id.
    */
   private async recordThread(
     handle: ProgrammaticAgentHandle,
@@ -1080,8 +1193,8 @@ export class ProgrammaticAgentRegistry {
     startedAt: string,
     usage: ThreadNote["usage"],
     opts: { threadId?: string; sameTurn?: boolean; phase?: "start" | "end"; session?: string } = {},
-  ): Promise<void> {
-    if (!this.writeThread) return;
+  ): Promise<string | undefined> {
+    if (!this.writeThread) return undefined;
     const thread: ThreadNote = {
       channel: handle.channel,
       name: handle.spec.name,
@@ -1107,12 +1220,18 @@ export class ProgrammaticAgentRegistry {
       ...(opts.phase ? { phase: opts.phase } : {}),
     };
     try {
-      await this.writeThread(thread);
+      // The seam returns the WRITTEN note id (`{ id }`) for a durable transport; `void` for
+      // one with no store. Surface it so the drain can set a RESOLVABLE callback
+      // `source_thread` (agent#124). A missing id → undefined → the drain falls back to the
+      // per-turn id.
+      const written = await this.writeThread(thread);
+      return written?.id;
     } catch (err) {
       console.error(
         `parachute-agent: writing #agent/thread note for channel "${handle.channel}" failed ` +
           `(continuing): ${(err as Error).message}`,
       );
+      return undefined;
     }
   }
 

package/src/backends/types.ts

@@ -84,6 +84,43 @@ export interface TurnSession {
   resume: boolean;
 }
 
+/**
+ * RUN CONTEXT for one turn (agent#162) — the runtime facts a programmatic `claude -p` turn
+ * otherwise has NO way to know, so an agent stops FABRICATING them. A headless `-p` turn has
+ * no clock and no notion of "which run this is": uni-weaver was openly inventing report
+ * timestamps (a fixed `10:05` slot, the date "derived from context") because it couldn't read
+ * a real clock mid-run. The daemon KNOWS these facts at dispatch time, so it injects them into
+ * the turn (a concise, clearly-labeled preamble the agent reads) rather than letting the agent
+ * guess. Cheap, and it removes a whole class of fabricated-time confusion.
+ *
+ * The backend renders this as a SHORT preamble prepended to the turn message — it never
+ * mangles the agent's own system-prompt semantics. ADDITIVE: a caller that omits it leaves the
+ * turn message exactly as before.
+ */
+export interface RunContext {
+  /** The REAL wall-clock at dispatch (ISO 8601) — the authoritative clock the turn lacks. */
+  now: string;
+  /**
+   * Whether this turn CONTINUES a prior conversation (`resumed`, single-threaded turn 2+) or
+   * STARTS a fresh one (`new`, the first turn / every multi-threaded fire) — the cheap "which
+   * run is this" signal the daemon already resolved (`TurnSession.resume`).
+   */
+  session: "new" | "resumed";
+  /**
+   * WHY this turn is running (provenance): a SCHEDULED job fire stamps `runner:<jobId>` (the
+   * runner's sender provenance) → reported as the job id; anything else is an interactive /
+   * delegated message → `interactive`. Lets a scheduled agent know it's a cron fire vs a live
+   * reply. Absent when the inbound carried no sender.
+   */
+  firedBy?: string;
+  /**
+   * The thread's COMPLETED turn count BEFORE this turn (single-threaded's rolling counter;
+   * 0 on the first turn). Best-effort — omitted when the daemon can't cheaply resolve it
+   * (no durable thread store). So the agent can stamp "turn N" accurately.
+   */
+  priorTurnCount?: number;
+}
+
 /**
  * An opaque handle to a started agent, returned by {@link AgentBackend.start} and
  * passed back to `deliver`/`stop`/`status`. The only field the seam itself depends
@@ -201,6 +238,12 @@ export interface AgentBackend {
    * a safe basename) before the turn and appends a workspace-relative pointer to the
    * prompt, so the `claude -p` turn can `Read` them. ADDITIVE — absent/empty → no
    * staging, the turn behaves exactly as before.
+   *
+   * `runContext` (optional, agent#162) is the runtime context the daemon knows but a headless
+   * `-p` turn can't (the real wall-clock, whether this run is new vs resumed, why it fired).
+   * The programmatic backend prepends it as a concise, clearly-labeled preamble to the turn
+   * message so the agent stamps ACCURATE times instead of fabricating them. ADDITIVE — omitted
+   * → the turn message is exactly as before.
    */
   deliver(
     handle: AgentHandle,
@@ -208,6 +251,7 @@ export interface AgentBackend {
     session: TurnSession,
     onInterim?: InterimSink,
     attachments?: InboundAttachment[],
+    runContext?: RunContext,
   ): Promise<DeliverResult>;
 
   /**