sitelooper 0.3.0

package/dist/skills/compile.js

@@ -0,0 +1,1420 @@
+import { newSkillId, originOf } from './store.js';
+import { identifierLike } from './ledger.js';
+import { WILDCARD, maskVolatile } from '../shared/text.js';
+/** Args whose string values are candidates for parameter slots. */
+const VALUE_ARGS = new Set(['value', 'text', 'option', 'url', 'prompt_text']);
+const MAX_ADDED_LINES = 5;
+const MAX_SLOT_VALUES = 12;
+/**
+ * Turn one successful instruction's recording into a skill.
+ *
+ * Parameterisation is deliberately deterministic: any literal the agent typed
+ * (fill/type/select/goto values) that also occurs as a whole token in the
+ * instruction text becomes a slot, substituted everywhere it appears — step
+ * args, locator names, expectations, the report. Values that do not occur in
+ * the instruction stay literal: they are defaults the agent invented, which is
+ * the right thing to replay and worth being able to see in `skills show`.
+ *
+ * Returns null when there is nothing replayable (no steps, or no origin).
+ */
+export function compileSkill(input) {
+    return compileSkills(input)[0] ?? null;
+}
+/**
+ * Like compileSkill, but the recording is first split at page-template seams
+ * — a step whose url PATTERN changed navigated to a different template — and
+ * each segment compiles into its own skill, scoped to the page it runs on
+ * (its own startUrl precondition and, when the recorder captured one, its own
+ * fingerprint). The segments share one template and one slot set and are
+ * linked by `seq`, so a caller binds params once and replay composes them;
+ * each segment is independently replayable, recoverable, and promotable, so a
+ * drift in one cannot cascade — the next segment refuses unless the page
+ * matches its template. A recording that never changes template compiles to
+ * exactly one skill, as before.
+ */
+export function compileSkills(input) {
+    const head = input.entries.find((e) => e.k === 'instruction');
+    const steps = input.entries.filter((e) => e.k === 'step');
+    if (!steps.length)
+        return [];
+    const startUrl = head?.url ?? firstUrl(steps);
+    const origin = startUrl ? originOf(startUrl) : null;
+    if (!origin || !startUrl)
+        return [];
+    const slots = discoverSlots(input.instruction, steps, input.knownValues);
+    const sub = (s) => substitute(s, slots);
+    /** Slots whose value the ledger banked from a `q.id` url position — the only
+     *  slots substituteUrlId may write into a navigation arg's `id=`. */
+    const idOriginValues = new Set(Object.entries(input.knownValues ?? {})
+        .filter(([k]) => /:q\.id$/.test(k))
+        .map(([, v]) => String(v ?? '').trim()));
+    const urlIdSlots = new Map([...slots].filter(([, v]) => idOriginValues.has(v)));
+    /** The caller's values for THIS run — a runid, a record it vouched for. */
+    const runValues = Object.values(input.knownValues ?? {})
+        .map((v) => String(v ?? '').trim())
+        .filter((v) => v.length >= 3);
+    const reportValues = input.report.evidence?.values ?? {};
+    // Inspection-only actions the agent used to ORIENT itself — probe the DOM with
+    // `eval`, grab a `screenshot`, read a value it never reported — are not part of
+    // the reproducible procedure. An `eval` is worse than noise: it assumes the
+    // record-time DOM and, unlike a read (which replay skips on failure), it is
+    // fatal, which is exactly what sent the sign-in and archive steps to recovery
+    // on every replay. Keep the actions, the synthetic read-backs, and any read
+    // whose value the run actually reported; drop the rest.
+    const replayable = steps.filter((step) => {
+        if (step.tool === 'screenshot' || step.tool === 'eval')
+            return false;
+        if (step.tool === 'read' || step.tool === 'read_all') {
+            return step.args.target === '(read-back)' || Boolean(readLabel(step, reportValues));
+        }
+        return true;
+    });
+    let kept = replayable.length ? replayable : steps;
+    // A variant covers only the territory it repaired: steps that were replayed
+    // via a DIFFERENT stored skill (an earlier segment completing cleanly) are
+    // that skill's procedure, not this variant's.
+    if (input.variantOf)
+        kept = kept.filter((s) => !s.via || s.via.skill === input.variantOf);
+    if (!kept.length)
+        return [];
+    // Split at page-template seams. A step that navigated (diff.url) to a url
+    // with a DIFFERENT pattern ends its segment; the recorder's fingerprintAfter
+    // (when captured) becomes the next segment's precondition.
+    const segments = [];
+    let seg = {
+        steps: [],
+        startUrl,
+        ...(head?.fingerprint ? { fingerprint: head.fingerprint } : {}),
+        ...(head?.startText ? { startText: head.startText } : {}),
+    };
+    let currentUrl = startUrl;
+    for (const step of kept) {
+        seg.steps.push(step);
+        if (step.diff?.url && step.diff.url !== currentUrl) {
+            const crossed = urlPattern(step.diff.url, slots) !== urlPattern(currentUrl, slots);
+            currentUrl = step.diff.url;
+            if (crossed) {
+                segments.push(seg);
+                seg = {
+                    steps: [],
+                    startUrl: currentUrl,
+                    ...(step.fingerprintAfter ? { fingerprint: step.fingerprintAfter } : {}),
+                    ...(step.diff?.added?.length ? { startText: step.diff.added.join('\n') } : {}),
+                };
+            }
+        }
+    }
+    if (seg.steps.length)
+        segments.push(seg);
+    // Provenance slots: values this run minted (first surfaced in a step's
+    // post-nav url). Kept only where they can pay: a later step or a later
+    // segment's start url mentions the value — otherwise the marker would just
+    // blunt the minting step's own expectation for nothing.
+    const mintedAll = discoverMinted(kept, startUrl, slots);
+    const minted = mintedAll.filter((m) => JSON.stringify(kept.slice(m.keptIndex + 1).map((s) => [s.args, s.locators, s.diff ?? null])).includes(m.value) ||
+        segments.some((sg, si) => si > 0 && urlParts(sg.startUrl).some((p) => p.value === m.value)));
+    const mintedMap = (pred) => new Map(minted.filter(pred).map((m) => [m.name, m.value]));
+    // Build every segment's steps first: slot retention is decided across the
+    // WHOLE chain (a slot used only by segment 2 must stay in the shared
+    // template, or binding an instruction to segment 1 would fail).
+    let segOffset = 0;
+    const built = segments.map((sg) => {
+        const base = segOffset;
+        segOffset += sg.steps.length;
+        const segParams = {};
+        for (const [name, value] of slots)
+            segParams[name] = { example: value, usedIn: [] };
+        const skillSteps = sg.steps.map((step, i) => {
+            const g = base + i;
+            // A minted value is a reference only DOWNSTREAM of its mint: in this
+            // step's args/locators when minted strictly earlier, and in this step's
+            // expectation when minted here or earlier (the minting step's own
+            // post-nav url is the first downstream occurrence).
+            const mintedBefore = mintedMap((m) => m.keptIndex < g);
+            const mintedHere = mintedMap((m) => m.keptIndex <= g);
+            const args = substituteDeep(substituteDeep(step.args, slots), mintedBefore);
+            // substitute() deliberately refuses to rewrite a number after `=` (the
+            // nth=25 guard), which is exactly where a navigation url carries its
+            // record id. Rewrite `id=<value>` structurally, and only for slots whose
+            // value the ledger banked from a q.id url position — a cost of "21"
+            // coinciding with a record id must not bind the url to the cost.
+            if (typeof args.url === 'string' && urlIdSlots.size)
+                args.url = substituteUrlId(args.url, urlIdSlots);
+            // The same `=` guard hides a MINTED value in a navigation url: fwod32's
+            // sign-in recorded `goto #action=135&menu_id=120` right after the step
+            // that minted action=135 and menu_id=120, so every replay navigated to
+            // the RECORDING run's action id. A minted value is rewritten at the
+            // url position it was minted from, and nowhere else.
+            if (typeof args.url === 'string')
+                args.url = substituteUrlParts(args.url, minted.filter((m) => m.keptIndex < g));
+            const locators = {};
+            for (const [key, loc] of Object.entries(step.locators)) {
+                const filled = (loc.chain ?? []).map((c) => substituteDeep(substituteDeep(c, slots), mintedBefore));
+                // An identity anchor still carrying THIS RUN's known value after
+                // slotting (the recorded runid, because the value was typed in an
+                // earlier instruction and so is not a slot here) can never match
+                // again — and worse, with no {{marker}} it carries no identity, so
+                // replay stops holding its fallbacks to the record and follows a
+                // positional one onto whatever sorted into that row (fwrd12l 04-add,
+                // 06-set). An anchor that cannot parameterise is not an anchor.
+                // Never strand the whole chain: a step with no way at all to find its
+                // element is worse than one carrying a candidate that will miss.
+                // `stranded` DELETES: the ledger knows the run made that value, so the
+                // candidate demonstrably cannot match another run. That is provenance,
+                // not a guess.
+                //
+                // `bookmarked` only DEMOTES. It reads an id's shape, and shape is a
+                // weak signal: grafana's ephemeral `_r8b_` matches none of our
+                // id patterns while odoo's stable `o_form_view` hooks trip several. A
+                // wrong deletion costs a working locator permanently; a wrong demotion
+                // costs one failed count(), and two replays of evidence put it right
+                // either way. So the shape rule sets the starting order and the
+                // running tally decides — see recordCandidateEvidence.
+                const usable = filled.filter((c) => !stranded(c, runValues));
+                const ranked = [...usable].sort((a, b) => Number(bookmarked(a)) - Number(bookmarked(b)));
+                const kept = stableFirst(ranked.length ? ranked : filled);
+                // A READ that lost its anchor and can now only be found BY POSITION
+                // must not publish. fwrd16-n3 is the cost of the alternative: the
+                // read fell back to `tbody > tr:nth-of-type(1) > td`, resolved
+                // instantly on a list whose first row was a seed ticket, and the step
+                // published `ref: RD-1014` at tier A with zero turns — a confidently
+                // wrong identity, which every later step then carried. Emptying the
+                // chain makes replay SKIP the read (reads are observations; a missing
+                // one is recoverable), so the value comes back absent, not wrong.
+                const lostAnchor = filled.length !== kept.length && filled.some((c) => c.kind === 'scoped');
+                const isRead = step.tool === 'read' || step.tool === 'read_all';
+                locators[key] = isRead && lostAnchor && kept.every(positional) ? [] : kept;
+            }
+            const out = { tool: step.tool, args, locators };
+            // Record-minting, from the evidence discoverMinted already gathered:
+            // this step's post-nav url carried an identifier the run had not seen
+            // before. Stored per step because a replay that stops needs to know
+            // whether it is past the point of creation, not merely how far it got.
+            const mintedHereOnly = mintedAll.find((m) => m.keptIndex === g);
+            if (mintedHereOnly)
+                out.mints = { at: mintedHereOnly.at };
+            // Minted values go into the url-pattern reduction as slots: an id-like
+            // one (odoo's "44", repair-desk's "t15") is otherwise reduced to `:id`
+            // before the {{dN}} marker can land, and the minting step then carries
+            // no reference to what it minted — so `derived` could not find it.
+            const expect = expectationFor(step, new Map([...slots, ...mintedHere]));
+            if (expect)
+                out.expect = substituteDeep(expect, mintedHere);
+            const label = readLabel(step, reportValues);
+            // A read with no way to find its element again publishes nothing, so it
+            // must not advertise the value either — publishedOutputs reads `label`,
+            // and a promised output that never arrives sends later steps to
+            // recovery with the reference blank.
+            const targetless = step.tool === 'read' && step.args.what === 'url';
+            if (label && (targetless || Object.values(locators).some((chain) => chain.length)))
+                out.label = label;
+            if (step.via)
+                out.via = step.via;
+            // Args and locators are use; expectations are NOT. Counting them (f24bdf9)
+            // kept a slot the procedure never types — a price the recording saw in
+            // a row, a uid in a post-save url — as a param bound by ORIGIN, and
+            // bindSkill then refused the whole skill whenever that origin had not
+            // been published (fwgr23 05-open, fwkb3-n3 03-create: tier null, 14-44
+            // model turns). The orphan-marker hazard it was fixing is handled below
+            // by re-inlining every dropped slot into the steps, expectations included.
+            for (const name of slotsUsed(JSON.stringify({ args, locators })))
+                segParams[name]?.usedIn.push(i + 1);
+            return out;
+        });
+        const mintedForStart = mintedMap((m) => m.keptIndex < base);
+        return { sg, segParams, mintedForStart, folded: foldLoops(coalesceControls(dropDismissedDialogs(dropSupersededNavigation(skillSteps)))) };
+    });
+    // Derived-param metadata lands on the MINTING segment: which post-fold step
+    // to bind from, and which url part to read there. Replay binds the value
+    // from the live run's own url right after that step executes.
+    const segDerived = {};
+    for (const m of minted) {
+        const si = segments.findIndex((sg, k) => {
+            const start = segments.slice(0, k).reduce((a, s) => a + s.steps.length, 0);
+            return m.keptIndex >= start && m.keptIndex < start + sg.steps.length;
+        });
+        if (si < 0)
+            continue;
+        const marker = `{{${m.name}}}`;
+        const stepIdx = built[si].folded.findIndex((st) => JSON.stringify(st).includes(marker));
+        if (stepIdx < 0)
+            continue;
+        (segDerived[si] ??= {})[m.name] = { step: stepIdx + 1, at: m.at, example: m.value };
+    }
+    // Drop slots no segment uses: instruction-only words (e.g. an id the
+    // orchestrator mentioned for context) would only make matching harder.
+    // EXCEPT known run values: a runid or threaded ref that appears only in the
+    // wording still changes every run, so leaving it literal would make the
+    // template single-run — bindSkill could never match run n+1's instruction.
+    const knownVals = new Set(Object.values(input.knownValues ?? {}).map((v) => String(v ?? '').trim()));
+    const usedNames = new Set();
+    for (const b of built)
+        for (const [name, p] of Object.entries(b.segParams))
+            if (p.usedIn.length)
+                usedNames.add(name);
+    // A known value can be wholly swallowed by a longer slot (the bare runid
+    // inside the ticket-title slot): its marker then appears nowhere, and a
+    // param that can never bind makes bindSkill refuse the skill's own source
+    // instruction. Keep a known-value slot only when its marker survives.
+    const tentative = sub(input.instruction);
+    const keptSlots = new Map([...slots].filter(([n, v]) => usedNames.has(n) || (knownVals.has(v) && tentative.includes(`{{${n}}}`))));
+    const finalTemplate = keptSlots.size === slots.size ? sub(input.instruction) : substitute(input.instruction, keptSlots);
+    // The mirror hazard: a slot whose marker survives only in STEPS (its every
+    // instruction occurrence was swallowed by a longer slot, or the value came
+    // from an EARLIER instruction and this one never names it) can never bind
+    // from the template — bindSkill derives values from the template alone,
+    // then requires every param to have one.
+    //
+    // If the run banked the value, the param binds to its ORIGIN instead: a
+    // later run resolves its own from the same place, and the marker stays. Only
+    // when the origin is unknown do we fall back to re-inlining the recorded
+    // literal, which is the compromise that put the recording run's runid inside
+    // an anchor's hasText and cost every replay a positional fallback
+    // (fwrd19l 04-edit, on both replays, deterministically).
+    const originOfValue = new Map(Object.entries(input.knownValues ?? {}).map(([key, v]) => [String(v ?? '').trim(), key]));
+    const bindings = new Map();
+    const inTemplate = new Set(Array.from(finalTemplate.matchAll(/\{\{(v\d+)\}\}/g), (m) => m[1]));
+    for (const [name, value] of [...keptSlots]) {
+        // Every slot whose origin is known records it — the ones the template
+        // can supply too. A re-pin onto this skill from another run rebinds its
+        // slots by origin (remapParams); without the origin it could only guess
+        // by value, and rpat2 guessed an earlier run's literal into a live run.
+        const origin = originOfValue.get(value);
+        if (origin)
+            bindings.set(name, origin);
+        if (inTemplate.has(name) || origin)
+            continue;
+        keptSlots.delete(name);
+    }
+    // Every slot that did not survive is re-inlined as its recorded literal —
+    // in args, locators AND expectations. A dropped slot whose marker lingered
+    // only in addedContains was an orphan {{vN}} that replay treated as a HARD,
+    // unfillable line.
+    for (const [name, value] of slots) {
+        if (keptSlots.has(name))
+            continue;
+        for (const b of built)
+            b.folded = fillParamsDeep(b.folded, { [name]: value });
+    }
+    const now = input.now ?? new Date().toISOString();
+    const reportTemplate = {
+        summary: sub(input.report.summary),
+        values: Object.fromEntries(Object.entries(reportValues).map(([k, v]) => [k, sub(String(v))])),
+    };
+    // What the page shows once this procedure's work is done. Derived from the
+    // recording's own before/after pair: report text that was NOT on the page
+    // when the instruction began. See deriveGoal.
+    const goal = deriveGoal({
+        startText: head?.startText,
+        reportValues,
+        sub,
+        // Single-segment only: startText is the page the instruction BEGAN on,
+        // and only when no page-template seam was crossed is that the same page
+        // the report read its values from. A confirm that started on the list
+        // would otherwise take "Sales Order" — listed in Odoo's status bar before
+        // the confirm as well — for its goal, and skip the step on a form.
+        mutating: built.length === 1 && built.some((b) => mutatesSteps(b.folded)),
+        // Identities, not states: anything the caller vouched for, anything the
+        // run minted, and every slot's recorded value. "S00021" appearing in the
+        // report is the record's NAME — it was equally true before the work.
+        identities: new Set([...knownVals, ...minted.map((m) => m.value), ...slots.values()].map((v) => String(v ?? '').replace(/\s+/g, ' ').trim()).filter(Boolean)),
+    });
+    const of = built.length;
+    const chain = of > 1 ? newSkillId(origin, finalTemplate, now) : null;
+    return built.map((b, k) => {
+        const params = {};
+        for (const name of keptSlots.keys()) {
+            const value = keptSlots.get(name) ?? '';
+            params[name] = {
+                ...b.segParams[name],
+                ...(derivesFromKnown(value, knownVals) ? { known: true } : {}),
+                ...(bindings.has(name) ? { binding: bindings.get(name) } : {}),
+            };
+        }
+        return {
+            id: newSkillId(origin, of > 1 ? `${finalTemplate}#${k}` : finalTemplate, now),
+            origin,
+            template: finalTemplate,
+            params,
+            preconditions: {
+                // keptSlots, not slots: a dropped slot has no param to bind, and its
+                // marker in the pattern would read as a wildcard segment.
+                urlPattern: urlPattern(b.sg.startUrl, new Map([...keptSlots, ...b.mintedForStart])),
+                ...(b.sg.fingerprint ? { fingerprint: b.sg.fingerprint } : {}),
+                ...(identityOf(b.sg.startText, keptSlots, knownVals).length
+                    ? { requireText: identityOf(b.sg.startText, keptSlots, knownVals) }
+                    : {}),
+            },
+            // Only the LAST segment finishes the work, so only it can vouch for the
+            // end state — an earlier segment carrying the goal would let a chain be
+            // skipped from its head on evidence its tail produced.
+            ...(k === of - 1 && goal ? { goal } : {}),
+            steps: b.folded,
+            ...(segDerived[k] ? { derived: segDerived[k] } : {}),
+            // Only the last segment can vouch for the instruction's end state.
+            ...(k === of - 1 ? { reportTemplate } : {}),
+            stats: { uses: 1, successes: 1, partial: 0, created: now, failedAtStep: {}, fallthroughs: 0 },
+            status: 'provisional',
+            ...(chain ? { seq: { chain, index: k, of } } : {}),
+            ...(input.variantOf ? { variantOf: input.variantOf } : {}),
+            provenance: { session: input.session, instruction: input.instruction, ...(input.model ? { model: input.model } : {}), created: now },
+        };
+    });
+}
+const MIN_GOAL_LEN = 3;
+const MAX_GOAL = 4;
+/** Does this procedure CHANGE anything? (learn.ts's `mutates`, at compile time.) */
+const MUTATING_TOOLS = new Set(['click', 'dblclick', 'right_click', 'modifier_click', 'fill', 'type', 'press', 'select', 'check', 'drag', 'upload']);
+function mutatesSteps(steps) {
+    return steps.some((s) => MUTATING_TOOLS.has(s.tool) || (s.body ? mutatesSteps(s.body) : false));
+}
+/**
+ * The GOAL: what the page shows once this procedure's work is done.
+ *
+ * The evidence is the recording's own before/after pair — `startText` (what
+ * the page showed when the instruction began) against the report's read-back
+ * values (what it showed when the work was finished). A report line that was
+ * NOT in `startText` is text the procedure BROUGHT INTO EXISTENCE, which is
+ * exactly the signal "already done" needs: Odoo's status bar lists every
+ * reachable state, so "Sales Order" is showing whether or not the order was
+ * cancelled, while "Cancelled" is listed only once it was.
+ *
+ * Everything here is a filter against FALSE POSITIVES, because a false
+ * positive skips work that never happened while a false negative merely runs
+ * the step as before:
+ *  - text already in `startText` is not evidence of anything (it was true
+ *    before);
+ *  - an identity — a caller-vouched value, a minted id, a slot's recorded
+ *    literal — names the RECORD, not its state, and is equally true before
+ *    and after;
+ *  - a line that still carries a `{{slot}}` after substitution cannot be
+ *    checked against a live page without guessing what fills it;
+ *  - and no startText, no report values, or a read-only procedure means no
+ *    goal at all. Never guess one.
+ */
+function deriveGoal(opts) {
+    if (!opts.mutating || !opts.startText)
+        return null;
+    const before = opts.startText.replace(/\s+/g, ' ').toLowerCase();
+    const out = [];
+    const seen = new Set();
+    for (const raw of Object.values(opts.reportValues)) {
+        for (const rawLine of String(raw ?? '').split('\n')) {
+            const line = rawLine.replace(/\s+/g, ' ').trim();
+            if (line.length < MIN_GOAL_LEN)
+                continue;
+            if (!/[A-Za-z]/.test(line))
+                continue; // digits and punctuation are ids and counts, not states
+            if (before.includes(line.toLowerCase()))
+                continue;
+            if (opts.identities.has(line))
+                continue;
+            const subbed = opts.sub(line);
+            if (subbed.includes('{{'))
+                continue;
+            if (seen.has(subbed.toLowerCase()))
+                continue;
+            seen.add(subbed.toLowerCase());
+            out.push(subbed);
+            if (out.length >= MAX_GOAL)
+                return { requireText: out };
+        }
+    }
+    return out.length ? { requireText: out } : null;
+}
+const MIN_IDENTITY_LEN = 4;
+const MAX_IDENTITY = 2;
+/**
+ * Which caller-vouched values the page ALREADY showed where this segment
+ * starts — the segment's identity precondition, as slot markers so replay
+ * checks the live run's own values.
+ *
+ * Only known values qualify (the runid, a threaded ref, url provenance): they
+ * are the ones that name the record the caller means, and a value the
+ * compiler merely inferred from repeated text could easily be page furniture.
+ * A value the segment is about to TYPE is not on the page yet, so it never
+ * qualifies either — which is what keeps this from refusing a create step.
+ */
+/**
+ * Caller-vouched, or built out of something the caller vouched for: the
+ * ticket TITLE ("r9-n2 RD Bench Ticket") is as run-scoped as the runid inside
+ * it, and it is usually the title — not the bare runid — that survives as a
+ * slot, because the longer value swallows the shorter one. Treating only the
+ * exact known value as identity would therefore lose identity on exactly the
+ * skills that need it.
+ */
+function derivesFromKnown(value, known) {
+    if (known.has(value))
+        return true;
+    for (const k of known) {
+        if (k.length < 3 || k.length === value.length)
+            continue;
+        if (new RegExp(`(?<![A-Za-z0-9])${escapeRe(k)}(?![A-Za-z0-9])`).test(value))
+            return true;
+    }
+    return false;
+}
+function identityOf(startText, slots, known) {
+    if (!startText)
+        return [];
+    const out = [];
+    for (const [name, raw] of slots) {
+        if (out.length >= MAX_IDENTITY)
+            break;
+        // Whitespace is not identity. fwkb3 published a column name as "Backlog "
+        // (trailing space, copied from the header's text), the slot became a
+        // requireText marker, and every replay refused the create step because
+        // the live page showed "Backlog" — the same word.
+        const value = raw.replace(/\s+/g, ' ').trim();
+        if (!derivesFromKnown(raw, known) || value.length < MIN_IDENTITY_LEN || /^https?:/i.test(value))
+            continue;
+        if (!startText.replace(/\s+/g, ' ').includes(value))
+            continue;
+        out.push(`{{${name}}}`);
+    }
+    return out;
+}
+const MAX_MINTED = 8;
+/**
+ * Mechanism-1 provenance (PLAN-replay-v2): values the run itself minted. A
+ * url part that first appears in a step's post-navigation url — absent from
+ * the start url, every earlier url, the caller's slot values and everything
+ * the agent typed — was created by this run (a fresh record id, a generated
+ * uid). Every later occurrence is downstream of that step's outcome, so it
+ * becomes a {{dN}} reference bound at replay time from where the browser
+ * actually lands — the same mechanism as discoverSlots, with a new value
+ * source, and the same guards: id-shaped, whole-value match, first
+ * appearance wins.
+ */
+function discoverMinted(kept, startUrl, slots) {
+    const seen = new Set(urlParts(startUrl).map((p) => p.value));
+    const slotVals = new Set(slots.values());
+    const out = [];
+    kept.forEach((step, i) => {
+        // Values the agent TYPED are inputs, not mints, wherever they surface later.
+        for (const v of Object.values(step.args))
+            if (typeof v === 'string')
+                seen.add(v);
+        if (!step.diff?.url)
+            return;
+        for (const part of urlParts(step.diff.url)) {
+            const v = part.value;
+            const fresh = !seen.has(v);
+            seen.add(v);
+            // Position is evidence. A bare "44" free in prose means nothing, which is
+            // why the ledger keeps a length floor — but "44" sitting in a url part
+            // is a record id, and isIdLike already says so for url-pattern
+            // generalisation. Requiring 4 characters here contradicted that: odoo's
+            // record ids are two-digit integers, so fwod15 compiled ZERO minting
+            // steps and the whole `mints` mechanism was inert on that target.
+            //
+            // Same shape as the two floor mismatches already fixed today ("t15"
+            // below identifierLike's floor; url parts published at >= 4 while
+            // buildFlow minted refs at >= 3). Three separate thresholds asking one
+            // question, disagreeing three times. This one now asks the question the
+            // url code already answers.
+            if (!fresh || !(isIdLike(v) || identifierLike(v)) || slotVals.has(v) || /\{\{/.test(v))
+                continue;
+            // A stable route word ("tickets", "dashboards") also first appears in a
+            // post-nav url once; claiming it would wildcard preconditions that
+            // should stay exact. Requiring a digit is a heuristic, but one whose
+            // being wrong costs a soft-match comparison (mechanism 2 still catches
+            // a digitless minted id), not a dead flow.
+            if (!/\d/.test(v))
+                continue;
+            if (out.length >= MAX_MINTED)
+                continue;
+            out.push({ name: `d${out.length + 1}`, value: v, keptIndex: i, at: part.label });
+        }
+    });
+    return out;
+}
+/**
+ * Literal values the agent used that also appear as whole tokens in the
+ * instruction. Ordered by first occurrence in the instruction, longest match
+ * first when values nest ("x7 RD Part A" before "x7").
+ *
+ * `known` are run-scoped values the CALLER vouches for — declared flow vars
+ * (the runid) and minted url-provenance parts. They are slotted by policy,
+ * not heuristics: every occurrence in the instruction, args, and locators is
+ * the same value playing the same role by construction, so the
+ * single-occurrence guard below does not apply to them (unlike admin/admin,
+ * where one string served two different roles). This is what keeps a run
+ * identifier out of a compiled skill: fwrd3 baked "fwrd3-n1"/"RD-1015" into
+ * templates and steps, so every skill was single-run poison — tier-A replay
+ * died at the first stale literal on every later run, and repairs minted a
+ * fresh single-run corpse each time instead of converging.
+ */
+export function discoverSlots(instruction, steps, known = {}) {
+    const values = new Set();
+    const locatorCandidates = new Set();
+    for (const step of steps) {
+        if (step.tool === 'read' || step.tool === 'read_all' || step.tool === 'eval')
+            continue;
+        for (const [key, v] of Object.entries(step.args)) {
+            if (!VALUE_ARGS.has(key) || typeof v !== 'string')
+                continue;
+            const value = v.trim();
+            if (value.length < 2 || value.length > 200)
+                continue;
+            if (!occursAsToken(instruction, value))
+                continue;
+            values.add(value);
+        }
+        // wait_for text is a check, but a check on a parameter is still parameterised
+        if (step.tool === 'wait_for' && typeof step.args.text === 'string' && occursAsToken(instruction, step.args.text.trim())) {
+            values.add(step.args.text.trim());
+        }
+        // A locator that IDENTIFIES a record — clicking the row for ticket
+        // "RD-1015", a link named after the value — hard-codes that record unless
+        // its identifying string is parameterised too. Collect candidates now;
+        // add them below only if they look record-specific, so a plain UI label
+        // ("Save") that happens to appear in the instruction is not parameterised.
+        for (const loc of Object.values(step.locators)) {
+            for (const value of locatorValues(loc.chain ?? [])) {
+                const v = value.trim();
+                if (v.length >= 2 && v.length <= 200 && occursAsToken(instruction, v))
+                    locatorCandidates.add(v);
+            }
+        }
+    }
+    for (const v of locatorCandidates) {
+        // Record-specific = already a value the caller typed (an arg slot), or
+        // carries an identifier (a digit / id-like token). Excludes stable UI text.
+        if (values.has(v) || /\d/.test(v) || v.split(/\s+/).some(isIdLike))
+            values.add(v);
+    }
+    const knownVals = [];
+    for (const raw of Object.values(known)) {
+        const v = String(raw ?? '').trim();
+        if (v.length < 2 || v.length > 200)
+            continue;
+        if (!occursAsToken(instruction, v) || knownVals.includes(v))
+            continue;
+        knownVals.push(v);
+    }
+    knownVals.sort((a, b) => instruction.indexOf(a) - instruction.indexOf(b) || b.length - a.length);
+    const ordered = [...values]
+        .filter((v) => !knownVals.includes(v))
+        // A value appearing twice in the instruction cannot be given a slot: one
+        // slot name would stand for two roles. "sign in with email admin and
+        // password admin" compiled to "email {{v1}} and password {{v1}}", and
+        // bindSkill emits a capture group per OCCURRENCE, so replaying it with
+        // "email alice@example.com and password hunter2" bound v1 to the last
+        // group and typed the password into the email field — silently, and with
+        // a credential. Leaving such a value literal costs generality (the skill
+        // only replays for the values it was recorded with) and keeps
+        // correctness, which is the right way round. Distinct positional slots
+        // per occurrence would recover the generality, but they also need the
+        // step-to-occurrence mapping that plain textual substitution cannot
+        // recover, so that is a separate change.
+        .filter((v) => countTokenOccurrences(instruction, v) === 1)
+        .map((v) => ({ v, at: instruction.indexOf(v) }))
+        .sort((a, b) => a.at - b.at || b.v.length - a.v.length)
+        .slice(0, Math.max(0, MAX_SLOT_VALUES - knownVals.length));
+    // Third slot source, exempt from instruction anchoring: a navigation arg's
+    // `id=` value that the ledger already banked from an EARLIER instruction's
+    // url. The armdoc rightly forbids instructions naming database ids, so this
+    // value can never anchor in prose — but its ORIGIN is known (a `url:iN:q.id`
+    // binding), and slots bind by origin when the template cannot supply them.
+    // fwod29 is the cost of the gap: three downstream skills carried
+    // `...&id=21` literally, every replay navigated to the recording run's
+    // deleted order, saw an empty page, and paid ~20 recovery turns.
+    const urlIdVals = [];
+    const knownIdOrigins = new Set(Object.entries(known)
+        .filter(([k]) => /:q\.id$/.test(k))
+        .map(([, v]) => String(v ?? '').trim()));
+    for (const step of steps) {
+        if (typeof step.args.url !== 'string')
+            continue;
+        for (const part of urlParts(step.args.url)) {
+            if (part.label !== 'q.id' || !/^\d{1,10}$/.test(part.value))
+                continue;
+            if (!knownIdOrigins.has(part.value) || urlIdVals.includes(part.value))
+                continue;
+            if (knownVals.includes(part.value) || values.has(part.value))
+                continue;
+            urlIdVals.push(part.value);
+        }
+    }
+    const slots = new Map();
+    // Known values first so a cap can never cut them: they are the slots that
+    // decide whether the skill survives past the run that recorded it.
+    [...knownVals, ...ordered.map(({ v }) => v), ...urlIdVals].forEach((v, i) => slots.set(`v${i + 1}`, v));
+    return slots;
+}
+/** Rewrite `id=<value>` url params to slot markers — see the call site. */
+/**
+ * Rewrite minted url parts inside a navigation url at the position each was
+ * minted from: a value minted at `q.action` replaces `action=<value>` (query
+ * or hash state) with `action={{dN}}`, and nothing else — a "135" elsewhere
+ * in the url is left alone.
+ */
+export function substituteUrlParts(url, minted) {
+    let out = url;
+    for (const m of minted) {
+        if (!m.value || !m.at.startsWith('q.'))
+            continue;
+        const key = m.at.slice(2);
+        out = out.replace(new RegExp(`([?&#]${escapeRe(key)}=)${escapeRe(m.value)}(?=[&#]|$)`, 'g'), `$1{{${m.name}}}`);
+    }
+    return out;
+}
+export function substituteUrlId(url, slots) {
+    let out = url;
+    for (const [name, value] of slots) {
+        if (!/^\d{1,10}$/.test(value))
+            continue;
+        out = out.replace(new RegExp(`([?&#]id=)${escapeRe(value)}(?=[&#]|$)`, 'g'), `$1{{${name}}}`);
+    }
+    return out;
+}
+/** How many times `value` stands as a whole token in `text`. */
+export function countTokenOccurrences(text, value) {
+    if (!value)
+        return 0;
+    const re = new RegExp(`(^|[^A-Za-z0-9])${escapeRe(value)}(?=$|[^A-Za-z0-9])`, 'g');
+    let n = 0;
+    while (re.exec(text) !== null)
+        n++;
+    return n;
+}
+function occursAsToken(text, value) {
+    if (!value)
+        return false;
+    const re = new RegExp(`(^|[^A-Za-z0-9])${escapeRe(value)}(?=$|[^A-Za-z0-9])`);
+    return re.test(text);
+}
+/**
+ * The human-meaningful identifying strings in a locator chain — the ones that
+ * can carry a record identifier (a role/link name, visible text, a label). Id
+ * and css selectors are excluded: their embedded ids are already handled by
+ * stableFirst (demoted) and are not values a caller would supply.
+ */
+/**
+ * An identity anchor left naming the recorded run's record: its text still
+ * contains a value the caller vouched for THIS run, with no slot to swap.
+ * Only anchors qualify — a role/text locator that survives un-slotted is
+ * ordinary UI text, and dropping it would cost a working fallback.
+ */
+/**
+ * Positional: this candidate finds an element by WHERE it sits (a structural
+ * path, or an index into a set of matches), not by what it is. Fine as a
+ * fallback for an action whose target is otherwise pinned; never sufficient
+ * on its own for a read that names a record.
+ */
+function positional(c) {
+    return c.kind === 'css' || c.kind === 'point' || c.nth !== undefined;
+}
+export function stranded(c, runValues) {
+    const fields = [];
+    if (c.kind === 'scoped')
+        fields.push(c.hasText);
+    // A NAME that is really a record reference. The rule used to stop at
+    // anchors, reasoning that "a role/text locator that survives un-slotted is
+    // ordinary UI text, and dropping it would cost a working fallback". True of
+    // ordinary UI text — false of a link whose accessible name IS the ticket
+    // ref. fwrd22l shipped six of these, `getByText('RD-1015')` and
+    // `getByRole('link', { name: 'RD-1015' })`, every one of them pinned to the
+    // record the RECORDING run created. A value that changes every run is not a
+    // working fallback, it is a fallback that has already stopped working.
+    else if (c.kind === 'role')
+        fields.push(c.name);
+    else if (c.kind === 'text')
+        fields.push(c.text);
+    else if (c.kind === 'label')
+        fields.push(c.label);
+    else if (c.kind === 'placeholder')
+        fields.push(c.placeholder);
+    // An ADDRESS welded out of a value this run minted. `ticket-link-t15` is
+    // the record's own id inside a test hook, and it survived every fix so far
+    // because this check only ever looked at anchors: fwrd20l and fwrd21l both
+    // shipped it. stableFirst demotes it to the tail, so it is not usually
+    // reached — but if the anchor and the structural path both miss, it
+    // resolves against whatever wears that id NEXT run, which on an app that
+    // reuses ids is a different record.
+    else if (c.kind === 'testid')
+        fields.push(c.value);
+    else if (c.kind === 'id' || c.kind === 'css')
+        fields.push(c.selector);
+    return fields.some((f) => runValues.some((v) => f.includes(v)));
+}
+/**
+ * An ADDRESS that is really a bookmark: a test hook or an id whose text
+ * carries a minted identifier, like `ticket-link-t15`. Next run the record is
+ * t16 and it matches nothing — or worse, on an app that reuses ids, it
+ * matches a DIFFERENT record.
+ *
+ * Distinct from `stranded`, which needs the value to be one the run
+ * demonstrably made. That is not enough here: the id an instruction MINTS is
+ * unknown while that instruction is compiling — repair-desk's create step
+ * never visits a t15 url, so nothing banks it — yet the testid recorded on
+ * that very step already has it welded in. fwrd19l shipped three, fwrd20l and
+ * fwrd21l two each, all of them below `stranded`'s reach.
+ *
+ * Structural, so it needs no provenance: an id-like token that is not a slot
+ * marker. Bare one- and two-digit numbers are excluded by `isIdLike`'s
+ * callers here, so ordinary hooks (`del-1`, `row-2`) are untouched.
+ */
+function bookmarked(c) {
+    if (c.kind !== 'testid' && c.kind !== 'id')
+        return false;
+    const text = c.kind === 'testid' ? c.value : c.selector;
+    return text
+        .split(/[^A-Za-z0-9{}]+/)
+        .filter(Boolean)
+        .some((tok) => !tok.includes('{{') && isIdLike(tok) && !/^\d{1,2}$/.test(tok));
+}
+function locatorValues(chain) {
+    const out = [];
+    for (const c of chain) {
+        if (c.kind === 'scoped')
+            out.push(c.hasText);
+        else if (c.kind === 'role')
+            out.push(c.name);
+        else if (c.kind === 'text')
+            out.push(c.text);
+        else if (c.kind === 'label')
+            out.push(c.label);
+        else if (c.kind === 'placeholder')
+            out.push(c.placeholder);
+    }
+    return out.filter(Boolean);
+}
+export function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** Replace every slot value in `text` by its "{{vN}}" marker, longest values first. */
+export function substitute(text, slots) {
+    let out = text;
+    const byLength = [...slots].sort((a, b) => b[1].length - a[1].length);
+    for (const [name, value] of byLength) {
+        if (!value)
+            continue;
+        // Whole-token only, and a bare number never rewrites a selector index:
+        // a cost of "25" must not touch the 25 in `:nth-of-type(25)` or `nth=25`.
+        const numeric = /^\d+$/.test(value);
+        // A number inside a dotted run of numbers (127.0.0.1, 1.2.3) is part of
+        // that address or version, never a slot: fwod31 compiled the odoo start
+        // url as `http://127.0.0.{{d1}}:8069/...` after `cids=1` minted d1 = "1".
+        const re = numeric
+            ? new RegExp(`(?<![A-Za-z0-9(=]|\\d\\.)${escapeRe(value)}(?![A-Za-z0-9)]|\\.\\d)`, 'g')
+            : new RegExp(`(?<![A-Za-z0-9])${escapeRe(value)}(?![A-Za-z0-9])`, 'g');
+        out = out.replace(re, `{{${name}}}`);
+    }
+    return out;
+}
+/** Inverse of substitute(): fill "{{vN}}" (caller param) and "{{dN}}" (derived,
+ * bound from the live run's own urls) markers from a param map. */
+export function fillParams(text, params) {
+    return text.replace(/\{\{([vd]\d+)\}\}/g, (m, name) => (name in params ? params[name] : m));
+}
+export function substituteDeep(value, slots) {
+    if (typeof value === 'string')
+        return substitute(value, slots);
+    if (Array.isArray(value))
+        return value.map((v) => substituteDeep(v, slots));
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, substituteDeep(v, slots)]));
+    }
+    return value;
+}
+export function fillParamsDeep(value, params) {
+    if (typeof value === 'string')
+        return fillParams(value, params);
+    if (Array.isArray(value))
+        return value.map((v) => fillParamsDeep(v, params));
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, fillParamsDeep(v, params)]));
+    }
+    return value;
+}
+export function slotsUsed(text) {
+    return [...new Set([...text.matchAll(/\{\{(v\d+)\}\}/g)].map((m) => m[1]))];
+}
+/**
+ * A url reduced to the shape that identifies its page: origin + path + hash
+ * route, with id-like segments replaced by `:id` and the query dropped.
+ * Slot values in the path become their markers, so a skill recorded on
+ * `/tickets/x7` matches `/tickets/{{v1}}` on the next run.
+ */
+export function urlPattern(url, slots = new Map()) {
+    let u;
+    try {
+        u = new URL(url);
+    }
+    catch {
+        return url;
+    }
+    const norm = (p) => p
+        .split('/')
+        .map((seg) => {
+        if (!seg)
+            return seg;
+        const filled = substitute(safeDecode(seg), slots);
+        if (filled !== seg && filled.includes('{{'))
+            return filled;
+        return isIdLike(seg) ? ':id' : seg;
+    })
+        .join('/');
+    /**
+     * A hash-routed app puts its route in the fragment, in one of two shapes: a
+     * path ("#/orders/123") or a query-like state string
+     * ("#action=123&cids=1&menu_id=81", which is Odoo). Only the path shape was
+     * being reduced, because norm() splits on "/" and a query-shaped fragment
+     * has none — so the whole fragment survived verbatim, volatile ids and all.
+     *
+     * That made a segment's precondition unmatchable by anything but the run
+     * that recorded it: Odoo hands out a fresh action id per session, so a
+     * chain's second segment refused every replay and the work fell back to the
+     * model, run after run, with the store looking perfectly healthy.
+     *
+     * Keys are kept (they are what distinguishes one template from another) and
+     * id-like values reduced. Pairs are sorted because the app is free to emit
+     * them in any order between runs, and two orderings of the same state are
+     * the same page.
+     */
+    const normHash = (raw) => {
+        const body = raw.split('?')[0];
+        if (!body)
+            return '';
+        if (body.startsWith('/') || !body.includes('='))
+            return '#' + norm(body);
+        const pairs = body
+            .split('&')
+            .filter(Boolean)
+            .map((pair) => {
+            const eq = pair.indexOf('=');
+            if (eq < 0)
+                return pair;
+            const key = pair.slice(0, eq);
+            const value = pair.slice(eq + 1);
+            const filled = substitute(safeDecode(value), slots);
+            if (filled !== value && filled.includes('{{'))
+                return `${key}=${filled}`;
+            return `${key}=${isIdLike(value) ? ':id' : value}`;
+        })
+            .sort();
+        return '#' + pairs.join('&');
+    };
+    const hash = u.hash && u.hash.length > 1 ? normHash(u.hash.slice(1)) : '';
+    // An opaque origin (chrome-error://, about:) prints as "null"; keep the
+    // url itself so a message says what the browser was actually showing.
+    if (u.origin === 'null')
+        return url;
+    const origin = u.protocol === 'file:' ? 'file://' : u.origin;
+    return `${origin}${norm(u.pathname)}${hash}`;
+}
+export function isIdLike(seg) {
+    if (/^\d+$/.test(seg))
+        return true;
+    if (/^[0-9a-f]{8,}$/i.test(seg))
+        return true;
+    if (/^[0-9a-f-]{32,}$/i.test(seg))
+        return true; // uuid
+    if (/^[A-Za-z]{1,4}[-_]?\d+$/.test(seg))
+        return true; // t15, RD-1015
+    if (/^[A-Za-z0-9_-]{16,}$/.test(seg) && /\d/.test(seg))
+        return true; // opaque tokens
+    return false;
+}
+function safeDecode(s) {
+    try {
+        return decodeURIComponent(s);
+    }
+    catch {
+        return s;
+    }
+}
+function urlShapeOf(s) {
+    let u;
+    try {
+        u = new URL(s);
+    }
+    catch {
+        return null;
+    }
+    const origin = u.protocol === 'file:' ? 'file://' : u.origin;
+    const shape = {
+        origin,
+        path: u.pathname.split('/').filter(Boolean).map(safeDecode),
+        hashKind: 'none',
+        hashPath: [],
+        hashState: new Map(),
+        hashSlash: false,
+    };
+    const body = u.hash && u.hash.length > 1 ? u.hash.slice(1).split('?')[0] : '';
+    if (!body)
+        return shape;
+    if (body.startsWith('/') || !body.includes('=')) {
+        shape.hashKind = 'path';
+        shape.hashSlash = body.startsWith('/');
+        shape.hashPath = body.split('/').filter(Boolean).map(safeDecode);
+        return shape;
+    }
+    shape.hashKind = 'state';
+    for (const pair of body.split('&').filter(Boolean)) {
+        const eq = pair.indexOf('=');
+        if (eq < 0)
+            shape.hashState.set(pair, '');
+        else
+            shape.hashState.set(pair.slice(0, eq), safeDecode(pair.slice(eq + 1)));
+    }
+    return shape;
+}
+function serializeShape(s) {
+    let hash = '';
+    if (s.hashKind === 'path')
+        hash = '#' + (s.hashSlash ? '/' : '') + s.hashPath.join('/');
+    else if (s.hashKind === 'state') {
+        hash = '#' + [...s.hashState].map(([k, v]) => `${k}=${v}`).sort().join('&');
+    }
+    return `${s.origin}/${s.path.join('/')}${hash}`;
+}
+/** A pattern segment that stands for "any value here". */
+function isWildcardSeg(seg) {
+    return seg === ':id' || seg === ':var' || /\{\{[\w.-]+\}\}/.test(seg);
+}
+/**
+ * Structural comparison of a stored pattern against a live url: `null` when
+ * the two are not even the same page shape (different origin, path length,
+ * route, or a required state key missing), otherwise the list of segments
+ * where a literal in the pattern disagrees with the live value — empty list
+ * means a match. Wildcard segments (`:id`, `:var`, unfilled `{{…}}`) match
+ * anything: matching consults the pattern's own markers, never a shape
+ * heuristic on the live value (that is what made isIdLike load-bearing).
+ *
+ * A query-shaped fragment is application STATE, and state accumulates (Odoo
+ * lands on "#cids=1" and has grown "#action=…&menu_id=…" by the next
+ * segment) — so it is a necessary condition: every pair the pattern names
+ * must be present, extra live pairs are allowed, and a pattern with no hash
+ * requires nothing of a live state fragment. A path-shaped fragment is a
+ * route and must match segment for segment.
+ */
+export function urlDiff(pattern, url) {
+    const p = urlShapeOf(pattern);
+    const l = urlShapeOf(url);
+    if (!p || !l)
+        return pattern === url ? [] : null;
+    if (p.origin !== l.origin || p.path.length !== l.path.length)
+        return null;
+    const diffs = [];
+    p.path.forEach((seg, i) => {
+        if (!isWildcardSeg(seg) && seg !== l.path[i])
+            diffs.push({ where: 'path', index: i, expected: seg, actual: l.path[i] });
+    });
+    if (p.hashKind === 'path') {
+        if (l.hashKind !== 'path' || p.hashPath.length !== l.hashPath.length)
+            return null;
+        p.hashPath.forEach((seg, i) => {
+            if (!isWildcardSeg(seg) && seg !== l.hashPath[i])
+                diffs.push({ where: 'hashPath', index: i, expected: seg, actual: l.hashPath[i] });
+        });
+    }
+    else if (p.hashKind === 'state') {
+        if (l.hashKind !== 'state')
+            return null;
+        for (const [key, val] of p.hashState) {
+            // A key the pattern only knows as a wildcard (`:id`, a {{dN}} it never
+            // learned a value for) is app-minted state, not identity: odoo adds
+            // `cids=1` to a url on one run and not the next, and fwod32's sign-in
+            // stopped on every replay because the live url lacked it. A missing
+            // key with a LITERAL value is still a different page.
+            if (!l.hashState.has(key)) {
+                if (isWildcardSeg(val))
+                    continue;
+                return null;
+            }
+            const lv = l.hashState.get(key);
+            if (!isWildcardSeg(val) && val !== lv)
+                diffs.push({ where: 'hashState', key, expected: val, actual: lv });
+        }
+    }
+    else if (l.hashKind === 'path' && l.hashPath.length) {
+        return null; // pattern names no route; the live url is on one
+    }
+    return diffs;
+}
+/** Whether a live url matches a stored pattern exactly (wildcards aside). */
+export function urlMatches(pattern, url, params = {}) {
+    return urlDiff(fillParams(pattern, params), url)?.length === 0;
+}
+const MAX_SOFT_DIFFS = 2;
+/**
+ * Mechanism-2 tolerance (PLAN-replay-v2): the live url is the same page
+ * SHAPE as the pattern but 1–2 literal segments disagree — the signature of
+ * an environment-minted identifier (a Grafana uid, an Odoo action id) that
+ * this run minted differently. Returns the pattern with exactly the
+ * disagreeing segments generalised to `:var`, for the caller to proceed
+ * optimistically and PERSIST only once the run past this point succeeds —
+ * the segment has then demonstrated volatility. Null when the urls differ in
+ * shape, everything matched already, or a slot value broke segmentation.
+ */
+export function softUrlMatch(pattern, url, params = {}) {
+    const filled = fillParams(pattern, params);
+    const diffs = urlDiff(filled, url);
+    if (!diffs || !diffs.length || diffs.length > MAX_SOFT_DIFFS)
+        return null;
+    // Generalise in the ORIGINAL pattern (markers intact). A param value
+    // containing '/' would shift segment positions between the two — bail.
+    const orig = urlShapeOf(pattern);
+    const fld = urlShapeOf(filled);
+    if (!orig || !fld || orig.path.length !== fld.path.length || orig.hashPath.length !== fld.hashPath.length)
+        return null;
+    for (const d of diffs) {
+        if (d.where === 'path')
+            orig.path[d.index] = ':var';
+        else if (d.where === 'hashPath')
+            orig.hashPath[d.index] = ':var';
+        else
+            orig.hashState.set(d.key, ':var');
+    }
+    return { generalised: serializeShape(orig), diffs };
+}
+/**
+ * The addressable parts of a url, labelled stably so a value observed at
+ * record time can be re-extracted from the live run's url at the same
+ * position: path segments `p<i>`, hash-route segments `h<i>`, hash-state
+ * values `q.<key>`.
+ */
+export function urlParts(url) {
+    const s = urlShapeOf(url);
+    if (!s)
+        return [];
+    const out = [];
+    s.path.forEach((value, i) => out.push({ label: `p${i}`, value }));
+    s.hashPath.forEach((value, i) => out.push({ label: `h${i}`, value }));
+    for (const [k, value] of s.hashState)
+        out.push({ label: `q.${k}`, value });
+    return out;
+}
+export function urlPart(url, label) {
+    return urlParts(url).find((p) => p.label === label)?.value;
+}
+/**
+ * Page lines that describe the page in transit — spinners, progress bars,
+ * and toasts (an alert that happened to be on screen, such as fwgr25's
+ * "Error loading RSS feed", is not what the step did; a step's own alert is
+ * carried by alertContains, which stays soft). Never a lasting effect.
+ */
+export const TRANSIENT_LINE = /^-?\s*(status|progressbar|alert)\b/;
+function expectationFor(step, slots) {
+    if (!step.diff)
+        return undefined;
+    const out = {};
+    if (step.diff.url)
+        out.urlPattern = urlPattern(step.diff.url, slots);
+    if (step.diff.alerts[0])
+        out.alertContains = substitute(step.diff.alerts[0], slots).slice(0, 120);
+    if (step.diff.added.length) {
+        // A status or progress indicator is the page in transit, not where the
+        // step left it: fwgr25's sign-in recorded `- status "Loading"` as its
+        // click's only page change, and every replay — which caught the page
+        // after the spinner — stopped there and recovered for 24 turns.
+        const lasting = step.diff.added.filter((l) => !TRANSIENT_LINE.test(l));
+        if (lasting.length)
+            out.addedContains = lasting.slice(0, MAX_ADDED_LINES).map((l) => maskMinted(maskVolatile(substitute(l, slots))).slice(0, 120));
+    }
+    return Object.keys(out).length ? out : undefined;
+}
+/**
+ * An effect expectation asserts what the PROCEDURE put on the page, and the
+ * procedure only ever puts values there through its own fills and choices —
+ * which are slots (`{{vN}}`, or a `{{dN}}` the app minted and a url showed)
+ * by the time this runs, because substitute() went first. A control's
+ * displayed value that is NOT a slot is therefore the app's: a default, a
+ * computed figure, the id of the record the recording happened to make.
+ * atelyr's project picker recorded `- combobox "…": 13f9pv52yozr` — the
+ * recording's own project id — and every replay's project had another, so
+ * both add-item steps stopped at "did not show … as it did when recorded".
+ *
+ * Provenance, not shape: no attempt is made to recognise an identifier by
+ * how it looks, which breaks on the next app. The role and name still have
+ * to match; only the value after the colon is wildcarded.
+ */
+export function maskMinted(line) {
+    // `- role "name" [state]: value` — the value colon is the one after the
+    // (quoted) name and any state markers, never one inside the name.
+    return line.replace(/^(-?\s*\S+(?:\s+"(?:[^"\\]|\\.)*")?(?:\s+\[[^\]]*\])*)(:\s*)(\S.*?)\s*$/, (whole, head, sep, value) => value.includes('{{') ? whole : `${head}${sep}${WILDCARD}`);
+}
+/**
+ * Clock and calendar tokens in a recorded page line are the RECORDING's
+ * moment, not the procedure's effect: kanboard names its due-date textbox
+ * after the current minute ("09/03/2026 07:22"), so the fill's expectation
+ * `- textbox "09/03/2026 07:22": {{v3}}` — HARD, because it carries the slot
+ * — could never match a replay nine minutes later, and fwkb3 sent every
+ * due-date step to recovery. The caller's own date is already a slot by the
+ * time this runs (substitute() went first), so what is left is volatile and
+ * becomes a `{{*}}` wildcard that lineShows() matches against anything short
+ * of a line break.
+ */
+export { WILDCARD, maskVolatile } from '../shared/text.js';
+/** If a read's result equals one of the report's evidence values, label it with that key. */
+function readLabel(step, values) {
+    if (step.tool !== 'read' && step.tool !== 'read_all')
+        return undefined;
+    // Carried from the report, where the name came from. Exact beats matching.
+    if (step.label && step.label in values)
+        return step.label;
+    if (step.result === undefined)
+        return undefined;
+    let observed;
+    try {
+        observed = JSON.parse(step.result);
+    }
+    catch {
+        observed = step.result;
+    }
+    const flat = Array.isArray(observed) ? observed.map(String) : [String(observed)];
+    // A list read is the LIST first: a read_all of three panel headings whose
+    // first element happens to equal a per-item value was labelled with that
+    // item (fwgr23: `read_all h2` → panel_title_request_rate) and the value the
+    // report joined from the whole list — panel_titles — was never published.
+    if (flat.length > 1) {
+        const joined = new Set([', ', ' | ', '; ', ' ', '\n', ','].map((sep) => flat.map((f) => f.trim()).join(sep)));
+        for (const [key, v] of Object.entries(values))
+            if (joined.has(String(v).trim()))
+                return key;
+    }
+    for (const [key, v] of Object.entries(values)) {
+        const s = String(v).trim();
+        if (s && flat.some((f) => f.trim() === s))
+            return key;
+    }
+    return undefined;
+}
+function firstUrl(steps) {
+    const goto = steps.find((s) => s.tool === 'goto' && typeof s.args.url === 'string');
+    return goto ? String(goto.args.url) : undefined;
+}
+/**
+ * Candidates whose selector text embeds something id-like (`ticket-link-t15`,
+ * `#row-1042`) were unique on the recorded page but will name a *different*
+ * element on the next run. They stay in the chain as a last resort; the
+ * semantic candidates (role+name, label, text — now parameterised) go first.
+ */
+export function stableFirst(chain) {
+    const volatile = (c) => {
+        // Where it was is the last resort by definition: behind every name and
+        // every path. fwgr27's store had it second, ahead of the anchored path.
+        if (c.kind === 'point')
+            return true;
+        if (c.kind === 'testid' || c.kind === 'id' || c.kind === 'css') {
+            const text = c.kind === 'testid' ? c.value : c.selector;
+            return text
+                .split(/[^A-Za-z0-9{}]+/)
+                .filter(Boolean)
+                .some((tok) => !tok.includes('{{') && isIdLike(tok) && !/^\d{1,2}$/.test(tok));
+        }
+        // A name that is nothing but an id ("RD-1017") names a record, not a
+        // control: the same element next run will carry a different one.
+        const name = c.kind === 'role' ? c.name : c.kind === 'text' ? c.text : '';
+        return Boolean(name) && !name.includes('{{') && isIdLike(name.trim());
+    };
+    const stable = chain.filter((c) => !volatile(c));
+    const points = chain.filter((c) => c.kind === 'point');
+    const rest = chain.filter((c) => volatile(c) && c.kind !== 'point');
+    return stable.length || points.length ? [...stable, ...rest, ...points] : chain;
+}
+/** Steps are structurally the same procedure: same tools, same primary locator shapes. */
+export function sameProcedure(a, b) {
+    if (a.steps.length !== b.steps.length)
+        return false;
+    return a.steps.every((s, i) => {
+        const t = b.steps[i];
+        if (s.tool !== t.tool)
+            return false;
+        // Same procedure = same tools driven by the same KIND of primary locator,
+        // regardless of the literal value (a label of 'Name' vs 'Name *', a role
+        // name that is a parameter or a record id). This is what lets two runs'
+        // "add a part" skills merge instead of fragmenting the store; the literal
+        // differences are exactly the parameters the skills already carry.
+        return locatorShape(s.locators.target?.[0]) === locatorShape(t.locators.target?.[0]);
+    });
+}
+/** A locator's structural shape for merge comparison: its kind, plus the stable
+ * part of a css/id selector (tag/structure, not any embedded id). */
+function locatorShape(c) {
+    if (!c)
+        return 'none';
+    if (c.kind === 'css' || c.kind === 'id') {
+        // Drop id-like and numeric tokens so `#row-1042 > a` and `#row-77 > a` match.
+        const skeleton = c.selector.replace(/[A-Za-z0-9_-]+/g, (tok) => (isIdLike(tok) ? '*' : tok));
+        return `${c.kind}:${skeleton}`;
+    }
+    return c.kind;
+}
+const MAX_GROUP_LEN = 3;
+const LOOP_MAX_ITER_CAP = 50;
+// A loop iterates an ACTION over records (delete each part, ...). Its anchor
+// must be a click; a group may carry connector controls (dialog_expect) but
+// never an observation — folding consecutive read-backs into a loop, which they
+// superficially resemble (same shape, per-record ids), is a bug: reads observe,
+// they do not iterate.
+const LOOP_ANCHOR_TOOLS = new Set(['click', 'dblclick', 'modifier_click', 'right_click']);
+const NON_LOOP_TOOLS = new Set(['read', 'read_all', 'eval', 'screenshot']);
+/**
+ * Collapse a run of consecutive, identical control steps that carry no target
+ * (chiefly `dialog_expect`, which the agent often re-arms redundantly) into
+ * one. Arming the same handler twice is a no-op, but the extra copies land
+ * unevenly between otherwise-identical action groups and stop foldLoops from
+ * seeing the repetition. Only no-locator steps with byte-identical args are
+ * touched, so real actions are never merged.
+ */
+export function coalesceControls(steps) {
+    const out = [];
+    for (const step of steps) {
+        const prev = out[out.length - 1];
+        const noTarget = !step.locators.target?.length && !step.locators.source?.length;
+        if (prev && noTarget && prev.tool === step.tool && !prev.locators.target?.length && JSON.stringify(prev.args) === JSON.stringify(step.args)) {
+            continue;
+        }
+        out.push(step);
+    }
+    return out;
+}
+/**
+ * Drop a navigation whose destination another navigation immediately
+ * replaces. The agent explores — fwod6's step-01 skill recorded `goto /web`,
+ * a hand-built `#action=&…&menu_id=` url, then `goto /web?cids=1` — and a
+ * procedure that re-walks the search is not the procedure, just its history.
+ * Only strictly adjacent navigations qualify: once anything else ran, the
+ * intermediate page may have been load-bearing (a session bootstrap, a
+ * redirect that set a cookie), and this cannot tell from the outside.
+ */
+export function dropSupersededNavigation(steps) {
+    return steps.filter((step, i) => !(step.tool === 'goto' && steps[i + 1]?.tool === 'goto'));
+}
+/** Button names that dismiss a dialog without acting — UI convention, not app knowledge. */
+const DISMISSAL = /^(cancel|close|dismiss|no|not now|back|keep editing)$/i;
+/**
+ * Drop a dialog the recording opened and immediately dismissed. fwgr25's
+ * create step recorded Exit edit → "Discard changes to dashboard?" → Cancel,
+ * because the RECORDING had unsaved edits when the model clicked Exit edit
+ * and then thought better of it. The pair did nothing to the app, but a
+ * replay with nothing unsaved has no dialog to cancel: Exit edit simply
+ * exits, and every step that expected to still be in edit mode fails (5/18
+ * on both replays, 23–49 model turns). Evidence-based: step N's recorded
+ * effect includes a dialog, step N+1 clicks a button that dialog listed,
+ * that button is named as a dismissal, and step N+1 recorded no page change
+ * of its own. A confirm ("Discard", "Delete", "Save") never matches.
+ */
+export function dropDismissedDialogs(steps) {
+    const out = [];
+    for (let i = 0; i < steps.length; i++) {
+        const opener = steps[i];
+        const closer = steps[i + 1];
+        const added = opener.expect?.addedContains ?? [];
+        const opensDialog = added.some((l) => /^-\s*dialog\b/.test(l));
+        if (opensDialog && closer?.tool === 'click' && !closer.expect?.addedContains?.length) {
+            const primary = (closer.locators.target ?? [])[0];
+            const name = primary?.kind === 'role' && primary.role === 'button' ? primary.name : primary?.kind === 'text' ? primary.text : undefined;
+            const listed = name !== undefined && added.some((l) => l.includes(`button "${name}"`));
+            if (name && listed && DISMISSAL.test(name.trim())) {
+                i += 1; // skip the closer too
+                continue;
+            }
+        }
+        out.push(opener);
+    }
+    return out;
+}
+/** Replace id-like whole tokens in a string with `*`, so per-record ids collapse. */
+function stripIds(text) {
+    return text
+        .split(/([^A-Za-z0-9]+)/)
+        .map((tok) => (/^[A-Za-z0-9]+$/.test(tok) && isIdLike(tok) ? '*' : tok))
+        .join('');
+}
+/** A candidate's identity with per-record ids blanked — its shape AND its name/value. */
+function candSkeleton(c) {
+    switch (c.kind) {
+        case 'role':
+            return `role:${c.role}:${stripIds(c.name ?? '')}`;
+        case 'text':
+            return `text:${stripIds(c.text ?? '')}`;
+        case 'label':
+            return `label:${stripIds(c.label ?? '')}`;
+        case 'placeholder':
+            return `placeholder:${stripIds(c.placeholder ?? '')}`;
+        case 'testid':
+            return `testid:${stripIds(c.value)}`;
+        default:
+            return locatorShape(c);
+    }
+}
+function chainSkeleton(chain) {
+    return (chain ?? []).map(candSkeleton).join('|');
+}
+/** Two steps are the same procedure applied to (possibly) a different record. */
+function loopEquivalent(a, b) {
+    if (a.tool !== b.tool || a.tool === 'loop')
+        return false;
+    // Same procedure means the same TYPED values too: two edits that set
+    // different quantities are two steps, not one loop replaying the first
+    // group's value on every record. Targets are per-record by design.
+    const typed = (s) => JSON.stringify(Object.fromEntries(Object.entries(s.args).filter(([k]) => k !== 'target' && k !== 'source')));
+    return typed(a) === typed(b) && chainSkeleton(a.locators.target) === chainSkeleton(b.locators.target) && chainSkeleton(a.locators.source) === chainSkeleton(b.locators.source);
+}
+/** True when two groups differ in a *raw* id somewhere — proof they act on distinct records, not an accidental repeat. */
+function differsInRawId(a, b) {
+    const raw = (g) => JSON.stringify(g.map((s) => [s.locators.target ?? [], s.locators.source ?? []]));
+    return raw(a) !== raw(b);
+}
+/**
+ * Collapse a run of ≥2 consecutive, structurally-identical action groups that
+ * differ only in a per-record id — the signature of iterating over a list (e.g.
+ * deleting each part in turn) — into a single `loop` step. The loop repeats its
+ * body while the body's first target still matches an element, so a replay on a
+ * list of a different length still clears it, instead of hard-coding the count
+ * seen when recording. Conservative by construction: distinct fields (a title
+ * vs a customer box) have different skeletons and never fold, and an accidental
+ * identical repeat (no id difference) is left alone.
+ */
+export function foldLoops(steps) {
+    const out = [];
+    let i = 0;
+    while (i < steps.length) {
+        let folded = false;
+        // Prefer the smallest group length so [del, confirm] folds before [del]×2.
+        for (let len = 1; len <= MAX_GROUP_LEN && i + 2 * len <= steps.length; len++) {
+            const group = steps.slice(i, i + len);
+            if (group.some((s) => s.tool === 'loop' || NON_LOOP_TOOLS.has(s.tool)))
+                continue;
+            // The body must anchor on a repeatable, locate-able ACTION (a click on a
+            // record's control), never an observation.
+            if (!LOOP_ANCHOR_TOOLS.has(group[0].tool) || !group[0].locators.target?.length)
+                continue;
+            let count = 1;
+            const groups = [group];
+            while (i + (count + 1) * len <= steps.length) {
+                const next = steps.slice(i + count * len, i + (count + 1) * len);
+                if (!group.every((s, k) => loopEquivalent(s, next[k])))
+                    break;
+                groups.push(next);
+                count++;
+            }
+            if (count < 2)
+                continue;
+            // Require a real per-record id difference across at least one pair, so we
+            // only fold genuine iteration, never a control legitimately hit twice.
+            if (!groups.slice(1).some((g) => differsInRawId(group, g)))
+                continue;
+            out.push({
+                tool: 'loop',
+                args: {},
+                locators: {},
+                body: group,
+                while: group[0].locators.target,
+                max: Math.min(count * 2 + 3, LOOP_MAX_ITER_CAP),
+            });
+            i += count * len;
+            folded = true;
+            break;
+        }
+        if (!folded)
+            out.push(steps[i++]);
+    }
+    return out;
+}
+//# sourceMappingURL=compile.js.map