@reticlehq/server 3.8.0 → 3.8.1

package/dist/command/daemon/win32-escape.d.ts

@@ -0,0 +1,32 @@
+/** What the launcher must start. */
+export interface EscapeRequest {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly cwd: string;
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly logPath: string;
+    /** The spec file. The launcher writes the daemon pid to `<specPath>.pid`. */
+    readonly specPath: string;
+}
+/**
+ * `launched: false` means nothing started, so the caller can start the daemon another way.
+ * `launched: true` with no pid means a daemon may start, but its pid is not known in time.
+ */
+export type EscapeResult = {
+    launched: false;
+} | {
+    launched: true;
+    pid?: number;
+};
+/**
+ * The launcher, as `node -e` source. It has no double quote and no backslash, so it passes as one
+ * Windows argument in double quotes. Its one argument is the spec path.
+ */
+export declare const JOB_ESCAPE_LAUNCHER: string;
+/** The PowerShell script: start the launcher through WMI, then wait for the pid file. */
+export declare function wmiScript(request: EscapeRequest): string;
+/**
+ * Start `request` through WMI. Never throws: every failure reads as `launched: false`, unless the
+ * launcher already claimed the spec, which means it is starting the daemon.
+ */
+export declare function escapeJobViaWmi(request: EscapeRequest, run?: (script: string) => void): EscapeResult;

package/dist/command/daemon/win32-escape.js

