@basein/runner 0.3.20 → 0.3.22

package/production.md

@@ -594,31 +594,6 @@ Truncation is always marked with the original size.
 - An Esc-interrupted turn is never booked as a saving (`measured:false`).
 - A step that a host other than Claude Code (§3.2) stopped itself has two stop reasons of its own. `host_rejected`: a person said no, or answered in the tool's place, or a call limit blocked the call. The note says "Step N of M (tool) was not run by the host. The result above was written by the host, not by the tool. Do not run the step again unless the user asks." `host_edited`: a person changed the call. The note says "Step N of M (tool) ran with arguments a person chose, not the scenario's. Its result above is real and its side effects are in place. Do not run it again." The report's `fallbackKind` stays `step_failed`.
 
-**The decision stop (0.3.19).** The service may serve a step with `stop: {kind: "decision"}`: the task has an "if … otherwise" there (the service's segmentsbreakdown.md). The plan never decides:
-
-- It runs only the steps before the decision, then hands the task back, in steer and direct mode and after a divergence.
-- The note says the plan "ran the steps before a decision, and stopped there", says which steps ran, and quotes the request's own sentences with a condition word (`if`, `otherwise`, `unless` and the others the service uses, Hebrew too; at most 600 characters). It ends "Decide from the results above which way applies, then continue the task". It has no intent line, no remaining steps and no parameters, and never the condition the service keeps (`stop.why`): each would hint at the half the recording took. The directive at the prompt leaves the intent out too, and says the task comes back "at a decision".
-- A plan whose chain has a decision keeps these protections when it stops earlier for another reason (a parked or failed step, a judgement, the budget). Its note has no intent line and no parameters, and lists the remaining steps only up to the decision. Its directive leaves the intent out. An agent sent on to the recorded half's steps would start that half's segment, and the plan would have decided after all.
-- The report is `fell_back` (or `failed` when no step ran) with `fallbackKind: "decision"` and `fallbackStepIndex` the decision step. The decision step gets no verdict, so nothing is counted against it.
-- When a step ran, the hand-over takes the plan's usage mark: the plan is billed up to the stop, and the agent's decision and the half it took are not on its bill. This holds for a plan the prompt started and for one an intent match started. Every other hand-over still takes no mark.
-- The agent's own next call opens the fragment, marked `metadata.decisionOf = {scenarioId, stepIndex, request}` (`request`, the turn's prompt, redacted and cut to 4,000 characters, from 0.3.20): the service makes a calculated scenario of that way from it, calculated with the request (the service's offer1.md O2). When a plan the intent check armed, or a next scenario (below), takes that call instead, the fragment is dropped (`run.fragment_dropped`).
-- `ranThrough` sends one entry per plan, with the plan's own position (the decision step itself for a decision). The service maps it onto the recording.
-- `bir replay` stops in front of a decision and says so (`stopped     before step N …: the plan's decision`).
-- A runner up to 0.3.18 reads the unknown kind as `known_bad_step`: it stops there too, but its note and report name a failure.
-
-**What can follow a decision (0.3.20, the service's offer1.md).** The first time a way is taken after a decision, the agent does it and its fragment becomes a calculated scenario of that decision. The next time:
-
-- When a plan stops at its decision, the runner asks the service once, in the background, which calculated scenarios can follow it (`POST /scenarios/:planId/next`, body `{turnId, supportsCalls}`; at most 4, each handed out with its own ticket and `key: "decision"`). An older service, a 404 or any failure is "none". It arms each one while the agent reads the note and decides: its values are read from the turn's request and this turn's results (the reading carries `atDecision: {scenarioId, stepIndex}`), and settled. `replay.next_ready` says how many are ready.
-- The agent's next calls are checked against them before the intent probe. A call that is a next scenario's first step, **value for value** (every argument the step's own; the pin guard's "plausibly the step" is not enough), is a hit: it is answered in its place with that scenario's directive (`replay.next_hit`), the agent calls `run_scenario`, and the scenario runs every step, that one included, once. It is booked on its own ticket. A scenario whose first step is inside a sub-task (a call row) can never be the agent's call in place: it is never compared.
-- Each scenario is checkable as soon as the service answers; its arm runs on its own. A call waits only for the arm of a scenario that starts with the call's own tool (at most 6 s, `BIR_NEXT_HIT_WAIT_MS`), and not at all for the others. While the service has not answered yet, a call waits for that answer only, at most 1 s.
-- When the background reading left a value of the first step empty, the call waits while it is read once more with the agent's call as `liveCall`; the service fills such a value from the call. A value read differently is never read again: an e-mail to carlos is never the recorded e-mail to olga.
-- **A call that only reads keeps the set** (by the service's own rule, mirrored in `src/replay/reads-only.ts`: Claude Code's read tools, a name with a reading word and no writing word, a Bash command that only looks). The set ends unused (`replay.next_miss`) at the agent's first call that may change something and is no hit: `other_values` when the call has a scenario's first tool with other values, `own_way` when it starts none of them — the agent is doing a way of its own, and no scenario may start in the middle of it — and `not_ready` when the scenario that starts with that tool was not armed in time. It also ends after 5 calls that start none (`calls_limit`), or at the turn's end. A scenario not armed in time for a call that only reads misses that call only. Unused ones never run and are never reported; the agent's own work is recorded as the fragment, as before.
-- A later decision in the same turn starts a new set: what could follow the earlier one is dropped, never checked again.
-- A hit after the agent's own looks had opened the fragment ends that fragment there (`run.fragment_closed`, finished with what the agent did itself): the scenario's own calls, pinned in steer mode, are never recorded into it.
-- `/health` shows the set per session: `next: {entries, armed, calls, ended}`.
-
-**Never twice (0.3.20, offer1.md O8).** A plan an intent match arms after the agent's call — not in its place — whose steps call the same tool is not started: it would make that call a second time (issue fx2: the agent's e-mail, then the plan's own). `replay.decision code=would_repeat`. A tool that only reads, by the same rule as above (`crm_search_customers`, `Read`), may repeat. For Bash and PowerShell the call is its command: only a step that would run that very command counts.
-
 **Measured cost.**
 
 - A turn's cost is measured only when tokens were found and every model of the turn has a price in the runner's table. This holds for every host, Claude Code too. A model outside the table used to cost $0, and that zero was called measured.
@@ -735,7 +710,7 @@ Truncation is always marked with the original size.
 | Remote servers without a literal credential header (OAuth, headersHelper, `${VAR}`) are left unwrapped. Earlier unasked wraps are undone. | The proxy has none of Claude Code's OAuth credentials; wrapped, these servers answered 401 to every call. | `--server <name>` (remembered). |
 | A flag-less install from an installed package writes absolute-path entries and the self-starting SessionStart hook, for `bir wrap` too. | No npx registry round trip per server start (about 1 s), and it works offline. npx installs had nothing to start the recorder. | `--npx`. A checkout, or `bir` run through npx, still writes npx. |
 | Hook timeouts: SessionStart command 15 s (was 30), HTTP 5 (10), UserPromptSubmit 10 (15), PreToolUse 15 (30), PostToolUse and PostToolUseFailure 5 (30), Subagent 3 (5), Stop 5 (10), SessionEnd 3 (30). | The timeout is the user's worst case during an incident. The server's deadlines sit inside it. | Not configurable; `bir setup` rewrites them. |
-| From 0.3.19 segments run mid-task by default (`BIR_SEGMENT_ARM` unset means on), and so may whole plans by intent. An unsteered PreToolUse waits for the intent probe: at most `BIR_INTENT_ARM_BUDGET_MS` (500 ms), and up to 1.5 s more while an armed plan's values are read. From 0.3.0 to 0.3.18 arming was opt-in and the probe was never waited on. | A plan that stops at its decision hands the rest of the task to segments of its halves, and a segment runs only mid-task (the service's segmentsbreakdown.md SB-21). 0.2.12 held every PreToolUse up to 4 s for the probe. | `BIR_SEGMENT_ARM=0` (observe only: what would have armed is logged). `BIR_INTENT_ARM=0` arms nothing mid-task and never waits; its probes then ask for no segment, as in a session of another host, so what would have armed is logged too. |
+| Mid-turn intent arming is opt-in, and no intent probe is sent by default. | 0.2.12 held every PreToolUse up to 4 s for the probe. | `BIR_INTENT_ARM=1` with `BIR_INTENT_ARM_BUDGET_MS=4000`. |
 | The prompt match budget is 3 s (was 2.5 s), and there is a match gate: over 2 s, prompts stop waiting for 5 min, doubling to 30 min. | A healthy service answers in 300-450 ms. A slower one would otherwise cost every prompt. A false trip costs one hold of replay, never latency. | `BIR_MATCH_BUDGET_MS=2500`. Raising `BIR_MATCH_SLOW_MS` above the budget effectively disables the gate. |
 | Recorded outputs no longer stand in for a step that produced no result; the plan hands over at that step. | Last week's output presented as this turn's result is wrong data. | `BIR_REPLAY_RECORDED_OUTPUTS=1`, only for steps that could not be sent. `bir replay` keeps the stand-ins. |
 | The direct plan budget is 100 s (was 120 s), and direct runs are clamped to 270 s. | Keeps a direct run under Claude Code's 2-minute auto-background of an MCP call, and inside `run_scenario`'s client timeout. | `BIR_REPLAY_PLAN_BUDGET_MS=120000` (or `BIR_REPLAY_BUDGET_MS`). |
@@ -870,7 +845,6 @@ Truncation is always marked with the original size.
   - where recording goes, and as whom;
   - when the service last answered;
   - who approves wrapped MCP calls (the recorder's correlation mode);
-  - whether segments run mid-task (the default from 0.3.19) or are observed only, and whether whole plans may start mid-task too; a recorder older than this `bir` is named, since it keeps its old default until `bir up --restart`;
   - superseded recorders;
   - an npx-started scenario server;
   - other installed projects.
@@ -919,9 +893,7 @@ In a folder that is set up for another host (§3.2), doctor prints `Host
 | `registeredProxies[]`, `wrappedServers` | proxies that registered (`serverName`, `pid`, `cwd`, `version`) and the wrapped server names |
 | `hooksVersion`, `pid`, `cwd`, `url` | the recorder's version and identity |
 | `hostFields` | `2`: how much of another host's protocol (§3.2) this recorder understands. An adapter reads it before it relies on a field: with 1 it records, and from 2 it may also ask for a plan and step through it. A recorder that does not know another host answers no `hostFields`. |
-| `segmentArm` | whether segments the service hands out may run mid-task (default from 0.3.19: yes; `BIR_SEGMENT_ARM=0`: observed only) |
-| `intentArm` | whether a step's intent may start a plan in its own PreToolUse, which then waits for the probe. It follows `segmentArm` unless `BIR_INTENT_ARM` is set. Absent from a recorder older than 0.3.19. |
-| `sessionCount`, `sessions[]` | at most 50, active ones first: `{sessionId, runId, active, idleMs, ended, steps, recording, replay, intent, fragment}`. `replay` includes `armed`, `unannounced`, `running`, `outcome` and `handover` (`{kind, stepIndex}`; `kind` may be `decision`). `fragment` is `{state}`, with `decision: true` for one scheduled at a plan's decision. |
+| `sessionCount`, `sessions[]` | at most 50, active ones first: `{sessionId, runId, active, idleMs, ended, steps, recording, replay, intent, fragment}`. `replay` includes `armed`, `unannounced`, `running`, `outcome` and `handover`. |
 
 ### 8.4 Logs and audit lines
 
@@ -943,7 +915,7 @@ Lines read `[bir] <ISO time> <event> key=value …`, with each field clipped at
 | Hooks | `control.listening` (port, `recorder=<state>`, `correlation=`). `control.correlation_allow` (auto-approval opted in). `control.hook_deadline`, `control.hook_unauthorized` (a token from another install), `control.hook_unknown`, `control.hook_oversize`, `control.hook_event_mismatch`, `control.route_failed`, `control.drain_abandoned`. |
 | Recorder lifecycle | `daemon.restart` (replaced an older recorder), `daemon.restart_deferred` (mid-run: next start), `daemon.start_alongside`, `daemon.newer_kept`, `daemon.revived`. `control.port_busy` (holder and fix), `control.already_running`, `control.superseded`, `control.discovery_reclaimed`, `control.log_reopened`, `control.fatal`. `overrides.stale` (a local copy no longer matches its source: run `bir setup`). |
 | Proxy (MCP log) | `proxy.upstream_gone` (exiting with the server), `proxy.recorder_revive`, `tier.downgrade`, `tier.rebound`, `relay.undeliverable`. `upstream.auth_required` (the remote refused the handshake: credentials), `upstream.needs_sign_in`, `upstream.headers_invalid`, `upstream.proxy_env_ignored` (this Node cannot use HTTPS_PROXY), `upstream.proxy_env_invalid`, `upstream.standing_stream_failed` (at most hourly). Verbose only: `proxy.started`, `tier.bound`, `tier.passthrough`, `run.start` / `run.finish`, `upstream.stream_*`. |
-| Replay | `replay.enabled` (at start: servers, threshold, who derives). `plan.armed`. `replay.decision` (also `arm_timeout`, `arm_unannounced`, `no_directive`, `no_delivery_tool`, `missing_target`, `host_records_only`, `host_tool_missing`). `replay.pin`, `replay.pin_declined`, `replay.pin_abandoned`, `replay.pin_overran`, `replay.diverge`, `replay.diverge_overran`, `replay.handover`, `replay.vetoed`, `replay.unsafe_param`, `replay.derive_timeout`, `replay.budget_clamped`, `replay.concurrent_call`, `replay.no_session_proxy`, `replay.run_ambiguous`, `replay.run_abandoned`. A plan's decision (0.3.19): `replay.handover kind=decision` (`via=divergence` when a divergence's bundle ran up to it), `run.fragment … decision=true` (the agent's own work after it is recorded), `run.fragment_dropped` (a plan the intent check armed took the agent's next call, so nothing is recorded as the other half), `replay.adhoc_decision` (`bir replay` stopped in front of it). `replay.enabled` also says `segments=run mid-task`, or `observed only` with `BIR_SEGMENT_ARM=0` or `BIR_INTENT_ARM=0`. |
+| Replay | `replay.enabled` (at start: servers, threshold, who derives). `plan.armed`. `replay.decision` (also `arm_timeout`, `arm_unannounced`, `no_directive`, `no_delivery_tool`, `missing_target`, `host_records_only`, `host_tool_missing`). `replay.pin`, `replay.pin_declined`, `replay.pin_abandoned`, `replay.pin_overran`, `replay.diverge`, `replay.diverge_overran`, `replay.handover`, `replay.vetoed`, `replay.unsafe_param`, `replay.derive_timeout`, `replay.budget_clamped`, `replay.concurrent_call`, `replay.no_session_proxy`, `replay.run_ambiguous`, `replay.run_abandoned`. |
 | Run cost | `run.unmeasured` (the turn's cost is not measured: `why` gives the reason, and `models` the models that have no price in the runner's table). |
 | A host other than Claude Code (§3.2) | `run.start … host=langchain` (`bir investigate` reads the host from it, and raises no `steer_mode` finding for such a turn: steer is the full mode there), `plan.armed … mode=steer host=langchain`. `run.finish … ended=<reason>` (the run did not end with an ordinary stop). `run.unmeasured` (`why="the host sent no usage"`, a model with no price, or a run that made no model call). `run.incomplete` (the host says the recording is not the whole run: its finish carries the `incomplete` mark). `run.host_failed` (the host says the run failed: its recording is closed with that error). The service's new build never picks a run with an `error` or that mark for automatic calculation, and such a run no longer catches its prompt, unless its owner preferred it or it already has a plan (built, not deployed yet). `replay.decision verdict=no-steer code=host_records_only` (the adapter asked for no plan with its prompt) and `code=host_tool_missing` (the plan names a tool that the agent which asked does not have). `replay.own_call` (the model made a call of its own while the plan was live: the plan is handed over). `replay.step_host_stopped` (`stop=rejected` or `stop=edited`). `session.host_refused` (a scope that is empty, longer than 64 characters or not a text: nothing of that session is recorded or replayed). |
 | `bir-scenario` (MCP log) | `scenario.answered` (`ok` means results were delivered; also `partial`, `bound`), `scenario.recorder_revive`, `scenario.switched`, `scenario.hello_failed`, `scenario.tool_timeout`, `scenario.tool_truncated`. |
@@ -1071,17 +1043,17 @@ Defaults were checked in `src/`.
 | `BIR_STEP_TIMEOUT_MS` | recorder | 60000 | One direct `tools/call`. |
 | `BIR_LOGIC_TIMEOUT_MS` | recorder | 1000 (capped at 10000) | Synchronous time limit for one scenario logic body. |
 | `BIR_REPLAY_RECORDED_OUTPUTS` | recorder | unset | `1`: a step that could not be sent may use its recorded output, labelled as such. |
-| `BIR_BUILTIN_TOOLS` | recorder | `Read,Glob,Grep,Edit,Write,Bash` | Built-ins the runner executes itself during a replay, in the session's project directory and confined to it (up to 0.3.7 the default was `Read,Glob,Grep`). Runner-side steps bypass the host's permission prompts; leave a tool off to have the model call it. `none` turns it off. Not in a session of another host (§3.2): the runner runs no step itself there, whatever a tool is named. |
+| `BIR_BUILTIN_TOOLS` | recorder | `Read,Glob,Grep,Edit,Write,Bash` | Built-ins the runner executes itself during a replay, from the session's project directory; which folders the file tools may touch is `BIR_PATH_ALLOW` (up to 0.3.7 the default was `Read,Glob,Grep`). Runner-side steps bypass the host's permission prompts; leave a tool off to have the model call it. `none` turns it off. Not in a session of another host (§3.2): the runner runs no step itself there, whatever a tool is named. |
 | `BIR_BASH_ALLOW` | recorder | unset (any command) | Command prefixes a runner-side `Bash` step may run (`*` for all). Unset means any command; `none` means no command, and `Bash` steps are steered. A plan's Bash steps share a working directory, as the host's do; variables do not persist, also as the host's. |
+| `BIR_PATH_ALLOW` | recorder | unset (any folder) | Folders a runner-side `Read`, `Glob`, `Grep`, `Edit` or `Write` may touch (`*` for all). Unset means any path, as the agent's own tools (from 0.3.21; up to 0.3.20 the project directory alone). `project` is the session's project directory, `~` the home folder: `project,~/.claude`. Under a list, a path outside it, symlinks included, is `not_run` (hand-over). `none` means no folder, and file steps are steered. |
 | `BIR_DERIVE_RECENT_RESULTS` | recorder | 5 | How many of this prompt's tool results derivation may read (`0`: none). Never for plans with a command sink, and never for a plan started at the prompt: a prompt just submitted has no results yet, and an earlier prompt's are not its own. So in a session of another host, where a plan starts at the prompt only, none are read. |
 | `BIR_INTENT_MATCH` | recorder | on | `0` turns mid-turn intent probes off. |
-| `BIR_INTENT_MATCH_BUDGET_MS` | recorder | 4000 | One probe's own ceiling. It is not a hook wait. |
+| `BIR_INTENT_MATCH_BUDGET_MS` | recorder | 1500 | One probe's own ceiling. A probe is sent only with `BIR_INTENT_ARM=1`. |
 | `BIR_INTENT_MATCHES_PER_TURN` | recorder | 3 | Plans intent may arm per turn. |
 | `BIR_INTENT_REQUESTS_PER_TURN` | recorder | 40 | Probes per turn. |
 | `BIR_INTENT_SOURCES` | recorder | `text,thinking,tool` | Which text an intent may be read from. |
-| `BIR_INTENT_ARM` | recorder | unset (follows `BIR_SEGMENT_ARM`, so on from 0.3.19) | `1`: a probe may arm a plan in its own PreToolUse, and that hook waits for it. `0`: never. Never in a session of another host (§3.2), where a probe only counts. |
+| `BIR_INTENT_ARM` | recorder | unset (off) | `1`: a call the agent explained sends an intent probe, and a whole plan it matches may arm in that call's own PreToolUse, which waits for it. Unset or `0`: off — no probe is sent and nothing arms mid-turn, as up to 0.3.18. Never in a session of another host (§3.2). |
 | `BIR_INTENT_ARM_BUDGET_MS` | recorder | 500 | How long that PreToolUse waits for the probe. |
-| `BIR_SEGMENT_ARM` | recorder | on (from 0.3.19; unset or `1`) | A segment the service hands out runs mid-task: one found by repeated work, or a half after a plan's decision. `0`: observe only, where what would have armed is logged (`replay.segment_would_arm`) and nothing is replaced. Up to 0.3.18 the default was observe only. Not in a session of another host. |
 | `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). |
@@ -1139,7 +1111,6 @@ Defaults were checked in `src/`.
    - `langChainGuide.md`, which is in the repository's root and not in the npm package: its "Where it stands" table and its part 5 describe the time before the release.
 
    The install scripts cannot set a folder up for such a host, so there is no one-line install for it.
-8. **A plan's decision (0.3.19): the service first.** Deploy the service build that accepts `fallbackKind: "decision"` before 0.3.19 is published (the service's segmentsbreakdown.md section 8, step 1). An older service answers such a report 400, and the run's cost and saving are lost. Then test 0.3.18 against a plan with a decision (it stops there, reported as `known_bad_step`). The deployed service makes no split while its `SCENARIO_SPLIT` is false, so run this check on a sandbox or local service started with `SCENARIO_SPLIT=true`, with bir 0.3.18 pointed at it: set `BIR_AUTH_URL` to its address, run `bir login` (with an account on that service), then `bir up --restart` in the folder you test in. bir keeps one session, for the service that issued it: without that sign-in nothing is recorded on the local service, and while bir is signed in there, nothing on this PC is recorded on the deployed one. The service's segmentsbreakdown.md section 8, step 2, has the steps. Then point bir back: set `BIR_AUTH_URL` to the deployed service's address (removing it is not enough, since the local sign-in stored the local address), run `bir login` again, then `bir up --restart` in that folder. Then publish 0.3.19, and only then turn the deployed service's `SCENARIO_SPLIT` on.
 
 **Manual end-to-end checks with the real Claude Code.** These are behaviours of Claude Code itself, which the automated tests simulate but cannot prove. Use the Claude Code version you will support; the approval rules and hook schema were read from 2.1.280.
 

