verikun 0.10.0 → 0.12.0

package/dist/agent/grammar.js

@@ -34,13 +34,75 @@ Each step is one of three node types:
    permission dialogs, "rate us" popups, cookie banners, A/B variants. This is how you
    keep a flow from breaking when an extra screen sometimes appears.
 
-3. REPEAT — { "type":"repeat", "selector":<sel>, "cap":<n>, "body":[<command leaves>] }
-   Repeat body until the selector appears, up to cap iterations. Use for "scroll until X
-   is visible". Always set a sane cap (e.g. 10). The engine also stops early if the screen
-   stops changing.
+3. REPEAT — { "type":"repeat", "selector":<sel>, "cap":<n>, "body":[<nodes>] }
+   Repeat body UNTIL the selector appears, up to cap iterations. Use for "scroll until X
+   is visible", or "keep answering until the results screen". Always set a sane cap (e.g.
+   10). The engine also stops early if the screen stops changing. A repeat that finishes
+   without its selector ever appearing FAILS the test — it did not do its job.
 
-NESTING: control-node bodies hold COMMAND leaves only — do NOT nest if-present/repeat
-inside another control node.
+4. WHEN — { "type":"when", "branches":[{ "selector":<sel>, "body":[<nodes>] }, ...],
+            "else":[<nodes>]  (optional) }
+   Ordered n-way dispatch: the FIRST branch whose selector is on screen runs, and only it.
+   Use when a screen is one of several KINDS that each need different handling —
+   "the question is multiple-choice, or match-the-pairs, or arrange-the-words".
+   If no branch matches and there is no "else", the test FAILS (the app showed something
+   this test does not handle — that is a real result, not something to skip past).
+   Use "else": [] to say explicitly "if none match, do nothing".
+   WHEN vs IF-PRESENT: if-present = "this may or may not be there, carry on either way".
+   when = "it is one of these; if it is none of them, that is a failure".
+
+5. WHILE-PRESENT — { "type":"while-present", "selector":<sel>, "bind":<name>,
+                     "cap":<n>, "body":[<nodes>] }
+   Repeat body WHILE the selector is present. With "bind", the named counter starts at 0
+   and increments after each iteration, and you reference it as {{ctx.<name>}} inside the
+   selector and the body. This is how you walk an index-addressed list whose LENGTH you
+   cannot know when compiling:
+     { "type":"while-present", "selector":"id:word_bubble_container_id_{{ctx.i}}",
+       "bind":"i", "cap":20,
+       "body":[ { "type":"command","command":"tap",
+                  "positionals":["id:word_bubble_container_id_{{ctx.i}}"],"flags":[] } ] }
+
+6. READ — { "type":"read", "selector":<sel>, "field":"text"|"desc"|"id"|"idShort",
+            "into":<name> }
+   Capture a value off the live screen into {{ctx.<name>}} for a later step to use. Use it
+   when the test must ACT ON a value it cannot know in advance — e.g. read the correct
+   answer's text, then type that text into a field.
+
+PLACEHOLDERS — any positional or flag value, and any control-node selector, may contain:
+  {{ctx.NAME}}   a value stored by read, or a while-present counter
+  {{env.NAME}}   an environment variable (use for credentials; never inline a secret)
+  {{uuid}}       a fresh id, generated once per run (same value everywhere in the run)
+  {{timestamp}}  epoch ms, once per run       {{run_id}}  this run's id
+Use {{uuid}} when the test needs data that must be unique per run, e.g. a signup email
+like "user-{{uuid}}@example.com" — never a hard-coded literal, which collides on rerun.
+
+NESTING: control nodes may nest ONE level — a control node inside a control node, whose
+body is command leaves. A repeat containing a when is the shape for "until the flow ends,
+handle whichever screen is showing", and it is legal. Three levels is not.
+EXCEPT: if-present and while-present may go one level deeper (their bodies are leaves), so
+  repeat { when { while-present { tap ... } } }     — walk an index-addressed list
+  repeat { when { if-present { tap ... } } }        — an optional step inside a branch
+are both legal. Use them rather than approximating.
+In particular: "if X appears, tap it" inside a branch is an if-present. Do NOT turn it
+into a bare wait + tap — wait FAILS the test when X never appears, and "if" means it
+might not. That mistake reads as a passing plan and fails on the first run where the app
+skips that step.
+
+Inside a "repeat until X" loop, GUARD a tap whose target is the thing that brings X about:
+  repeat until <form> { if-present <button> { tap <button> } ; screenshot }
+Once the transition starts, <button> is gone — so on the final iteration an unguarded tap
+misses and fails the whole run, even though the loop did its job. The guard makes that
+last lap a no-op instead of an error. Apply this whenever the prose says "tap ... until"
+or "repeatedly until".
+
+Do NOT flatten a branch into an unconditional sequence: emitting the taps for ALL the
+kinds of screen one after another is wrong — on any given iteration most of them are not
+there, and the test will fail on the first one that is missing. Use when.
+
+Do NOT hard-code a run of indices you were not told the length of. If the prose says
+"tap each pair", "until every pair is matched", or "tap the bubbles in order", the COUNT
+varies per run — emit a while-present over {{ctx.i}} rather than tap _0, _1, _2, _3.
+A hard-coded list is right only when the prose states the exact count.
 
 SELECTORS (the engine auto-heals case/whitespace/partial, so prefer stable identifiers):
   @login            resource-id 'login' (shorthand for id:login)
