@reticlehq/server 3.8.2 → 3.9.0

package/dist/judgement/runs/run-ledger.js

@@ -1,142 +1,171 @@
 /**
- * The run ledger: what one agent run checked, saved and read, kept until its report is taken.
+ * The run ledger: what each agent run checked, saved and read, kept until its report is taken.
  *
- * A run is the agent's calls from its first Reticle call to the call that ends it (a session end, a
+ * A run is one agent's calls from its first Reticle call to the call that ends it (a session end, a
  * yield, a released tab). The verdicts come from the journal records the agent's own calls wrote;
- * the Harness's are never counted. Taking the report empties the ledger, so the next run starts at
- * zero.
+ * the Harness's are never counted. Taking the report ends that run, so the agent's next run starts
+ * at zero.
  *
- * A call from another agent (another MCP attach id) starts a new run. An agent that stops without a
- * call that ends its run then does not leak its claims into the next agent's report.
+ * The ledger keeps one run for each MCP attach id. Two agents on one daemon (two worktrees of one
+ * project) call in turn. When the ledger kept one run, each call restarted the other agent's run,
+ * and a released lease reported the other agent's claims and none of its own. A record goes to the
+ * run of the connection that wrote it, and a call that ends a run takes the caller's run (#1900).
  *
- * ponytail: one ledger for each daemon, not for each agent. Two agents that call at the same time
- * restart each other's run. Key the ledger by attach id when that happens.
+ * A record from no connection (the HUD, the CLI, an agent record that ends outside its call
+ * context) goes to the run of the agent that called last. An agent that stops without a call that
+ * ends its run leaves its run here. That run is dropped when it is idle for `RUN_IDLE_LIMIT_MS`.
  */
 import { supersededChecks } from '@reticlehq/engine/evidence/superseded-checks.js';
 import { JournalVerdictEffectSchema, ReticleTool, Verified, } from '@reticlehq/core';
+import { callingAttachId } from '../../hooks/coding-agents.js';
 const SAW = 'saw ';
 const FLOW = 'flow ';
+/** A run with no agent call for this long is dropped. A working agent calls much more often. */
+export const RUN_IDLE_LIMIT_MS = 6 * 60 * 60 * 1000;
 /** One piece of evidence for a claim: what the check saw, else the source line it drove. */
 function evidenceOf(effect) {
-    if (effect.observed !== undefined)
+    if (effect.observed !== undefined) {
         return `${SAW}${effect.observed}`;
+    }
     return effect.source;
 }
 /** `no` when anything failed, `yes` only when something held and nothing was undecided. */
 function runVerified(all) {
-    if (all.includes(Verified.NO))
+    if (all.includes(Verified.NO)) {
         return Verified.NO;
-    if (0 === all.length || all.some((v) => Verified.YES !== v))
+    }
+    if (0 === all.length || all.some((v) => Verified.YES !== v)) {
         return Verified.UNKNOWN;
+    }
     return Verified.YES;
 }