package/dist/replay/condition-words.d.ts

@@ -1,28 +0,0 @@
-/**
- * condition-words — the request's own words for its decision (the service's
- * segmentsbreakdown.md SB-18).
- *
- * When a plan stops at its decision, the hand-over note quotes the sentences
- * of the live request that hold a word for a condition ("if … otherwise"), so
- * the agent sees which choice is its own to make. Only the request's words:
- * never the condition the service keeps, which is written from the recorded
- * run and would hint at the half the recording took.
- *
- * The word lists are the service's (its src/scenarios/condition.ts), copied
- * exactly. Keep the two the same: the service decides which requests may hold
- * a condition with them, and this quotes the sentences they find.
- */
-/** The longest quote a decision note carries, in characters. */
-export declare const MAX_DECISION_QUOTE = 600;
-/** Whether a text has a word for a condition in it: the service's `mayHoldCondition`. */
-export declare function mayHoldCondition(text: string): boolean;
-/**
- * The sentences of `request` that hold a word for a condition, in order,
- * each on one line of single spaces, joined by a space. Cut to at most `max`
- * characters, ending in "…" when cut. Null when no sentence holds one.
- *
- * Lines are sentences of their own: the request is split at line breaks
- * first, then at {@link SENTENCE_BREAK}.
- */
-export declare function conditionSentences(request: string | null | undefined, max?: number): string | null;
-//# sourceMappingURL=condition-words.d.ts.map