@@ -0,0 +1,119 @@
+/**
+ * Start the daemon outside the Windows Job Object of the process that starts it.
+ *
+ * A child of `spawn(..., { detached: true })` stays in the job of its parent. An agent host can run
+ * `reticle mcp` in a job with KILL_ON_JOB_CLOSE, and the close of that job then kills the daemon
+ * too. A process that WMI `Win32_Process.Create` starts is in no job of ours.
+ *
+ * WMI cannot give the new process our stdio or our env. So WMI starts a small launcher, and the
+ * launcher does the same detached spawn as `spawnDaemon`: stdout and stderr go to the daemon log,
+ * opened for append, and the env is ours. The daemon is a child of the launcher, so it is outside
+ * the job too. The launcher reads the spawn spec from a file and writes the daemon pid to a file.
+ *
+ * The spec file is also the lock between the launcher and the fallback. The launcher claims it with
+ * a rename before it starts anything. The parent removes it after the WMI call. Only one of the two
+ * can win. If the parent wins, nothing started and the detached fallback is safe.
+ */
+import { execFileSync } from 'node:child_process';
+import { readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+/**
+ * The launcher, as `node -e` source. It has no double quote and no backslash, so it passes as one
+ * Windows argument in double quotes. Its one argument is the spec path.
+ */
+export const JOB_ESCAPE_LAUNCHER = [
+    "const fs=require('fs'),cp=require('child_process');",
+    "const f=process.argv[1],t=f+'.taken';",
+    'fs.renameSync(f,t);',
+    "const s=JSON.parse(fs.readFileSync(t,'utf8'));",
+    'fs.unlinkSync(t);',
+    "const fd=fs.openSync(s.log,'a');",
+    "const c=cp.spawn(s.command,s.args,{cwd:s.cwd,env:s.env,detached:true,stdio:['ignore',fd,fd]});",
+    "c.on('error',()=>{});",
+    'c.unref();',
+    "fs.writeFileSync(f+'.tmp',String(c.pid));",
+    "fs.renameSync(f+'.tmp',f+'.pid');",
+].join('');
+const PID_SUFFIX = '.pid';
+/** How long the script waits for the launcher to report the daemon pid. */
+const PID_WAIT_MS = 5000;
+/** A hard limit on the whole PowerShell call: its start, the WMI call and the pid wait. */
+const WMI_CALL_TIMEOUT_MS = 8000;
+const POWERSHELL = 'powershell.exe';
+const ENCODING_UTF16LE = 'utf16le';
+/** A PowerShell single-quoted literal. */
+function psLiteral(value) {
+    return `'${value.replaceAll("'", "''")}'`;
+}
+/** The PowerShell script: start the launcher through WMI, then wait for the pid file. */
+export function wmiScript(request) {
+    const commandLine = `"${request.command}" -e "${JOB_ESCAPE_LAUNCHER}" "${request.specPath}"`;
+    const pidPath = `${request.specPath}${PID_SUFFIX}`;
+    return [
+        "$ErrorActionPreference = 'Stop'",
+        // SW_HIDE, so the launcher opens no console window.
+        '$startup = New-CimInstance -CimClass (Get-CimClass -ClassName Win32_ProcessStartup) -ClientOnly -Property @{ ShowWindow = [uint16]0 }',
+        `$null = Invoke-CimMethod -ClassName Win32_Process -MethodName Create -Arguments @{ CommandLine = ${psLiteral(commandLine)}; CurrentDirectory = ${psLiteral(request.cwd)}; ProcessStartupInformation = $startup }`,
+        `$deadline = (Get-Date).AddMilliseconds(${PID_WAIT_MS})`,
+        `while (-not (Test-Path -LiteralPath ${psLiteral(pidPath)}) -and (Get-Date) -lt $deadline) { Start-Sleep -Milliseconds 50 }`,
+    ].join('\n');
+}
+function runPowerShell(script) {
+    execFileSync(POWERSHELL, [
+        '-NoProfile',
+        '-NonInteractive',
+        '-EncodedCommand',
+        Buffer.from(script, ENCODING_UTF16LE).toString('base64'),
+    ], { stdio: 'ignore', timeout: WMI_CALL_TIMEOUT_MS, windowsHide: true });
+}
+function removeIfPresent(path) {
+    try {
+        unlinkSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function readLauncherPid(pidPath) {
+    try {
+        const pid = parseInt(readFileSync(pidPath, 'utf8').trim(), 10);
+        return Number.isInteger(pid) && pid > 0 ? pid : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Start `request` through WMI. Never throws: every failure reads as `launched: false`, unless the
+ * launcher already claimed the spec, which means it is starting the daemon.
+ */
+export function escapeJobViaWmi(request, run = runPowerShell) {
+    const pidPath = `${request.specPath}${PID_SUFFIX}`;
+    try {
+        removeIfPresent(pidPath);
+        writeFileSync(request.specPath, JSON.stringify({
+            command: request.command,
+            args: request.args,
+            cwd: request.cwd,
+            env: request.env,
+            log: request.logPath,
+        }), 
+        // The spec holds the env. Only the user may read it, and it lives until the launcher reads it.
+        { encoding: 'utf8', mode: 0o600 });
+    }
+    catch {
+        return { launched: false };
+    }
+    try {
+        run(wmiScript(request));
+    }
+    catch {
+        // PowerShell missing, blocked, failed or timed out. The spec says whether the launcher ran.
+    }
+    if (removeIfPresent(request.specPath)) {
+        return { launched: false };
+    }
+    const pid = readLauncherPid(pidPath);
+    removeIfPresent(pidPath);
+    return pid === undefined ? { launched: true } : { launched: true, pid };
+}

package/dist/command/setup/bringup/dev-server-files.d.ts

@@ -13,15 +13,7 @@ declare const HandedOverSchema: z.ZodObject<{
     pid: z.ZodNumber;
     url: z.ZodString;
     appDir: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    url: string;
-    pid: number;
-    appDir: string;
-}, {
-    url: string;
-    pid: number;
-    appDir: string;
-}>;
+}, z.core.$strip>;
 export type HandedOver = z.infer<typeof HandedOverSchema>;
 /**
  * Written when `init` leaves a server running, so the next `init` can attach to it.

package/dist/command/setup/bringup/dev-server-wait.js

@@ -52,7 +52,11 @@ export function judgeWait(facts) {
  */
 const CRA_PORT_BUSY = /Something is already running on port (\d+)/i;
 const NAMED_PORT_BUSY = /Port (\d+) is (?:already )?in use/i;
-const EADDRINUSE_PORT = /(?:EADDRINUSE|address already in use)[^\d]*(\d+)/i;
+// Node prints `address already in use <address>:<port>`; the port sits after the last colon of the
+// address, so the first digit can belong to the host (`0.0.0.0:3000` said port 0, #1846). The scan
+// also stops at the line end: the stack frame under the error (`at Server (node:net:1817:16)`)
+// carries digits of its own, and they are not the port.
+const EADDRINUSE_PORT = /(?:EADDRINUSE|address already in use)[^\d\n]*(?:.*:)?(\d+)/i;
 export function portBusyMessage(output) {
     const match = CRA_PORT_BUSY.exec(output) ?? NAMED_PORT_BUSY.exec(output) ?? EADDRINUSE_PORT.exec(output);
     const port = match?.[1];

package/dist/command/version/version-skew.d.ts

@@ -67,6 +67,8 @@ interface SelfIdentity {
     contract: string;
     contractParts?: ContractParts | undefined;
 }
+/** The one line that converges every piece, after the detailed fix. Not said for one version. */
+export declare const SKEW_CONVERGE: string;
 /**
  * The one sentence to tell the agent, or undefined when the pair agrees.
  *

package/dist/command/version/version-skew.js

@@ -56,6 +56,9 @@ function namesWeDoNotKnow(peer, self) {
     ].filter((name) => !RETIRED_WIRE_NAMES.includes(name));
     return [...new Set(unknown)].sort();
 }
+/** The one line that converges every piece, after the detailed fix. Not said for one version. */
+export const SKEW_CONVERGE = "To put every piece on one version, update the CLI and the app SDK (`reticle update` in the app's " +
+    'folder does both), then restart the MCP host.';
 /** The fix for two builds of one version. */
 const SAME_VERSION_FIX = 'Both say the same version, so one of them is an older build of it: run `reticle restart`, then ' +
     'reload the page so it loads the SDK the dev server serves now.';
@@ -87,6 +90,7 @@ export function describeSkew(given, self) {
     // One version, two builds (a daemon running code older than its install, a cached page bundle):
     // installing that version again changes nothing, so the fix is the restart and the reload.
     const peer = given.version === self.version ? { ...given, fix: SAME_VERSION_FIX } : given;
+    const converge = given.version === self.version ? '' : ` ${SKEW_CONVERGE}`;
     // Both sides said which names they speak, so compare the names rather than a hash over them.
     if (peer.contractParts !== undefined && self.contractParts !== undefined) {
         const unknown = namesWeDoNotKnow(peer.contractParts, self.contractParts);
@@ -100,14 +104,14 @@ export function describeSkew(given, self) {
             : 'so it was built against a newer contract than this one';
         return (`version skew: ${versionPhrase(peer, self)}, and ${peer.what} speaks names this daemon does ` +
             `not know (${unknown.join(', ')}) — ${why}. ` +
-            `Tools will behave in ways neither side reports. ${peer.fix}`);
+            `Tools will behave in ways neither side reports. ${peer.fix}${converge}`);
     }
     if (peer.contract === undefined) {
         if (peer.version === undefined || peer.version === self.version)
             return undefined;
         return (`version skew: ${versionPhrase(peer, self)}, and it is too old to report which wire contract ` +
             `it speaks. They connect anyway and then disagree about behaviour, which usually surfaces as ` +
-            `a bare -32000 with nothing naming a version. ${peer.fix}`);
+            `a bare -32000 with nothing naming a version. ${peer.fix}${converge}`);
     }
     /*
      * A fingerprint alone cannot tell an ADDITION from a RENAME, so this sentence must not claim it can.
@@ -125,7 +129,7 @@ export function describeSkew(given, self) {
     return (`version skew: ${versionPhrase(peer, self)}, and they were built against different wire ` +
         `contracts (${peer.contract} vs ${self.contract}). ${peer.what} is too old to say WHICH names ` +
         `it speaks, so this cannot tell an added name — which breaks nothing — from a renamed one, ` +
-        `which breaks the call that uses it. Update it and the question goes away. ${peer.fix}`);
+        `which breaks the call that uses it. Update it and the question goes away. ${peer.fix}${converge}`);
 }
 /**
  * The fix line for a page whose SDK disagrees with this daemon, with no project to read.

package/dist/features/crawl/crawl-tools.js

@@ -80,7 +80,7 @@ export const CRAWL_TOOLS = [
                     .optional()
                     .describe('Where the fault is written, as `file:line`; console errors prefer their own stack and fall back to the clicked control.'),
             })),
-            counts: z.record(z.number()),
+            counts: z.record(z.string(), z.number()),
             visited: z.array(z.string()).describe('The controls actually clicked, in order.'),
             coverageNote: z
                 .string()
@@ -92,7 +92,7 @@ export const CRAWL_TOOLS = [
                 .optional()
                 .describe('Controls clicked whose silence could not be judged, e.g. on a background tab. They are NOT reported as dead, and they are not known to work either.'),
             // Only on `exhaustive` — see features/exhaust/exhaust-run.ts. Loose: it carries the levels.
-            exhaustive: z.record(z.unknown()).optional(),
+            exhaustive: z.record(z.string(), z.unknown()).optional(),
         },
         handler: async (deps, args) => {
             const session = deps.sessions.resolve(asString(args['sessionId']));

package/dist/features/exhaust/ledger.d.ts

@@ -32,110 +32,29 @@ export declare const CoverageLevel: {
 export type CoverageLevel = (typeof CoverageLevel)[keyof typeof CoverageLevel];
 declare const LedgerSchema: z.ZodObject<{
     routes: z.ZodObject<{
-        discovered: z.ZodArray<z.ZodString, "many">;
-        reached: z.ZodArray<z.ZodString, "many">;
-    }, "strip", z.ZodTypeAny, {
-        reached: string[];
-        discovered: string[];
-    }, {
-        reached: string[];
-        discovered: string[];
-    }>;
+        discovered: z.ZodArray<z.ZodString>;
+        reached: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
     controls: z.ZodObject<{
-        seen: z.ZodArray<z.ZodString, "many">;
-        touched: z.ZodArray<z.ZodString, "many">;
-        proved: z.ZodArray<z.ZodString, "many">;
-    }, "strip", z.ZodTypeAny, {
-        proved: string[];
-        seen: string[];
-        touched: string[];
-    }, {
-        proved: string[];
-        seen: string[];
-        touched: string[];
-    }>;
+        seen: z.ZodArray<z.ZodString>;
+        touched: z.ZodArray<z.ZodString>;
+        proved: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
     journeys: z.ZodObject<{
-        completed: z.ZodArray<z.ZodString, "many">;
-    }, "strip", z.ZodTypeAny, {
-        completed: string[];
-    }, {
-        completed: string[];
-    }>;
+        completed: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
     writes: z.ZodObject<{
-        seen: z.ZodArray<z.ZodString, "many">;
-        branched: z.ZodArray<z.ZodString, "many">;
-        unhandled: z.ZodArray<z.ZodString, "many">;
-    }, "strip", z.ZodTypeAny, {
-        seen: string[];
-        branched: string[];
-        unhandled: string[];
-    }, {
-        seen: string[];
-        branched: string[];
-        unhandled: string[];
-    }>;
+        seen: z.ZodArray<z.ZodString>;
+        branched: z.ZodArray<z.ZodString>;
+        unhandled: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
     code: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
         name: z.ZodString;
         executed: z.ZodBoolean;
-    }, "strip", z.ZodTypeAny, {
-        name: string;
-        executed: boolean;
-    }, {
-        name: string;
-        executed: boolean;
-    }>>>;
-    /** Per file, when its code coverage was last taken. Absent in a ledger from before it existed. */
+    }, z.core.$strip>>>;
     codeTaken: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
     best: z.ZodRecord<z.ZodString, z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    code: Record<string, Record<string, {
-        name: string;
-        executed: boolean;
-    }>>;
-    journeys: {
-        completed: string[];
-    };
-    best: Record<string, number>;
-    writes: {
-        seen: string[];
-        branched: string[];
-        unhandled: string[];
-    };
-    routes: {
-        reached: string[];
-        discovered: string[];
-    };
-    controls: {
-        proved: string[];
-        seen: string[];
-        touched: string[];
-    };
-    codeTaken: Record<string, number>;
-}, {
-    code: Record<string, Record<string, {
-        name: string;
-        executed: boolean;
-    }>>;
-    journeys: {
-        completed: string[];
-    };
-    best: Record<string, number>;
-    writes: {
-        seen: string[];
-        branched: string[];
-        unhandled: string[];
-    };
-    routes: {
-        reached: string[];
-        discovered: string[];
-    };
-    controls: {
-        proved: string[];
-        seen: string[];
-        touched: string[];
-    };
-    codeTaken?: Record<string, number> | undefined;
-}>;
+}, z.core.$strip>;
 export type AppLedger = z.infer<typeof LedgerSchema>;
 /** What one producer contributes. Every part optional: a drive adds what it saw and nothing else. */
 export interface LedgerDelta {

package/dist/features/exhaust/ledger.js

@@ -41,10 +41,10 @@ const LedgerSchema = z.object({
     controls: z.object({ seen: names, touched: names, proved: names }),
     journeys: z.object({ completed: names }),
     writes: z.object({ seen: names, branched: names, unhandled: names }),
-    code: z.record(z.record(z.object({ name: z.string(), executed: z.boolean() }))),
+    code: z.record(z.string(), z.record(z.string(), z.object({ name: z.string(), executed: z.boolean() }))),
     /** Per file, when its code coverage was last taken. Absent in a ledger from before it existed. */
-    codeTaken: z.record(z.number()).default({}),
-    best: z.record(z.number()),
+    codeTaken: z.record(z.string(), z.number()).default({}),
+    best: z.record(z.string(), z.number()),
 });
 /** A ledger file's text, or an empty ledger for anything unreadable: coverage never throws. */
 function parseLedger(text) {

package/dist/features/license/license.d.ts

@@ -37,20 +37,8 @@ declare const LicensePayloadSchema: z.ZodObject<{
     org: z.ZodString;
     plan: z.ZodString;
     exp: z.ZodNumber;
-    features: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-    plan: string;
-    lid: string;
-    org: string;
-    exp: number;
-    features?: string[] | undefined;
-}, {
-    plan: string;
-    lid: string;
-    org: string;
-    exp: number;
-    features?: string[] | undefined;
-}>;
+    features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
 export type LicensePayload = z.infer<typeof LicensePayloadSchema>;
 type LicenseCheck = {
     status: typeof LicenseStatus.VALID;

package/dist/hooks/hook-commands.js

@@ -49,12 +49,20 @@ const MAX_IN_FLIGHT = 8;
 let inFlight = 0;
 const reported = new Set();
 function reportOnce(key, message) {
-    if (reported.has(key))
+    if (reported.has(key)) {
         return;
+    }
     reported.add(key);
     log(`hook: ${message}`);
 }
-/** Cached config plus the mtime it was read at, so an edit takes effect without a daemon restart. */
+/**
+ * Cached config plus the file and mtime it was read at, so an edit takes effect without a
+ * daemon restart.
+ *
+ * The path is part of the key. Two roots can share an mtime — a coarse filesystem stamps
+ * every write in the same millisecond — and a cache that remembers only the time returns
+ * the other root's commands.
+ */
 let cached;
 /**
  * Read `.reticle/hooks.json`, or nothing.
@@ -76,21 +84,22 @@ export function readHookConfig(reticleRoot) {
         return {};
     }
     try {
-        return readOpenHookConfig(fd);
+        return readOpenHookConfig(fd, path);
     }
     finally {
         closeSync(fd);
     }
 }
-function readOpenHookConfig(fd) {
+function readOpenHookConfig(fd, path) {
     const mtime = fstatSync(fd).mtimeMs;
-    if (cached !== undefined && cached.at === mtime)
+    if (cached !== undefined && cached.path === path && cached.at === mtime) {
         return cached.config;
+    }
     try {
         const parsed = HookConfigSchema.safeParse(JSON.parse(readFileSync(fd, 'utf8')));
         if (!parsed.success) {
             reportOnce(`config:${String(mtime)}`, `${ReticleDir.HOOKS_FILE} is not a map of event→command`);
-            cached = { at: mtime, config: {} };
+            cached = { path, at: mtime, config: {} };
             return {};
         }
         // An unknown event name is the likeliest mistake in this file and the one that is otherwise
@@ -103,12 +112,12 @@ function readOpenHookConfig(fd) {
             }
             reportOnce(`unknown:${event}`, `${ReticleDir.HOOKS_FILE} names "${event}", which is not a Reticle event. Known events: ${HOOK_EVENT_NAMES.join(', ')}`);
         }
-        cached = { at: mtime, config: known };
+        cached = { path, at: mtime, config: known };
         return known;
     }
     catch (error) {
         reportOnce(`parse:${String(mtime)}`, `${ReticleDir.HOOKS_FILE} could not be read: ${error instanceof Error ? error.message : String(error)}`);
-        cached = { at: mtime, config: {} };
+        cached = { path, at: mtime, config: {} };
         return {};
     }
 }
@@ -167,8 +176,9 @@ export function runHookCommand(command, payload, cwd) {
 export function installCommandHooks(reticleRoot) {
     return onHook(undefined, (payload) => {
         const command = readHookConfig(reticleRoot)[payload.event];
-        if (command === undefined || 0 === command.trim().length)
+        if (command === undefined || 0 === command.trim().length) {
             return;
+        }
         runHookCommand(command, payload, reticleRoot);
     });
 }

package/dist/judgement/capsule/capsule-store.d.ts

@@ -18,52 +18,15 @@ export declare const CAPSULE_VERSION = 1;
 declare const CapsuleSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     id: z.ZodString;
-    /** The flow the failure happened in, when it came from one (a bare assert has no flow). */
     flow: z.ZodOptional<z.ZodString>;
     createdAt: z.ZodNumber;
-    /** Why it was captured — a failed assertion, a crawl anomaly, a human review pin. */
     origin: z.ZodString;
-    /** The consequence that was supposed to hold. */
     expected: z.ZodString;
-    /** What was observed instead — the first-divergence sentence. */
     observed: z.ZodString;
-    /** Minimal steps to reproduce (prefix-trimmed). */
-    steps: z.ZodArray<z.ZodType<FlowStep, z.ZodTypeDef, FlowStep>, "many">;
-    /**
-     * How many times this exact failure has been captured, and when it last was.
-     *
-     * A repeat is not a new capsule -- it is the same one, again. "This failed 37 times, most
-     * recently at T" is strictly MORE than 37 files each holding one timestamp, so folding the
-     * duplicates in adds information rather than discarding it.
-     *
-     * Optional, because a capsule written before these existed has neither and must not be read as
-     * though it were seen once when nobody counted.
-     */
+    steps: z.ZodArray<z.ZodType<FlowStep, unknown, z.core.$ZodTypeInternals<FlowStep, unknown>>>;
     seen: z.ZodOptional<z.ZodNumber>;
     lastSeenAt: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    version: 1;
-    id: string;
-    origin: string;
-    expected: string;
-    createdAt: number;
-    steps: FlowStep[];
-    observed: string;
-    flow?: string | undefined;
-    seen?: number | undefined;
-    lastSeenAt?: number | undefined;
-}, {
-    version: 1;
-    id: string;
-    origin: string;
-    expected: string;
-    createdAt: number;
-    steps: FlowStep[];
-    observed: string;
-    flow?: string | undefined;
-    seen?: number | undefined;
-    lastSeenAt?: number | undefined;
-}>;
+}, z.core.$strip>;
 export type Capsule = z.infer<typeof CapsuleSchema>;
 /** Capsule ids are filenames — refuse anything that could escape the capsules directory. */
 export declare function isValidCapsuleId(id: string): boolean;

package/dist/language/flows/annotate-tools.js

@@ -85,7 +85,7 @@ export const ANNOTATE_TOOLS = [
                 .optional()
                 .describe('Treat statePath as an INVARIANT that must still hold AFTER the action settles (a blast-radius "this unrelated path must not have moved" check), not a condition to wait for. Without it a wait-until-true read passes before an over-reaching side-effect lands.'),
             dataMatches: z
-                .record(z.unknown())
+                .record(z.string(), z.unknown())
                 .optional()
                 .describe('Key/value pairs the signal payload must match (assert-signal only).'),
             net: z

package/dist/language/flows/fields/flow-secret-field.js

@@ -55,7 +55,7 @@ export const secretEnvKey = (field) => `${SECRET_ENV_PREFIX}${field.replace(/[^a
 /** The schema of that argument, shared by every tool that replays a flow. */
 export { CALL_SECRETS_ARG };
 export const callSecretsArg = z
-    .record(z.string())
+    .record(z.string(), z.string())
     .optional()
     .describe('Redacted fields\' values, this call only, never kept: { "auth-password": "…" }');
 /**

package/dist/language/flows/flow-expect-grammar.js

@@ -124,15 +124,22 @@ export function coerceFlowFileExpects(raw) {
  * The issues a union rejection buries.
  *
  * `expect` accepts a predicate OR a v1 expect, and zod reports a union failure as one
- * `invalid_union` issue whose branch errors live inside `unionErrors`. The one that matters is the
+ * `invalid_union` issue whose branch errors live inside `errors`, with paths relative to the union. The one that matters is the
  * v1 branch's `unrecognized_keys` — the misspelled field. Without this the file was still correctly
  * REFUSED and the message said only "malformed", which sends the author back to hunt a
  * one-character typo we had already identified.
  */
 function flatten(issues) {
-    return issues.flatMap((issue) => 'invalid_union' === issue.code
-        ? [issue, ...flatten(issue.unionErrors.flatMap((e) => e.issues))]
-        : [issue]);
+    return issues.flatMap((issue) => {
+        if ('invalid_union' !== issue.code) {
+            return [issue];
+        }
+        const branches = issue.errors.flat().map((inner) => ({
+            ...inner,
+            path: [...issue.path, ...inner.path],
+        }));
+        return [issue, ...flatten(branches)];
+    });
 }
 export function describeFlowZodFailure(error) {
     const all = flatten(error.issues);
@@ -145,12 +152,13 @@ export function describeFlowZodFailure(error) {
      * top-level `invalid_union` says only "malformed", which is true and useless.
      */
     const named = (one) => {
-        // NOT the discriminator complaint. `invalid_union_discriminator` on `expect.kind` is the
+        // NOT the discriminator complaint. An `invalid_union` with a `discriminator` on `expect.kind` is the
         // PREDICATE branch objecting that a v1 expect has no `kind` — which is true of every v1 expect
         // ever written and tells the author nothing. The useful issue is the one from the branch they
         // were actually writing.
-        if ('invalid_union_discriminator' === one.code)
+        if ('invalid_union' === one.code && undefined !== one.discriminator) {
             return false;
+        }
         return (('steps' === one.path[0] && 'expect' === one.path[2] && one.path.length > 3) ||
             ('success' === one.path[0] && one.path.length > 1));
     };

package/dist/language/flows/flow-lease.d.ts

@@ -0,0 +1,27 @@
+/**
+ * What a flow needs from the live session to run in a leased context, and what it reports when the
+ * lease never came up.
+ */
+import { type FlowReplayResult } from '@reticlehq/core';
+import type { ToolDeps } from '../../surface/tools/tool-kit.js';
+/**
+ * The URL a leased context should open: the app's ORIGIN, not the live tab's current location.
+ *
+ * The live tab drifts — every replay navigates it — so using its full URL made each lease start wherever
+ * the previous run happened to finish (observed: leases opening /deployments and failing to find the
+ * login control that only exists at the root). A lease must be a FRESH visit to a deterministic entry
+ * point; flows that need another page carry their own startPath.
+ */
+export declare function leasableAppUrl(deps: ToolDeps, sessionId: string | undefined): string | undefined;
+/**
+ * The live session's own URL — what the fixture port must be looked up by.
+ *
+ * NOT `leasableAppUrl`. That returns an ORIGIN, and the input provider finds a page by comparing
+ * full URLs, so an origin matched no page: `suiteFixtureSeed` answered `undefined` on every run and
+ * every leased flow booted cold while the code read as if it were seeded. Silent, because every
+ * refusal on that path is deliberately silent — a fixture is an optimisation, and a suite must not
+ * die when one is unavailable.
+ */
+export declare function sessionUrlOf(deps: ToolDeps, sessionId: string | undefined): string | undefined;
+/** A flow whose leased context never came up is a suite ERROR, never a silent pass. */
+export declare function leaseFailureReplay(name: string, error: string | undefined): FlowReplayResult;