@basein/runner 0.3.11 → 0.3.13

package/dist/bin/bir-scenario.d.ts

@@ -24,7 +24,14 @@
  * MCP call's `params._meta["claudecode/toolUseId"]` — the same id that hook
  * carried as `tool_use_id` — so the request forwards it as `toolUseId` and the
  * control server matches it exactly instead of inferring the session. A host
- * that names nothing sends an empty body, as before.
+ * that names nothing sends no `toolUseId`, as before.
+ *
+ * WHOSE PROXIES. The request also carries `ppid`, the process that started
+ * this server. Claude Code starts all of a session's MCP servers, so that is
+ * the parent of the session's proxies too, and the control server binds them
+ * to the session before the plan's first step (replay/executor.ts,
+ * `bindSiblings`): that step is the session's first call to their server, so
+ * nothing else could yet say which proxies are its own.
  *
  * IT RUNS IN EVERY SESSION, SO IT MUST NEVER BE WHY ONE GOES WRONG. Startup and
  * `tools/list` are answered from local files alone (the hello to the recorder

package/dist/bin/bir-scenario.js

@@ -24,7 +24,14 @@
  * MCP call's `params._meta["claudecode/toolUseId"]` — the same id that hook
  * carried as `tool_use_id` — so the request forwards it as `toolUseId` and the
  * control server matches it exactly instead of inferring the session. A host
- * that names nothing sends an empty body, as before.
+ * that names nothing sends no `toolUseId`, as before.
+ *
+ * WHOSE PROXIES. The request also carries `ppid`, the process that started
+ * this server. Claude Code starts all of a session's MCP servers, so that is
+ * the parent of the session's proxies too, and the control server binds them
+ * to the session before the plan's first step (replay/executor.ts,
+ * `bindSiblings`): that step is the session's first call to their server, so
+ * nothing else could yet say which proxies are its own.
  *
  * IT RUNS IN EVERY SESSION, SO IT MUST NEVER BE WHY ONE GOES WRONG. Startup and
  * `tools/list` are answered from local files alone (the hello to the recorder
@@ -206,7 +213,8 @@ async function runArmedPlan(cwd, flight, toolUseId) {
                 "content-type": "application/json",
                 authorization: `Bearer ${found.token}`,
             },
-            body: JSON.stringify(toolUseId ? { toolUseId } : {}),
+            // `ppid`: the host that started this server and the session's proxies (WHOSE PROXIES above).
+            body: JSON.stringify(toolUseId ? { toolUseId, ppid: process.ppid } : { ppid: process.ppid }),
             signal: controller.signal,
         });
         const raw = await res.text();

package/dist/bin/bir.js

@@ -68,6 +68,7 @@ import { SCENARIO_EDIT_SUBCOMMANDS, scenarioEditCommand } from "./scenario-edit.
 import { loadCredentials } from "../auth/client.js";
 import { packageVersion } from "../util/version.js";
 import { runnerOutdated, serviceHeaders } from "../util/service-headers.js";
