@basein/runner 0.3.5 → 0.3.7

package/README.md

@@ -303,9 +303,14 @@ does a plain `bir install` where replay was never set up. `bir install --replay`
 never turns back on a `bir replay off` of yours. The switches are kept per
 project in `~/.baseinstrunner/installed.json`, so a recorder the hook starts — with Claude
 Code's environment, not your terminal's — keeps them. A recorder reads them when
-it starts: `bir up --restart` applies a change. `BIR_REPLAY`,
-`BIR_REPLAY_ALLOW_SERVERS` and `BIR_MIN_STEER_SIMILARITY` in the environment
-still override them, and `bir doctor` says which source is in effect.
+it starts: `bir up --restart` applies a change. `BIR_REPLAY` and
+`BIR_REPLAY_ALLOW_SERVERS` in the environment still override them, and
+`bir doctor` says which source is in effect.
+
+Every match is used. When the service matches a prompt to a recording with a
+ready scenario, bir runs the scenario; there is no second, stricter score on
+this side. (Up to 0.3.6 bir declined a match under 0.92, and
+`BIR_MIN_STEER_SIMILARITY` set that bar; it is ignored now.)
 
 Two switches, not one, because of what replay is: **a scenario is a pre-approved
 list of tool calls with computed arguments.** A steered step is answered
@@ -435,7 +440,6 @@ what to do when they register, so there is one switch and no second copy of it:
 | `BIR_REPLAY_ALLOW_SERVERS` | Server keys bir may call unattended: **direct** execution, and a steered plan's recovery. Unset means the list `bir replay allow` stored for the project, else every wrapped server; narrowing it is the recommendation. |
 | `BIR_BUILTIN_TOOLS` | Built-in tools bir may execute itself during a replay — in the session's own project directory, and confined to it. Default `Read,Glob,Grep` (read-only). Add `Edit,Write,Bash` only deliberately: a runner-side step never reaches Claude Code's permission prompts. `none` turns it off, and a built-in step hands the turn back as before. |
 | `BIR_BASH_ALLOW` | Command prefixes a runner-side `Bash` step may run (`*` for all). Unset, `Bash` never executes on the runner, even when `BIR_BUILTIN_TOOLS` lists it. A plan's Bash steps share a working directory, as Claude Code's do (variables and functions do not persist, also as in Claude Code). |
