@basein/runner 0.3.11 → 0.3.13

package/dist/record/prompt-text.js

@@ -0,0 +1,65 @@
+/**
+ * prompt-text — the user's words in a Claude Code prompt (fx121.md).
+ *
+ * Claude Code puts blocks of its own in front of what the user typed: the Claude
+ * in Chrome guide, the file open in the IDE, the selection, a background task's
+ * notification. The hook's `prompt` carries them all, and the service embeds the
+ * prompt with a model that reads 512 tokens. The Chrome guide alone is 1,008: in
+ * a session with Claude in Chrome connected, every prompt was embedded as the
+ * guide, and every one matched the same recording at 1.000.
+ *
+ * The prompt-side twin of `housekeeping.ts`. That file covers host tools that
+ * are not work; this one covers host text that is not the user's. Like it, it is
+ * deliberately narrow: a closed list of blocks, complete ones only, from the
+ * front only. When in doubt, the text is the user's.
+ */
+/** Blocks Claude Code adds in front of the user's text (fx121 R2). Closed list. */
+export const HOST_BLOCKS = [
+    "browser_instruction", // Claude in Chrome: the tool guide, or "[Browser disconnected …]"
+    "ide_opened_file", // the IDE: the file that happens to be open
+    "ide_selection", // the IDE: the selected lines and their text
+    "system-reminder", // Claude Code's general wrapper for injected text
+    "task-notification", // a background task finished: a turn with no user text
+];
+/** An opening tag, after any whitespace, starting exactly at `lastIndex`. */
+const OPENING_TAG = /\s*<([a-z][\w-]*)(?:\s[^<>]*)?>/y;
+/** Claude Code's wrapper around text the user pasted, opening and closing. */
+const PASTED_TAGS = /<\/?pasted_content(?:\s[^<>]*)?>/g;
+/** The prompt exactly as the hook gave it: another host's text (fx121 R1), or one with nothing to clean. */
+export function asSent(raw) {
+    return { text: raw, stripped: [], eventOnly: false, rawChars: raw.length };
+}
+/** The user's words in a Claude Code prompt, and what was taken off the front of them. */
+export function userText(raw) {
+    const stripped = [];
+    let at = 0;
+    // fx121 R2, R3: complete host blocks, from the front only. A block ends at its
+    // first closing tag; one with no closing tag stays, and so does all after it.
+    for (;;) {
+        OPENING_TAG.lastIndex = at;
+        const open = OPENING_TAG.exec(raw);
+        if (!open || !HOST_BLOCKS.includes(open[1]))
+            break;
+        const closing = `</${open[1]}>`;
+        const end = raw.indexOf(closing, OPENING_TAG.lastIndex);
+        if (end < 0)
+            break;
+        stripped.push(open[1]);
+        at = end + closing.length;
+    }
+    const rest = raw.slice(at);
+    // fx121 R4: after R2, never before. A paste that starts with a copy of the
+    // Chrome guide would otherwise become a leading block, and R2 would remove it.
+    const unwrapped = rest.replace(PASTED_TAGS, "");
+    // fx121 R3: nothing to remove or unwrap, so the prompt goes as it came.
+    if (stripped.length === 0 && unwrapped === rest)
+        return asSent(raw);
+    const text = unwrapped.trim();
+    return {
+        text,
+        stripped,
+        eventOnly: text === "" && stripped.includes("task-notification"), // fx121 R7
+        rawChars: raw.length,
+    };
+}
+//# sourceMappingURL=prompt-text.js.map

package/dist/record/recorder.d.ts