@@ -51,6 +113,11 @@ SELECTORS (the engine auto-heals case/whitespace/partial, so prefer stable ident
   "Sign in"         bare string == text:Sign in
 
 RULES:
+- --enabled on a tap makes it match only a control that is ACTIONABLE right now, and (with
+  auto-wait) wait until it becomes so. Use it for any button that the app disables until
+  something else is done — a Check/Submit/Continue that only lights up once an answer is
+  selected or a form is valid. Without it the step taps a dead control, does nothing, and
+  the failure surfaces later as a confusing timeout on the NEXT step.
 - assert is for VERIFICATION only and is terminal — never use it as a step you expect to
   fail. Put genuinely-optional UI behind if-present.
 - Prefer resource-id / accessibility selectors over visible text where possible.

package/dist/agent/ir.js

@@ -18,10 +18,25 @@
 //    structured-output schemas can't express an arbitrary-key object. A pure boolean
 //    flag is value:"true" (flagBool reads 'true' as true; flagStr reads the string).
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvalidPlanError = exports.REPAIR_DECISION_JSON_SCHEMA = exports.PLAN_JSON_SCHEMA = exports.DEFAULT_LOOP_CAP = exports.KNOWN_COMMANDS = void 0;
+exports.InvalidPlanError = exports.REPAIR_DECISION_JSON_SCHEMA = exports.PLAN_JSON_SCHEMA = exports.DEFAULT_LOOP_CAP = exports.KNOWN_COMMANDS = exports.isControlNode = exports.MAX_CONTROL_DEPTH = void 0;
+exports.bodiesOf = bodiesOf;
 exports.validateNode = validateNode;
 exports.parsePlan = parsePlan;
 exports.leafToFlags = leafToFlags;
+/** Max control-node nesting. 1 = a control node at top level whose body is leaves
+ *  (the v1 rule). 2 = a control node inside that body, whose own body is leaves —
+ *  i.e. `repeat { when { … } }`, the loop-that-branches shape a real dynamic flow
+ *  needs. The schema is hand-unrolled to exactly this depth, so raising it means
+ *  editing controlSchema()'s nesting as well as this constant. */
+exports.MAX_CONTROL_DEPTH = 2;
+const isControlNode = (n) => n.type === 'if-present' || n.type === 'when' || n.type === 'repeat' || n.type === 'while-present';
+exports.isControlNode = isControlNode;
+/** Every body a control node owns (a `when` owns one per branch, plus `else`). */
+function bodiesOf(n) {
+    if (n.type === 'when')
+        return [...n.branches.map((b) => b.body), ...(n.else ? [n.else] : [])];
+    return [n.body];
+}
 /** Commands a leaf step is allowed to carry — the agent-emittable ACTION/assertion verbs
  *  the grammar offers, a SUBSET of cli.ts's dispatch (inspection/diagnostic commands are
  *  excluded; see the note in the set). The engine validates every step — including a
@@ -47,10 +62,115 @@ exports.KNOWN_COMMANDS = new Set([
 exports.DEFAULT_LOOP_CAP = 25;
 /**
  * JSON Schema for `output_config.format` so the model returns a guaranteed-valid
- * Plan. Deliberately NON-RECURSIVE: control-node `body` arrays reference only the
- * leaf schema, so there is no `Plan -> node -> Plan` cycle (structured output
- * rejects recursive schemas). One nesting level, by design.
+ * Plan. Deliberately NON-RECURSIVE: instead of a `Plan -> node -> Plan` cycle
+ * (structured output rejects recursive schemas) the control levels are HAND-UNROLLED
+ * to MAX_CONTROL_DEPTH. Raising the depth means adding another unrolled level here.
  */
+const stepItems = (bodyItems) => ({
+    anyOf: [
+        leafSchema(),
+        readSchema(),
+        {
+            type: 'object',
+            additionalProperties: false,
+            required: ['type', 'selector', 'body'],
+            properties: {
+                type: { type: 'string', enum: ['if-present'] },
+                selector: { type: 'string' },
+                body: { type: 'array', items: bodyItems },
+            },
+        },
+        {
+            type: 'object',
+            additionalProperties: false,
+            required: ['type', 'branches'],
+            properties: {
+                type: { type: 'string', enum: ['when'] },
+                branches: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        additionalProperties: false,
+                        required: ['selector', 'body'],
+                        properties: { selector: { type: 'string' }, body: { type: 'array', items: bodyItems } },
+                    },
+                },
+                else: { type: 'array', items: bodyItems },
+            },
+        },
+        {
+            type: 'object',
+            additionalProperties: false,
+            required: ['type', 'selector', 'cap', 'body'],
+            properties: {
+                type: { type: 'string', enum: ['repeat'] },
+                selector: { type: 'string' },
+                cap: { type: 'integer' },
+                body: { type: 'array', items: bodyItems },
+            },
+        },
+        {
+            type: 'object',
+            additionalProperties: false,
+            required: ['type', 'selector', 'cap', 'body'],
+            properties: {
+                type: { type: 'string', enum: ['while-present'] },
+                selector: { type: 'string' },
+                bind: { type: 'string' },
+                cap: { type: 'integer' },
+                body: { type: 'array', items: bodyItems },
+            },
+        },
+    ],
+});
+/** The innermost level: leaves, reads, and the two SIMPLE control nodes — `if-present`
+ *  and `while-present` — restricted to leaf-only bodies so they cannot open a further
+ *  level.
+ *
+ *  Both were added from measured failures, and both are the same failure: when the model
+ *  needs a construct one level deeper than the grammar allows, it does not give up — it
+ *  DEGRADES to an unconditional approximation, which is exactly the bug #33 is about.
+ *    - Without `while-present` here, a compile of the dynamic-lesson repro produced
+ *      `repeat { when { … } }` correctly but HARD-CODED the index lists inside each branch
+ *      (pairs 0..3, bubbles 0..5) — broken the moment a question has a different count.
+ *    - Without `if-present` here, the same compile turned the prose "IF a Continue button
+ *      appears, tap it" into an unconditional `wait id:continue_button_id` inside every
+ *      branch. The app auto-advances and shows no Continue, so all three runs failed on
+ *      that wait — a conditional flattened into an assertion, one level down.
+ *
+ *  A full third level for every node would ~3x a 28KB schema (bad for OpenAI strict
+ *  limits, worse for cursor, which injects the schema as prompt text). Granting it to the
+ *  two leaf-bodied nodes is the cheap, bounded version. `when` and `repeat` stay at
+ *  MAX_CONTROL_DEPTH: they are the nodes whose bodies want to be deep, and allowing them
+ *  here is what would actually cost the schema. */
+const innerControls = () => {
+    const leafBody = { type: 'array', items: { anyOf: [leafSchema(), readSchema()] } };
+    return [
+        {
+            type: 'object',
+            additionalProperties: false,
+            required: ['type', 'selector', 'body'],
+            properties: {
+                type: { type: 'string', enum: ['if-present'] },
+                selector: { type: 'string' },
+                body: leafBody,
+            },
+        },
+        {
+            type: 'object',
+            additionalProperties: false,
+            required: ['type', 'selector', 'cap', 'body'],
+            properties: {
+                type: { type: 'string', enum: ['while-present'] },
+                selector: { type: 'string' },
+                bind: { type: 'string' },
+                cap: { type: 'integer' },
+                body: leafBody,
+            },
+        },
+    ];
+};
+const LEAF_ONLY_ITEMS = { anyOf: [leafSchema(), readSchema(), ...innerControls()] };
 exports.PLAN_JSON_SCHEMA = {
     type: 'object',
     additionalProperties: false,
@@ -61,32 +181,7 @@ exports.PLAN_JSON_SCHEMA = {
         platform: { type: 'string', enum: ['android', 'ios'] },
         steps: {
             type: 'array',
-            items: {
-                anyOf: [
-                    leafSchema(),
-                    {
-                        type: 'object',
-                        additionalProperties: false,
-                        required: ['type', 'selector', 'body'],
-                        properties: {
-                            type: { type: 'string', enum: ['if-present'] },
-                            selector: { type: 'string' },
-                            body: { type: 'array', items: leafSchema() },
-                        },
-                    },
-                    {
-                        type: 'object',
-                        additionalProperties: false,
-                        required: ['type', 'selector', 'cap', 'body'],
-                        properties: {
-                            type: { type: 'string', enum: ['repeat'] },
-                            selector: { type: 'string' },
-                            cap: { type: 'integer' },
-                            body: { type: 'array', items: leafSchema() },
-                        },
-                    },
-                ],
-            },
+            items: stepItems(stepItems(LEAF_ONLY_ITEMS)),
         },
     },
 };