+const openRun = (now) => ({
+    startedAt: now,
+    lastAt: now,
+    firstVerdictAt: undefined,
+    verdicts: [],
+    saved: new Set(),
+    replayed: new Map(),
+    written: 0,
+    read: new Set(),
+});
 export class RunLedger {
-    #owner;
-    #startedAt;
-    #firstVerdictAt;
-    #verdicts = [];
-    #saved = new Set();
-    #replayed = new Map();
-    #written = 0;
-    #read = new Set();
-    /** An agent call starts. The first one starts the run, and a call from another agent starts a new one. */
+    #runs = new Map();
+    #last;
+    /** An agent call starts. The agent's first call starts its run. A run idle too long is dropped. */
     begin(now, owner) {
-        if (this.#owner !== owner)
-            this.#reset();
-        this.#owner = owner;
-        this.#startedAt ??= now;
+        for (const [id, run] of this.#runs) {
+            if (now - run.lastAt > RUN_IDLE_LIMIT_MS) {
+                this.#runs.delete(id);
+            }
+        }
+        const run = this.#runs.get(owner) ?? openRun(now);
+        run.lastAt = now;
+        this.#runs.set(owner, run);
+        this.#last = owner;
     }
     /** An agent call ended. The first one that left a verdict sets the time to the first verdict. */
-    after(now) {
-        if (0 < this.#verdicts.length || 0 < this.#replayed.size)
-            this.#firstVerdictAt ??= now;
+    after(now, owner) {
+        const run = this.#run(owner);
+        if (run === undefined) {
+            return;
+        }
+        run.lastAt = Math.max(run.lastAt, now);
+        if (0 < run.verdicts.length || 0 < run.replayed.size) {
+            run.firstVerdictAt ??= now;
+        }
     }
     /** A journal record from the agent's own call. A record with no verdict is not a claim. */
     verdict(action) {
-        if (this.#idle() || action.drivenBy !== undefined)
+        const run = this.#run();
+        if (run === undefined || action.drivenBy !== undefined) {
             return;
+        }
         // A replay is counted once, as a flow, decided as its run decides it (`replayed`). Its journal
         // record said `unknown` where the run said `no`, and one report gave both answers.
-        if (ReticleTool.FLOW_REPLAY === action.tool)
+        if (ReticleTool.FLOW_REPLAY === action.tool) {
             return;
+        }
         const parsed = JournalVerdictEffectSchema.safeParse(action.effect);
-        if (parsed.success)
-            this.#verdicts.push(parsed.data);
+        if (parsed.success) {
+            run.verdicts.push(parsed.data);
+        }
     }
     flowSaved(name) {
-        if (!this.#idle())
-            this.#saved.add(name);
+        this.#run()?.saved.add(name);
     }
     /** The last replay of a flow in this run is its verdict. */
     replayed(name, verified) {
-        if (!this.#idle())
-            this.#replayed.set(name, verified);
+        this.#run()?.replayed.set(name, verified);
     }
     memoryWritten(count = 1) {
-        if (!this.#idle())
-            this.#written += count;
+        const run = this.#run();
+        if (run !== undefined) {
+            run.written += count;
+        }
     }
     /** Notes given to the agent. Each one counts once, however often it is shown. */
     memoryRead(notes) {
-        if (this.#idle())
+        const run = this.#run();
+        if (run === undefined) {
             return;
-        for (const note of notes)
-            this.#read.add(note);
+        }
+        for (const note of notes) {
+            run.read.add(note);
+        }
+    }
+    isEmpty(owner) {
+        return this.#run(owner) === undefined;
     }
-    isEmpty() {
-        return this.#idle();
+    /** The named owner, else the calling connection, else the agent that called last. */
+    #owner(owner) {
+        return owner ?? callingAttachId() ?? this.#last;
     }
     /**
-     * No agent run is open. A CLI `reticle verify` replays through the same code, and what it did is
-     * not the next agent's run, so nothing is kept until an agent call begins one.
+     * The run a record belongs to. None while no agent call has begun one: a CLI `reticle verify`
+     * replays through the same code, and what it did is not the next agent's run.
      */
-    #idle() {
-        return this.#startedAt === undefined;
+    #run(owner) {
+        const id = this.#owner(owner);
+        return id === undefined ? undefined : this.#runs.get(id);
     }
-    /** The report, without the cloud line (the caller knows the project). Empties the ledger. */
-    take(now) {
-        const started = this.#startedAt ?? now;
+    /** The owner's report, without the cloud line (the caller knows the project). Ends that run. */
+    take(now, owner) {
+        const id = this.#owner(owner);
+        const run = this.#run(owner) ?? openRun(now);
+        if (id !== undefined) {
+            this.#runs.delete(id);
+        }
+        const started = run.startedAt;
         // A passive check that read too early is not counted: the rule every fold applies.
-        const superseded = supersededChecks(this.#verdicts.map((v) => ({
+        const superseded = supersededChecks(run.verdicts.map((v) => ({
             key: v.claim,
             passive: false === v.declaredBeforeActing,
             held: Verified.YES === v.verified,
             failed: Verified.NO === v.verified,
         })));
-        const counted = this.#verdicts.filter((_, at) => !superseded.has(at));
+        const counted = run.verdicts.filter((_, at) => !superseded.has(at));
         const claims = counted.map((v) => {
             const evidence = evidenceOf(v);
             return evidence === undefined
                 ? { claim: v.claim, verified: v.verified }
                 : { claim: v.claim, verified: v.verified, evidence };
         });
-        const replayed = [...this.#replayed].map(([name, verified]) => ({ name, verified }));
-        const report = {
+        const replayed = [...run.replayed].map(([name, verified]) => ({ name, verified }));
+        return {
             verified: runVerified([...claims.map((c) => c.verified), ...replayed.map((r) => r.verified)]),
             claims,
             caught: [
                 ...claims.filter((c) => Verified.NO === c.verified).map((c) => c.claim),
                 ...replayed.filter((r) => Verified.NO === r.verified).map((r) => `${FLOW}${r.name}`),
             ],
-            flows: { saved: [...this.#saved], replayed },
-            memory: { written: this.#written, read: this.#read.size },
+            flows: { saved: [...run.saved], replayed },
+            memory: { written: run.written, read: run.read.size },
             wallMs: Math.max(0, now - started),
-            ...(this.#firstVerdictAt === undefined
+            ...(run.firstVerdictAt === undefined
                 ? {}
-                : { firstVerdictMs: Math.max(0, this.#firstVerdictAt - started) }),
+                : { firstVerdictMs: Math.max(0, run.firstVerdictAt - started) }),
         };
-        this.#reset();
-        return report;
-    }
-    #reset() {
-        this.#owner = undefined;
-        this.#startedAt = undefined;
-        this.#firstVerdictAt = undefined;
-        this.#verdicts = [];
-        this.#saved = new Set();
-        this.#replayed = new Map();
-        this.#written = 0;
-        this.#read = new Set();
     }
 }
 /** The daemon's ledger. */

package/dist/judgement/runs/verification-sync.d.ts

@@ -1,5 +1,6 @@
 import { type FlowFile, type FlowReplayResult } from '@reticlehq/core';
 import { type VerificationRunInput } from './artifact/build-verification-run.js';
+import { AutomationHint } from '@reticlehq/core/telemetry';
 import { type ProjectTarget } from '../../memory/project/session-root.js';
 import type { ToolDeps } from '../../surface/tools/tool-kit.js';
 /** A replay plus the wall-clock time it took — the shape the verify handler already collects. */
@@ -12,8 +13,10 @@ export interface TimedReplay {
 /** The MCP client name `reticle verify` (the command line, CI's path) connects to a daemon as. */
 export declare const CLI_CLIENT_NAME = "reticle-cli";
 /**
- * Who ran the command line, and why. On a CI runner it is the pipeline; anywhere else it is the
- * person who holds the key, so the cloud credits them and the run does not read as CI.
+ * Who ran the command line, and why. Off CI it is the person who holds the key, so the cloud
+ * credits them. On CI the `automation` hint says which kind: a CI vendor runner is the pipeline,
+ * trigger `ci`; a coding-agent sandbox is a coding agent. A container, or `CI` with no vendor,
+ * keeps trigger `oem`, because the cloud has no value for either yet.
  */
-export declare function cliRunAuthor(env: NodeJS.ProcessEnv): Pick<VerificationRunInput, 'agent' | 'trigger'>;
+export declare function cliRunAuthor(env: NodeJS.ProcessEnv, automation?: AutomationHint | undefined): Pick<VerificationRunInput, 'agent' | 'trigger'>;
 export declare function persistAndSyncVerificationRun(deps: ToolDeps, timed: TimedReplay[], target: ProjectTarget): Promise<string | undefined>;

package/dist/judgement/runs/verification-sync.js

@@ -21,26 +21,37 @@ import { RunStore } from './artifact/run-store.js';
 import { cloudFetch, syncRunToCloud, SyncOutcome } from '../../memory/cloud/cloud-sync.js';
 import { resolveProjectCloud } from '../../memory/cloud/cloud-config.js';
 import { log } from '../../log.js';
-import { isCiEnv } from '../../telemetry/automation-hint.js';
+import { currentAutomationHint, isCiEnv } from '../../telemetry/automation-hint.js';
+import { AutomationHint } from '@reticlehq/core/telemetry';
 import { rootForTarget } from '../../memory/project/session-root.js';
 /** The author of record when no MCP peer introduced itself — a CLI run, or a client that skipped the handshake. */
 const RETICLE_MCP_AGENT_ID = 'reticle-mcp';
 /** The MCP client name `reticle verify` (the command line, CI's path) connects to a daemon as. */
 export const CLI_CLIENT_NAME = 'reticle-cli';
 /**
- * Who ran the command line, and why. On a CI runner it is the pipeline; anywhere else it is the
- * person who holds the key, so the cloud credits them and the run does not read as CI.
+ * Who ran the command line, and why. Off CI it is the person who holds the key, so the cloud
+ * credits them. On CI the `automation` hint says which kind: a CI vendor runner is the pipeline,
+ * trigger `ci`; a coding-agent sandbox is a coding agent. A container, or `CI` with no vendor,
+ * keeps trigger `oem`, because the cloud has no value for either yet.
  */
-export function cliRunAuthor(env) {
-    return isCiEnv(env)
-        ? {
-            agent: { id: CLI_CLIENT_NAME, kind: RunAgentKind.OEM_PIPELINE },
-            trigger: { kind: RunTrigger.OEM },
-        }
-        : {
+export function cliRunAuthor(env, automation = currentAutomationHint(env)) {
+    if (!isCiEnv(env)) {
+        return {
             agent: { id: CLI_CLIENT_NAME, kind: RunAgentKind.HUMAN },
             trigger: { kind: RunTrigger.MANUAL },
         };
+    }
+    if (AutomationHint.AGENT_SANDBOX === automation) {
+        return {
+            agent: { id: CLI_CLIENT_NAME, kind: RunAgentKind.CODING_AGENT },
+            trigger: { kind: RunTrigger.MANUAL },
+        };
+    }
+    const trigger = AutomationHint.CI_RUNNER === automation ? RunTrigger.CI : RunTrigger.OEM;
+    return {
+        agent: { id: CLI_CLIENT_NAME, kind: RunAgentKind.OEM_PIPELINE },
+        trigger: { kind: trigger },
+    };
 }
 /** Who ran a suite, and why: the command line by `cliRunAuthor`, any other client as a coding agent. */
 function agentAndTrigger(client) {

package/dist/language/flows/flow-store-for-session.js

@@ -24,16 +24,18 @@
  * returned unchanged.
  */
 import { FlowStore } from './flows.js';
-import { sessionTarget } from '../../memory/project/session-root.js';
+import { rootForTarget, sessionTarget } from '../../memory/project/session-root.js';
 export function flowsForSession(deps, target) {
-    const resolved = deps.artifactRootFor?.(target.projectId, target.origin);
-    if (resolved === undefined || resolved.root === deps.reticleRoot) {
+    // Through `rootForTarget`, so the root a lease claimed wins here as it does for runs. Without
+    // it a lease from one folder replayed the flows of the folder the daemon was started in.
+    const root = rootForTarget(deps, target);
+    if (root === deps.reticleRoot) {
         return { flows: deps.flows, root: deps.reticleRoot };
     }
     const onWrote = deps.onRunPersisted;
     return {
-        flows: new FlowStore(deps.fs, resolved.root, { now: deps.now }, onWrote === undefined ? {} : { onWrote }),
-        root: resolved.root,
+        flows: new FlowStore(deps.fs, root, { now: deps.now }, onWrote === undefined ? {} : { onWrote }),
+        root,
     };
 }
 /** `flowsForSession` for a session id, with the project id to scope the store by. Same refusals. */

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

@@ -160,8 +160,8 @@ export declare class RecordingStore {
     markMocked(session: string | undefined, active: boolean): void;
     /**
      * `forAmbient` is the step as the ambient tape keeps it, when that differs: a journey's refuted
-     * claims come off the ambient tape (see `unassertLast`), and a recording somebody opened keeps
-     * every claim they declared, held or not.
+     * claims stay off the ambient tape, and a recording somebody opened keeps every claim they
+     * declared, held or not. See captureVerdictedAct.
      */
     capture(step: RecordedStep, route?: string, session?: string, forAmbient?: RecordedStep): void;
     /**
@@ -178,17 +178,6 @@ export declare class RecordingStore {
      * 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.
      *

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

@@ -40,8 +40,6 @@ 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;
     /** Tabs with network mocks installed now, keyed by session ('' for none named). See markMocked. */
@@ -52,8 +50,9 @@ export class RecordingStore {
     }
     start(name, cursor, startPath, session, document) {
         const openedOver = new Map();
-        for (const [outer, rec] of this.#targets(session))
+        for (const [outer, rec] of this.#targets(session)) {
             openedOver.set(outer, rec.steps.length);
+        }
         this.#active.set(name, {
             cursor,
             steps: [],
@@ -96,15 +95,17 @@ export class RecordingStore {
      * they are, so the journey it belongs to is not auto-saved as a flow (#1459).
      */
     markMocked(session, active) {
-        if (active)
+        if (active) {
             this.#mocked.add(session ?? '');
-        else
+        }
+        else {
             this.#mocked.delete(session ?? '');
+        }
     }
     /**
      * `forAmbient` is the step as the ambient tape keeps it, when that differs: a journey's refuted
-     * claims come off the ambient tape (see `unassertLast`), and a recording somebody opened keeps
-     * every claim they declared, held or not.
+     * claims stay off the ambient tape, and a recording somebody opened keeps every claim they
+     * declared, held or not. See captureVerdictedAct.
      */
     capture(step, route, session, forAmbient) {
         this.#navigatedSinceStep = false;
@@ -118,23 +119,25 @@ export class RecordingStore {
                 ...(session === undefined ? {} : { session }),
             });
         }
-        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)
+            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 (isAmbient(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())
+            if (isAmbient(name) && this.byHarness()) {
                 continue;
+            }
             // A step nobody marked ended where the next one began.
             const previous = rec.steps.at(-1);
             if (previous !== undefined && previous.endPage === undefined && step.page !== undefined) {
@@ -161,26 +164,33 @@ export class RecordingStore {
      * the proof. What the step already declared is kept; the new check joins it under `allOf`.
      */
     attachExpect(expect, session) {
-        if (this.#navigatedSinceStep)
+        if (this.#navigatedSinceStep) {
             return;
+        }
         const mocked = this.#mocked.has(session ?? '');
         for (const [name, rec] of this.#targets(session)) {
-            if (isAmbient(name) && name !== ambientRecordingOf(session))
+            if (isAmbient(name) && name !== ambientRecordingOf(session)) {
                 continue;
+            }
             const last = rec.steps.at(-1);
-            if (last === undefined)
+            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))
+            if (mocked && isAmbient(name)) {
                 last.mocked = true;
+            }
             const held = last.expect;
-            last.expect =
-                held === undefined
-                    ? expect
-                    : PredicateKind.ALL_OF === held.kind
-                        ? { ...held, predicates: [...held.predicates, expect] }
-                        : { kind: PredicateKind.ALL_OF, predicates: [held, expect] };
+            if (held === undefined) {
+                last.expect = expect;
+            }
+            else if (PredicateKind.ALL_OF === held.kind) {
+                last.expect = { ...held, predicates: [...held.predicates, expect] };
+            }
+            else {
+                last.expect = { kind: PredicateKind.ALL_OF, predicates: [held, expect] };
+            }
         }
     }
     /**
@@ -191,24 +201,6 @@ 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.
      *
@@ -216,14 +208,17 @@ export class RecordingStore {
      * previous step's own answer alone.
      */
     markEnded(page, session) {
-        if (page === undefined)
+        if (page === undefined) {
             return;
+        }
         for (const [name, rec] of this.#targets(session)) {
-            if (isAmbient(name) && name !== ambientRecordingOf(session))
+            if (isAmbient(name) && name !== ambientRecordingOf(session)) {
                 continue;
+            }
             const last = rec.steps.at(-1);
-            if (last !== undefined && last.endPage === undefined)
+            if (last !== undefined && last.endPage === undefined) {
                 last.endPage = page;
+            }
         }
     }
     /**
@@ -241,14 +236,16 @@ export class RecordingStore {
     stop(name) {
         const rec = this.#active.get(name);
         this.#active.delete(name);
-        if (rec === undefined)
+        if (rec === undefined) {
             return undefined;
+        }
         for (const [outer, mark] of rec.openedOver) {
             const parent = this.#active.get(outer);
             // Gone already, or somehow shorter than when we started: leave it exactly as it is rather
             // than splice a range that no longer means what it meant.
-            if (parent === undefined || parent.steps.length < mark)
+            if (parent === undefined || parent.steps.length < mark) {
                 continue;
+            }
             parent.steps.splice(mark, parent.steps.length - mark, {
                 tool: INVOKE_TOOL,
                 args: { flow: name },

package/dist/language/flows/replay.d.ts

@@ -55,21 +55,31 @@ export declare const UNKEPT_EXPECT: string;
  */
 export declare function captureAct(recordings: {
     active: () => string[];
-    capture: (step: RecordedStep, route?: string, session?: string) => void;
+    capture: (step: RecordedStep, route?: string, session?: string, forAmbient?: RecordedStep) => void;
 }, args: Record<string, unknown>, res: unknown, 
 /** Where this step ran, so the ambient tape can be cut into journeys. See RecordedStep.route. */
 route?: string, 
 /** The session that acted: only recordings it started take the step. */
 session?: string, 
 /** The act's window sent a write request; see `wroteIn`. */
-wrote?: boolean): void;
+wrote?: boolean, 
+/** The act as the ambient tape keeps it, when that differs. See RecordingStore.capture. */
+ambientArgs?: Record<string, unknown>): void;
 /**
- * Capture an act_and_wait once its verdict is known, keeping `until` as the step's expectation only
- * on a yes. Recorded before the verdict, a step kept an `until` that came back `no` or `no-fault` —
- * a regression test asserting something never once observed to hold because of the action. The
- * action itself is always recorded: it happened, and replay needs it to reach the next step.
+ * Capture an act_and_wait once its verdict is known.
+ *
+ * The rule act_sequence keeps (#988). A recording somebody opened keeps every claim the agent
+ * declared, held or not: dropping a refuted one saved a flow that replayed green on the defect it
+ * had caught. The ambient tape keeps a claim only if the action made it hold (`held`), so a flow cut
+ * from it never replays a claim that was never once true because of the action. The action is
+ * always recorded: replay needs it to reach the next step.
+ *
+ * Keyed on `held`, not on `verified: yes`. A claim the action made hold under an `unknown` or a
+ * contradicted verdict is still what the agent proved about the page, and dropping it left the
+ * replay with no check at all. One function decides both tapes: a second rule that took the claim off the tape
+ * after the fact ran before this capture, so it took the PREVIOUS step's claim, which had passed.
  */
-export declare function captureVerdictedAct(recordings: Parameters<typeof captureAct>[0], args: Record<string, unknown>, res: unknown, route: string | undefined, verified: string | undefined, session?: string, 
+export declare function captureVerdictedAct(recordings: Parameters<typeof captureAct>[0], args: Record<string, unknown>, res: unknown, route: string | undefined, held: boolean, session?: string, 
 /** The act's window sent a write request; see `wroteIn`. */
 wrote?: boolean): void;
 /** Fold a PASSING standalone assertion into the step it proved. See RecordingStore.attachExpect. */