package/dist/replay/condition-words.js

@@ -1,59 +0,0 @@
-/**
- * condition-words — the request's own words for its decision (the service's
- * segmentsbreakdown.md SB-18).
- *
- * When a plan stops at its decision, the hand-over note quotes the sentences
- * of the live request that hold a word for a condition ("if … otherwise"), so
- * the agent sees which choice is its own to make. Only the request's words:
- * never the condition the service keeps, which is written from the recorded
- * run and would hint at the half the recording took.
- *
- * The word lists are the service's (its src/scenarios/condition.ts), copied
- * exactly. Keep the two the same: the service decides which requests may hold
- * a condition with them, and this quotes the sentences they find.
- */
-/** Words that say a part of a task depends on something: English, and the Hebrew the service reads. */
-const CONDITION_WORDS = /\b(if|otherwise|else|unless|only when|only if|in case|whether)\b/i;
-const HEBREW_CONDITION = /(^|[\s,.;:!?"'()\-])(אם|אחרת|אלא אם|במקרה ש|רק אם|רק כאשר)($|[\s,.;:!?"'()\-])/;
-/** The longest quote a decision note carries, in characters. */
-export const MAX_DECISION_QUOTE = 600;
-/** Whether a text has a word for a condition in it: the service's `mayHoldCondition`. */
-export function mayHoldCondition(text) {
-    return CONDITION_WORDS.test(text) || HEBREW_CONDITION.test(text);
-}
-/**
- * Where one sentence ends and the next begins: after `.`, `!`, `?` or `…` and
- * white space, in front of a capital letter, a letter of a script with no
- * capitals (Hebrew), a quote mark or a bracket. Never in front of a digit or a
- * small letter, so "Nov. 20" and "e.g. the" stay in one sentence.
- */
-const SENTENCE_BREAK = /(?<=[.!?…])\s+(?=[\p{Lu}\p{Lo}"'“‘(\[])/u;
-/**
- * The sentences of `request` that hold a word for a condition, in order,
- * each on one line of single spaces, joined by a space. Cut to at most `max`
- * characters, ending in "…" when cut. Null when no sentence holds one.
- *
- * Lines are sentences of their own: the request is split at line breaks
- * first, then at {@link SENTENCE_BREAK}.
- */
-export function conditionSentences(request, max = MAX_DECISION_QUOTE) {
-    if (typeof request !== "string" || request.trim() === "")
-        return null;
-    const sentences = request
-        .replace(/\r\n?/g, "\n")
-        .split("\n")
-        .flatMap((line) => line.split(SENTENCE_BREAK))
-        .map((s) => s.replace(/\s+/g, " ").trim())
-        .filter((s) => s !== "" && mayHoldCondition(s));
-    if (sentences.length === 0)
-        return null;
-    const quote = sentences.join(" ");
-    if (quote.length <= max)
-        return quote;
-    let cut = quote.slice(0, Math.max(0, max - 1));
-    // Never half of a character written as two code units (an emoji).
-    if (/[\uD800-\uDBFF]$/.test(cut))
-        cut = cut.slice(0, -1);
-    return `${cut.trimEnd()}…`;
-}
-//# sourceMappingURL=condition-words.js.map

package/dist/replay/flatten.d.ts

@@ -1,161 +0,0 @@
-/**
- * Flattening calls into frames (segmented.md 10.6).
- *
- * A chain may hold a **call**: one row that says "here the agent does this
- * sub-task", answered by a recorded scenario the service inlines into the
- * payload. Running it is not a second plan. It is one plan over one flat list
- * of steps, in which some steps belong to another scenario and run with *its*
- * parameters, *its* intent and *its* accumulated values.
- *
- * That is what a **frame** is: the scope one stretch of steps runs in. Frame 0
- * is the caller's own. Entering a called frame evaluates the call's
- * `paramMapLogic` to build the segment's parameters; leaving it evaluates
- * `resultMapLogic` and merges the result back into the caller's `respParams`
- * (R-CALL-29).
- *
- * Everything downstream reads the flat list rather than the chain: the gates
- * judge the steps that will really run (R-CALL-30), recorded outputs come from
- * the right recording and range (R-CALL-31), and a failure is reported on the
- * scenario that owns the step (R-CALL-13).
- *
- * The flattener itself decides nothing about *which* segment answers a call —
- * the service did that long before this payload was built. It only lays out
- * what it was served, and stops in front of anything it cannot run.
- */
-import type { SerializedScenario, SerializedScenarioStep, CallUnusable, StepTest } from "./types.js";
-import type { ParamsSchema } from "./types.js";
-/** The scope one stretch of steps runs in. Frame 0 is the caller's own. */
-export interface Frame {
-    id: number;
-    /** 0 for the caller, 1 for a segment it calls, 2 for one that segment calls. */
-    depth: number;
-    scenarioId: string;
-    runId: string;
-    /** The recorded range the frame's outputs come from. Null means the whole run. */
-    stepFrom: number | null;
-    stepTo: number | null;
-    /** The intent the frame's step logic runs with (R-INTENT-12). */
-    intent: string;
-    parent?: Frame;
-    /** The caller's chain `stepIndex` of the call row that opened this frame. */
-    callerStepIndex?: number;
-    callIntent?: string;
-    paramMapLogic?: string;
-    resultMapLogic?: string;
-    segmentId?: string;
-    /** The inlined segment's `chainRevision` as served (R-CALL-13). */
-    chainRevision?: number;
-    /** The segment's own parameters, for the settings a mapping omits (R-CALL-21). */
-    paramsObject?: ParamsSchema | null;
-    /**
-     * The call row that opened this frame, when it carries a test (the
-     * service's autocorrect.md AC5): the whole sub-task runs only when the test
-     * says so. It is evaluated in the *caller's* frame, before this one is
-     * entered.
-     */
-    when?: StepTest;
-    /** That call row itself, for the verdict a sub-task left out gets. */
-    callStep?: SerializedScenarioStep;
-    /** Filled by the plan when the frame is entered. */
-    parameters?: Record<string, unknown>;
-    respParams: Record<string, unknown>;
-}
-/** One step that will really run, with the frame it runs in. */
-export interface FlatEntry {
-    scenarioId: string;
-    runId: string;
-    stepFrom: number | null;
-    stepTo: number | null;
-    /** The owning scenario's own `scenario_steps.step_index`, not a flat position. */
-    stepIndex: number;
-    /** Always a tool row: a call row becomes a frame, or a stop. */
-    step: SerializedScenarioStep;
-    frame: Frame;
-    depth: number;
-    /**
-     * First / last of its frame's *own* entries. Where a frame is entered and
-     * left is {@link frameEdges}: a frame whose chain begins or ends with a
-     * call begins or ends with that call's steps.
-     */
-    first: boolean;
-    last: boolean;
-}
-/** Why the flat list stops short, and which call row said so. */
-export interface FlatStop {
-    kind: "unusable";
-    reason: CallUnusable;
-    /** The scenario whose chain holds the call row. */
-    scenarioId: string;
-    /** That call row's own `stepIndex`. */
-    stepIndex: number;
-    segmentId?: string | null;
-    callIntent?: string | null;
-}
-export interface FlatChain {
-    entries: FlatEntry[];
-    /** Flat position the plan stops in front of. Undefined means the whole chain. */
-    stopAt?: number;
-    stopReason?: FlatStop;
-}
-/**
- * Mirrors the service's `SEGMENT_MAX_DEPTH`. A constant, not a setting: one
- * call row holds one answer, which is only correct because a call inside a
- * level-two segment is never answered (R-CALL-12).
- */
-export declare const MAX_CALL_DEPTH = 2;
-/**
- * Lay a served chain out as one flat list of steps, with a frame per call.
- *
- * Stops at the first call it cannot run. The stop is *clamped* to the start of
- * the outermost called frame that contains it: a plan must never run half a
- * sub-task and leave its `resultMapLogic` unevaluated, because the caller's
- * later steps read what that body returns (R-CALL-30).
- */
-export declare function flattenChain(scenario: SerializedScenario, opts?: {
-    maxDepth?: number;
-    /** The range a segment armed on its own covers (its own recording). */
-    range?: {
-        stepFrom: number;
-        stepTo: number;
-    } | null;
-}): FlatChain;
-/**
- * Move a stop back to the start of the outermost called frame it falls in
- * (R-CALL-30, 10.6 step 3).
- *
- * Used for the known-bad-step gate, which judges entries: a parked step in the
- * middle of a sub-task stops the plan in front of the *sub-task*, not in front
- * of the step, because stopping inside it would skip the body that hands its
- * results back. The sub-task starts at its first entry *or its callee's*: one
- * whose chain begins with a call starts where that call's steps do.
- */
-export declare function clampToFrameStart(entries: readonly FlatEntry[], index: number): number;
-/**
- * Where each called frame begins and ends in the flat list, its callees'
- * entries included — not where its *own* entries do (`first` / `last`).
- *
- * The two differ when a sub-task's chain begins or ends with a call: for
- * F = [call G, f1] the flat order is g0, g1, f1, and F begins at g0. Entering
- * F there, before G, is what gives G's mapping (and G's test) F's parameters;
- * deciding F's own test there is what keeps G from running when F is not
- * needed (the service's autocorrect.md AC5). Leaving F after the last of
- * them is what hands G's results on through F.
- */
-export interface FrameEdges {
-    /** Per frame id, the flat position of its first entry, its callees' included. */
-    start: Map<number, number>;
-    /** Per frame id, the flat position of its last entry, its callees' included. */
-    end: Map<number, number>;
-    /** Per flat position, the called frames that begin there, outermost first. */
-    startsAt: Map<number, Frame[]>;
-    /** Per flat position, the called frames that end there, innermost first. */
-    endsAt: Map<number, Frame[]>;
-}
-export declare function frameEdges(entries: readonly FlatEntry[]): FrameEdges;
-/**
- * One frame per chain, for a payload with no calls in it and for the callers
- * that build a plan by hand (tests, `bir replay`). Byte for byte the old
- * behaviour: one frame, one scenario, one range.
- */
-export declare function flatEntriesOf(scenario: SerializedScenario): FlatEntry[];
-//# sourceMappingURL=flatten.d.ts.map

package/dist/replay/flatten.js

@@ -1,222 +0,0 @@
-/**
- * Flattening calls into frames (segmented.md 10.6).
- *
- * A chain may hold a **call**: one row that says "here the agent does this
- * sub-task", answered by a recorded scenario the service inlines into the
- * payload. Running it is not a second plan. It is one plan over one flat list
- * of steps, in which some steps belong to another scenario and run with *its*
- * parameters, *its* intent and *its* accumulated values.
- *
- * That is what a **frame** is: the scope one stretch of steps runs in. Frame 0
- * is the caller's own. Entering a called frame evaluates the call's
- * `paramMapLogic` to build the segment's parameters; leaving it evaluates
- * `resultMapLogic` and merges the result back into the caller's `respParams`
- * (R-CALL-29).
- *
- * Everything downstream reads the flat list rather than the chain: the gates
- * judge the steps that will really run (R-CALL-30), recorded outputs come from
- * the right recording and range (R-CALL-31), and a failure is reported on the
- * scenario that owns the step (R-CALL-13).
- *
- * The flattener itself decides nothing about *which* segment answers a call —
- * the service did that long before this payload was built. It only lays out
- * what it was served, and stops in front of anything it cannot run.
- */
-/**
- * Mirrors the service's `SEGMENT_MAX_DEPTH`. A constant, not a setting: one
- * call row holds one answer, which is only correct because a call inside a
- * level-two segment is never answered (R-CALL-12).
- */
-export const MAX_CALL_DEPTH = 2;
-/**
- * Lay a served chain out as one flat list of steps, with a frame per call.
- *
- * Stops at the first call it cannot run. The stop is *clamped* to the start of
- * the outermost called frame that contains it: a plan must never run half a
- * sub-task and leave its `resultMapLogic` unevaluated, because the caller's
- * later steps read what that body returns (R-CALL-30).
- */
-export function flattenChain(scenario, opts = {}) {
-    const maxDepth = opts.maxDepth ?? MAX_CALL_DEPTH;
-    const entries = [];
-    let frameId = 0;
-    let stopAt;
-    let stopReason;
-    const root = {
-        id: frameId++,
-        depth: 0,
-        scenarioId: scenario.id,
-        runId: scenario.runId,
-        stepFrom: opts.range?.stepFrom ?? null,
-        stepTo: opts.range?.stepTo ?? null,
-        intent: scenario.intent ?? "",
-        respParams: {},
-    };
-    /** The entry a frame's steps start at, for the clamp. */
-    const frameStart = new Map();
-    const walk = (steps, frame, stack) => {
-        for (const step of steps) {
-            if (stopAt !== undefined)
-                return;
-            if (step.kind !== "segment") {
-                entries.push({
-                    scenarioId: frame.scenarioId,
-                    runId: frame.runId,
-                    stepFrom: frame.stepFrom,
-                    stepTo: frame.stepTo,
-                    stepIndex: step.stepIndex,
-                    step,
-                    frame,
-                    depth: frame.depth,
-                    first: false,
-                    last: false,
-                });
-                continue;
-            }
-            // A call the service already marked unrunnable, a third level, or a
-            // segment already on this stack (which would be a cycle): all the same
-            // thing to a plan — it stops here and the agent takes over (R-CALL-29).
-            const cycles = !!step.segment && stack.includes(step.segment.id);
-            const tooDeep = frame.depth + 1 > maxDepth;
-            const reason = step.unusable
-                ? step.unusable
-                : !step.segment || cycles || tooDeep
-                    ? "depth"
-                    : undefined;
-            if (reason) {
-                // The clamp: a stop inside a called frame moves back to the first entry
-                // of the outermost called frame containing it, so the caller never runs
-                // part of a sub-task (R-CALL-30).
-                let outermost = frame;
-                while (outermost && outermost.depth > 1)
-                    outermost = outermost.parent;
-                stopAt =
-                    frame.depth > 0 && outermost
-                        ? (frameStart.get(outermost.id) ?? entries.length)
-                        : entries.length;
-                stopReason = {
-                    kind: "unusable",
-                    reason,
-                    scenarioId: frame.scenarioId,
-                    stepIndex: step.stepIndex,
-                    segmentId: step.segmentId ?? step.segment?.id ?? null,
-                    callIntent: step.callIntent ?? null,
-                };
-                return;
-            }
-            const segment = step.segment;
-            const child = {
-                id: frameId++,
-                depth: frame.depth + 1,
-                scenarioId: segment.id,
-                runId: segment.runId,
-                stepFrom: segment.stepFrom,
-                stepTo: segment.stepTo,
-                intent: segment.intent ?? "",
-                parent: frame,
-                callerStepIndex: step.stepIndex,
-                callIntent: step.callIntent ?? undefined,
-                paramMapLogic: step.paramMapLogic ?? undefined,
-                resultMapLogic: step.resultMapLogic ?? undefined,
-                segmentId: segment.id,
-                chainRevision: segment.chainRevision,
-                paramsObject: segment.paramsObject ?? null,
-                // A sub-task may run only when a test says so (AC5): the plan decides
-                // the whole frame at its first entry, in the caller's scope.
-                ...(step.when ? { when: step.when } : {}),
-                callStep: step,
-                respParams: {},
-            };
-            frameStart.set(child.id, entries.length);
-            walk(segment.steps ?? [], child, [...stack, segment.id]);
-        }
-    };
-    frameStart.set(root.id, 0);
-    walk(scenario.steps ?? [], root, [scenario.id]);
-    // `first` / `last` per frame, marked once the whole list is known: they are
-    // where the two mapping bodies run. A frame's entries are not necessarily
-    // contiguous — a call sitting in the middle of a chain interleaves its
-    // callee's entries with its own — so these are the frame's first and last
-    // entries overall, never the edges of a run of them.
-    const firstOf = new Map();
-    const lastOf = new Map();
-    entries.forEach((entry, index) => {
-        if (!firstOf.has(entry.frame.id))
-            firstOf.set(entry.frame.id, index);
-        lastOf.set(entry.frame.id, index);
-    });
-    entries.forEach((entry, index) => {
-        entry.first = firstOf.get(entry.frame.id) === index;
-        entry.last = lastOf.get(entry.frame.id) === index;
-    });
-    return { entries, stopAt, stopReason };
-}
-/** Whether `frame` is `outer` or lies inside it. */
-function within(frame, outer) {
-    for (let f = frame; f; f = f.parent)
-        if (f.id === outer.id)
-            return true;
-    return false;
-}
-/**
- * Move a stop back to the start of the outermost called frame it falls in
- * (R-CALL-30, 10.6 step 3).
- *
- * Used for the known-bad-step gate, which judges entries: a parked step in the
- * middle of a sub-task stops the plan in front of the *sub-task*, not in front
- * of the step, because stopping inside it would skip the body that hands its
- * results back. The sub-task starts at its first entry *or its callee's*: one
- * whose chain begins with a call starts where that call's steps do.
- */
-export function clampToFrameStart(entries, index) {
-    const at = entries[index];
-    if (!at || at.depth === 0)
-        return index;
-    let outermost = at.frame;
-    while (outermost && outermost.depth > 1)
-        outermost = outermost.parent;
-    if (!outermost)
-        return index;
-    for (let i = 0; i < entries.length; i += 1) {
-        if (within(entries[i].frame, outermost))
-            return i;
-    }
-    return index;
-}
-export function frameEdges(entries) {
-    const start = new Map();
-    const end = new Map();
-    const frames = new Map();
-    entries.forEach((entry, index) => {
-        for (let f = entry.frame; f; f = f.parent) {
-            frames.set(f.id, f);
-            if (!start.has(f.id))
-                start.set(f.id, index);
-            end.set(f.id, index);
-        }
-    });
-    const startsAt = new Map();
-    const endsAt = new Map();
-    for (const f of frames.values()) {
-        if (f.depth === 0)
-            continue;
-        const s = start.get(f.id);
-        const e = end.get(f.id);
-        startsAt.set(s, [...(startsAt.get(s) ?? []), f]);
-        endsAt.set(e, [...(endsAt.get(e) ?? []), f]);
-    }
-    for (const list of startsAt.values())
-        list.sort((a, b) => a.depth - b.depth);
-    for (const list of endsAt.values())
-        list.sort((a, b) => b.depth - a.depth);
-    return { start, end, startsAt, endsAt };
-}
-/**
- * One frame per chain, for a payload with no calls in it and for the callers
- * that build a plan by hand (tests, `bir replay`). Byte for byte the old
- * behaviour: one frame, one scenario, one range.
- */
-export function flatEntriesOf(scenario) {
-    return flattenChain(scenario).entries;
-}
-//# sourceMappingURL=flatten.js.map

package/dist/replay/reads-only.d.ts

@@ -1,29 +0,0 @@
-/**
- * Whether a tool call may change something, judged by its name alone — the
- * runner's copy of the service's own rule (BaseIn src/scenarios/correctionCheck.ts,
- * `readsOnly`, `commandReadsOnly`, `callMayChange`), kept word for word so the
- * two never disagree about the same call.
- *
- * Used where a call after a plan's decision is the agent starting a way of its
- * own (the service's offer1.md O7), and where a plan started after a call
- * would make it a second time (O8). When in doubt, a call is a change: that
- * only ends a set of scenarios early or keeps a plan from starting, never lets
- * a second write through.
- */
-/**
- * A tool that only reads: Claude Code's read-only tools, then the name — a
- * reading word and no writing word (`calendar_search_events`, `getJiraIssue`;
- * `run_sql` no: `run` writes). A name with both (`get_or_create_contact`)
- * changes something.
- */
-export declare function readsOnly(toolName: string): boolean;
-/** Whether a shell command only looks: every part of it is a looking command, and nothing is written to a file. */
-export declare function commandReadsOnly(command: string): boolean;
-/**
- * Whether one call may change something. A Bash call changes nothing only
- * when its command is there and only looks; any other tool is a change unless
- * {@link readsOnly} says it only reads — a tool it cannot tell about counts as
- * a change. `input` is the call's arguments, as an object or as JSON text.
- */
-export declare function callMayChange(toolName: string, input: unknown): boolean;
-//# sourceMappingURL=reads-only.d.ts.map