+import { localDay } from "../replay/derive.js";
 const VERSION = packageVersion();
 /**
  * The npx SessionStart hook's own budget, passed as `ensure --budget-ms <n>`
@@ -3630,6 +3631,9 @@ async function replayCommand(args) {
     if (args.dry) {
         const { status, body } = await service("POST", `/scenarios/${scenarioId}/replay`, {
             prompt: args.prompt,
+            // The day on this machine, as a session's reading sends it: a dry
+            // replay works a value like "tomorrow" out from the same day.
+            today: localDay(),
         });
         if (status !== 200) {
             out(`Dry replay failed (HTTP ${status}): ${JSON.stringify(body)}`);

package/dist/bin/investigate.d.ts

@@ -29,6 +29,16 @@ export interface Turn {
     startedAt: string;
     finishedAt?: string;
     prompt?: string;
+    /**
+     * Claude Code's own blocks the runner took off the front of the prompt, in
+     * order (fx121.md): `run.prompt_stripped`. Absent when there were none.
+     */
+    stripped?: string[];
+    /** The turn was a task notification, with no words of the user's: never matched. */
+    eventOnly?: boolean;
+    /** The prompt's length as the hook gave it, and as the service got it. */
+    rawChars?: number;
+    promptChars?: number;
     matched?: {
         runId: string;
         scenarioId?: string;

package/dist/bin/investigate.js

@@ -99,6 +99,12 @@ export function turnsFromJournal(entries) {
             case "run.prompt":
                 turn.prompt = str(e.prompt);
                 break;
+            case "run.prompt_stripped":
+                turn.stripped = list(e.stripped);
+                turn.eventOnly = bool(e.eventOnly);
+                turn.rawChars = num(e.rawChars);
+                turn.promptChars = num(e.chars);
+                break;
             case "run.matched":
                 turn.matched = { runId: str(e.matchedRun) ?? "", scenarioId: str(e.scenario), similarity: num(e.similarity) };
                 break;
@@ -217,6 +223,11 @@ export const DECLINES = {
         cause: "the plan was not ready before the hook that would have announced it had to answer: the prompt hook waits 7.5 s in all, match included, and a tool call that starts a plan mid-task waits 1.5 s. What arming waits for is the reading of the prompt's values (the derivation). A plan that was not announced is never run.",
         fix: "run the prompt again. If it keeps happening the reading is slow: the recorder's log (`bir status` names the file) shows when its `replay.derived` line landed, and a dry replay shows what the service's reading took, under `reading` (`bir scenario replay <scnId> --prompt \"…\" --dry --json`). BIR_HOOK_DERIVE_BUDGET_MS does not help here, because the hook's own limit was reached first. To read values on this machine instead of asking the service, set BIR_DERIVE_API_KEY where Claude Code starts.",
     },
+    // Nor is this one: the match itself was late, so nothing was armed at all.
+    match_late: {
+        cause: "the service's answer to the match landed too late: after the prompt hook had stopped waiting for it (3 s, BIR_MATCH_BUDGET_MS); while prompts were not waiting on the match at all — after one slow answer they stop waiting for a few minutes (`replay.match_gate state=holding`); or with the hook not waiting from the start, because a failure to reach the service was still on record (a `service.degraded` line, perhaps hours before, and no `service.recovered` until after this prompt) or the match request's first attempt failed. The agent did the task itself.",
+        fix: "nothing in the prompt has to change: run it again a few minutes later. A `service.recovered` line just after this turn's `run.start` means an old failure was still on record, and the next prompt waits again. If it keeps happening without one, the service answers matches slowly: `bir doctor` shows its state, and `/health.matchGate` when prompts wait again.",
+    },
     runner_update_required: {
         cause: "the service matched the prompt and handed over no plan: this runner is older than its plans need.",
         fix: "update the runner (`bir update`), then run `bir setup` in each project that uses it; `bir doctor` says when the service is satisfied.",
@@ -308,13 +319,17 @@ const pct = (v) => `${(v * 100).toFixed(1)}%`;
 export function localFindings(turn) {
     const out = [];
     if (!turn.matched) {
-        out.push({
-            code: "no_match",
-            severity: "info",
-            title: "This turn matched no recording, so the agent did the task itself.",
-            cause: "The service found no recording whose prompt is similar enough (its SIMILARITY_THRESHOLD). A run that is below the recording threshold is never embedded and can never be matched.",
-            fix: "If a recording of this task exists, run the prompt closer to its wording. The service section below says whether this turn became a recording.",
-        });
+        // A task notification is never matched (fx121 R7), so no prompt was
+        // compared and none can be reworded: "no match" would explain nothing.
+        if (!turn.eventOnly) {
+            out.push({
+                code: "no_match",
+                severity: "info",
+                title: "This turn matched no recording, so the agent did the task itself.",
+                cause: "The service found no recording whose prompt is similar enough (its SIMILARITY_THRESHOLD). A run that is below the recording threshold is never embedded and can never be matched.",
+                fix: "If a recording of this task exists, run the prompt closer to its wording. The service section below says whether this turn became a recording.",
+            });
+        }
     }
     else if (turn.decision?.verdict === "no-steer") {
         const code = turn.decision.code ?? "";
@@ -478,6 +493,8 @@ export function savedPct(turn) {
     return baseline > 0 ? r.savedUsd / baseline : null;
 }
 const short = (id) => (id ? id.slice(0, 13) : "—");
+/** 4624 → "4,624", whatever the machine's locale. */
+const count = (n) => String(n).replace(/\B(?=(\d{3})+(?!\d))/g, ",");
 const money = (v) => (v == null ? "—" : usd(v));
 const when = (iso) => (iso ? iso.replace("T", " ").replace(/\.\d+Z$/, "Z") : "—");
 function renderFindings(out, findings, heading) {
@@ -495,12 +512,21 @@ function renderFindings(out, findings, heading) {
 }
 export function renderTurn(out, turn) {
     out(`Turn ${turn.runId}  ${when(turn.startedAt)}${turn.sessionId ? `  session ${turn.sessionId.slice(0, 8)}` : ""}`);
-    if (turn.prompt)
+    if (turn.prompt) {
         out(`  prompt    ${turn.prompt.replace(/\s+/g, " ").slice(0, 110)}`);
+    }
+    else if (turn.eventOnly) {
+        // No `run.prompt` line: nothing of the user's was left to send (fx121 R7).
+        out("  prompt    (none: a task notification, never matched)");
+    }
+    if (turn.stripped?.length) {
+        const sizes = turn.rawChars != null ? `  (${count(turn.rawChars)} → ${count(turn.promptChars ?? 0)} chars)` : "";
+        out(`  stripped  ${turn.stripped.join(", ")}${sizes}`);
+    }
     if (turn.matched) {
         out(`  matched   ${turn.matched.runId}${turn.matched.similarity != null ? ` (similarity ${turn.matched.similarity.toFixed(3)})` : ""}${turn.matched.scenarioId ? ` → scenario ${turn.matched.scenarioId}` : " → no scenario"}`);
     }
-    else {
+    else if (!turn.eventOnly) {
         out("  matched   no recording — the agent ran the task; this turn was recorded");
     }
     if (turn.decision?.verdict === "no-steer") {
@@ -667,6 +693,8 @@ export async function investigateCommand(args, deps) {
             out(`  ${when(t.startedAt)}  ${t.runId}  ${verdict}${saved}`);
             if (t.prompt)
                 out(`      "${t.prompt.replace(/\s+/g, " ").slice(0, 90)}"`);
+            else if (t.eventOnly)
+                out("      (none: a task notification)");
         }
         out();
         out("Investigate one with `bir investigate <run_…>`; the newest with `bir investigate`.");

package/dist/control/client.d.ts

@@ -46,6 +46,12 @@ export interface ProxyIdentity {
     /** Process start, epoch ms. */
     startedAt: number;
     pid: number;
+    /**
+     * The process that started the proxy: its session's host. `bir-scenario`
+     * reports its own, so a session's proxies can be told apart before they
+     * have called anything (replay/executor.ts, `bindSiblings`).
+     */
+    ppid: number;
 }
 export declare class ControlClient {
     private readonly url;

package/dist/control/server.d.ts

@@ -567,6 +567,8 @@ export declare class ControlServer {
      *
      * `asked` is what the prompt that opens the run asked for, in a session of
      * another host: whether its adapter wants a plan (`HookPayload.replay`).
+     * `cleaned` is how `onPrompt` got `input` from the hook's prompt, the only
+     * caller that has one (fx121.md).
      */
     private ensureRun;
     private runMetadata;
@@ -582,6 +584,12 @@ export declare class ControlServer {
      * plan. Memoized, because `ensureRun` is reached from five different hooks and
      * arming twice would run the scenario twice.
      *
+     * Two answers are followed. `pending` is what the prompt hook may wait for,
+     * and the recorder answers it null at once while a failure is on record or
+     * once the create's first attempt failed. `settled` is the service's own
+     * answer, whenever it lands: the hit that stops the recording, and a ticket
+     * the turn owes a report even when nobody waited for it.
+     *
      * Resolves with the steering directive to inject, or undefined.
      */
     private watchForMatch;
@@ -593,6 +601,11 @@ export declare class ControlServer {
      * match. A match that misses its budget, or a plan still deriving when the
      * budget runs out, is never delivered: the turn runs as an ordinary one, and
      * one `replay.decision` line says why (docs/calculatedReplay.md §10).
+     *
+     * `pending` is what the prompt may wait for; `settled` is the service's own
+     * answer, whenever it lands (see {@link watchForMatch}). Every way of going
+     * ahead without a match follows `settled`, so a hand-out nobody waited for
+     * still has its ticket reported ({@link followLateMatch}).
      */
     private armFromMatch;
     /**
@@ -607,6 +620,25 @@ export declare class ControlServer {
      * not several, so the hold doubles at most once per hold (on its probe).
      */
     private noteMatchLatency;
+    /**
+     * The prompt went ahead without the match: when the service's own answer
+     * lands, a hit is a hand-out nobody used. It is said once, as `match_late`
+     * with `why`, and its ticket is carried to the turn's report
+     * ({@link noteLateMatch}). A miss says nothing: the service has no ticket out.
+     */
+    private followLateMatch;
+    /**
+     * A match that landed after its prompt had been answered, or while prompts
+     * were not waiting on it. Nothing is armed for it, and nothing derived. But
+     * the service issued a ticket with that hand-out, and without a report under
+     * it the console can only say the turn never reported — for a turn the agent
+     * simply did itself. So the turn carries the ticket to its report, as a
+     * decline with its own code, like a plan that was only late ({@link shelve}).
+     *
+     * Only a hand-out with a ticket: a match the service handed nothing for has
+     * its reason on the service already. And only while the turn is open.
+     */
+    private noteLateMatch;
     /**
      * {@link armFromMatch} with replay off: nothing can be announced, and no hook
      * waits for the answer (`onPrompt` has already returned). So there is no
@@ -614,7 +646,8 @@ export declare class ControlServer {
      * had, and must not mark the service slow (that would open the process-wide
      * cool-down, and `/health` would report a degradation the user never had).
      * A hit still books its decline — the ledger's baseline sample — whenever
-     * it lands, as long as the turn is still open to carry it.
+     * it lands, as long as the turn is still open to carry it. So `settled` is
+     * the service's own answer, not the one a hook may have been given at once.
      */
     private noteDisabledMatch;
     /**
@@ -1135,6 +1168,14 @@ export declare class ControlServer {
      * ONE RUN PER PLAN. A second call while the plan is executing would run
      * every step again beside the first — duplicated writes — and is told so.
      *
+     * WHOSE PROXIES. `run_scenario` is the session's first call, so no
+     * correlated call has bound its proxies yet, and with another session open
+     * an unbound proxy may be either's: the plan's first step was refused. But
+     * Claude Code starts all of a session's MCP servers as its own children, and
+     * `bir-scenario` sends its parent's pid (`ppid`), as every proxy does with its
+     * poll. The proxies with that parent are this session's, and are bound to it
+     * before the plan runs (replay/executor.ts, `bindSiblings`).
+     *
      * `signal` aborts when `bir-scenario`'s request goes away — the host
      * cancelled the call (Esc) or its own timeout fired — so no further step is
      * started for a caller that can no longer read the result.

package/dist/control/server.js

@@ -33,10 +33,11 @@ import { pidAlive } from "./discovery.js";
 import { pinCompatible } from "./pin-guard.js";
 import { contextForToolUse, intentForToolUse, markTranscriptUsage, recentToolResults, settledLastAssistantText, thinkingForToolUse, usageSince, } from "./transcript.js";
 import { isHousekeepingCall } from "../record/housekeeping.js";
+import { asSent, userText } from "../record/prompt-text.js";
 import { redact, redactText } from "../record/redact.js";
 import { DEFAULT_MAX_STRING_BYTES, serializeCapped, truncateString, truncateStrings, } from "../record/truncate.js";
 import { StepQueue } from "../record/queue.js";
-import { NullRecorder, isIntentMatcher, isMatchAware, isRecorderHealthReporter, isRunCreationAware, isScenarioReporter, } from "../record/recorder.js";
+import { NullRecorder, isIntentMatcher, isMatchAware, isRecorderHealthReporter, isRunCreationAware, isScenarioReporter, isServiceProber, } from "../record/recorder.js";
 import { ReplayController, POLL_HOLD_MS, } from "../replay/controller.js";
 import { calculateCostUsd, hasModelPricing } from "../replay/pricing.js";
 import { logDetail, logLine, logOnce, errText } from "../util/log.js";
@@ -1561,8 +1562,10 @@ export class ControlServer {
      *
      * `asked` is what the prompt that opens the run asked for, in a session of
      * another host: whether its adapter wants a plan (`HookPayload.replay`).
+     * `cleaned` is how `onPrompt` got `input` from the hook's prompt, the only
+     * caller that has one (fx121.md).
      */
-    ensureRun(session, input = "", asked = {}) {
+    ensureRun(session, input = "", asked = {}, cleaned) {
         if (session.run && !session.run.finished)
             return session.run;
         // The sealed run stays reachable for a moment: a report or a post that
@@ -1572,7 +1575,12 @@ export class ControlServer {
         // A run of another host says so in its `framework`: the service keeps a
         // plan inside the host, and the scope, that recorded it.
         const framework = frameworkOf(session);
-        const runId = this.recorder.startRun(input, this.runMetadata(session), framework ? { framework } : undefined);
+        // fx121 R8: blocks taken off the front of the prompt are said on the run
+        // itself, and in the journal below. A prompt that was only unwrapped is not.
+        const removed = cleaned && cleaned.stripped.length > 0
+            ? { stripped: cleaned.stripped, eventOnly: cleaned.eventOnly, rawChars: cleaned.rawChars }
+            : undefined;
+        const runId = this.recorder.startRun(input, removed ? { ...this.runMetadata(session), prompt: removed } : this.runMetadata(session), framework ? { framework } : undefined);
         const run = {
             runId,
             input,
@@ -1607,6 +1615,8 @@ export class ControlServer {
         // on stderr, and never more than a preview.
         if (input)
             journal("run.prompt", { run: runId, prompt: input.slice(0, 200) });
+        if (removed)
+            journal("run.prompt_stripped", { run: runId, ...removed, chars: input.length });
         // Started here so the round trip overlaps whatever the caller does next;
         // `onPrompt` awaits the same memoized promise under its own budget.
         void this.watchForMatch(session, run);
@@ -1640,6 +1650,12 @@ export class ControlServer {
      * plan. Memoized, because `ensureRun` is reached from five different hooks and
      * arming twice would run the scenario twice.
      *
+     * Two answers are followed. `pending` is what the prompt hook may wait for,
+     * and the recorder answers it null at once while a failure is on record or
+     * once the create's first attempt failed. `settled` is the service's own
+     * answer, whenever it lands: the hit that stops the recording, and a ticket
+     * the turn owes a report even when nobody waited for it.
+     *
      * Resolves with the steering directive to inject, or undefined.
      */
     watchForMatch(session, run, prompt = "") {
@@ -1650,7 +1666,10 @@ export class ControlServer {
         const runId = run.runId;
         const startedAt = Date.now();
         const pending = this.recorder.getMatch(runId).catch(() => null);
-        void pending.then((match) => {
+        const settled = this.recorder.settledMatch
+            ? this.recorder.settledMatch(runId).catch(() => null)
+            : pending;
+        void settled.then((match) => {
             if (!match || run.runId !== runId)
                 return;
             run.recording = false;
@@ -1662,7 +1681,7 @@ export class ControlServer {
                 why: "similar prompt — the service kept its own run; not recording this one",
             });
         });
-        run.matchWatch = this.armFromMatch(session, run, pending, prompt, startedAt).catch((err) => {
+        run.matchWatch = this.armFromMatch(session, run, pending, settled, prompt, startedAt).catch((err) => {
             // Replay is an optimisation; a broken one must never cost a turn.
             logLine("replay.arm_failed", { run: run.runId, error: errText(err) });
             return undefined;
@@ -1677,12 +1696,17 @@ export class ControlServer {
      * match. A match that misses its budget, or a plan still deriving when the
      * budget runs out, is never delivered: the turn runs as an ordinary one, and
      * one `replay.decision` line says why (docs/calculatedReplay.md §10).
+     *
+     * `pending` is what the prompt may wait for; `settled` is the service's own
+     * answer, whenever it lands (see {@link watchForMatch}). Every way of going
+     * ahead without a match follows `settled`, so a hand-out nobody waited for
+     * still has its ticket reported ({@link followLateMatch}).
      */
-    async armFromMatch(session, run, pending, prompt, startedAt) {
+    async armFromMatch(session, run, pending, settled, prompt, startedAt) {
         // Off for the recorder, or — in a session of another host — not asked
         // for by this run's adapter: either way nothing can be announced.
         if (!this.replay.enabled || this.recordsOnly(session, run)) {
-            return this.noteDisabledMatch(session, run, pending, prompt);
+            return this.noteDisabledMatch(session, run, settled, prompt);
         }
         const promptWaitMs = this.promptWaitMs();
         const matchBudget = Math.min(this.replay.budgets.matchMs, promptWaitMs);
@@ -1699,18 +1723,7 @@ export class ControlServer {
                 run: run.runId,
                 why: "the service has been answering matches slowly — not waited on; this turn runs normally",
             });
-            void pending.then((late) => {
-                if (!late)
-                    return;
-                logLine("replay.decision", {
-                    verdict: "no-steer",
-                    code: "match_late",
-                    run: run.runId,
-                    scenario: late.scenarioId ?? undefined,
-                    ms: Date.now() - startedAt,
-                    why: "the match landed while prompts were not waiting on it — not steered, and not recorded",
-                });
-            });
+            this.followLateMatch(session, run, settled, startedAt, "the match landed while prompts were not waiting on it — not steered, and not recorded");
             return undefined;
         }
         const cooling = !this.service.canWait();
@@ -1734,23 +1747,18 @@ export class ControlServer {
                         ? "the service is failing — not waited on; this turn runs normally"
                         : "the match did not answer inside its budget; this turn runs normally",
                 });
-                void pending.then((late) => {
-                    if (!late)
-                        return;
-                    logLine("replay.decision", {
-                        verdict: "no-steer",
-                        code: "match_late",
-                        run: run.runId,
-                        scenario: late.scenarioId ?? undefined,
-                        ms: Date.now() - startedAt,
-                        why: "the match landed after the prompt was answered — not steered, and not recorded",
-                    });
-                });
+                this.followLateMatch(session, run, settled, startedAt, "the match landed after the prompt was answered — not steered, and not recorded");
             }
             return undefined;
         }
-        if (!match)
+        if (!match) {
+            // "No match" — which may have come without waiting: the recorder answers
+            // the prompt so at once while a service failure is on record, however
+            // old, and once the create's first attempt failed. The service may have
+            // matched the prompt all the same, and issued a ticket.
+            this.followLateMatch(session, run, settled, startedAt, "the match landed after the prompt had gone ahead without it (a service failure was still on record, or the create's first attempt failed) — not steered, and not recorded");
             return undefined;
+        }
         // Awaited: a scenario with a target derives before the directive goes
         // out, so a plan that cannot find its target is never delivered
         // (segmented.md R-PARAM-4). Inside the prompt's own budget.
@@ -1869,6 +1877,45 @@ export class ControlServer {
             why: "the match answered fast again — prompts wait on it as before",
         });
     }
+    /**
+     * The prompt went ahead without the match: when the service's own answer
+     * lands, a hit is a hand-out nobody used. It is said once, as `match_late`
+     * with `why`, and its ticket is carried to the turn's report
+     * ({@link noteLateMatch}). A miss says nothing: the service has no ticket out.
+     */
+    followLateMatch(session, run, settled, startedAt, why) {
+        void settled.then((late) => {
+            if (!late)
+                return;
+            logLine("replay.decision", {
+                verdict: "no-steer",
+                code: "match_late",
+                run: run.runId,
+                scenario: late.scenarioId ?? undefined,
+                ms: Date.now() - startedAt,
+                why,
+            });
+            this.noteLateMatch(session, run, late);
+        });
+    }
+    /**
+     * A match that landed after its prompt had been answered, or while prompts
+     * were not waiting on it. Nothing is armed for it, and nothing derived. But
+     * the service issued a ticket with that hand-out, and without a report under
+     * it the console can only say the turn never reported — for a turn the agent
+     * simply did itself. So the turn carries the ticket to its report, as a
+     * decline with its own code, like a plan that was only late ({@link shelve}).
+     *
+     * Only a hand-out with a ticket: a match the service handed nothing for has
+     * its reason on the service already. And only while the turn is open.
+     */
+    noteLateMatch(session, run, match) {
+        if (run.finished || run.lateMatch || !match.scenarioId || !match.executionTicket)
+            return;
+        const state = this.replay.lateMatch(match, this.hostContext(session, run));
+        state.sessionId = session.sessionId;
+        run.lateMatch = state;
+    }
     /**
      * {@link armFromMatch} with replay off: nothing can be announced, and no hook
      * waits for the answer (`onPrompt` has already returned). So there is no
@@ -1876,10 +1923,11 @@ export class ControlServer {
      * had, and must not mark the service slow (that would open the process-wide
      * cool-down, and `/health` would report a degradation the user never had).
      * A hit still books its decline — the ledger's baseline sample — whenever
-     * it lands, as long as the turn is still open to carry it.
+     * it lands, as long as the turn is still open to carry it. So `settled` is
+     * the service's own answer, not the one a hook may have been given at once.
      */
-    async noteDisabledMatch(session, run, pending, prompt) {
-        const match = await pending;
+    async noteDisabledMatch(session, run, settled, prompt) {
+        const match = await settled;
         if (!match || run.finished)
             return undefined;
         // Declined at its first gate, before derivation: no transcript is read for it.
@@ -2436,6 +2484,25 @@ export class ControlServer {
             }
             this.queue.push(() => recorder.reportExecution(report));
         });
+        // The prompt match that landed too late (see `noteLateMatch`). Not when a
+        // plan of the same scenario armed later in the turn: that one has a ticket
+        // of its own, and says what happened. The turn's cost is a sample of the
+        // task's usual cost only when no plan ran in it at all.
+        const late = run.lateMatch;
+        if (late && !states.some((s) => s.scenarioId === late.scenarioId)) {
+            const alone = states.length === 0;
+            const report = this.replay.buildReport(late, {
+                sessionCostUsd: alone ? cost.usd : 0,
+                measured: alone && cost.measured,
+                durationMs,
+                prompt: run.input || undefined,
+                siblings: [...states, late],
+                runId: run.runId,
+                cutShort: cutShort || undefined,
+            });
+            if (report)
+                this.queue.push(() => recorder.reportExecution(report));
+        }
     }
     /**
      * Seal the session's run now, and drain it to the service in the background.
@@ -2513,11 +2580,24 @@ export class ControlServer {
             cwd: session.cwd,
             why: "run deferred to prompt",
         });
+        // The first prompt is seconds away, and its match is not waited for while
+        // a service failure is on record — one from hours ago included, when the
+        // machine slept or went offline and nothing was sent since. Find out now,
+        // in the background, whether the service answers again.
+        if (isServiceProber(this.recorder))
+            this.recorder.probeIfFailing();
         return {};
     }
     async onPrompt(payload) {
         const session = this.ensureSession(payload);
-        const input = payload.prompt ?? "";
+        const other = otherHost(session);
+        const raw = typeof payload.prompt === "string" ? payload.prompt : "";
+        // fx121 R1, R6: the user's words, without Claude Code's own blocks in front
+        // of them, and from here on the prompt everywhere. `input` is what the
+        // service embeds, and its model reads 512 tokens: the Claude in Chrome
+        // guide alone is 1,008. Another host's text goes as it was sent.
+        const prompt = other ? asSent(raw) : userText(raw);
+        const input = prompt.text;
         const open = session.run && !session.run.finished ? session.run : undefined;
         if (open?.promptSeen) {
             // A second prompt in the same session: close the previous turn's run and
@@ -2564,14 +2644,13 @@ export class ControlServer {
             });
             return {};
         }
-        const other = otherHost(session);
         if (other) {
             // What a host hands over with its prompt, kept before the run opens:
             // the match watched from there may start a plan at once, and the places
             // that do have no prompt payload in reach.
             session.hostSinks = hostSinksOf(payload);
         }
-        const run = this.ensureRun(session, input, { replay: other && payload.replay === true });
+        const run = this.ensureRun(session, input, { replay: other && payload.replay === true }, prompt);
         run.promptSeen = true;
         run.input = input;
         session.prompts += 1;
@@ -4369,10 +4448,13 @@ export class ControlServer {
             return { error: "serverName required" };
         const hold = Number(body.holdMs);
         const startedAt = Number(body.startedAt);
+        const ppid = Number(body.ppid);
         const work = await this.replay.work.waitForWork(serverName, Number.isFinite(hold) && hold > 0 ? Math.min(hold, POLL_HOLD_MS) : POLL_HOLD_MS, signal, {
             proxyId: typeof body.proxyId === "string" ? body.proxyId : undefined,
             startedAt: Number.isFinite(startedAt) ? startedAt : undefined,
             pid: Number.isFinite(pid) ? pid : undefined,
+            // The host process that started the proxy (see `onScenarioRun`).
+            ppid: Number.isInteger(ppid) && ppid > 0 ? ppid : undefined,
         });
         return work ? { work } : {};
     }
@@ -4446,6 +4528,14 @@ export class ControlServer {
      * ONE RUN PER PLAN. A second call while the plan is executing would run
      * every step again beside the first — duplicated writes — and is told so.
      *
+     * WHOSE PROXIES. `run_scenario` is the session's first call, so no
+     * correlated call has bound its proxies yet, and with another session open
+     * an unbound proxy may be either's: the plan's first step was refused. But
+     * Claude Code starts all of a session's MCP servers as its own children, and
+     * `bir-scenario` sends its parent's pid (`ppid`), as every proxy does with its
+     * poll. The proxies with that parent are this session's, and are bound to it
+     * before the plan runs (replay/executor.ts, `bindSiblings`).
+     *
      * `signal` aborts when `bir-scenario`'s request goes away — the host
      * cancelled the call (Esc) or its own timeout fired — so no further step is
      * started for a caller that can no longer read the result.
@@ -4467,6 +4557,12 @@ export class ControlServer {
             });
             return { ok: false, why: ALREADY_RUNNING };
         }
+        // `bir-scenario` and this session's proxies share the host process that
+        // started them: bind those proxies to the session now, so the plan's first
+        // step can run even while another session's proxies are live.
+        const hostPid = Number(body.ppid);
+        if (Number.isInteger(hostPid) && hostPid > 0)
+            this.replay.work.bindSiblings(hostPid, call.sessionId);
         this.runningPlans.add(state);
         // The session is busy for as long as its plan runs, and sends no hook
         // meanwhile: the host is waiting on this very call.

package/dist/proxy/session.js

@@ -438,6 +438,7 @@ export class ProxySession {
                 proxyId: this.proxyId,
                 startedAt: this.startedAt,
                 pid: process.pid,
+                ppid: process.ppid,
             });
         const registered = await client.register({
             serverName: this.serverName,

package/dist/record/prompt-text.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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 declare const HOST_BLOCKS: readonly string[];
+export interface PromptText {
+    /** The user's words: what the service embeds and matches, and what derive reads. */
+    text: string;
+    /** Tags of the blocks removed from the front, in order. Empty for a plain prompt. */
+    stripped: string[];
+    /** Nothing of the user's is left, and the turn was a task notification (fx121 R7). */
+    eventOnly: boolean;
+    /** Length of the prompt as the hook gave it. */
+    rawChars: number;
+}
+/** The prompt exactly as the hook gave it: another host's text (fx121 R1), or one with nothing to clean. */
+export declare function asSent(raw: string): PromptText;
+/** The user's words in a Claude Code prompt, and what was taken off the front of them. */
+export declare function userText(raw: string): PromptText;
+//# sourceMappingURL=prompt-text.d.ts.map