@reticlehq/server 3.5.0 → 3.7.0

package/dist/language/flows/flows.js

@@ -1,15 +1,15 @@
 import { asFlowName, asProjectId, } from '@reticlehq/core';
-import { REDACTED_FILL } from './fields/flow-secret-field.js';
+import { REDACTED_FILL, SECRET_NAME_ARG, secretEnvKey } from './fields/flow-secret-field.js';
 export { REDACTED_FILL, secretEnvKey } from './fields/flow-secret-field.js';
 import { safeProjectId } from './flow-result.js';
 import { changeInPlace } from './narrow-write.js';
 import { AnchorKind, DEGRADED_ANCHOR_ROLE, FLOW_FILE_VERSION, flowFileVersionFor, FlowErrorCode, FlowFileSchema, FlowStepTool, QueryBy, defaultIsSensitiveKey, } from '@reticlehq/core';
-import { ReticleTool } from '@reticlehq/core';
+import { ReticleTool, flowJsonReplacer } from '@reticlehq/core';
 import { asRecord, asString } from '@reticlehq/core';
 import { applyHealChanges } from './heal.js';
 import { withLearnedSources } from './learned-sources.js';
 import { flowIntentGap, linkFlowIntent } from './flow-intent.js';
-import { journeyFingerprint, journeyName, mergeJourney, routeClaims } from './flow-journey.js';
+import { journeyFingerprint, journeyName, mergeJourney, routeClaims, withinJourney, } from './flow-journey.js';
 import { IntentStore } from '../../memory/intent/intent-store.js';
 import { flowDir, flowParentDir, flowPath, reticleDirPaths, isValidFlowName, } from '../../memory/project/dir/reticle-dir.js';
 import { describeFlowZodFailure, parseFlowFileText } from './flow-expect-grammar.js';