@@ -180,6 +180,16 @@ export interface RunMatch {
 /** Optional capability: `null` means "fresh run, keep recording". */
 export interface MatchAware {
     getMatch(runId: string): Promise<RunMatch | null>;
+    /**
+     * The create call's own answer, whenever it lands. `getMatch` is what a hook
+     * may wait for, and a recorder may answer it null without waiting — while
+     * the service has a failure on record, or once the create's first attempt
+     * failed. The service can still match the prompt then, hand out the scenario
+     * and issue a ticket the turn owes a report; this is how the turn finds out.
+     * Never for a hook to wait on. Absent where `getMatch` always waits for the
+     * create's answer: it is the same answer then.
+     */
+    settledMatch?(runId: string): Promise<RunMatch | null>;
 }
 export declare function isMatchAware(r: Recorder): r is Recorder & MatchAware;
 /**
@@ -201,6 +211,21 @@ export interface RunCreationAware {
     runCreated(runId: string): Promise<RunCreation>;
 }
 export declare function isRunCreationAware(r: Recorder): r is Recorder & RunCreationAware;
+/**
+ * Optional capability: a prompt is on its way, so the service verdict it will
+ * be decided by should be current.
+ *
+ * A hook never waits on a service with a failure on record, and is never the
+ * request that finds out whether it answers again. After hours with nothing
+ * sent — a laptop asleep, a network that dropped — the failure is still on
+ * record at the next prompt, whose match is then not waited for however fast
+ * the service answers. Called when a session starts, before its first prompt:
+ * it checks in the background, and sends nothing while no failure is on record.
+ */
+export interface ServiceProber {
+    probeIfFailing(): void;
+}
+export declare function isServiceProber(r: Recorder): r is Recorder & ServiceProber;
 /** What a ReAct iteration sends to find a scenario by its intent (fallbk.md §Runner 4). */
 export interface IntentMatchRequest {
     /**

package/dist/record/recorder.js

@@ -14,6 +14,9 @@ export function isMatchAware(r) {
 export function isRunCreationAware(r) {
     return typeof r.runCreated === "function";
 }
+export function isServiceProber(r) {
+    return typeof r.probeIfFailing === "function";
+}
 export function isIntentMatcher(r) {
     return typeof r.matchIntent === "function";
 }

package/dist/record/remote-recorder.d.ts

@@ -43,8 +43,10 @@
  * SIMILAR-PROMPT HITS. `POST /recordings/runs` may answer `{ id: null, matched }`,
  * meaning the server recognised the prompt and did **not** create a run. Every
  * later step post for that id would then 404, so callers must stop recording —
- * {@link RemoteRecorder.getMatch} is how they find out — and this recorder skips
- * them itself too, for the caller that stopped waiting before the answer came.
+ * {@link RemoteRecorder.settledMatch} is how they find out, whenever the answer
+ * lands ({@link RemoteRecorder.getMatch} is only what a hook may wait for) — and
+ * this recorder skips them itself too, for the caller that stopped waiting
+ * before the answer came.
  */
 import { type AuthSession } from "../auth/client.js";
 import { type ServiceHealth } from "../util/service-health.js";
@@ -187,11 +189,34 @@ export declare class RemoteRecorder implements Recorder, RecorderHealthReporter
     matchIntent(req: IntentMatchRequest, opts?: IntentMatchOptions): Promise<IntentMatchAnswer | null>;
     /**
      * The similar-prompt match for a run's create call (null = fresh run). Like
-     * {@link runCreated}, answers null at once while the service is cooling down,
-     * and as soon as the create's first attempt fails — the first prompt of an
-     * outage is not held for the retry's sleep (up to 2 s behind a Retry-After).
+     * {@link runCreated}, answers null at once while a failure is on record —
+     * in a cool-down, and after it until an answer clears it, however long ago
+     * it was — and as soon as the create's first attempt fails: the first prompt
+     * of an outage is not held for the retry's sleep (up to 2 s behind a
+     * Retry-After). The create goes on, and its own answer is
+     * {@link settledMatch}'s.
      */
     getMatch(runId: string): Promise<RunMatch | null>;
+    /**
+     * The create's own match (null = fresh run), whenever it lands — after the
+     * cool-down and the retry, if it took them — however {@link getMatch}
+     * answered the hook. A hook told "no match" at once, because a failure was
+     * on record or the first attempt failed, may be about a prompt the service
+     * matched all the same: it then handed out the scenario and issued a ticket,
+     * and the turn owes that ticket a report. Never for a hook to wait on. Null
+     * for an id this recorder never opened.
+     */
+    settledMatch(runId: string): Promise<RunMatch | null>;
+    /**
+     * A prompt is on its way (a session just started). While a failure is on
+     * record no hook waits on the service, and none is the request that finds
+     * out whether it answers again ({@link mayHotWait}). After hours with
+     * nothing sent, the failure is still on record at the first prompt, and its
+     * match is not waited for however fast the service answers — so find out
+     * now: one background `GET /health`, once the cool-down is over. Nothing
+     * while no failure is on record, during a cool-down, or with a probe out.
+     */
+    probeIfFailing(): void;
     recordToolSelected(runId: string, stepIndex: number, data: {
         toolName: string;
         toolInput: string;

package/dist/record/remote-recorder.js

@@ -43,8 +43,10 @@
  * SIMILAR-PROMPT HITS. `POST /recordings/runs` may answer `{ id: null, matched }`,
  * meaning the server recognised the prompt and did **not** create a run. Every
  * later step post for that id would then 404, so callers must stop recording —
- * {@link RemoteRecorder.getMatch} is how they find out — and this recorder skips
- * them itself too, for the caller that stopped waiting before the answer came.
+ * {@link RemoteRecorder.settledMatch} is how they find out, whenever the answer
+ * lands ({@link RemoteRecorder.getMatch} is only what a hook may wait for) — and
+ * this recorder skips them itself too, for the caller that stopped waiting
+ * before the answer came.
  */
 import { randomUUID } from "node:crypto";
 import { statSync } from "node:fs";
@@ -479,7 +481,8 @@ export class RemoteRecorder {
                     }), 
                     // The id is client-generated, so the service can tell a repeat. A
                     // hook waiting on this answer is let go before the retry: a match
-                    // found by the retry is not the turn's any more.
+                    // found by the retry can no longer steer the turn, and only its
+                    // ticket's report is left to it (`settledMatch`).
                     { retryTransient: true, onRetry: () => entry.release() });
                     const b = body && typeof body === "object"
                         ? body
@@ -579,9 +582,12 @@ export class RemoteRecorder {
     }
     /**
      * The similar-prompt match for a run's create call (null = fresh run). Like
-     * {@link runCreated}, answers null at once while the service is cooling down,
-     * and as soon as the create's first attempt fails — the first prompt of an
-     * outage is not held for the retry's sleep (up to 2 s behind a Retry-After).
+     * {@link runCreated}, answers null at once while a failure is on record —
+     * in a cool-down, and after it until an answer clears it, however long ago
+     * it was — and as soon as the create's first attempt fails: the first prompt
+     * of an outage is not held for the retry's sleep (up to 2 s behind a
+     * Retry-After). The create goes on, and its own answer is
+     * {@link settledMatch}'s.
      */
     async getMatch(runId) {
         const entry = this.runs.get(runId);
@@ -595,6 +601,39 @@ export class RemoteRecorder {
         await entry.hot;
         return entry.settled?.match ?? null;
     }
+    /**
+     * The create's own match (null = fresh run), whenever it lands — after the
+     * cool-down and the retry, if it took them — however {@link getMatch}
+     * answered the hook. A hook told "no match" at once, because a failure was
+     * on record or the first attempt failed, may be about a prompt the service
+     * matched all the same: it then handed out the scenario and issued a ticket,
+     * and the turn owes that ticket a report. Never for a hook to wait on. Null
+     * for an id this recorder never opened.
+     */
+    async settledMatch(runId) {
+        const entry = this.runs.get(runId);
+        if (!entry)
+            return null;
+        entry.lastUsed = Date.now();
+        if (entry.settled)
+            return entry.settled.match;
+        return (await entry.answer) ?? null;
+    }
+    /**
+     * A prompt is on its way (a session just started). While a failure is on
+     * record no hook waits on the service, and none is the request that finds
+     * out whether it answers again ({@link mayHotWait}). After hours with
+     * nothing sent, the failure is still on record at the first prompt, and its
+     * match is not waited for however fast the service answers — so find out
+     * now: one background `GET /health`, once the cool-down is over. Nothing
+     * while no failure is on record, during a cool-down, or with a probe out.
+     */
+    probeIfFailing() {
+        this.checkCredentials();
+        if (this.state !== "recording" || this.healthyNow())
+            return;
+        this.probeSoon();
+    }
     recordToolSelected(runId, stepIndex, data) {
         const id = "step_" + randomUUID();
         const toolInput = pend(data.toolInput, DEFAULT_MAX_PAYLOAD_BYTES, true);
@@ -796,6 +835,7 @@ export class RemoteRecorder {
     newEntry() {
         let resolveHot;
         let resolveCreated;
+        let resolveAnswer;
         const entry = {
             userId: this.session.user.id,
             hot: new Promise((r) => {
@@ -804,6 +844,9 @@ export class RemoteRecorder {
             created: new Promise((r) => {
                 resolveCreated = r;
             }),
+            answer: new Promise((r) => {
+                resolveAnswer = r;
+            }),
             settle: (match, created) => {
                 if (entry.settled)
                     return;
@@ -811,9 +854,11 @@ export class RemoteRecorder {
                 entry.settledAt = Date.now();
                 resolveHot();
                 resolveCreated(created);
+                resolveAnswer(match);
                 // Callers that are waiting hold the promises themselves.
                 entry.hot = undefined;
                 entry.created = undefined;
+                entry.answer = undefined;
             },
             release: () => {
                 if (entry.settled || entry.released)

package/dist/record/switchable-recorder.js

@@ -46,10 +46,12 @@ import { NullRecorder, } from "./recorder.js";
  */
 const NEUTRAL = {
     getMatch: () => Promise.resolve(null),
+    settledMatch: () => Promise.resolve(null),
     runCreated: () => Promise.resolve({ created: true }),
     matchIntent: () => Promise.resolve(null),
     reportExecution: () => undefined,
     backfillContext: () => undefined,
+    probeIfFailing: () => undefined,
 };
 /**
  * `RemoteRecorder`'s private helpers. They are methods at runtime (TypeScript's

package/dist/replay/controller.d.ts

@@ -514,7 +514,13 @@ export type DeclineCode = "replay_disabled" | "not_ready" | "flatten_failed" | "
  * (`arm_unannounced`). Set by the control server, where a prompt's wait
  * ends, so the report can say why a matched turn was not steered.
  */
- | "arm_timeout" | "arm_unannounced";
+ | "arm_timeout" | "arm_unannounced"
+/**
+ * Nothing was armed at all: the service's answer to the match landed after
+ * the prompt had been answered, or while prompts were not waiting on it
+ * (the match gate). Set by the control server, like the two above.
+ */
+ | "match_late";
 /** What `PreToolUse` should do about this call. */
 export type PreToolAction = 
 /** Pin the arguments and let the real tool run. */
@@ -587,6 +593,17 @@ export declare class ReplayController {
      * covers both "no match" and "too slow", which are the same thing from here.
      */
     awaitMatch(pending: Promise<unknown>): Promise<RunMatchLike | null>;
+    /** A matched state before any gate has judged it: nothing planned, nothing run. */
+    private blankState;
+    /**
+     * The state of a prompt match that landed too late to be used
+     * (`match_late`). No gate is run and nothing is derived — a plan could no
+     * longer be announced, and a reading nobody waits for is money spent on
+     * nothing. It exists for the one thing the hand-out still owes: its ticket's
+     * report, with the reason, so the service does not show a turn the agent did
+     * itself as one that never reported.
+     */
+    lateMatch(match: RunMatchLike, host?: HostContext): ReplayState;
     /**
      * Run the gate ladder and, if every gate passes, arm a plan.
      *

package/dist/replay/controller.js

@@ -305,18 +305,9 @@ export class ReplayController {
                 clearTimeout(timer);
         }
     }
-    /**
-     * Run the gate ladder and, if every gate passes, arm a plan.
-     *
-     * Always returns a state — a declined match still has a ticket to redeem and a
-     * baseline sample to contribute, and losing that is how a savings ledger ends
-     * up with a denominator nobody measured.
-     *
-     * `host` is given for a session whose host is not Claude Code, and is kept
-     * on the state (see {@link HostContext}).
-     */
-    async arm(match, prompt, wrapped, armedBy = "prompt", ctx = {}, host) {
-        const state = {
+    /** A matched state before any gate has judged it: nothing planned, nothing run. */
+    blankState(match, wrapped, armedBy, host) {
+        return {
             scenarioId: match.scenarioId,
             ticket: match.executionTicket,
             similarity: match.similarity,
@@ -345,6 +336,33 @@ export class ReplayController {
             verified: match.verified,
             sharedWith: [],
         };
+    }
+    /**
+     * The state of a prompt match that landed too late to be used
+     * (`match_late`). No gate is run and nothing is derived — a plan could no
+     * longer be announced, and a reading nobody waits for is money spent on
+     * nothing. It exists for the one thing the hand-out still owes: its ticket's
+     * report, with the reason, so the service does not show a turn the agent did
+     * itself as one that never reported.
+     */
+    lateMatch(match, host) {
+        const state = this.blankState(match, new Set(), "prompt", host);
+        state.declined = "match_late";
+        state.retired = true;
+        return state;
+    }
+    /**
+     * Run the gate ladder and, if every gate passes, arm a plan.
+     *
+     * Always returns a state — a declined match still has a ticket to redeem and a
+     * baseline sample to contribute, and losing that is how a savings ledger ends
+     * up with a denominator nobody measured.
+     *
+     * `host` is given for a session whose host is not Claude Code, and is kept
+     * on the state (see {@link HostContext}).
+     */
+    async arm(match, prompt, wrapped, armedBy = "prompt", ctx = {}, host) {
+        const state = this.blankState(match, wrapped, armedBy, host);
         const isSegment = state.kind === "segment";
         const decline = (why, code) => {
             state.declined = code;

package/dist/replay/derive.d.ts

@@ -60,6 +60,8 @@ export interface DeriveOptions extends DeriveContext {
     prompt: string;
     intent: string;
     paramsObject: ParamsSchema | null;
+    /** The day on this machine. Injected by tests; defaults to {@link localDay}. */
+    today?: string;
     /** An override that keeps the reading on this machine. Absent → the service. */
     apiKey?: string;
     /** Used when there is no `apiKey`. Absent too → recorded samples. */
@@ -90,6 +92,16 @@ export interface DeriveResult {
     /** Settings filled from their recorded sample (R-PARAM-2). */
     sampled: string[];
 }
+/**
+ * The day on this machine, `YYYY-MM-DD`, in its own time zone.
+ *
+ * Sent to the service with every reading, because a prompt says "tomorrow" and
+ * the date is in no prompt: the service works such a value out, and it must
+ * count from the user's day. Its own day is the wrong one — a server on UTC is
+ * a day ahead of a user in Seattle for a third of the working day. Local on
+ * purpose, then, and never `toISOString`, which is UTC.
+ */
+export declare function localDay(now?: Date): string;
 /**
  * First balanced `{…}` in a text blob. Models wrap JSON in prose and fences more
  * often than they emit it bare, and a failed parse here costs a whole replay.

package/dist/replay/derive.js

@@ -75,6 +75,19 @@ function serviceOk(startedAt) {
     const ok = serviceHealth.ok.bind(serviceHealth);
     ok(startedAt);
 }
+/**
+ * The day on this machine, `YYYY-MM-DD`, in its own time zone.
+ *
+ * Sent to the service with every reading, because a prompt says "tomorrow" and
+ * the date is in no prompt: the service works such a value out, and it must
+ * count from the user's day. Its own day is the wrong one — a server on UTC is
+ * a day ahead of a user in Seattle for a third of the working day. Local on
+ * purpose, then, and never `toISOString`, which is UTC.
+ */
+export function localDay(now = new Date()) {
+    const two = (n) => String(n).padStart(2, "0");
+    return `${now.getFullYear()}-${two(now.getMonth() + 1)}-${two(now.getDate())}`;
+}
 /** Every parameter at its recorded sample value. The zero-cost fallback. */
 function sampleValues(schema) {
     const out = {};
@@ -251,6 +264,15 @@ export async function deriveParameters(opts) {
     const missing = [];
     const sampled = [];
     for (const key of keys) {
+        // A value worked out from the day ("tomorrow") cannot be read here: this
+        // copy of the text does not tell the model the day, and what comes back
+        // for such a value is then the recorded date or a guess. The service's
+        // reading does work it out; with a key of its own the value is missing.
+        if (isTarget(schema, key) && schema[key].from === "today") {
+            parsed[key] = null;
+            missing.push(key);
+            continue;
+        }
         if (parsed[key] !== null && parsed[key] !== undefined)
             continue;
         if (isTarget(schema, key)) {
@@ -318,6 +340,9 @@ async function deriveViaService(opts, service, schema, keys) {
                 prompt: outgoingPrompt(opts.prompt),
                 liveCall: context.liveCall,
                 recentResults: context.recentResults,
+                // What "tomorrow" is counted from. A service that does not know the
+                // field ignores it.
+                today: opts.today ?? localDay(),
             }),
             signal: opts.signal ?? timeoutSignal(),
         });

package/dist/replay/executor.d.ts

@@ -29,14 +29,16 @@
  * every proxy polls under its own id, and a step goes to, in order:
  *
  *   1. a proxy bound to the step's session — learned from a correlated step the
- *      proxy reported, or from an earlier step of this session it ran;
+ *      proxy reported, from an earlier step of this session it ran, or, when a
+ *      direct plan starts, from the host process it shares with the
+ *      `bir-scenario` that asked for the plan ({@link ProxyWorkQueue.bindSiblings});
  *   2. otherwise an unbound proxy, but ONLY while no other session is live
  *      (none bound elsewhere, and no server with two proxies polling — each
  *      session starts its own). A lone session's unbound proxy can only be
- *      its own. With two sessions open, the one that has not called the server
- *      yet cannot be told apart from the other: "the newest" was a guess, and
- *      when the older session asked it ran the step on the newer one's
- *      upstream — another browser page, another database session — and
+ *      its own. With two sessions open, a proxy nothing has tied to a session
+ *      cannot be told apart from the other session's: "the newest" was a
+ *      guess, and when the older session asked it ran the step on the newer
+ *      one's upstream — another browser page, another database session — and
  *      answered wrongly;
  *   3. otherwise NOBODY. A proxy bound, or possibly belonging, to another
  *      session is never used for this one: the call rejects with a
@@ -76,6 +78,12 @@ export interface PollerIdentity {
     /** When the proxy process started, epoch ms — "newest" is judged by this. */
     startedAt?: number;
     pid?: number;
+    /**
+     * The process that started the proxy: its session's host. `bir-scenario`
+     * sends its own with `/scenario/run`, so a session's proxies can be told
+     * apart before they have called anything ({@link ProxyWorkQueue.bindSiblings}).
+     */
+    ppid?: number;
 }
 /** Rejection reason when no proxy is polling for a server. */
 export declare const NO_PROXY = "no_proxy";
@@ -113,6 +121,19 @@ export declare class ProxyWorkQueue {
      * `/clear` starts a new session on the same proxies.
      */
     bindProxy(proxyId: string, sessionId: string): void;
+    /**
+     * Bind to `sessionId` every live proxy started by host process `hostPid` —
+     * the process that also started the `bir-scenario` asking for this
+     * session's plan. Claude Code starts a session's MCP servers as its own
+     * children, so a shared parent ties a proxy to the session before it has
+     * called anything. Without it a direct plan's first step was refused
+     * whenever another session held a proxy for the same server: `run_scenario`
+     * is the session's first call, so no correlated call could have bound one.
+     *
+     * A proxy proven to belong to another session (a correlated call) is left
+     * alone. A legacy one, which sends no id, stays a pool.
+     */
+    bindSiblings(hostPid: number, sessionId: string): void;
     /**
      * `POST /proxy/poll`. Resolves with work, or with `undefined` at the poll
      * deadline so the proxy re-polls. Work held for this proxy while it was

package/dist/replay/executor.js

@@ -29,14 +29,16 @@
  * every proxy polls under its own id, and a step goes to, in order:
  *
  *   1. a proxy bound to the step's session — learned from a correlated step the
- *      proxy reported, or from an earlier step of this session it ran;
+ *      proxy reported, from an earlier step of this session it ran, or, when a
+ *      direct plan starts, from the host process it shares with the
+ *      `bir-scenario` that asked for the plan ({@link ProxyWorkQueue.bindSiblings});
  *   2. otherwise an unbound proxy, but ONLY while no other session is live
  *      (none bound elsewhere, and no server with two proxies polling — each
  *      session starts its own). A lone session's unbound proxy can only be
- *      its own. With two sessions open, the one that has not called the server
- *      yet cannot be told apart from the other: "the newest" was a guess, and
- *      when the older session asked it ran the step on the newer one's
- *      upstream — another browser page, another database session — and
+ *      its own. With two sessions open, a proxy nothing has tied to a session
+ *      cannot be told apart from the other session's: "the newest" was a
+ *      guess, and when the older session asked it ran the step on the newer
+ *      one's upstream — another browser page, another database session — and
  *      answered wrongly;
  *   3. otherwise NOBODY. A proxy bound, or possibly belonging, to another
  *      session is never used for this one: the call rejects with a
@@ -139,6 +141,38 @@ export class ProxyWorkQueue {
             by: "correlated",
         });
     }
+    /**
+     * Bind to `sessionId` every live proxy started by host process `hostPid` —
+     * the process that also started the `bir-scenario` asking for this
+     * session's plan. Claude Code starts a session's MCP servers as its own
+     * children, so a shared parent ties a proxy to the session before it has
+     * called anything. Without it a direct plan's first step was refused
+     * whenever another session held a proxy for the same server: `run_scenario`
+     * is the session's first call, so no correlated call could have bound one.
+     *
+     * A proxy proven to belong to another session (a correlated call) is left
+     * alone. A legacy one, which sends no id, stays a pool.
+     */
+    bindSiblings(hostPid, sessionId) {
+        for (const info of this.proxies.values()) {
+            if (info.ppid !== hostPid || !this.isLive(info) || isLegacy(info.proxyId))
+                continue;
+            if (info.sessionId === sessionId)
+                continue;
+            if (info.sessionId && info.boundBy === "correlated")
+                continue;
+            info.sessionId = sessionId;
+            info.boundBy = "sibling";
+            logDetail("replay.proxy_bound", {
+                server: info.serverName,
+                proxy: shortId(info.proxyId),
+                pid: info.pid,
+                sess: sessionId,
+                by: "sibling",
+                host: hostPid,
+            });
+        }
+    }
     /**
      * `POST /proxy/poll`. Resolves with work, or with `undefined` at the poll
      * deadline so the proxy re-polls. Work held for this proxy while it was
@@ -325,6 +359,7 @@ export class ProxyWorkQueue {
             serverName,
             startedAt: Number.isFinite(started) && started > 0 ? started : now,
             pid: who.pid,
+            ppid: who.ppid,
             lastSeen: now,
         });
     }

package/dist/replay/types.d.ts

@@ -138,6 +138,13 @@ export type ParamsSchema = Record<string, {
     sampleValue: unknown;
     description: string;
     kind?: ParameterKind;
+    /**
+     * Where the recorded value came from, when the service calculated the plan
+     * beside its request. Only `today` is read here: a value worked out from
+     * the day the request is made on ("tomorrow"), which the service works out
+     * again from the day this runner sends (replay/derive.ts, `localDay`).
+     */
+    from?: string;
 }>;
 /** Whether this schema has anything the runner may not guess (R-PARAM-4). */
 export declare function hasTargets(schema: ParamsSchema | null | undefined): boolean;