@basein/runner 0.3.21 → 0.3.22

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