@basein/runner 0.3.16 → 0.3.18

package/dist/replay/plan.js

@@ -25,9 +25,93 @@ import { flatEntriesOf, frameEdges } from "./flatten.js";
 import { assembleBundle, bundleInput, MAX_REPLAY_REASON, testWords } from "./bundle.js";
 import { redact, redactText } from "../record/redact.js";
 import { sinkOfPlan, unsafeParameter } from "./safety.js";
+import { testedOnlyTargets } from "./targets.js";
 import { errText } from "../util/log.js";
 import { awaitWithin } from "../util/service-health.js";
 import { isMissingToolError, toolResultError } from "./tool-error.js";
+/**
+ * A value a step of the recording worked out — an address the directory
+ * returned, the id a search found; the service labels it `from: "step"` —
+ * is never replayed from the recording (issue 1212). The plan holds this mark
+ * in its place. A step whose input still holds it, because its earlier steps
+ * did not return the value and its code fell back on the parameter, stops the
+ * plan in front of it, for the agent; a summary that holds it is left out.
+ * Never the recorded e-mail address, never the recorded lead.
+ */
+export const FROM_STEP_MARK = "\u2063bir-from-step:";
+const markOf = (key) => `${FROM_STEP_MARK}${key}\u2063`;
+/**
+ * A value the request did not give, which only the steps of one half of an
+ * "if \u2026 otherwise" read (the service's review of calcscenarioautocorrect.md,
+ * item 11; targets.ts, `testedOnlyTargets`). The plan arms without it \u2014 the
+ * other half needs nothing it lacks \u2014 and holds this mark in its place, never
+ * `null` and never the recorded value. A step whose input reads or holds it
+ * stops in front of its call, and the agent does that half; a test that reads
+ * it decides nothing; a summary that reads it is left out.
+ */
+export const MISSING_VALUE_MARK = "\u2063bir-missing:";
+const missingMarkOf = (key) => `${MISSING_VALUE_MARK}${key}\u2063`;
+/**
+ * The plan's values a step worked out in the recording: settings labelled
+ * `step` that code found in an earlier step's output (`verified`), so the
+ * plan's own steps have them. One the calculation only claimed has no such
+ * source, and keeps its recorded value as before.
+ */
+function fromStepKeys(schema) {
+    if (!schema || typeof schema !== "object")
+        return [];
+    return Object.entries(schema)
+        .filter(([, p]) => p?.kind === "setting" && p.from === "step" && p.verified === true)
+        .map(([key]) => key);
+}
+/**
+ * A step's code read a value a step works out, which here only the recording
+ * holds (issue 1212). Not a fault of the step: its earlier steps did not
+ * return the value this time. The plan stops in front of it, the step counts
+ * as not run, and the agent does the rest.
+ */
+export class RecordedValueError extends Error {
+    key;
+    constructor(key, message) {
+        super(message ?? `the value "${key}" was not in what the earlier steps returned, and a replay never takes it from the recording`);
+        this.name = "RecordedValueError";
+        this.key = key;
+    }
+}
+/**
+ * A step's code read a value the request did not give ({@link
+ * MISSING_VALUE_MARK}). The same stop as {@link RecordedValueError} \u2014 not a
+ * fault of the step: it counts as not run, nothing is parked or repaired, and
+ * the agent does the rest \u2014 so it is one, and every place that tells that
+ * stop apart tells this one apart too. Its words name the value.
+ */
+export class MissingValueError extends RecordedValueError {
+    constructor(key) {
+        super(key, `a value the request did not give: ${key}`);
+        this.name = "MissingValueError";
+    }
+}
+/** The first mark `value` holds anywhere, and which kind it is. */
+function markIn(value) {
+    let text;
+    try {
+        text = typeof value === "string" ? value : (JSON.stringify(value) ?? "");
+    }
+    catch {
+        return undefined;
+    }
+    const step = text.indexOf(FROM_STEP_MARK);
+    const missing = text.indexOf(MISSING_VALUE_MARK);
+    if (step === -1 && missing === -1)
+        return undefined;
+    const isMissing = missing !== -1 && (step === -1 || missing < step);
+    const at = isMissing ? missing + MISSING_VALUE_MARK.length : step + FROM_STEP_MARK.length;
+    return { key: text.slice(at).split("\u2063")[0], missing: isMissing };
+}
+/** The value a mark stands for, when `value` holds one anywhere \u2014 either kind. */
+export function markedKey(value) {
+    return markIn(value)?.key;
+}
 /** A rejection from an {@link ExecuteStep} that says what happened to the call. */
 export class StepRunError extends Error {
     rejection;
@@ -229,7 +313,8 @@ function reportingStage(onStep, entry, stage, input, startedAt, fn, output) {
             entry,
             input,
             output,
-            outcome: "failed",
+            // A value only the recording holds is no fault of the step's (issue 1212).
+            outcome: err instanceof RecordedValueError ? "skipped" : "failed",
             stage,
             error: err instanceof Error ? err.message : String(err),
             ms: Date.now() - startedAt,
@@ -246,6 +331,16 @@ export class ScenarioReplayPlan {
     /** The flat list this plan walks. One entry per step that will really run. */
     entries;
     paramsPromise;
+    /** The values a step worked out in the recording ({@link FROM_STEP_MARK}). */
+    fromStep;
+    /**
+     * The targets only the steps of one half read (targets.ts,
+     * `testedOnlyTargets`): each held as {@link MISSING_VALUE_MARK} when the
+     * request does not give it.
+     */
+    oneHalf;
+    /** Of {@link oneHalf}, the ones the request did not give: held as the mark now. */
+    missingMarked = [];
     params = {};
     /** The derivation's own answer, before `paramsLogic`. What safety.ts judges. */
     derivedParams = {};
@@ -279,6 +374,7 @@ export class ScenarioReplayPlan {
         this.entries = opts.entries ?? flatEntriesOf(opts.scenario);
         this.mode = opts.mode;
         this.paramsPromise = opts.params;
+        this.fromStep = fromStepKeys(opts.scenario.paramsObject);
         this.fallbackTargets = opts.fallbackTargets ?? "null";
         this.respParams = { ...(opts.respParamsInit ?? {}) };
         // The caller's own frame accumulates into the plan's `respParams`, so
@@ -291,6 +387,12 @@ export class ScenarioReplayPlan {
             typeof stop === "number" && stop >= 0 && stop < this.entries.length
                 ? stop
                 : this.entries.length;
+        // Judged over the steps this plan will run, as the gate that armed it was.
+        const schema = opts.scenario.paramsObject;
+        this.oneHalf =
+            schema && typeof schema === "object"
+                ? testedOnlyTargets(Object.keys(schema).filter((k) => schema[k]?.kind !== "setting"), schema, this.entries.slice(0, this.stopAt), opts.scenario.paramsLogic)
+                : [];
         this.edges = frameEdges(this.entries);
         this.entries.forEach((entry, index) => {
             this.positions.set(entry, index);
@@ -477,13 +579,17 @@ export class ScenarioReplayPlan {
         if (this.paramsSettled)
             return Promise.resolve();
         if (!this.readyPromise) {
-            this.readyPromise = this.paramsPromise
+            const source = this.paramsPromise;
+            this.readyPromise = source
                 .then((derived) => derived, () => undefined)
                 .then((derived) => {
                 // Settled already, without the derivation: a late answer must not
                 // change the parameters under steps that ran on the others.
                 if (this.paramsSettled)
                     return;
+                // Read again since (`resetParams`): this answer is no one's now.
+                if (this.paramsPromise !== source)
+                    return;
                 this.settleParams(derived ?? this.fallbackValues());
             });
         }
@@ -508,6 +614,20 @@ export class ScenarioReplayPlan {
             return;
         this.settleParams(this.fallbackValues());
     }
+    /**
+     * The values read again, before any step ran (issue 1212): the agent's own
+     * day showed in the session only after the first reading. False once a step
+     * has run, when the values the steps ran on are the ones that stand.
+     */
+    resetParams(params) {
+        if (this.stepIndex > 0)
+            return false;
+        params.catch(() => undefined);
+        this.paramsPromise = params;
+        this.readyPromise = undefined;
+        this.paramsSettled = false;
+        return true;
+    }
     /** Whether the parameters are final. */
     get parametersSettled() {
         return this.paramsSettled;
@@ -530,9 +650,28 @@ export class ScenarioReplayPlan {
     settleParams(derived) {
         const own = { ...derived };
         let params = { ...derived };
+        // A value a step worked out: its mark, never the recorded value (issue 1212).
+        for (const key of this.fromStep) {
+            delete own[key];
+            params[key] = markOf(key);
+        }
+        // A value only one half reads, which this request did not give (review
+        // item 11): its mark, never `null` — a step with a null in its input would
+        // still run — and never the recorded value.
+        const missing = this.oneHalf.filter((key) => derived[key] === null || derived[key] === undefined);
+        for (const key of missing)
+            params[key] = missingMarkOf(key);
         if (this.scenario.paramsLogic) {
             params = evalParamsLogic(this.scenario.paramsLogic, params, this.intent);
+            // And after `paramsLogic` too, whatever it made of the key: dropped, a
+            // step would read `undefined`; replaced, a default someone typed —
+            // either way a value this request did not give (targets.ts). On a copy:
+            // what the body returned may be frozen.
+            if (missing.length > 0) {
+                params = { ...params, ...Object.fromEntries(missing.map((key) => [key, missingMarkOf(key)])) };
+            }
         }
+        this.missingMarked = missing;
         this.derivedParams = own;
         this.params = params;
         this.paramsSettled = true;
@@ -571,7 +710,45 @@ export class ScenarioReplayPlan {
     }
     /** The parameters in force. Empty until {@link ready} resolves. */
     get parameters() {
-        return this.params;
+        // For the agent's eyes (the hand-over note): never a mark.
+        if (this.fromStep.length === 0 && this.missingMarked.length === 0)
+            return this.params;
+        return Object.fromEntries(Object.entries(this.params).filter(([, v]) => markedKey(v) === undefined));
+    }
+    /**
+     * The values a body may not use: a value a step works out ({@link
+     * FROM_STEP_MARK}) and a value the request did not give ({@link
+     * MISSING_VALUE_MARK}). A read of one is the stop {@link valueError} names.
+     */
+    watchedKeys() {
+        return this.missingMarked.length === 0 ? this.fromStep : [...this.fromStep, ...this.missingMarked];
+    }
+    /** The stop a read of `key` means: a value the request did not give, or one only the recording had. */
+    valueError(key) {
+        return this.missingMarked.includes(key) ? new MissingValueError(key) : new RecordedValueError(key);
+    }
+    /**
+     * `parameters` for one body, with every read of a value a step works out
+     * noted (issue 1212): a read is the recorded value used, however the code
+     * changes it afterwards — upper-cased, encoded, sliced or counted. A value
+     * the request did not give is watched the same way (review item 11).
+     */
+    watched(params) {
+        const read = new Set();
+        const watchedKeys = this.watchedKeys();
+        if (watchedKeys.length === 0)
+            return { params, read };
+        const keys = new Set(watchedKeys);
+        return {
+            read,
+            params: new Proxy(params, {
+                get(target, key, receiver) {
+                    if (typeof key === "string" && keys.has(key))
+                        read.add(key);
+                    return Reflect.get(target, key, receiver);
+                },
+            }),
+        };
     }
     /** Everything the steps have accumulated so far. */
     get accumulated() {
@@ -626,7 +803,25 @@ export class ScenarioReplayPlan {
         // the first moment the caller's own accumulation is final (R-CALL-29) —
         // unless the step's test needed the frame first (AC5).
         this.enterFramesAt(this.stepIndex, this.walk);
-        return evalToolInputLogic(entry.step.toolInputLogic ?? "return {};", this.paramsFor(entry), entry.frame.intent, this.respFor(entry));
+        return this.inputOf(entry, this.paramsFor(entry), entry.frame.intent, this.respFor(entry));
+    }
+    /**
+     * A step's input, refused when it holds a value only the recording had: its
+     * code fell back on a parameter a step works out, and the earlier steps did
+     * not return it (issue 1212). The caller stops the plan in front of it. So
+     * is one that reads, or holds, a value the request did not give (review
+     * item 11): {@link MissingValueError}.
+     */
+    inputOf(entry, params, intent, resp, opts) {
+        const w = this.watched(params);
+        const input = evalToolInputLogic(entry.step.toolInputLogic ?? "return {};", w.params, intent, resp, opts);
+        const read = [...w.read][0];
+        if (read !== undefined)
+            throw this.valueError(read);
+        const held = markIn(input);
+        if (held)
+            throw held.missing ? new MissingValueError(held.key) : new RecordedValueError(held.key);
+        return input;
     }
     // ── tests (the service's autocorrect.md AC5) ──────────────────────────────
     //
@@ -680,7 +875,14 @@ export class ScenarioReplayPlan {
     /** One test, answered — or the reason it could not be. Never throws. */
     answer(test, params, intent, resp) {
         try {
-            return { yes: evalWhenLogic(test.logic, params, intent, resp) };
+            const w = this.watched(params);
+            const yes = evalWhenLogic(test.logic, w.params, intent, resp);
+            // A test on a value only the recording holds decides nothing (issue
+            // 1212), and nor does one on a value the request did not give (item 11).
+            const key = [...w.read][0];
+            if (key !== undefined)
+                return { error: this.valueError(key).message };
+            return { yes };
         }
         catch (err) {
             return { error: errText(err) };
@@ -910,9 +1112,25 @@ export class ScenarioReplayPlan {
     }
     /** Build the final response model from everything the steps accumulated. */
     responseModel() {
-        if (!this.scenario.responseParamsLogic)
-            return { ...this.respParams };
-        return evalResponseParamsLogic(this.scenario.responseParamsLogic, this.respParams, this.params, this.intent);
+        const w = this.watched(this.params);
+        const model = this.scenario.responseParamsLogic
+            ? evalResponseParamsLogic(this.scenario.responseParamsLogic, this.respParams, w.params, this.intent)
+            : { ...this.respParams };
+        // The answer's code read a value only the recording had (issue 1212): its
+        // summary would name the recorded address and the recorded lead. Left out.
+        // So is one that read a value the request did not give (review item 11):
+        // it would name a mark, or what the code made of one.
+        const read = [...w.read];
+        const held = markIn(model);
+        if (read.length > 0 || held) {
+            const missing = read.length > 0 ? read.every((k) => this.missingMarked.includes(k)) : held.missing;
+            return {
+                summaryLeftOut: missing
+                    ? "The plan's summary read a value this request did not give, so it is left out: answer from the steps' own results."
+                    : "The plan's summary read values recorded from another run, so it is left out: answer from the steps' own results.",
+            };
+        }
+        return model;
     }
     /**
      * The arguments each planned step will run with, where they are known before
@@ -963,7 +1181,7 @@ export class ScenarioReplayPlan {
                 });
             let input;
             try {
-                input = evalToolInputLogic(entry.step.toolInputLogic ?? "return {};", params, entry.frame.intent, resp, { timeoutMs: Math.min(bodyMs, left) });
+                input = this.inputOf(entry, params, entry.frame.intent, resp, { timeoutMs: Math.min(bodyMs, left) });
             }
             catch (err) {
                 // A body that throws (often on an earlier result it does not have
@@ -1220,7 +1438,7 @@ export class ScenarioReplayPlan {
                 computed = reportingStage(onStep, entry, "tool_input_logic", {}, startedAt, () => {
                     this.enterFramesAt(flatIndex, walk);
                     const respParams = resp.get(entry.frame.id) ?? {};
-                    return evalToolInputLogic(step.toolInputLogic ?? "return {};", this.paramsFor(entry), entry.frame.intent, respParams);
+                    return this.inputOf(entry, this.paramsFor(entry), entry.frame.intent, respParams);
                 });
             }
             catch (err) {
@@ -1232,6 +1450,7 @@ export class ScenarioReplayPlan {
                     flatIndex,
                     stage: "tool_input_logic",
                     error: errText(err),
+                    ...(err instanceof RecordedValueError ? { reason: "not_run" } : {}),
                 };
                 break;
             }
@@ -1330,6 +1549,7 @@ export class ScenarioReplayPlan {
                 // left out a sub-task reaching past the parked step did not stop short.
                 handover: (opts.handover === true && flatIndex <= this.stopAt) || stopped !== undefined,
                 subTask: this.subTask,
+                reportTool: opts.reportTool,
             }),
             executed,
             recorded: recordedCount,
@@ -1418,6 +1638,7 @@ export class ScenarioReplayPlan {
                     flatIndex,
                     stage: "tool_input_logic",
                     error: errText(err),
+                    ...(err instanceof RecordedValueError ? { reason: "not_run" } : {}),
                 };
                 break;
             }
@@ -1516,6 +1737,7 @@ export class ScenarioReplayPlan {
             text: assembleBundle(entries, maxChars, {
                 handover: stopped !== undefined,
                 subTask: this.subTask,
+                reportTool: opts.reportTool,
             }),
             executed,
             recorded: recordedCount,

package/dist/replay/source-run.d.ts

@@ -68,8 +68,8 @@ export declare class SourceRunCache {
     /**
      * A step its test left out (the service's autocorrect.md AC5). Every step
      * of a plan was in the recording, and made its call there — unless a
-     * correction added it from the agent's redo (`correctionKind: "added"`),
-     * which made none. So one that was in it passes over its recorded output,
+     * correction added it from the agent's redo (`correctionKind: "added"`)
+     * or wrote it from the agent's answer (`"written"`, AC12), which made none. So one that was in it passes over its recorded output,
      * and the next step of its tool takes its own; an added one passes over
      * nothing. Nothing is fetched: the cursor is a count of this frame's calls
      * of the tool, whichever of them are read later (docs/calculatedReplay.md

package/dist/replay/source-run.js

@@ -90,8 +90,8 @@ export class SourceRunCache {
     /**
      * A step its test left out (the service's autocorrect.md AC5). Every step
      * of a plan was in the recording, and made its call there — unless a
-     * correction added it from the agent's redo (`correctionKind: "added"`),
-     * which made none. So one that was in it passes over its recorded output,
+     * correction added it from the agent's redo (`correctionKind: "added"`)
+     * or wrote it from the agent's answer (`"written"`, AC12), which made none. So one that was in it passes over its recorded output,
      * and the next step of its tool takes its own; an added one passes over
      * nothing. Nothing is fetched: the cursor is a count of this frame's calls
      * of the tool, whichever of them are read later (docs/calculatedReplay.md
@@ -99,7 +99,7 @@ export class SourceRunCache {
      */
     leftOut(entry) {
         const toolName = entry.step.toolName;
-        if (!toolName || entry.step.correctionKind === "added")
+        if (!toolName || entry.step.correctionKind === "added" || entry.step.correctionKind === "written")
             return;
         const key = cursorKey(entry, toolName);
         this.cursor.set(key, (this.cursor.get(key) ?? 0) + 1);

package/dist/replay/targets.d.ts

@@ -39,6 +39,18 @@
  * call's `paramMapLogic` builds, not on these, so that body is scanned as a
  * consumer and the segment's own steps are not (R-CALL-29).
  *
+ * A THIRD WAY NOT TO BLOCK: A VALUE ONLY ONE HALF NEEDS (the service's review
+ * of calcscenarioautocorrect.md, item 11). A plan that holds both halves of an
+ * "if … otherwise" reads values only one half needs — the task's name, its
+ * board, the meeting's day — and a prompt for the other half names none of
+ * them. Declined as a whole (`missing_target`), the half that needed nothing
+ * the prompt lacked never ran. Such a value does not block when every use of
+ * it is in the input of a step that runs only under a test of its own: the
+ * step is reached only when this request is its half. The plan holds a mark
+ * in its place then, never `null` and never the recorded value (plan.ts,
+ * `MISSING_VALUE_MARK`), and a step whose input reads it stops in front of its
+ * call, for the agent. See {@link testedOnlyTargets}.
+ *
  * WHEN IN DOUBT, IT BLOCKS. This reads source text, not a parse tree, so it can
  * only prove "safe" for the shapes it recognises: `parameters.key`,
  * `parameters?.key` and `parameters["key"]`. Any other use of `parameters` —
@@ -51,7 +63,7 @@
  * the steps then read under another name.
  */
 import type { FlatEntry } from "./flatten.js";
-import type { ParamsSchema } from "./types.js";
+import { type ParamsSchema } from "./types.js";
 /**
  * The subset of `missing` this plan must decline on.
  *
@@ -63,4 +75,31 @@ import type { ParamsSchema } from "./types.js";
  * parameters before step 0, and what it returns is what every step reads.
  */
 export declare function blockingTargets(missing: readonly string[], schema: ParamsSchema | null | undefined, planned: readonly FlatEntry[], paramsLogic?: string | null): string[];
+/**
+ * Of `missing`, the targets that only the steps of one half read (see A THIRD
+ * WAY NOT TO BLOCK above): the plan holds them as a mark, and they do not stop
+ * it. A key is one only when
+ *
+ *  - some step of frame 0 that runs under a test of its own (`when`, either
+ *    `otherwise`) reads it in its input logic; and
+ *  - nothing else names it: no step without a test, no output logic, no test,
+ *    no sub-task's parameter mapping or test — the mark is never something a
+ *    test decides on, or that an output passes on to another value; and
+ *  - `paramsLogic`, when there is one, does not name the key at all, not even
+ *    as a bare word (`{ ...parameters, task_name: 'x' }` is a typed default:
+ *    a guessed target), and uses `parameters` only as a spread that hands
+ *    every key on; and
+ *  - no body carries the recorded sample as a literal.
+ *
+ * Anything this cannot follow — `parameters` destructured, passed or aliased —
+ * and it answers none: every missing target blocks, as before. Nor in a plan
+ * that calls a sub-task: the sub-task's mappings — the one that builds its
+ * parameters, the one that hands its results back — run on the caller's
+ * values out of every watch, and a mark is a truthy text a mapping could
+ * branch on, change past recognising, or pass into what a later test decides
+ * on. The plan also puts the mark back after `paramsLogic` has run, so a body
+ * that dropped the key or wrote one of its own in its place still stops in
+ * front of the step.
+ */
+export declare function testedOnlyTargets(missing: readonly string[], schema: ParamsSchema | null | undefined, planned: readonly FlatEntry[], paramsLogic?: string | null): string[];
 //# sourceMappingURL=targets.d.ts.map

package/dist/replay/targets.js

@@ -39,6 +39,18 @@
  * call's `paramMapLogic` builds, not on these, so that body is scanned as a
  * consumer and the segment's own steps are not (R-CALL-29).
  *
+ * A THIRD WAY NOT TO BLOCK: A VALUE ONLY ONE HALF NEEDS (the service's review
+ * of calcscenarioautocorrect.md, item 11). A plan that holds both halves of an
+ * "if … otherwise" reads values only one half needs — the task's name, its
+ * board, the meeting's day — and a prompt for the other half names none of
+ * them. Declined as a whole (`missing_target`), the half that needed nothing
+ * the prompt lacked never ran. Such a value does not block when every use of
+ * it is in the input of a step that runs only under a test of its own: the
+ * step is reached only when this request is its half. The plan holds a mark
+ * in its place then, never `null` and never the recorded value (plan.ts,
+ * `MISSING_VALUE_MARK`), and a step whose input reads it stops in front of its
+ * call, for the agent. See {@link testedOnlyTargets}.
+ *
  * WHEN IN DOUBT, IT BLOCKS. This reads source text, not a parse tree, so it can
  * only prove "safe" for the shapes it recognises: `parameters.key`,
  * `parameters?.key` and `parameters["key"]`. Any other use of `parameters` —
@@ -50,6 +62,7 @@
  * more strictly still, because it runs before any step and can rename a target
  * the steps then read under another name.
  */
+import { isStepTest } from "./types.js";
 /**
  * The subset of `missing` this plan must decline on.
  *
@@ -82,9 +95,98 @@ export function blockingTargets(missing, schema, planned, paramsLogic) {
     const logic = paramsLogic?.trim() ? paramsLogic : undefined;
     if (logic && readsWhole(withoutSpread(logic)))
         return [...missing];
-    return missing.filter((key) => (logic !== undefined &&
-        (mentions(logic, key) || carriesLiteral(logic, schema[key]?.sampleValue))) ||
-        bodies.some((body) => readsOutright(body, key) || carriesLiteral(body, schema[key]?.sampleValue)));
+    // Read only by the steps of one half: not blocking, and held as a mark.
+    const oneHalf = new Set(testedOnlyTargets(missing, schema, planned, paramsLogic));
+    return missing.filter((key) => !oneHalf.has(key) &&
+        ((logic !== undefined &&
+            (mentions(logic, key) || carriesLiteral(logic, schema[key]?.sampleValue))) ||
+            bodies.some((body) => readsOutright(body, key) || carriesLiteral(body, schema[key]?.sampleValue))));
+}
+/**
+ * Of `missing`, the targets that only the steps of one half read (see A THIRD
+ * WAY NOT TO BLOCK above): the plan holds them as a mark, and they do not stop
+ * it. A key is one only when
+ *
+ *  - some step of frame 0 that runs under a test of its own (`when`, either
+ *    `otherwise`) reads it in its input logic; and
+ *  - nothing else names it: no step without a test, no output logic, no test,
+ *    no sub-task's parameter mapping or test — the mark is never something a
+ *    test decides on, or that an output passes on to another value; and
+ *  - `paramsLogic`, when there is one, does not name the key at all, not even
+ *    as a bare word (`{ ...parameters, task_name: 'x' }` is a typed default:
+ *    a guessed target), and uses `parameters` only as a spread that hands
+ *    every key on; and
+ *  - no body carries the recorded sample as a literal.
+ *
+ * Anything this cannot follow — `parameters` destructured, passed or aliased —
+ * and it answers none: every missing target blocks, as before. Nor in a plan
+ * that calls a sub-task: the sub-task's mappings — the one that builds its
+ * parameters, the one that hands its results back — run on the caller's
+ * values out of every watch, and a mark is a truthy text a mapping could
+ * branch on, change past recognising, or pass into what a later test decides
+ * on. The plan also puts the mark back after `paramsLogic` has run, so a body
+ * that dropped the key or wrote one of its own in its place still stops in
+ * front of the step.
+ */
+export function testedOnlyTargets(missing, schema, planned, paramsLogic) {
+    if (missing.length === 0 || !schema || planned.length === 0)
+        return [];
+    if (planned.some((entry) => entry.depth > 0))
+        return [];
+    const { tested, others } = consumerBodies(planned);
+    const all = [...tested, ...others];
+    if (all.length === 0 || all.some(readsWhole))
+        return [];
+    const logic = paramsLogic?.trim() ? paramsLogic : undefined;
+    if (logic && readsWhole(withoutSpread(logic)))
+        return [];
+    return missing.filter((key) => {
+        const sample = schema[key]?.sampleValue;
+        if (logic !== undefined && (namesKey(logic, key) || carriesLiteral(logic, sample)))
+            return false;
+        if (all.some((body) => carriesLiteral(body, sample)))
+            return false;
+        if (others.some((body) => mentions(body, key)))
+            return false;
+        return tested.some((body) => mentions(body, key));
+    });
+}
+/**
+ * The bodies that run with the caller's own `parameters`, as
+ * {@link callerBodies} lists them, told apart: the input logic of each step of
+ * frame 0 that runs under a test of its own, and every other body.
+ */
+function consumerBodies(planned) {
+    const tested = [];
+    const others = [];
+    const seenFrames = new Set();
+    for (const entry of planned) {
+        if (entry.depth === 0) {
+            const input = entry.step.toolInputLogic;
+            if (input)
+                (isStepTest(entry.step.when) ? tested : others).push(input);
+            if (entry.step.toolOutputLogic)
+                others.push(entry.step.toolOutputLogic);
+            if (entry.step.when?.logic)
+                others.push(entry.step.when.logic);
+            continue;
+        }
+        const frame = entry.frame;
+        if (frame.depth !== 1 || seenFrames.has(frame.id))
+            continue;
+        seenFrames.add(frame.id);
+        if (frame.paramMapLogic)
+            others.push(frame.paramMapLogic);
+        if (frame.when?.logic)
+            others.push(frame.when.logic);
+    }
+    return { tested, others };
+}
+/** Whether `body` names `key` at all — `parameters.key`, or the bare word, as a key of an object it returns. */
+function namesKey(body, key) {
+    if (mentions(body, key))
+        return true;
+    return new RegExp(`(?<![\\w$])${escapeRegExp(key)}(?![\\w$])`).test(body);
 }
 /**
  * `parameters` used in any shape other than `parameters.key`,

package/dist/replay/types.d.ts

@@ -83,13 +83,14 @@ export interface SerializedScenarioStep {
     when?: StepTest | null;
     /**
      * The correction that wrote this step, and what it did (the service's
-     * autocorrect.md AC6). `"added"` is a step taken from the agent's redo: it
-     * made no call in the recording the plan was calculated from, so it pairs
-     * with no recorded output (source-run.ts). Absent or null on every other
-     * step, and on every step of an older service.
+     * autocorrect.md AC6). `"added"` is a step taken from the agent's redo,
+     * and `"written"` one written from the agent's answer (AC12): neither made
+     * a call in the recording the plan was calculated from, so it pairs with no
+     * recorded output (source-run.ts). Absent or null on every other step, and
+     * on every step of an older service.
      */
     correctionId?: string | null;
-    correctionKind?: "added" | "tested" | "changed" | null;
+    correctionKind?: "added" | "tested" | "changed" | "written" | null;
     /**
      * `"segment"` is a call: a sub-task this chain runs by calling a recorded
      * scenario instead of carrying a copy of its steps (R-CALL-1). Absent means

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basein/runner",
-  "version": "0.3.16",
+  "version": "0.3.18",
   "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",