@@ -107,6 +202,19 @@ exports.REPAIR_DECISION_JSON_SCHEMA = {
         reason: { type: 'string' },
     },
 };
+function readSchema() {
+    return {
+        type: 'object',
+        additionalProperties: false,
+        required: ['type', 'selector', 'field', 'into'],
+        properties: {
+            type: { type: 'string', enum: ['read'] },
+            selector: { type: 'string' },
+            field: { type: 'string', enum: ['text', 'desc', 'id', 'idShort'] },
+            into: { type: 'string' },
+        },
+    };
+}
 function leafSchema() {
     return {
         type: 'object',
@@ -141,11 +249,49 @@ function isFlagSpecArray(v) {
     return (Array.isArray(v) &&
         v.every((f) => f && typeof f === 'object' && typeof f.name === 'string' && typeof f.value === 'string'));
 }
-/** Validate a single node (used for both compile output and a spliced repair). */
-function validateNode(node, where) {
+const READ_FIELDS = new Set(['text', 'desc', 'id', 'idShort']);
+/** ctx keys are interpolated into selectors as {{ctx.NAME}}; keep them boring so a
+ *  name can never smuggle regex/template metacharacters into a selector. */
+const CTX_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/** Validate a single node (used for both compile output and a spliced repair).
+ *
+ *  `depth` is how many control nodes enclose this one. It is the ONLY thing bounding
+ *  nesting at runtime, and it must agree with PLAN_JSON_SCHEMA's hand-unrolled levels
+ *  — the schema stops a compliant model, this stops everything else (a repair, a
+ *  hand-edited plan, a poisoned cache entry). */
+function validateNode(node, where, depth = 0) {
     if (!node || typeof node !== 'object')
         throw new InvalidPlanError(`${where}: not an object`);
     const n = node;
+    /** Validate one control body. `allowEmpty` is true only for `when`'s `else`. */
+    const validateBody = (raw, label, allowEmpty = false) => {
+        if (!Array.isArray(raw))
+            throw new InvalidPlanError(`${label}: body must be an array`);
+        if (raw.length === 0 && !allowEmpty) {
+            // Silence must never read as success — same rule parsePlan applies to the plan.
+            throw new InvalidPlanError(`${label}: body is empty (a control body must do something; use when's "else": [] to mean "do nothing")`);
+        }
+        return raw.map((b, i) => validateNode(b, `${label}[${i}]`, depth + 1));
+    };
+    /** `if-present` and `while-present` are allowed one level deeper than the branching
+     *  nodes: they are the conditional and the index-walk an innermost branch body needs,
+     *  and because their own bodies are leaves they cannot open a further level. Blocking
+     *  them here does not make the model simplify — it makes it emit an unconditional
+     *  approximation instead. See LEAF_ONLY_ITEMS. */
+    const guardDepth = (extra = 0) => {
+        const limit = exports.MAX_CONTROL_DEPTH + extra;
+        if (depth >= limit) {
+            throw new InvalidPlanError(`${where}: control nodes may nest ${limit} deep at most (got ${depth + 1}) — flatten this or lift it to an outer step`);
+        }
+    };
+    const selectorOf = () => {
+        if (typeof n.selector !== 'string' || !n.selector)
+            throw new InvalidPlanError(`${where}: ${n.type} needs a selector`);
+        return n.selector;
+    };
+    // OpenAI/codex strict mode forces every property into `required` and nullifies the
+    // optional ones, so an absent `else`/`bind` arrives as null rather than missing.
+    const optional = (v, pick) => v === undefined || v === null ? undefined : pick(v);
     switch (n.type) {
         case 'command': {
             if (typeof n.command !== 'string' || !exports.KNOWN_COMMANDS.has(n.command)) {
@@ -158,22 +304,50 @@ function validateNode(node, where) {
                 throw new InvalidPlanError(`${where}: flags must be {name,value}[]`);
             return { type: 'command', command: n.command, positionals: n.positionals, flags: n.flags };
         }
-        case 'if-present':
-        case 'repeat': {
-            if (typeof n.selector !== 'string' || !n.selector)
-                throw new InvalidPlanError(`${where}: ${n.type} needs a selector`);
-            if (!Array.isArray(n.body))
-                throw new InvalidPlanError(`${where}: ${n.type} body must be an array`);
-            const body = n.body.map((b, i) => {
-                const leaf = validateNode(b, `${where}.body[${i}]`);
-                if (leaf.type !== 'command')
-                    throw new InvalidPlanError(`${where}.body[${i}]: only leaf commands allowed (no nesting in v1)`);
-                return leaf;
+        case 'read': {
+            const selector = selectorOf();
+            if (typeof n.field !== 'string' || !READ_FIELDS.has(n.field)) {
+                throw new InvalidPlanError(`${where}: read needs field one of ${[...READ_FIELDS].join('|')} (got ${JSON.stringify(n.field)})`);
+            }
+            if (typeof n.into !== 'string' || !CTX_NAME_RE.test(n.into)) {
+                throw new InvalidPlanError(`${where}: read "into" must be a plain identifier (got ${JSON.stringify(n.into)})`);
+            }
+            return { type: 'read', selector, field: n.field, into: n.into };
+        }
+        case 'if-present': {
+            guardDepth(1);
+            return { type: 'if-present', selector: selectorOf(), body: validateBody(n.body, `${where}.body`) };
+        }
+        case 'when': {
+            guardDepth();
+            if (!Array.isArray(n.branches) || n.branches.length === 0) {
+                throw new InvalidPlanError(`${where}: when needs at least one branch`);
+            }
+            const branches = n.branches.map((b, i) => {
+                const br = b;
+                if (!br || typeof br !== 'object' || typeof br.selector !== 'string' || !br.selector) {
+                    throw new InvalidPlanError(`${where}.branches[${i}]: needs a selector`);
+                }
+                return { selector: br.selector, body: validateBody(br.body, `${where}.branches[${i}].body`) };
             });
-            if (n.type === 'if-present')
-                return { type: 'if-present', selector: n.selector, body };
+            const els = optional(n.else, (v) => validateBody(v, `${where}.else`, true));
+            return { type: 'when', branches, ...(els ? { else: els } : {}) };
+        }
+        case 'repeat':
+        case 'while-present': {
+            guardDepth(n.type === 'while-present' ? 1 : 0);
+            const selector = selectorOf();
             const cap = typeof n.cap === 'number' && n.cap > 0 ? Math.floor(n.cap) : exports.DEFAULT_LOOP_CAP;
-            return { type: 'repeat', selector: n.selector, cap, body };
+            const body = validateBody(n.body, `${where}.body`);
+            if (n.type === 'repeat')
+                return { type: 'repeat', selector, cap, body };
+            const bind = optional(n.bind, (v) => {
+                if (typeof v !== 'string' || !CTX_NAME_RE.test(v)) {
+                    throw new InvalidPlanError(`${where}: while-present "bind" must be a plain identifier (got ${JSON.stringify(v)})`);
+                }
+                return v;
+            });
+            return { type: 'while-present', selector, cap, body, ...(bind ? { bind } : {}) };
         }
         default:
             throw new InvalidPlanError(`${where}: unknown node type ${JSON.stringify(n.type)}`);

package/dist/agent/lint.js

@@ -0,0 +1,77 @@
+"use strict";
+// Compile-fidelity lint: does the plan the model produced still say what the prose said?
+//
+// The model is a compiler, and this is the compiler's own sanity check. It exists because
+// compilation is NONDETERMINISTIC in a way that is invisible until a run fails, and two
+// failure modes showed up repeatedly against a real suite:
+//
+//   1. An explicit directive silently vanishes. The same prose ("Launch the app WITH ITS
+//      DATA CLEARED so it starts logged-out") compiled to `launch <pkg> --clear` on one
+//      run and plain `launch <pkg>` on the next. The plan looked fine and the test failed
+//      several steps later, on a screen that only appears when you are already logged in.
+//   2. Conditional prose compiles to an unconditional step. "IF a Continue button appears,
+//      tap it" becomes `wait` + `tap`, which FAILS on every run where the app skips it.
+//
+// Both are cheap to detect and cheap to fix: hand the finding back to the model and let it
+// compile once more. That is far better than the alternative, which is a plan that is
+// quietly wrong and burns a device run to say so.
+//
+// Deliberately CONSERVATIVE — a false positive costs a wasted recompile, so every rule
+// requires a fairly unambiguous phrase and checks for a specific structural counterpart.
+// It never edits the plan; the model gets the feedback and stays the author.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lintPlan = lintPlan;
+const ir_1 = require("./ir");
+/** Walk every node in the plan, including control-node bodies. */
+function* walk(nodes) {
+    for (const n of nodes) {
+        yield n;
+        if ((0, ir_1.isControlNode)(n))
+            for (const body of (0, ir_1.bodiesOf)(n))
+                yield* walk(body);
+    }
+}
+const hasControlNode = (plan) => {
+    for (const n of walk(plan.steps))
+        if ((0, ir_1.isControlNode)(n))
+            return true;
+    return false;
+};
+const hasLeafWithFlag = (plan, command, flag) => {
+    for (const n of walk(plan.steps)) {
+        if (n.type === 'command' && n.command === command && n.flags.some((f) => f.name === flag))
+            return true;
+    }
+    return false;
+};
+/** Phrases that state the app must start from a clean slate. Kept tight on purpose:
+ *  "clear" alone is far too common (clearing a text field, a clear button). */
+const FRESH_START_RE = /\b(data cleared|cleared data|clear its data|with its data cleared|freshly installed|logged[- ]out|logged out|clean state|from scratch)\b/i;
+/** Phrases that make a step conditional. These are the ones that produced an
+ *  unconditional step in practice; vaguer hedges ("should", "normally") are excluded. */
+const CONDITIONAL_RE = /\b(if (?:a|an|the|any)\b|may appear|might appear|sometimes|optionally|if present|if shown|if it appears|dismiss any)\b/i;
+/**
+ * Check a compiled plan against the prose it came from.
+ *
+ * @param nl   the natural-language test, verbatim
+ * @param plan the plan the model just produced
+ * @returns findings; empty means the plan is consistent with the prose
+ */
+function lintPlan(nl, plan) {
+    const findings = [];
+    if (FRESH_START_RE.test(nl) && !hasLeafWithFlag(plan, 'launch', 'clear')) {
+        findings.push({
+            message: 'The test says the app must start from cleared data / logged out, but no step launches it with --clear. ' +
+                'Emit `launch <package> --clear` so the run does not inherit the previous run\'s session.',
+        });
+    }
+    if (CONDITIONAL_RE.test(nl) && !hasControlNode(plan)) {
+        findings.push({
+            message: 'The test describes something that may or may not appear ("if ...", "may appear", "dismiss any ..."), ' +
+                'but the plan has no if-present/when node — every step is unconditional. An unconditional step for ' +
+                'optional UI fails on every run where that UI does not show. Put the optional part behind if-present ' +
+                '(skip when absent), or behind when (when the screen is one of several known kinds).',
+        });
+    }
+    return findings;
+}

package/dist/agent/openai.js

@@ -116,6 +116,12 @@ class OpenAiProvider {
                 JSON.stringify(input.seed, null, 2));
         }
         parts.push('NATURAL-LANGUAGE TEST:\n' + input.nl);
+        if (input.retryFeedback) {
+            // Last, so it is the freshest thing in context: a previous compile of this same
+            // test lost something the prose stated. Naming it beats hoping the retry differs.
+            parts.push('YOUR PREVIOUS ATTEMPT AT THIS TEST WAS REJECTED. Fix this and emit the whole plan again:\n' +
+                input.retryFeedback);
+        }
         // Generous completion budget: on reasoning models the plan JSON shares this ceiling
         // with reasoning tokens, so leave headroom (a 'length' finish is surfaced as an error).
         const { json, usage } = await this.call(grammar_1.GRAMMAR, parts.join('\n\n'), ir_1.PLAN_JSON_SCHEMA, 16384);