-| `BIR_MIN_STEER_SIMILARITY` | Minimum match similarity to replay (default `0.92`, above the service's own `0.9` detection threshold). |
 | `BIR_DERIVE_API_KEY` | **Optional.** Working out what a new request is about — which fleet, which file, which date — is done for you by the service on its own key, as long as you are signed in. Set this (an Anthropic key) only to keep that reading on your machine, on your key. Signed out *and* unset, a scenario whose values change between requests is declined rather than replayed on stale ones. |
 | `ANTHROPIC_API_KEY` | Not used by the background recorder, which has Claude Code's environment and would bill your own key — unless `BIR_USE_ANTHROPIC_API_KEY=1`. A `bir-hooks` run by hand in a terminal uses that terminal's key. |
 | `BIR_DERIVE_MODEL` | Derivation model, when you set a key of your own (default `claude-haiku-4-5-20251001`). |

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

@@ -73,7 +73,6 @@
  *   BIR_BASH_ALLOW            command prefixes a runner-side Bash step may run
  *                             (`*` for all). Unset, Bash never executes on the
  *                             runner even when BIR_BUILTIN_TOOLS lists it
- *   BIR_MIN_STEER_SIMILARITY  minimum match similarity to replay (default 0.92)
  *   BIR_DERIVE_API_KEY        OPTIONAL. Derivation — reading what this turn acts
  *                             on — is done by the service for a signed-in
  *                             runner. Set this (an Anthropic key) only to keep

package/dist/bin/bir-hooks.js

@@ -73,7 +73,6 @@
  *   BIR_BASH_ALLOW            command prefixes a runner-side Bash step may run
  *                             (`*` for all). Unset, Bash never executes on the
  *                             runner even when BIR_BUILTIN_TOOLS lists it
- *   BIR_MIN_STEER_SIMILARITY  minimum match similarity to replay (default 0.92)
  *   BIR_DERIVE_API_KEY        OPTIONAL. Derivation — reading what this turn acts
  *                             on — is done by the service for a signed-in
  *                             runner. Set this (an Anthropic key) only to keep

package/dist/bin/bir.js

@@ -3292,8 +3292,7 @@ async function doctor(args) {
     // reading a log file.
     const replay = health?.replay;
     if (replay?.enabled) {
-        out(`Replay            : ON  servers=${replay.allowServers?.join(",") || "(all wrapped)"}  ` +
-            `minSimilarity=${replay.minSimilarity ?? "?"}` +
+        out(`Replay            : ON  servers=${replay.allowServers?.join(",") || "(all wrapped)"}` +
             (replay.source ? `  source=${replay.source}` : ""));
         // An older control server sends only `deriveKey`; read it as the two states
         // it could describe then.
@@ -3527,8 +3526,7 @@ function replayPolicyCommand(args) {
                 ? "off (not asked for at install: --no-replay, `bir uninstall --replay`, or no --replay) — `bir replay on` turns it on"
                 : "off"}`);
         out(`  direct servers ${policy?.allowServers?.length ? policy.allowServers.join(", ") : "(all wrapped)"}`);
-        out(`  minSimilarity  ${policy?.minSimilarity ?? 0.92}`);
-        const overrides = ["BIR_REPLAY", "BIR_REPLAY_ALLOW_SERVERS", "BIR_MIN_STEER_SIMILARITY"].filter((k) => process.env[k] !== undefined);
+        const overrides = ["BIR_REPLAY", "BIR_REPLAY_ALLOW_SERVERS"].filter((k) => process.env[k] !== undefined);
         if (overrides.length) {
             out(`  (set in this shell's environment, which a recorder started from it would prefer: ${overrides.join(", ")})`);
         }

package/dist/bin/investigate.js

@@ -170,9 +170,11 @@ export const DECLINES = {
         cause: "the matched recording had no ready scenario at that moment.",
         fix: "wait for the calculation, or start one with `bir scenario calc <runId>`, then run the prompt again.",
     },
+    // Written only by runners up to 0.3.6, which re-scored a match against a
+    // bar of their own; kept so their log lines still read.
     similarity: {
-        cause: "the prompt was a hit on the recording but below the steering threshold (BIR_MIN_STEER_SIMILARITY, default 0.92).",
-        fix: "phrase the prompt closer to the recorded one, or lower BIR_MIN_STEER_SIMILARITY.",
+        cause: "an older runner used a scenario only when the prompt scored 0.92 or more, above the service's own bar for a match (0.9, or a checked match under it).",
+        fix: "update the runner (`npm install -g @basein/runner`) and restart it (`bir up --restart`): every match is used now.",
     },
     coverage: {
         cause: "no step of the scenario could run anywhere: its tools are neither wrapped MCP servers registered in this session nor built-ins.",

package/dist/config/generate.d.ts

@@ -412,8 +412,6 @@ export interface ReplayPolicy {
     disabledBy?: "install";
     /** Server keys eligible for direct execution. Absent means every wrapped one. */
     allowServers?: string[];
-    /** `BIR_MIN_STEER_SIMILARITY`'s stored twin. */
-    minSimilarity?: number;
 }
 /** What `bir install` decided for one project directory. */
 export interface ProjectRecord {

package/dist/control/recorder-main.d.ts

@@ -52,7 +52,7 @@ export declare function derivationKey(daemon?: boolean): {
     apiKey?: string;
     source?: string;
 };
-/** Where the three replay switches came from, for `/health` and `bir doctor`. */
+/** Where the two replay switches came from, for `/health` and `bir doctor`. */
 export type ReplaySource = "env" | "sidecar" | "default";
 /** What a recorder still serves (K4, `ControlServer.activity()`). */
 export interface RecorderActivity {

package/dist/control/recorder-main.js

@@ -155,11 +155,9 @@ export function derivationKey(daemon = process.env[DAEMON_ENV] === "1") {
 /**
  * Assemble the replay configuration (docs/calculatedReplay.md §5.3 of the guide).
  *
- * The steer threshold defaults **above** the service's own detection threshold
- * (0.9). Detection decides "do not record this again", which is cheap — the worst
- * case is a lost recording. Steering decides "do not think about this again",
- * which is a much stronger claim, and a 0.90-similar prompt usually covers only
- * part of the live task.
+ * There is no steer threshold: a match the service hands out is steered
+ * (controller.ts, gate 4). A recorder started with `BIR_MIN_STEER_SIMILARITY`
+ * or `BIR_MIN_SEGMENT_STEER_SIMILARITY` set ignores them.
  */
 function buildReplayOptions(keeper, policy, key) {
     // The environment still wins — an operator at a terminal is the most
@@ -168,8 +166,7 @@ function buildReplayOptions(keeper, policy, key) {
     // switches the project stored instead of forgetting them (generate.ts).
     const envReplay = process.env.BIR_REPLAY;
     const envAllow = process.env.BIR_REPLAY_ALLOW_SERVERS;
-    const envMin = Number(process.env.BIR_MIN_STEER_SIMILARITY);
-    const fromEnv = envReplay !== undefined || envAllow !== undefined || Number.isFinite(envMin);
+    const fromEnv = envReplay !== undefined || envAllow !== undefined;
     const source = fromEnv ? "env" : policy ? "sidecar" : "default";
     const enabled = envReplay !== undefined ? envReplay !== "0" : policy?.enabled !== false;
     const allowServers = envAllow !== undefined
@@ -177,7 +174,6 @@ function buildReplayOptions(keeper, policy, key) {
         : policy?.allowServers
             ? parseAllowList(policy.allowServers.join(","))
             : undefined;
-    const minSimilarity = Number.isFinite(envMin) ? envMin : (policy?.minSimilarity ?? 0.92);
     // Which built-ins the runner may execute itself (replay/builtins.ts):
     // read-only by default, `BIR_BUILTIN_TOOLS` to change, `BIR_BASH_ALLOW`
     // before a `Bash` step may run at all. Environment-only knobs, like
@@ -186,7 +182,6 @@ function buildReplayOptions(keeper, policy, key) {
     const bashAllow = parseBashAllow(process.env.BIR_BASH_ALLOW);
     const opts = {
         enabled,
-        minSimilarity,
         allowServers,
         builtinTools,
         bashAllow,
@@ -222,10 +217,6 @@ function buildReplayOptions(keeper, policy, key) {
         // Observe-only until an operator has read the logs and turned it on
         // (segmented.md R-OUT-10, R-LIFE-7). Arming is never the way to find out.
         segmentArm: process.env.BIR_SEGMENT_ARM === "1",
-        minSegmentSimilarity: (() => {
-            const n = Number(process.env.BIR_MIN_SEGMENT_STEER_SIMILARITY);
-            return Number.isFinite(n) ? n : 0.95;
-        })(),
         // Both read live, never captured (C5). The recorder signs in after it
         // listens, refreshes the token as the session outlives it, and may sign
         // in or out while it runs; replay reads whatever holds *now*. The old
@@ -244,7 +235,6 @@ function buildReplayOptions(keeper, policy, key) {
         // and nothing else: an ordinary wrapped call keeps its permission prompt
         // (see the correlation line under `control.listening`).
         logLine("replay.enabled", {
-            minSimilarity: opts.minSimilarity,
             allowServers: allowServers ? [...allowServers].join(",") : "(all wrapped)",
             // Which built-ins may run on the runner itself, and whether Bash may at
             // all — loud for the same reason as the rest of this line.

package/dist/control/server.js

@@ -404,7 +404,7 @@ export class ControlServer {
         this.token = opts.token ?? randomBytes(32).toString("hex");
         for (const name of opts.wrappedServers ?? [])
             this.wrapped.add(name);
-        this.replay = new ReplayController(opts.replay ?? { enabled: false, minSimilarity: 1 });
+        this.replay = new ReplayController(opts.replay ?? { enabled: false });
         this.deriveRecentResults = opts.deriveRecentResults ?? 5;
         this.intentSources = opts.intentSources ?? new Set(["text", "thinking", "tool"]);
         this.timings = { ...DEFAULT_SESSION_TIMINGS, ...(opts.sessionTimings ?? {}) };
@@ -579,7 +579,6 @@ export class ControlServer {
             replay: {
                 enabled: this.replay.enabled,
                 source: this.opts.replaySource ?? null,
-                minSimilarity: this.opts.replay?.minSimilarity ?? null,
                 allowServers: this.opts.replay?.allowServers ? [...this.opts.replay.allowServers] : null,
                 deriveKey: Boolean(this.opts.replay?.apiKey ?? process.env.ANTHROPIC_API_KEY),
                 // Who reads the turn for its parameters (segmented.md R-PARAM-5). The

package/dist/replay/controller.d.ts

@@ -180,15 +180,6 @@ export declare const RUN_NO_PLAN = "no_plan";
 export interface ReplayOptions {
     /** On unless `BIR_REPLAY=0`. Everything here is inert when false. */
     enabled: boolean;
-    /** Minimum similarity to steer — deliberately above the service's detection threshold. */
-    minSimilarity: number;
-    /**
-     * Minimum similarity to steer a **segment** (`BIR_MIN_SEGMENT_STEER_SIMILARITY`,
-     * segmented.md R-OUT-11). The same number as the server's clear band, so a
-     * clear hand-out is always accepted and no score falls between "clear" and
-     * "accepted".
-     */
-    minSegmentSimilarity?: number;
     /**
      * `BIR_SEGMENT_ARM`. Off means observe-only: the runner asks for no segment
      * and arms none, and only logs what would have armed (R-OUT-10).
@@ -439,7 +430,7 @@ export interface ReplayState {
  * Why a match did not arm. One code per gate of the ladder, so the caller can
  * act on a decline without parsing the sentence that explains it.
  */
-export type DeclineCode = "replay_disabled" | "not_ready" | "flatten_failed" | "similarity" | "known_bad_first_step" | "nondeterministic_first_step" | "unusable_first_step" | "coverage" | "missing_target" | "no_derive_key";
+export type DeclineCode = "replay_disabled" | "not_ready" | "flatten_failed" | "known_bad_first_step" | "nondeterministic_first_step" | "unusable_first_step" | "coverage" | "missing_target" | "no_derive_key";
 /** What `PreToolUse` should do about this call. */
 export type PreToolAction = 
 /** Pin the arguments and let the real tool run. */

package/dist/replay/controller.js

@@ -333,14 +333,7 @@ export class ReplayController {
             verified: match.verified,
             sharedWith: [],
         };
-        // A segment is judged against its own gate, and a `same` verdict stands in
-        // for the score (segmented.md R-OUT-11): the question was asked *because*
-        // the score sat below the threshold, so a numeric gate would decline every
-        // verified hand-out.
         const isSegment = state.kind === "segment";
-        const threshold = isSegment
-            ? (this.opts.minSegmentSimilarity ?? 0.95)
-            : this.opts.minSimilarity;
         const decline = (why, code) => {
             state.declined = code;
             logLine("replay.decision", {
@@ -349,7 +342,6 @@ export class ReplayController {
                 run: match.runId,
                 scenario: match.scenarioId ?? undefined,
                 similarity: match.similarity.toFixed(3),
-                threshold,
                 kind: state.kind,
                 key: state.key,
                 verified: state.verified?.verdict,
@@ -371,18 +363,14 @@ export class ReplayController {
         if (!match.scenarioId || !isReadyScenario(scenario)) {
             return decline(match.scenarioId ? "scenario is not ready" : "no scenario for the matched run", "not_ready");
         }
-        // Gate 4 — similarity. Detection decides "don't record this again"; steering
-        // decides "don't think about this again", which is a much stronger claim and
-        // deserves a stronger threshold.
-        //
-        // For a segment, a `same` verdict from the live question stands in for the
-        // score (R-OUT-11). Only `same` ever reaches a runner with a ticket, so it
-        // is the only verdict this sees.
-        const scoreOk = match.similarity >= threshold;
-        const verifiedOk = isSegment && match.verified?.verdict === "same";
-        if (!scoreOk && !verifiedOk) {
-            return decline("similarity below threshold", "similarity");
-        }
+        // Gate 4 — similarity — is gone. A hand-out is the service's decision that
+        // this scenario does what the prompt asks: its match threshold, the
+        // same-request question under it, the intent pass, a segment's clear band
+        // or `same` verdict. Scoring it again here declined matches the service
+        // had made (a checked 0.85, a task line at 0.91), so every match now
+        // steers. What a plan cannot do — a step that keeps failing, a tool
+        // nobody wrapped, a target the prompt never named — the gates below
+        // still stop.
         // Flatten the chain before the remaining gates, so every one of them judges
         // the steps that will *really* run — the caller's own and, in order, those
         // of every segment it calls (segmented.md R-CALL-29, R-CALL-30).

package/docs/calculatedReplay.md

@@ -193,7 +193,7 @@ Every gate that declines logs **one** `replay.decision` line carrying the reason
 | 1 | **A match arrived** | `getMatch()` resolved `null`, or the budget expired (§10) | (no report — nothing matched) |
 | 2 | **Replay enabled** | `BIR_REPLAY === "0"`, or, with it unset, the project's stored switch is off (`bir replay off`, or a `bir install` without `--replay`) | `not_steered` |
 | 3 | **Scenario ready** | `scenario == null`, `state !== "ready"`, or `steps.length === 0` | `not_steered` |
-| 4 | **Similarity** | `similarity < BIR_MIN_STEER_SIMILARITY` (default **0.92**) | `not_steered` |
+| 4 | ~~**Similarity**~~ | Retired: a match is the decision to use the scenario (below) | — |
 | 5 | **Tool coverage** | No step is executable anywhere (§5 → `mode: "none"`) | `not_steered` |
 
 Past the table, a plan can still be refused before the model hears of it, each refusal with its own
@@ -205,12 +205,16 @@ after the prompt was answered is retired unannounced (`match_late`, `arm_unannou
 plan is declined when no running `bir-scenario` has said it serves `run_scenario`
 (`no_delivery_tool`, §6.3). In plan mode (`permission_mode: "plan"`) nothing is announced at all.
 
-Gate 4 deserves its own note. The server's own detection threshold is 0.9, and it uses it to decide
-*"do not record this again"* — a cheap claim: the worst case is a lost recording. Steering makes a
-much stronger claim: *"do not think about this again."* A prompt that is 0.90-similar usually covers
-only part of the live task, and steering it produces a confident, thin, wrong answer. So the steer
-threshold sits **above** the detection threshold by default, and `BIR_MIN_STEER_SIMILARITY` is the
-single knob an operator turns after watching `replay.decision` lines for a week.
+Gate 4 is retired. Up to 0.3.6 it declined a match under `BIR_MIN_STEER_SIMILARITY` (0.92),
+above the server's 0.9, on the argument that the server only decided *"do not record this again"*
+while steering claims *"do not think about this again."* The server's match stopped being detection
+alone: it hands a scenario over only when it may run, with a ticket, and it decides the match with
+more than one score — a same-request question under its threshold, and a second pass on the
+prompt's task line. Re-scoring that on this side declined matches the server had made (a checked
+0.85, a task line at 0.91). **A match is the decision to use the scenario**, so every hand-out
+steers; what a plan cannot do — a parked first step, a tool nothing reaches, a target the prompt
+never named — the gates after it still stop. `BIR_MIN_STEER_SIMILARITY` and
+`BIR_MIN_SEGMENT_STEER_SIMILARITY` are ignored.
 
 `not_steered` as the floor is not a failure code. It is the **control group**: the prompt matched,
 the agent ran the task the ordinary way, and the cost of doing so is a fresh measurement of what this
@@ -1486,7 +1490,7 @@ plans when it is replayed. The operator's walk-through is
 source run's *recorded* outputs — no real tools, no side effects, one Haiku call. Without `--dry`,
 `bir replay` runs the same plan through the same executor against the live proxies. `bir doctor`
 gains a `replay` block: on/off, the effective `BIR_REPLAY_ALLOW_SERVERS` allowlist,
-`BIR_MIN_STEER_SIMILARITY`, and who derives — this machine, the service, or nobody, which is the
+and who derives — this machine, the service, or nobody, which is the
 state in which a scenario with a target never runs (§13.2, mitigation 3).
 
 ---
@@ -1627,7 +1631,7 @@ changes the corpus, the threshold and every stored vector. §20 question 1.
    and argument objects the bodies rely on today.
 4. **Should a declined match still arm a *dry* plan?** Deriving parameters and computing the first
    step's input without executing anything would make `bir doctor` able to say *"this scenario would
-   have run these three calls"* — excellent for tuning `BIR_MIN_STEER_SIMILARITY`, at the price of a
+   have run these three calls"* — excellent for fixing the plan behind a decline, at the price of a
    Haiku call on turns that replay nothing.
 5. **Should `scenario_steps` carry `recorded_output`?** §8.1 works around its absence with one lazy
    `GET /recordings/runs/:runId`. A column would make it a field read, would let a scenario outlive

package/docs/calculatedReplayGuide.md

@@ -300,7 +300,7 @@ bir doctor
 ```
 
 ```
-Replay            : ON  servers=chrome-devtools,fleet-api  minSimilarity=0.92  source=sidecar
+Replay            : ON  servers=chrome-devtools,fleet-api  source=sidecar
                     derive=the service (no key needed here)
 Wrapped in config : chrome-devtools, fleet-api
 Registered proxies: chrome-devtools, fleet-api
@@ -324,7 +324,7 @@ uses, with the account it is signed in as. The two normally agree.
 
 ### 5.3 Environment
 
-The first three switches are stored per project, and that is where to set them:
+The first two switches are stored per project, and that is where to set them:
 
 ```bash
 bir replay allow chrome-devtools,fleet-api   # the servers bir may call by itself; `allow all` clears it
@@ -344,7 +344,6 @@ so there is exactly one switch and it cannot get out of step with itself.
 |---|---|---|
 | `BIR_REPLAY` | *(the stored switch)* | `0` disables replay and any other value turns it on, whatever `bir replay on` or `off` or the install stored. Unset, the stored switch decides: on after `bir setup` or `bir install --replay`, off after a plain `bir install`. Nothing below matters while replay is off |
 | `BIR_REPLAY_ALLOW_SERVERS` | *(the stored list, else all wrapped)* | Comma-separated server keys bir may call by itself: **direct** execution and divergence recovery. Overrides `bir replay allow` |
-| `BIR_MIN_STEER_SIMILARITY` | `0.92` | Below this a match is detected but not replayed (§8) |
 | `BIR_DERIVE_API_KEY` | *(unset)* | **Not required.** Derivation — reading what this request acts on — is done by the service on its key for a signed-in runner. Set this to keep the reading on this machine instead: the prompt then never leaves it, and it is one round trip faster. Signed out *and* unset, only a scenario with nothing to work out replays. A recorder running in the background (started by the SessionStart hook, `bir up` or `bir setup`) ignores `ANTHROPIC_API_KEY` (usually Claude Code's own, and billed) unless `BIR_USE_ANTHROPIC_API_KEY=1`; a `bir-hooks` you run in a terminal uses it |
 | `BIR_DERIVE_MODEL` | `claude-haiku-4-5-20251001` | The derivation model, when this machine does the reading |
 | `BIR_MATCH_BUDGET_MS` | `3000` | How long the prompt hook waits for a match before giving up. After a match slower than `BIR_MATCH_SLOW_MS` (`2000`), prompts stop waiting for one for 5 minutes, doubling up to 30 while the service stays slow |
@@ -515,8 +514,8 @@ a turn cut short says nothing about what the task costs.
 
 `not_steered` is not an error, and it is not wasted. A saving is `baseline − actual`, and the baseline
 is *what this task costs when the agent does it*. Every declined match is a fresh measurement of
-exactly that. A deployment that never declines has no baseline to measure against — which is a good
-reason to leave `BIR_MIN_STEER_SIMILARITY` where it is rather than driving it to zero.
+exactly that. A deployment that seldom declines measures its baseline mostly from the recording
+itself; `bir replay off` for a few runs of the prompt, then `bir replay on`, gives it more.
 
 An **unredeemed** ticket books nothing at all. Silence loses a saving; it never invents one.
 
@@ -524,25 +523,22 @@ An **unredeemed** ticket books nothing at all. Silence loses a saving; it never
 
 ## 8. Tuning
 
-Only one knob matters in practice.
-
-**`BIR_MIN_STEER_SIMILARITY` (default 0.92).** The server detects matches at 0.9 and uses that to
-decide *"don't record this again"* — cheap: the worst case is a lost recording. Steering makes a much
-stronger claim, *"don't think about this again"*, and a 0.90-similar prompt usually covers only part
-of the live task. Steering it produces a confident, thin, wrong answer.
-
-Tune it from evidence, not taste. Run for a week and read the declines:
-
-```bash
-grep 'replay.decision' audit.log | grep 'why="similarity below threshold"'
-```
-
-- Prompts you *would* have wanted replayed, sitting at 0.90–0.92 → lower it, in steps of 0.01.
-- Replays that answered the wrong question → raise it, and re-read the scenario's `intent`.
-
-If a specific pair of prompts *should* match and does not, the fix is usually upstream of the
-threshold: the two prompts genuinely mean different things to the embedding model. Re-record with a
-first prompt that states the task plainly.
+There is no threshold on this side. **Every match steers**: a match is the service's decision that
+the scenario does what the prompt asks, and bir does not score it again. (Up to 0.3.6 it did:
+`BIR_MIN_STEER_SIMILARITY`, default 0.92, declined matches the service had made. It is ignored now.)
+
+Whether a prompt matches is decided by the service, in three steps. A prompt at 0.9 or more against
+a recording matches (`SIMILARITY_THRESHOLD`). From 0.7 (`SIMILARITY_CHECK_FLOOR`) up to that, a quick
+model check asks whether the two prompts are the same request, values included, and only a yes
+matches. A prompt that missed both is matched once more on its task line (`PROMPT_INTENT_THRESHOLD`,
+0.9) — the way the same task with a different value finds its scenario.
+
+- A replay that answered the wrong question → switch that recording off in the console (its
+  scenario then never runs), or `bir replay off` in the project, and re-read the scenario's
+  `intent`. On a service you run yourself, raise `SIMILARITY_THRESHOLD` or `SIMILARITY_CHECK_FLOOR`.
+- A prompt you *would* have wanted replayed that did not match → the fix is usually upstream of any
+  threshold: the two prompts genuinely mean different things to the embedding model. Re-record with
+  a first prompt that states the task plainly.
 
 ---
 

package/docs/installRun.md

@@ -571,8 +571,8 @@ Fleet switches on `bir setup`: `--allow-servers a,b` stores the servers replay
 may call unattended for this project; `bir replay allow|on|off|status` changes
 it later. Both live in the project record (§4.3), so a recorder the hook starts
 — with Claude Code's environment, not the operator's terminal — keeps them;
-`BIR_REPLAY`, `BIR_REPLAY_ALLOW_SERVERS` and `BIR_MIN_STEER_SIMILARITY` in the
-recorder's environment still override, and `bir doctor` says which source is in
+`BIR_REPLAY` and `BIR_REPLAY_ALLOW_SERVERS` in the recorder's environment still
+override, and `bir doctor` says which source is in
 effect. `--no-replay` adds no scenario server (one an earlier setup added stays
 until `bir uninstall --replay`) and stores replay off (`bir replay on` turns it
 on); `--no-daemon` wires everything and starts

package/docs/t-bench.md

@@ -357,9 +357,8 @@ Per arm, per domain: reward (mean), pass^k across trials, `$`/episode and `$`/tu
 `--output-format json`'s `total_cost_usd`, wall-clock per episode, and turn count.
 
 Per replayed turn, from the audit log and the execution ledger: outcome
-(`steered_full` / `diverged` / `fell_back` / `not_steered` / `failed`), match similarity against
-`BIR_MIN_STEER_SIMILARITY` (default 0.92), direct vs steered mode, `deriveCostUsd` against
-`sessionCostUsd`, and the per-step verdicts.
+(`steered_full` / `diverged` / `fell_back` / `not_steered` / `failed`), match similarity, direct
+vs steered mode, `deriveCostUsd` against `sessionCostUsd`, and the per-step verdicts.
 
 Two τ-specific splits worth reporting that MCPMark cannot give us:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basein/runner",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "A recording MCP proxy: sits between any MCP client and its MCP servers, executes each call on the client's behalf, and records the run as a reusable BaseIn scenario.",
   "type": "module",
   "license": "MIT",

package/production.md

@@ -847,7 +847,7 @@ Truncation is always marked with the original size.
 | `matchGate` | `{holding, holdMs, until}`: whether prompts have stopped waiting on the match because the service is slow |
 | `correlation` | `auto`, `allow` or `ask`, or `fingerprint` when correlation is off: who approves wrapped calls |
 | `deliveryTool`, `scenarioServers[]` | whether a live `bir-scenario` has said hello (`{pid, tools, off, version, ageMs}`). An empty list means no direct plan is announced. |
-| `replay` | `{enabled, source, minSimilarity, allowServers, deriveKey, deriveVia, pollingProxies}`. `deriveVia` is `service`, `key` or `samples`; `samples` means no scenario with a target can run. |
+| `replay` | `{enabled, source, allowServers, deriveKey, deriveVia, pollingProxies}`. `deriveVia` is `service`, `key` or `samples`; `samples` means no scenario with a target can run. |
 | `registeredProxies[]`, `wrappedServers` | proxies that registered (`serverName`, `pid`, `cwd`, `version`) and the wrapped server names |
 | `hooksVersion`, `pid`, `cwd`, `url` | the recorder's version and identity |
 | `segmentArm` | whether service-found sub-tasks may run mid-task (default: observe only) |
@@ -981,7 +981,6 @@ Defaults were checked in `src/`.
 | `BIR_DERIVE_MODEL` | recorder | `claude-haiku-4-5-20251001` | Model for derivation on this machine. |
 | `BIR_REPLAY` | recorder | on, or the project's stored switch | `0` turns replay off. Any other value forces it on over the stored switch. |
 | `BIR_REPLAY_ALLOW_SERVERS` | recorder | all wrapped servers | Servers that direct runs and divergence recovery may call unattended (comma-separated). |
-| `BIR_MIN_STEER_SIMILARITY` | recorder | 0.92 | Minimum match similarity to replay. |
 | `BIR_MATCH_BUDGET_MS` | recorder | 3000 | Longest a prompt waits for the match. |
 | `BIR_MATCH_SLOW_MS` | recorder | 2000 | A match slower than this, or one that timed out, stops prompts waiting for 5 min, doubling to 30 min. |
 | `BIR_DERIVE_BUDGET_MS` | recorder | 8000 | Derivation wait for `/scenario/run`. Hooks use the smaller of this and `BIR_HOOK_DERIVE_BUDGET_MS`. |
@@ -1003,7 +1002,6 @@ Defaults were checked in `src/`.
 | `BIR_INTENT_ARM` | recorder | unset (follows `BIR_SEGMENT_ARM`) | `1`: a probe may arm a plan in its own PreToolUse, and that hook waits for it. `0`: never. |
 | `BIR_INTENT_ARM_BUDGET_MS` | recorder | 500 | How long that PreToolUse waits for the probe. |
 | `BIR_SEGMENT_ARM` | recorder | unset (observe only) | `1`: recurring sub-tasks the service found may run mid-task. |
-| `BIR_MIN_SEGMENT_STEER_SIMILARITY` | recorder | 0.95 | Minimum similarity to steer a segment. |
 | `BIR_CONTROL_URL` | proxy, scenario | written into wrapped entries | The project's control server. Together with `BIR_CONTROL_TOKEN` it is the SDK channel and wins over discovery. |
 | `BIR_CONTROL_TOKEN` | proxy, scenario | unset | Bearer token for the SDK channel. |
 | `BIR_PROXY_STAY_UP` | proxy | unset | `1`: keep answering errors after the upstream dies (0.2.12). |