@@ -76,8 +76,11 @@ export function anchorForStep(args) {
     if (by === QueryBy.ROLE && value !== undefined) {
         const name = asString(args['name']);
         if (name !== undefined && name.length > 0) {
-            // The schema carries role + name only; provenance lives on the step, not the anchor.
-            return { anchor: { kind: AnchorKind.ROLE, role: value, name }, degraded: false };
+            // Provenance lives on the step, not the anchor; the position among namesakes is identity.
+            const nth = args['nth'];
+            const of = args['of'];
+            const among = 'number' === typeof nth && 'number' === typeof of ? { nth, of } : {};
+            return { anchor: { kind: AnchorKind.ROLE, role: value, name, ...among }, degraded: false };
         }
     }
     if (by === QueryBy.COMPONENT) {
@@ -127,7 +130,32 @@ function redactSecretFill(anchor, args) {
     const field = anchorFieldName(anchor);
     if (field === undefined || !defaultIsSensitiveKey(field))
         return args;
-    return { ...args, value: REDACTED_FILL };
+    // The variable that supplies it, beside the placeholder: the file alone says what to set.
+    return { ...args, value: REDACTED_FILL, [SECRET_NAME_ARG]: secretEnvKey(field) };
+}
+/**
+ * The recorded steps as they may be SHOWN: every credential fill carries the placeholder.
+ *
+ * The same rule the saved flow is written by, applied to what a tool hands back. `record stop`
+ * returned the compiled program verbatim, so the password a saved flow never contained went into
+ * the agent's transcript instead. The store keeps the real value — an in-session replay types it.
+ */
+export function redactRecordedSteps(steps) {
+    return steps.map((step) => {
+        if (step.tool === ReticleTool.ACT_SEQUENCE && Array.isArray(step.args['steps'])) {
+            const subs = step.args['steps'].map((raw) => redactNormalizedArgs(asRecord(raw)));
+            return { ...step, args: { ...step.args, steps: subs } };
+        }
+        return { ...step, args: redactNormalizedArgs(step.args) };
+    });
+}
+/** One normalized act's args with its inner fill `args` redacted by the anchor it would save as. */
+function redactNormalizedArgs(normalized) {
+    const inner = normalized['args'];
+    if ('object' !== typeof inner || null === inner)
+        return normalized;
+    const redacted = redactSecretFill(anchorForStep(normalized).anchor, asRecord(inner));
+    return redacted === inner ? normalized : { ...normalized, args: redacted };
 }
 /**
  * What the anchor CALLS the field it points at.
@@ -166,6 +194,8 @@ function buildStep(tool, anchor, action, args, degraded) {
  */
 export function recordedStepToFlowStep(step) {
     const out = anchoredStep(step);
+    if (step.timeoutMs !== undefined)
+        out.timeoutMs = step.timeoutMs;
     if (step.page !== undefined)
         out.page = step.page;
     if (step.endPage !== undefined && step.endPage !== step.page)
@@ -235,10 +265,17 @@ export class FlowStore {
     #fs;
     #root;
     #clock;
-    constructor(fs, root, clock) {
+    #onWrote;
+    /**
+     * `onWrote` is told after a save lands, so cloud sync cycles on a new flow the way it does on a
+     * new run (`RunStore` takes the same callback). Without it a flow saved with no run behind it
+     * waited for the timer, and a daemon that exited first never sent it.
+     */
+    constructor(fs, root, clock, opts = {}) {
         this.#fs = fs;
         this.#root = root;
         this.#clock = clock;
+        this.#onWrote = opts.onWrote;
     }
     /**
      * The single byte-stable flow serializer: 2-space indent + one trailing newline. save,
@@ -247,7 +284,7 @@ export class FlowStore {
      */
     #serialize(flow) {
         const stamped = { ...flow, version: flowFileVersionFor(flow) };
-        return `${JSON.stringify(stamped, null, JSON_INDENT)}\n`;
+        return `${JSON.stringify(stamped, flowJsonReplacer, JSON_INDENT)}\n`;
     }
     /**
      * Register the flow's business goal in the intent ledger and stamp the row's id onto the flow.
@@ -321,6 +358,7 @@ export class FlowStore {
         const flow = await this.#linkIntent(base);
         await this.#fs.mkdir(flowParentDir(this.#root, program.name, pid));
         await this.#fs.writeFile(flowPath(this.#root, program.name, pid), this.#serialize(flow));
+        this.#onWrote?.();
         return { ok: true, value: this.#summary(flow) };
     }
     /**
@@ -337,19 +375,40 @@ export class FlowStore {
         const pid = safeProjectId(projectId);
         const fresh = this.#build(program, undefined, pid);
         const saved = [];
-        for (const name of (await this.list(pid)).filter((n) => n.startsWith(prefix))) {
+        const freshPrint = journeyFingerprint(fresh);
+        for (const name of await this.list(pid)) {
             const loaded = await this.load(name, pid);
-            if (loaded.ok)
+            if (!loaded.ok)
+                continue;
+            if (name.startsWith(prefix))
                 saved.push(loaded.value);
+            // The agent already saved this journey under its own name: one journey, one flow. A web drive
+            // saved its named flow and an automatic `drive-saved-<email>` beside it, every time.
+            else if (journeyFingerprint(loaded.value) === freshPrint) {
+                return { ok: true, value: this.#summary(loaded.value) };
+            }
         }
         const byPrint = new Map();
         for (const flow of saved) {
             const print = journeyFingerprint(flow);
             byPrint.set(print, [...(byPrint.get(print) ?? []), flow]);
         }
-        const print = journeyFingerprint(fresh);
+        const print = freshPrint;
         const taken = new Map(saved.map((flow) => [flow.name, journeyFingerprint(flow)]));
-        const named = { ...fresh, name: journeyName(fresh.name, print, taken) };
+        // The same name holding this journey driven with a step more or less: one file, the fuller drive.
+        const same = saved.find((flow) => flow.name === fresh.name && taken.get(flow.name) !== print);
+        if (same !== undefined && withinJourney(same, fresh))
+            return { ok: true, value: this.#summary(same) };
+        const extended = same !== undefined && withinJourney(fresh, same);
+        if (extended)
+            taken.delete(fresh.name);
+        const named = {
+            ...fresh,
+            ...(extended && fresh.intent === undefined && same.intent !== undefined
+                ? { intent: same.intent }
+                : {}),
+            name: journeyName(fresh.name, print, taken),
+        };
         byPrint.set(print, [...(byPrint.get(print) ?? []), named]);
         let result = named;
         for (const [groupPrint, group] of byPrint) {
@@ -367,6 +426,7 @@ export class FlowStore {
             if (groupPrint === print)
                 result = merged;
         }
+        this.#onWrote?.();
         return { ok: true, value: this.#summary(result) };
     }
     /** Write a flow where it already lives, or into its project's directory when it is new. */
@@ -401,6 +461,7 @@ export class FlowStore {
         const valid = await this.#linkIntent(parsed.data);
         await this.#fs.mkdir(flowParentDir(this.#root, asFlowName(valid.name), pid));
         await this.#fs.writeFile(flowPath(this.#root, asFlowName(valid.name), pid), this.#serialize(valid));
+        this.#onWrote?.();
         return { ok: true, value: this.#summary(valid) };
     }
     /**
@@ -419,6 +480,7 @@ export class FlowStore {
             resolvePath: (n, p) => this.#resolveReadPath(asFlowName(n), p),
             write: (path, contents) => this.#fs.writeFile(path, contents),
             serialize: (flow) => this.#serialize(flow),
+            readRaw: (path) => this.#fs.readFile(path),
         }, name, projectId, change);
     }
     /** Write back only what a replay LEARNED. See `#changeInPlace` for why it is not `saveFlow`. */

package/dist/language/flows/heal-run.js

@@ -12,7 +12,8 @@ import { replayFlow } from './flow-replay.js';
 import { applyHealChanges, collectProposals } from './heal.js';
 import { healPrecondition } from './heal-precondition.js';
 import { assertSuccess, dynamicTestids, successLabel } from './flow-success.js';
-import { flowErrorMessage, sessionProjectId } from './flow-replay-run.js';
+import { flowErrorMessage } from './flow-replay-run.js';
+import { sessionTarget } from '../../memory/project/session-root.js';
 import { flowsForSession } from './flow-store-for-session.js';
 const HEAL_MESSAGES = {
     NOTHING: 'nothing to heal — every anchor resolved on replay',
@@ -48,8 +49,9 @@ function toChange(proposal) {
 export async function healFlow(deps, args) {
     const name = asString(args['flowName']) ?? '';
     const apply = true === args['apply'];
-    const projectId = sessionProjectId(deps, asString(args['sessionId']));
-    const loaded = await flowsForSession(deps, projectId).flows.load(name, projectId);
+    const target = sessionTarget(deps, asString(args['sessionId']));
+    const { projectId } = target;
+    const loaded = await flowsForSession(deps, target).flows.load(name, projectId);
     if (!loaded.ok) {
         return {
             name,
@@ -163,7 +165,7 @@ export async function healFlow(deps, args) {
     }
     // Healing WRITES, so it must land where the load came from — a heal that read the app's flow and
     // wrote the daemon's copy would silently fork the two.
-    const written = await flowsForSession(deps, projectId).flows.heal(name, proposals.map(toChange), projectId);
+    const written = await flowsForSession(deps, target).flows.heal(name, proposals.map(toChange), projectId);
     if (!written.ok) {
         return {
             name,

package/dist/language/flows/narrow-write.d.ts

@@ -25,7 +25,14 @@ export interface NarrowWritePort {
     resolvePath: (name: string, projectId?: ProjectId) => Promise<string | null>;
     write: (path: string, contents: string) => Promise<void>;
     serialize: (flow: FlowFile) => string;
+    /** The file as it is on disk, so a change lands in it and nothing else moves. */
+    readRaw?: (path: string) => Promise<string>;
 }
+/**
+ * `raw` with only what changed between `before` and `after` applied, everything else as written:
+ * its key order, its fields the reader fills in by default, its own spelling. Pure.
+ */
+export declare function withChangesOnly(raw: unknown, before: unknown, after: unknown): unknown;
 export declare function changeInPlace<T>(port: NarrowWritePort, name: string, projectId: ProjectId | undefined, change: (flow: FlowFile) => {
     next: FlowFile;
     value: T;

package/dist/language/flows/narrow-write.js

@@ -2,6 +2,28 @@ import { FlowErrorCode, FlowFileSchema } from '@reticlehq/core';
 import { describeFlowZodFailure } from './flow-expect-grammar.js';
 import { isValidFlowName } from '../../memory/project/dir/reticle-dir.js';
 import { safeProjectId } from './flow-result.js';
+const isPlain = (v) => 'object' === typeof v && null !== v && !Array.isArray(v);
+const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+/**
+ * `raw` with only what changed between `before` and `after` applied, everything else as written:
+ * its key order, its fields the reader fills in by default, its own spelling. Pure.
+ */
+export function withChangesOnly(raw, before, after) {
+    if (Array.isArray(raw) && Array.isArray(before) && Array.isArray(after))
+        return raw.length === before.length && before.length === after.length
+            ? raw.map((item, i) => withChangesOnly(item, before[i], after[i]))
+            : after;
+    if (!isPlain(raw) || !isPlain(before) || !isPlain(after))
+        return after;
+    const out = { ...raw };
+    for (const key of Object.keys(after))
+        if (!same(after[key], before[key]))
+            out[key] = key in raw ? withChangesOnly(raw[key], before[key], after[key]) : after[key];
+    for (const key of Object.keys(before))
+        if (!(key in after))
+            delete out[key];
+    return out;
+}
 export async function changeInPlace(port, name, projectId, change) {
     if (!isValidFlowName(name))
         return { ok: false, code: FlowErrorCode.INVALID_NAME };
@@ -21,6 +43,19 @@ export async function changeInPlace(port, name, projectId, change) {
             detail: describeFlowZodFailure(parsed.error),
         };
     }
-    await port.write(path, port.serialize(parsed.data));
+    // A replay that learned nothing new leaves a committed file alone: every replay used to rewrite
+    // it (keys reordered, defaults written in), and `git status` called it modified.
+    if (port.serialize(parsed.data) === port.serialize(loaded.value))
+        return { ok: true, value };
+    let raw;
+    try {
+        raw = JSON.parse((await port.readRaw?.(path)) ?? 'null');
+    }
+    catch {
+        raw = null;
+    }
+    await port.write(path, isPlain(raw)
+        ? `${JSON.stringify(withChangesOnly(raw, loaded.value, parsed.data), null, 2)}\n`
+        : port.serialize(parsed.data));
     return { ok: true, value };
 }

package/dist/language/flows/recording/flake.d.ts

@@ -31,17 +31,17 @@ export declare const FlakeFileSchema: z.ZodObject<{
         fails: number;
     }>>;
 }, "strip", z.ZodTypeAny, {
-    version: 1;
     flows: Record<string, {
         runs: number;
         fails: number;
     }>;
-}, {
     version: 1;
+}, {
     flows: Record<string, {
         runs: number;
         fails: number;
     }>;
+    version: 1;
 }>;
 export declare function emptyRecord(): FlakeRecord;
 /** Accrue one unchanged-code replay outcome. */

package/dist/language/flows/recording/recording-backtrack.js

@@ -27,6 +27,19 @@ function recordingRouteOf(pathname, hash = '') {
         return routePathOf(0 === pathname.length ? '/' : pathname, fragment);
     return pathname;
 }
+/**
+ * A startPath as a page key: its query dropped, hash kept. A startPath keeps the app's query so
+ * replay starts on the filtered page (#1411), but a ROUTE_CHANGE contributes only pathname and
+ * hash, so `/products?scope=X` then `/checkout` then `/products` must compare the first and last
+ * as one page or the backtrack goes unseen.
+ */
+function pageKeyOf(startPath) {
+    const hashAt = startPath.indexOf('#');
+    const queryAt = startPath.indexOf('?');
+    if (queryAt < 0 || (hashAt >= 0 && queryAt > hashAt))
+        return startPath;
+    return startPath.slice(0, queryAt) + (hashAt >= 0 ? startPath.slice(hashAt) : '');
+}
 function collapseConsecutive(routes) {
     const out = [];
     for (const route of routes) {
@@ -60,7 +73,7 @@ export function recordingBacktrackWarning(routes) {
 export function routesFromRecording(startPath, events) {
     const raw = [];
     if (undefined !== startPath)
-        raw.push(recordingRouteOf(startPath));
+        raw.push(recordingRouteOf(pageKeyOf(startPath)));
     for (const event of events) {
         if (EventType.ROUTE_CHANGE !== event.type)
             continue;

package/dist/language/flows/recording/tape/recordings.d.ts

@@ -7,6 +7,8 @@ export interface RecordedStep {
     args: Record<string, unknown>;
     /** false if any ref could not be normalized to a testid (replay only valid in-session). */
     stable: boolean;
+    /** The caller's per-step wait budget, when one was explicitly provided. */
+    timeoutMs?: number;
     /** Optional post-condition annotation carried into the on-disk flow's expect. */
     expect?: Predicate;
     /**
@@ -27,18 +29,41 @@ export interface RecordedStep {
      * `invoke` first and treats the step as a call.
      */
     invoke?: string;
+    /**
+     * Network mocks were active on this step's tab when it ran. RECORDER-INTERNAL, ambient tape only,
+     * like `route`: a journey that ran against mocked responses replays against the real backend,
+     * so it is not auto-saved (#1459).
+     */
+    mocked?: true;
     /** The page this step ran on. Written to the saved step (unlike `route`, which cuts journeys). */
     page?: string;
     /** The page it ended on once it settled — see `markEnded`. */
     endPage?: string;
     /** Why the agent took this step: the `intent` it declared on the action. Names the saved flow. */
     intent?: string;
+    /**
+     * Why a consequence this step PROVED is not in the flow: the flow file could not express it (a
+     * session ref such as `e12` means nothing on a later page). Said at stop, so a weaker flow is
+     * never saved silently.
+     */
+    unkeptExpect?: string;
 }
 interface ActiveRecording {
     cursor: number;
+    /**
+     * The session (tab) that started it. Only that session's steps join it: one daemon serves every
+     * agent and app on the machine, and capturing into every open recording put a click from an
+     * unrelated app into somebody else's saved flow (#988). Absent: takes every session's steps.
+     */
+    session?: string;
     steps: RecordedStep[];
     /** The route the journey began on. See CompiledProgram.startPath. */
     startPath?: string;
+    /**
+     * The document the tab was on at start. A full-page load makes a new one even when the SDK keeps
+     * its session id, and its clock is from a different connection, so this is how stop tells (#1411).
+     */
+    document?: string;
     /**
      * For each recording that was ALREADY in flight when this one started, how many steps it had.
      *
@@ -89,9 +114,20 @@ export declare const INVOKE_TOOL: string;
  * buffer.
  */
 export declare const AMBIENT_RECORDING = "__ambient__";
+/**
+ * One ambient tape per tab. It was one for the whole daemon, so a drive in ANOTHER app (the console
+ * beside the repo's own app) was cut into a flow and saved into this repo's committed `flows/`, and
+ * synced to its project. A tape now holds one tab's steps, and that tab's end takes only its own.
+ */
+export declare const ambientRecordingOf: (session: string | undefined) => string;
+/** Whether a recording is an ambient tape: the daemon's own, never one somebody opened. */
+export declare const isAmbient: (name: string) => boolean;
 export declare class RecordingStore {
     #private;
-    start(name: string, cursor: number, startPath?: string): void;
+    private readonly byHarness;
+    /** `byHarness`: whether the step being captured was driven by the Harness, which tapes its own. */
+    constructor(byHarness?: () => boolean);
+    start(name: string, cursor: number, startPath?: string, session?: string, document?: string): void;
     isRecording(name: string): boolean;
     /**
      * Number of steps captured so far in the named ACTIVE recording (0 if it
@@ -112,7 +148,12 @@ export declare class RecordingStore {
      * Opened lazily on the first step rather than in the constructor: a store that never records
      * anything should not carry an empty tape, and "did anything happen at all" stays answerable.
      */
-    capture(step: RecordedStep, route?: string): void;
+    /**
+     * Whether a tab has network mocks installed from now on. Each ambient step on it is marked while
+     * they are, so the journey it belongs to is not auto-saved as a flow (#1459).
+     */
+    markMocked(session: string | undefined, active: boolean): void;
+    capture(step: RecordedStep, route?: string, session?: string): void;
     /**
      * Add a consequence to the last captured step of every active recording.
      *
@@ -120,20 +161,31 @@ export declare class RecordingStore {
      * reached the recorder — only the act tools called `capture` — so the flow kept the click and lost
      * the proof. What the step already declared is kept; the new check joins it under `allOf`.
      */
-    attachExpect(expect: Predicate): void;
+    attachExpect(expect: Predicate, session?: string): void;
     /**
      * A navigation happened. Navigating records no step, so until the next one is captured, a check
      * proved now is about the page the navigation opened, not about the last step — and kept on that
      * step, replay would ask it right after the click, of a page it was never true on.
      */
     markNavigated(): void;
+    /**
+     * Take the expectation off the ambient tape's last step, because the verdict on it came back no.
+     *
+     * A step is captured at dispatch, before anything is judged, so a claim that turned out false is
+     * already on the tape as that step's `expect`. Cut into a journey it becomes a flow that is red for
+     * ever, on an expectation nobody but the agent's wrong guess made. The failure is not lost: it is
+     * filed as a capsule, the artifact built for "this should hold and does not". The ACTION stays,
+     * since the steps after it ran on the page it produced. A recording somebody opened deliberately
+     * is left as they drove it.
+     */
+    unassertLast(): void;
     /**
      * The page the step just captured ended on, once its action settled.
      *
      * Fills only a step that has none, so calling it after an action that captured nothing leaves the
      * previous step's own answer alone.
      */
-    markEnded(page: string | undefined): void;
+    markEnded(page: string | undefined, session?: string): void;
     /**
      * Returns the active recording (cursor + steps) and clears it, or undefined if not recording.
      *
@@ -150,6 +202,8 @@ export declare class RecordingStore {
     saveCompiled(program: CompiledProgram): void;
     getCompiled(name: string): CompiledProgram | undefined;
     active(): string[];
+    /** The ambient tape of one tab (or of steps no tab named), taken: what its session end saves. */
+    takeAmbient(session: string | undefined): ActiveRecording | undefined;
     /**
      * Names of recordings that have been STOPPED and compiled.
      *

package/dist/language/flows/recording/tape/recordings.js

@@ -20,6 +20,14 @@ export const INVOKE_TOOL = FlowStepTool.INVOKE;
  * buffer.
  */
 export const AMBIENT_RECORDING = '__ambient__';
+/**
+ * One ambient tape per tab. It was one for the whole daemon, so a drive in ANOTHER app (the console
+ * beside the repo's own app) was cut into a flow and saved into this repo's committed `flows/`, and
+ * synced to its project. A tape now holds one tab's steps, and that tab's end takes only its own.
+ */
+export const ambientRecordingOf = (session) => session === undefined ? AMBIENT_RECORDING : `${AMBIENT_RECORDING}:${session}`;
+/** Whether a recording is an ambient tape: the daemon's own, never one somebody opened. */
+export const isAmbient = (name) => AMBIENT_RECORDING === name || name.startsWith(`${AMBIENT_RECORDING}:`);
 /**
  * How long a journey the ambient tape will hold.
  *
@@ -29,21 +37,36 @@ export const AMBIENT_RECORDING = '__ambient__';
  */
 const AMBIENT_STEP_CAP = 400;
 export class RecordingStore {
+    byHarness;
     #active = new Map();
     #compiled = new Map();
+    /** The ambient tape the last step went on: the one a refuted claim is taken off. */
+    #lastAmbient;
     /** A navigation came after the last captured step — see markNavigated. */
     #navigatedSinceStep = false;
-    start(name, cursor, startPath) {
+    /** Tabs with network mocks installed now, keyed by session ('' for none named). See markMocked. */
+    #mocked = new Set();
+    /** `byHarness`: whether the step being captured was driven by the Harness, which tapes its own. */
+    constructor(byHarness = () => false) {
+        this.byHarness = byHarness;
+    }
+    start(name, cursor, startPath, session, document) {
         const openedOver = new Map();
-        for (const [outer, rec] of this.#active)
+        for (const [outer, rec] of this.#targets(session))
             openedOver.set(outer, rec.steps.length);
         this.#active.set(name, {
             cursor,
             steps: [],
             openedOver,
             ...(startPath === undefined ? {} : { startPath }),
+            ...(session === undefined ? {} : { session }),
+            ...(document === undefined ? {} : { document }),
         });
     }
+    /** The open recordings a step from `session` belongs to. See ActiveRecording.session. */
+    #targets(session) {
+        return [...this.#active].filter(([, rec]) => rec.session === undefined || session === undefined || rec.session === session);
+    }
     isRecording(name) {
         return this.#active.has(name);
     }
@@ -68,23 +91,44 @@ export class RecordingStore {
      * Opened lazily on the first step rather than in the constructor: a store that never records
      * anything should not carry an empty tape, and "did anything happen at all" stays answerable.
      */
-    capture(step, route) {
+    /**
+     * Whether a tab has network mocks installed from now on. Each ambient step on it is marked while
+     * they are, so the journey it belongs to is not auto-saved as a flow (#1459).
+     */
+    markMocked(session, active) {
+        if (active)
+            this.#mocked.add(session ?? '');
+        else
+            this.#mocked.delete(session ?? '');
+    }
+    capture(step, route, session) {
         this.#navigatedSinceStep = false;
-        if (!this.#active.has(AMBIENT_RECORDING)) {
-            this.#active.set(AMBIENT_RECORDING, {
+        const mocked = this.#mocked.has(session ?? '');
+        const ambient = ambientRecordingOf(session);
+        if (!this.#active.has(ambient)) {
+            this.#active.set(ambient, {
                 cursor: 0,
                 steps: [],
                 openedOver: new Map(),
+                ...(session === undefined ? {} : { session }),
             });
         }
-        for (const [name, rec] of this.#active) {
+        this.#lastAmbient = ambient;
+        for (const [name, rec] of this.#targets(session)) {
+            // Another tab's tape is that tab's journey, whatever else this step belongs to.
+            if (isAmbient(name) && name !== ambient)
+                continue;
             // The ambient tape is opened by the system and closed by nobody, so it is the one recording
             // with no human deciding when it has seen enough. Bounded here rather than left to grow for
             // the length of a daemon's life. Appending STOPS at the cap instead of dropping the oldest: a
             // flow replays from its FIRST step, so a tape missing its beginning is not a shorter journey,
             // it is a different one that starts in a state nothing established. A recording somebody
             // opened on purpose is not capped — they said when it starts and they say when it stops.
-            if (AMBIENT_RECORDING === name && rec.steps.length >= AMBIENT_STEP_CAP)
+            if (isAmbient(name) && rec.steps.length >= AMBIENT_STEP_CAP)
+                continue;
+            // The Harness saves its own recordings. Taping its steps too saved every drive twice: once as
+            // the Harness's flow and again, at session end, as a `drive-*` copy with a guessed name.
+            if (isAmbient(name) && this.byHarness())
                 continue;
             // A step nobody marked ended where the next one began.
             const previous = rec.steps.at(-1);
@@ -94,7 +138,13 @@ export class RecordingStore {
             // The route rides on the AMBIENT tape only: a recording somebody opened deliberately is
             // already one journey by construction, and stamping a route on its steps would change what a
             // deliberate recording contains.
-            rec.steps.push(AMBIENT_RECORDING === name && route !== undefined ? { ...step, route } : step);
+            rec.steps.push(isAmbient(name) && (route !== undefined || mocked)
+                ? {
+                    ...step,
+                    ...(route === undefined ? {} : { route }),
+                    ...(mocked ? { mocked: true } : {}),
+                }
+                : step);
         }
     }
     /**
@@ -104,13 +154,20 @@ export class RecordingStore {
      * reached the recorder — only the act tools called `capture` — so the flow kept the click and lost
      * the proof. What the step already declared is kept; the new check joins it under `allOf`.
      */
-    attachExpect(expect) {
+    attachExpect(expect, session) {
         if (this.#navigatedSinceStep)
             return;
-        for (const rec of this.#active.values()) {
+        const mocked = this.#mocked.has(session ?? '');
+        for (const [name, rec] of this.#targets(session)) {
+            if (isAmbient(name) && name !== ambientRecordingOf(session))
+                continue;
             const last = rec.steps.at(-1);
             if (last === undefined)
                 continue;
+            // A proof read while mocks are active rests on mocked responses even when the act before it
+            // ran unmocked, so the ambient step it joins is marked too (#1459).
+            if (mocked && isAmbient(name))
+                last.mocked = true;
             const held = last.expect;
             last.expect =
                 held === undefined
@@ -128,16 +185,36 @@ export class RecordingStore {
     markNavigated() {
         this.#navigatedSinceStep = true;
     }
+    /**
+     * Take the expectation off the ambient tape's last step, because the verdict on it came back no.
+     *
+     * A step is captured at dispatch, before anything is judged, so a claim that turned out false is
+     * already on the tape as that step's `expect`. Cut into a journey it becomes a flow that is red for
+     * ever, on an expectation nobody but the agent's wrong guess made. The failure is not lost: it is
+     * filed as a capsule, the artifact built for "this should hold and does not". The ACTION stays,
+     * since the steps after it ran on the page it produced. A recording somebody opened deliberately
+     * is left as they drove it.
+     */
+    unassertLast() {
+        const tape = this.#lastAmbient === undefined ? undefined : this.#active.get(this.#lastAmbient);
+        const last = tape?.steps.at(-1);
+        if (tape === undefined || last === undefined || last.expect === undefined)
+            return;
+        const { expect: _dropped, ...kept } = last;
+        tape.steps[tape.steps.length - 1] = kept;
+    }
     /**
      * The page the step just captured ended on, once its action settled.
      *
      * Fills only a step that has none, so calling it after an action that captured nothing leaves the
      * previous step's own answer alone.
      */
-    markEnded(page) {
+    markEnded(page, session) {
         if (page === undefined)
             return;
-        for (const rec of this.#active.values()) {
+        for (const [name, rec] of this.#targets(session)) {
+            if (isAmbient(name) && name !== ambientRecordingOf(session))
+                continue;
             const last = rec.steps.at(-1);
             if (last !== undefined && last.endPage === undefined)
                 last.endPage = page;
@@ -182,7 +259,12 @@ export class RecordingStore {
         return this.#compiled.get(name);
     }
     active() {
-        return [...this.#active.keys()];
+        // One tab's tape is that tab's: the list names what somebody opened, and the plain tape as before.
+        return [...this.#active.keys()].filter((name) => !name.startsWith(`${AMBIENT_RECORDING}:`));
+    }
+    /** The ambient tape of one tab (or of steps no tab named), taken: what its session end saves. */
+    takeAmbient(session) {
+        return this.stop(ambientRecordingOf(session));
     }
     /**
      * Names of recordings that have been STOPPED and compiled.