@reticlehq/server 3.7.0 → 3.8.1

package/dist/judgement/runs/artifact/run-store.js

@@ -5,10 +5,13 @@
  * individual run to a deploy. The run is already clock-stamped by buildVerificationRun, so the store
  * needs no clock.
  */
-import { asRunId, ReticleVerificationRunSchema, RUN_RETENTION, RUN_RETENTION_SLACK, RunReadError, RunScreenshotSchema, STEP_SCREENSHOT, } from '@reticlehq/core';
+import { callingAttachId } from '../../../hooks/coding-agents.js';
+import { episodeStampFor } from '../../../hooks/episode-stamp.js';
+import { asRunId, checkoutOf, ReticleDir, ReticleVerificationRunSchema, RUN_RETENTION, RUN_RETENTION_SLACK, RunReadError, RunScreenshotSchema, STEP_SCREENSHOT, } from '@reticlehq/core';
 import { PromptContextSchema } from '@reticlehq/core/artifacts';
+import { readTextOrUndefined } from '../../../memory/project/fs/fs-port.js';
 import { reticleDirPaths, isValidRunId, runPath, stepShotDir, } from '../../../memory/project/dir/reticle-dir.js';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 const JSON_INDENT = 2;
 const JSON_EXT = '.json';
 const TMP_EXT = '.tmp';
@@ -34,18 +37,53 @@ export class RunStore {
      * Guards runId as a safe path segment BEFORE building the path — a runId can originate from a caller
      * (an OEM may set it), so an unsafe value must never escape .reticle/runs/ (mirrors the read guard).
      */
-    async write(given) {
+    /**
+     * The branch of the checkout that holds these runs. None for a folder inside Reticle's own
+     * storage (`~/.reticle/unmatched/<id>`): the walk up from there finds the home folder, which can be
+     * a dotfiles repository, and its branch says nothing about the app.
+     */
+    #branch() {
+        const project = dirname(this.#root);
+        if (project.split(/[\\/]/).includes(ReticleDir.ROOT)) {
+            return undefined;
+        }
+        return checkoutOf(project, readTextOrUndefined)?.branch;
+    }
+    async write(given, 
+    /** The tab the run came from, so a run written outside any call still finds its episode. */
+    hint = {}) {
         let run = given;
         if (!isValidRunId(run.runId)) {
             throw new Error(`refusing to write run with unsafe runId: ${JSON.stringify(run.runId)}`);
         }
         await this.#fs.mkdir(reticleDirPaths(this.#root).runs);
-        const context = run.context ?? (await this.#recentRequest(run.createdAt, run.runId));
-        if (context !== undefined)
+        const context = run.context ??
+            (await this.#recentRequest(run.createdAt, run.runId)) ??
+            (await this.#heldContext(run.runId));
+        if (context !== undefined) {
             run = { ...run, context };
+        }
+        // The episode this run came from, the agent session behind it, and the commit it ran against,
+        // so it joins exactly.
+        const episode = episodeStampFor(this.#root, callingAttachId(), hint.sessionId);
+        if (episode !== undefined) {
+            const commit = run.project.commit ?? episode.head;
+            run = {
+                ...run,
+                episodeId: episode.episodeId,
+                ...(episode.agentSession === undefined ? {} : { agentSession: episode.agentSession }),
+                project: { ...run.project, ...(commit === undefined ? {} : { commit }) },
+            };
+        }
         // The step screenshots taken for this run, the last of which may still be landing.
         await shotsLanded(this.#root, run.runId);
         run = withScreenshots(run, await readStepShots(this.#fs, this.#root, run.runId));
+        // Several agents drive one project at once, each in its own git worktree. Every run kind is
+        // written here, so here the run learns which branch it belongs to.
+        const branch = run.project.branch ?? this.#branch();
+        if (branch !== undefined) {
+            run = { ...run, project: { ...run.project, branch } };
+        }
         // Atomic publish: write a temp file then rename, so a crash mid-write never leaves a half-written
         // artifact (a partial.json would otherwise read back as MALFORMED).
         const path = runPath(this.#root, run.runId);
@@ -71,16 +109,19 @@ export class RunStore {
             const path = reticleDirPaths(this.#root).request;
             const raw = JSON.parse(await this.#fs.readFile(path));
             const parsed = PromptContextSchema.safeParse(raw);
-            if (!parsed.success)
+            if (!parsed.success) {
                 return undefined;
+            }
             const given = parsed.data.at;
-            if (given === undefined || at - given < 0 || REQUEST_RELEVANT_MS < at - given)
+            if (given === undefined || at - given < 0 || REQUEST_RELEVANT_MS < at - given) {
                 return undefined;
+            }
             // The first run written for a request answers it; a later run (the next agent session in the
             // same tab) inherited it and showed a goal it never had. Its own rewrite keeps it.
             const answeredBy = raw[REQUEST_RUN_KEY];
-            if ('string' === typeof answeredBy)
+            if ('string' === typeof answeredBy) {
                 return answeredBy === runId ? parsed.data : undefined;
+            }
             await this.#fs.writeFile(path, `${JSON.stringify({ ...raw, [REQUEST_RUN_KEY]: runId }, null, JSON_INDENT)}\n`);
             return parsed.data;
         }
@@ -88,14 +129,30 @@ export class RunStore {
             return undefined; // no request recorded: the common case
         }
     }
+    /**
+     * The request this run already carries on disk. A tab's run is written again after every verdict,
+     * and the prompt hook replaces request.json on every prompt: a newer prompt made the rewrite find
+     * no request of its own and drop the one it had, on this machine and on the platform.
+     */
+    async #heldContext(runId) {
+        try {
+            const held = JSON.parse(await this.#fs.readFile(runPath(this.#root, runId)));
+            const parsed = PromptContextSchema.safeParse(held.context);
+            return parsed.success ? parsed.data : undefined;
+        }
+        catch {
+            return undefined; // a first write: nothing held yet
+        }
+    }
     /**
      * Keep .reticle/runs/ bounded. Only acts once the count exceeds RUN_RETENTION + SLACK, then deletes the
      * oldest (by createdAt) back down to RUN_RETENTION — so the read-all is amortized, not per-write.
      */
     async #pruneOld() {
         const ids = await this.list();
-        if (ids.length <= this.#retention + this.#slack)
+        if (ids.length <= this.#retention + this.#slack) {
             return;
+        }
         // `id: RunId`, not `string`. `list()` already returns RunId[]; annotating the local as string
         // silently discarded the brand and handed a bare string to runPath — which is the transposition
         // the brand exists to prevent, reintroduced by a type annotation rather than by a bad call.
@@ -111,11 +168,13 @@ export class RunStore {
     }
     /** Never throws. Invalid id / missing → MISSING; bad JSON or failed schema → MALFORMED. */
     async read(runId) {
-        if (!isValidRunId(runId))
+        if (!isValidRunId(runId)) {
             return { ok: false, reason: RunReadError.MISSING };
+        }
         const path = runPath(this.#root, runId);
-        if (!(await this.#fs.exists(path)))
+        if (!(await this.#fs.exists(path))) {
             return { ok: false, reason: RunReadError.MISSING };
+        }
         let text;
         try {
             text = await this.#fs.readFile(path);
@@ -134,15 +193,17 @@ export class RunStore {
             return { ok: false, reason: RunReadError.MALFORMED };
         }
         const result = ReticleVerificationRunSchema.safeParse(parsed);
-        if (!result.success)
+        if (!result.success) {
             return { ok: false, reason: RunReadError.MALFORMED };
+        }
         return { ok: true, run: result.data };
     }
     /** List run ids on disk (filenames minus.json). Empty when the runs dir is absent. */
     async list() {
         const dir = reticleDirPaths(this.#root).runs;
-        if (!(await this.#fs.exists(dir)))
+        if (!(await this.#fs.exists(dir))) {
             return [];
+        }
         let entries;
         try {
             entries = await this.#fs.readdir(dir);
@@ -154,6 +215,17 @@ export class RunStore {
             .filter((e) => e.endsWith(JSON_EXT))
             .map((e) => asRunId(e.slice(0, -JSON_EXT.length)));
     }
+    /** Every readable run. Retention bounds how many there are. */
+    async all() {
+        const runs = [];
+        for (const id of await this.list()) {
+            const result = await this.read(id);
+            if (result.ok) {
+                runs.push(result.run);
+            }
+        }
+        return runs;
+    }
     /** The most-recent run by createdAt (undefined when none). Powers reticle_run_export's default. */
     async latest() {
         const ids = await this.list();
@@ -166,6 +238,44 @@ export class RunStore {
         }
         return best;
     }
+    /**
+     * The newest recorded result for each flow name, taken across every readable run, with the time
+     * and id of the run it came from. A run that carries no flows (a drive or an export) says nothing
+     * about any flow, so it can neither supply nor erase a result: judging coverage from `latest()`
+     * alone let one such run hide every earlier replay. Equal times break on the run id, so the answer
+     * never depends on the order `list()` returns.
+     */
+    async latestPerFlow() {
+        const newest = new Map();
+        for (const id of await this.list()) {
+            const read = await this.read(id);
+            if (!read.ok) {
+                continue;
+            }
+            const createdAt = read.run.createdAt;
+            for (const result of read.run.flows) {
+                const s = newest.get(result.name);
+                if (!s || createdAt > s.createdAt || (createdAt === s.createdAt && id > s.id)) {
+                    newest.set(result.name, { result, createdAt, id });
+                }
+            }
+        }
+        return newest;
+    }
+    /**
+     * The names `credit` (the gate's passing rule) gives each flow's newest result, each with the time
+     * of that result, so a caller can refuse a pass that predates an edit. The rule is passed in, so
+     * the run store does not reach into the flow language.
+     */
+    async passingFlowTimes(credit) {
+        const passing = new Map();
+        for (const { result, createdAt } of (await this.latestPerFlow()).values()) {
+            for (const name of credit([result])) {
+                passing.set(name, Math.max(passing.get(name) ?? createdAt, createdAt));
+            }
+        }
+        return passing;
+    }
     /**
      * The two most-recent runs by createdAt as `[previous, current]` (oldest-first), or undefined when
      * fewer than two readable runs exist. Powers reticle_run_export's `format:"diff"` (run-to-run deltas).
@@ -174,16 +284,19 @@ export class RunStore {
         const runs = [];
         for (const id of await this.list()) {
             const result = await this.read(id);
-            if (result.ok)
+            if (result.ok) {
                 runs.push(result.run);
+            }
         }
-        if (runs.length < 2)
+        if (runs.length < 2) {
             return undefined;
+        }
         runs.sort((a, b) => a.createdAt - b.createdAt);
         const previous = runs[runs.length - 2];
         const current = runs[runs.length - 1];
-        if (previous === undefined || current === undefined)
+        if (previous === undefined || current === undefined) {
             return undefined;
+        }
         return [previous, current];
     }
 }
@@ -205,11 +318,13 @@ export function noteLanding(dir, land) {
 }
 /** Wait for this run's screenshots still landing, so a run written now can list them. Bounded. */
 export async function shotsLanded(root, runId) {
-    if (!isValidRunId(runId))
+    if (!isValidRunId(runId)) {
         return;
+    }
     const pending = landing.get(stepShotDir(root, runId));
-    if (pending === undefined || 0 === pending.size)
+    if (pending === undefined || 0 === pending.size) {
         return;
+    }
     let timer;
     await Promise.race([
         Promise.allSettled([...pending]),
@@ -217,8 +332,9 @@ export async function shotsLanded(root, runId) {
             timer = setTimeout(resolve, LANDING_WAIT_MS);
         }),
     ]);
-    if (timer !== undefined)
+    if (timer !== undefined) {
         clearTimeout(timer);
+    }
 }
 /** One line of a run's record, read back; anything malformed is skipped. */
 function parseLine(line) {
@@ -232,8 +348,9 @@ function parseLine(line) {
 }
 /** Every screenshot a run has landed, in the order they were taken (by seq). Never throws. */
 export async function readStepShots(fs, root, runId) {
-    if (!isValidRunId(runId))
+    if (!isValidRunId(runId)) {
         return [];
+    }
     try {
         const text = await fs.readFile(join(stepShotDir(root, runId), STEP_SCREENSHOT.MANIFEST_FILE));
         return (text
@@ -256,9 +373,11 @@ function stepShotOf(shot) {
 /** An id that occurs once in the list; a repeated one (a reload restarts the count) pairs nothing. */
 function uniqueIds(ids) {
     const seen = new Map();
-    for (const id of ids)
-        if (id !== undefined)
+    for (const id of ids) {
+        if (id !== undefined) {
             seen.set(id, (seen.get(id) ?? 0) + 1);
+        }
+    }
     return new Set([...seen].filter(([, n]) => 1 === n).map(([id]) => id));
 }
 /**
@@ -268,8 +387,9 @@ function uniqueIds(ids) {
  */
 function pairByAction(run, shots) {
     const verdictShots = shots.filter((shot) => true === shot.verdict && shot.actionId !== undefined);
-    if (0 === verdictShots.length || run.checks.every((check) => check.actionId === undefined))
+    if (0 === verdictShots.length || run.checks.every((check) => check.actionId === undefined)) {
         return undefined;
+    }
     const okChecks = uniqueIds(run.checks.map((check) => check.actionId));
     const okShots = uniqueIds(verdictShots.map((shot) => shot.actionId));
     const shotOf = new Map(verdictShots.flatMap((shot) => shot.actionId !== undefined && okShots.has(shot.actionId) && okChecks.has(shot.actionId)
@@ -278,10 +398,12 @@ function pairByAction(run, shots) {
     const checkIdOf = new Map();
     const checks = run.checks.map((check) => {
         const shot = check.actionId === undefined ? undefined : shotOf.get(check.actionId);
-        if (shot === undefined)
+        if (shot === undefined) {
             return check;
-        if (check.checkId !== undefined)
+        }
+        if (check.checkId !== undefined) {
             checkIdOf.set(shot, check.checkId);
+        }
         return { ...check, screenshot: stepShotOf(shot) };
     });
     return {
@@ -300,13 +422,15 @@ function pairByAction(run, shots) {
  */
 function pairWithChecks(run, shots) {
     const byAction = pairByAction(run, shots);
-    if (byAction !== undefined)
+    if (byAction !== undefined) {
         return byAction;
+    }
     const verdictShots = shots.filter((shot) => true === shot.verdict);
     if (0 === verdictShots.length ||
         verdictShots.length !== run.checks.length ||
-        run.checks.some((check) => check.checkId === undefined))
+        run.checks.some((check) => check.checkId === undefined)) {
         return { checks: run.checks, shots: [...shots] };
+    }
     const checkIdOf = new Map(verdictShots.map((shot, i) => [shot, run.checks[i]?.checkId]));
     return {
         checks: run.checks.map((check, i) => {
@@ -325,8 +449,9 @@ function pairWithChecks(run, shots) {
  * back unchanged.
  */
 export function withScreenshots(run, taken) {
-    if (0 === taken.length)
+    if (0 === taken.length) {
         return run;
+    }
     const { checks, shots } = pairWithChecks(run, taken);
     const byStep = new Map(shots.flatMap((shot) => (shot.step === undefined ? [] : [[shot.step, shot]])));
     const flows = run.flows.map((flow) => flow.stepResults === undefined

package/dist/judgement/runs/default-run-id.d.ts

@@ -1,11 +1,13 @@
 import { type RunId } from '@reticlehq/core';
 /**
- * The default run-id generator — a branded uuid.
+ * The default run-id generator — 16 random hex characters.
  *
  * A leaf on purpose: `verification-sync.ts` wants this one function, and reaching it through the
  * flow-replay stack would be a cycle.
  */
 export declare function defaultRunId(): RunId;
+/** A short id that is always the same for `key`, and always a safe path segment. */
+export declare function stableRunId(key: string): string;
 export declare function withShotRun<T>(runId: string, fn: () => Promise<T>): Promise<T>;
 /** The run being replayed now, or undefined outside a verify. */
 export declare function currentShotRun(): string | undefined;

package/dist/judgement/runs/default-run-id.js

@@ -1,14 +1,26 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
-import { randomUUID } from 'node:crypto';
+import { createHash, randomBytes } from 'node:crypto';
 import { asRunId } from '@reticlehq/core';
 /**
- * The default run-id generator — a branded uuid.
+ * How many hex characters a new run id has: 64 bits.
+ *
+ * Each step screenshot path that an agent reads contains the run id, so a 36-character uuid cost
+ * tokens on every action. 64 bits keeps a collision in one organisation's runs improbable. Old
+ * uuid ids stay valid: a run id is any safe path segment, and nothing reads its shape.
+ */
+const RUN_ID_HEX = 16;
+/**
+ * The default run-id generator — 16 random hex characters.
  *
  * A leaf on purpose: `verification-sync.ts` wants this one function, and reaching it through the
  * flow-replay stack would be a cycle.
  */
 export function defaultRunId() {
-    return asRunId(randomUUID());
+    return asRunId(randomBytes(RUN_ID_HEX / 2).toString('hex'));
+}
+/** A short id that is always the same for `key`, and always a safe path segment. */
+export function stableRunId(key) {
+    return createHash('sha256').update(key).digest('hex').slice(0, RUN_ID_HEX);
 }
 /**
  * The run a replay's step screenshots belong to, carried across every await under it.

package/dist/judgement/runs/drive-run.d.ts

@@ -66,9 +66,9 @@ export declare function checkWords(verdict: {
  * reload, each a superset of the last, and the dashboard would fill with overlapping copies of one
  * drive. Derived from the session instead, so the fold is idempotent.
  *
- * A session id is a free string on the wire, so the derived id is CHECKED before it becomes a path
- * segment; anything that would not be a safe one falls back to a random id, which loses idempotence
- * for that session rather than refusing to record it.
+ * A hash of the session id, not the id itself. A session id is a free string on the wire, and a
+ * uuid one put 36 characters into every step screenshot path. The hash is short, stable and always
+ * a safe path segment. A run that an older daemon wrote keeps its long id and stays readable.
  */
 export declare function driveRunId(sessionId: string): string;
 /** The run the agent's session now open in this tab is kept under. */

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

@@ -25,7 +25,7 @@
 import { supersededChecks } from '@reticlehq/engine/evidence/superseded-checks.js';
 import { isValidRunId } from '../../memory/project/dir/reticle-dir.js';
 import { defaultRunId } from './runner-port.js';
-import { currentShotRun } from './default-run-id.js';
+import { currentShotRun, stableRunId } from './default-run-id.js';
 import { currentDrivenBy } from '../../hooks/driven-by.js';
 import { JournalVerdictEffectSchema, RunAgentKind, asRecord, asString, RunFramework, RunProfile, RunTrigger, PredicateKind, Verified, VerifiedReason, driveFlowStatus, } from '@reticlehq/core';
 import { withCorrections } from './late-answer.js';
@@ -79,13 +79,12 @@ const DRIVE_RUN_PREFIX = 'drive-';
  * reload, each a superset of the last, and the dashboard would fill with overlapping copies of one
  * drive. Derived from the session instead, so the fold is idempotent.
  *
- * A session id is a free string on the wire, so the derived id is CHECKED before it becomes a path
- * segment; anything that would not be a safe one falls back to a random id, which loses idempotence
- * for that session rather than refusing to record it.
+ * A hash of the session id, not the id itself. A session id is a free string on the wire, and a
+ * uuid one put 36 characters into every step screenshot path. The hash is short, stable and always
+ * a safe path segment. A run that an older daemon wrote keeps its long id and stays readable.
  */
 export function driveRunId(sessionId) {
-    const candidate = `${DRIVE_RUN_PREFIX}${sessionId}`;
-    return isValidRunId(candidate) ? candidate : defaultRunId();
+    return `${DRIVE_RUN_PREFIX}${stableRunId(sessionId)}`;
 }
 /** The run of the `segment`th agent session in a tab: the tab's id first, then `-2`, `-3`… */
 function segmentRunId(base, segment) {
@@ -179,12 +178,17 @@ export function driveRunFrom(actions, deps) {
     const intentOf = new Map(actions.map((a) => [a.actionId, asString(asRecord(a.args)['intent'])]));
     const checks = [];
     for (const verdict of found) {
-        const intent = intentOf.get(verdict.actionId);
+        // The agent's own words on the call win; else the sentence the verdict recorded.
+        const given = intentOf.get(verdict.actionId);
+        const own = given !== undefined && 0 < given.length;
+        const intent = own ? given : verdict.intent;
         checks.push({
             predicate: verdict.claim,
             status: verdict.verified,
             actionId: verdict.actionId,
             ...(intent === undefined || 0 === intent.length ? {} : { intent }),
+            ...(!own && true === verdict.intentDerived ? { intentDerived: true } : {}),
+            ...(verdict.failedPart === undefined ? {} : { failedPart: verdict.failedPart }),
             // Where it was written, and on a miss the calls of its window: what an issue page shows.
             ...(verdict.source === undefined && verdict.net === undefined
                 ? {}

package/dist/judgement/runs/run-ledger.d.ts

@@ -0,0 +1,21 @@
+import { Verified, type JournalAction, type RunReport } from '@reticlehq/core';
+export declare class RunLedger {
+    #private;
+    /** An agent call starts. The first one starts the run, and a call from another agent starts a new one. */
+    begin(now: number, owner: string): void;
+    /** An agent call ended. The first one that left a verdict sets the time to the first verdict. */
+    after(now: number): void;
+    /** A journal record from the agent's own call. A record with no verdict is not a claim. */
+    verdict(action: JournalAction): void;
+    flowSaved(name: string): void;
+    /** The last replay of a flow in this run is its verdict. */
+    replayed(name: string, verified: Verified): void;
+    memoryWritten(count?: number): void;
+    /** Notes given to the agent. Each one counts once, however often it is shown. */
+    memoryRead(notes: readonly string[]): void;
+    isEmpty(): boolean;
+    /** The report, without the cloud line (the caller knows the project). Empties the ledger. */
+    take(now: number): RunReport;
+}
+/** The daemon's ledger. */
+export declare const runLedger: RunLedger;

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

@@ -0,0 +1,143 @@
+/**
+ * The run ledger: what one 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
+ * 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.
+ *
+ * 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.
+ *
+ * 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.
+ */
+import { supersededChecks } from '@reticlehq/engine/evidence/superseded-checks.js';
+import { JournalVerdictEffectSchema, ReticleTool, Verified, } from '@reticlehq/core';
+const SAW = 'saw ';
+const FLOW = 'flow ';
+/** One piece of evidence for a claim: what the check saw, else the source line it drove. */
+function evidenceOf(effect) {
+    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))
+        return Verified.NO;
+    if (0 === all.length || all.some((v) => Verified.YES !== v))
+        return Verified.UNKNOWN;
+    return Verified.YES;
+}
+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. */
+    begin(now, owner) {
+        if (this.#owner !== owner)
+            this.#reset();
+        this.#owner = owner;
+        this.#startedAt ??= now;
+    }
+    /** 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;
+    }
+    /** 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)
+            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)
+            return;
+        const parsed = JournalVerdictEffectSchema.safeParse(action.effect);
+        if (parsed.success)
+            this.#verdicts.push(parsed.data);
+    }
+    flowSaved(name) {
+        if (!this.#idle())
+            this.#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);
+    }
+    memoryWritten(count = 1) {
+        if (!this.#idle())
+            this.#written += count;
+    }
+    /** Notes given to the agent. Each one counts once, however often it is shown. */
+    memoryRead(notes) {
+        if (this.#idle())
+            return;
+        for (const note of notes)
+            this.#read.add(note);
+    }
+    isEmpty() {
+        return this.#idle();
+    }
+    /**
+     * 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.
+     */
+    #idle() {
+        return this.#startedAt === undefined;
+    }
+    /** The report, without the cloud line (the caller knows the project). Empties the ledger. */
+    take(now) {
+        const started = this.#startedAt ?? now;
+        // A passive check that read too early is not counted: the rule every fold applies.
+        const superseded = supersededChecks(this.#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 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 = {
+            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 },
+            wallMs: Math.max(0, now - started),
+            ...(this.#firstVerdictAt === undefined
+                ? {}
+                : { firstVerdictMs: Math.max(0, this.#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. */
+export const runLedger = new RunLedger();

package/dist/judgement/runs/runner-port.d.ts

@@ -1,6 +1,6 @@
 /**
  * The live adapter: build a RunnerPort from the real ToolDeps so ReticleRunner drives actual flow
- * replays against the connected app. Thin glue — it wires deps.flows.list, replayNamedFlow, deps.now,
+ * replays against the connected app. Thin glue — it wires the session's flow list, replayNamedFlow, deps.now,
  * and a uuid generator. The ReticleRunner core (tested with a fake port) holds all the orchestration and
  * verdict logic, so this layer carries no decisions.
  */

package/dist/judgement/runs/runner-port.js

@@ -1,10 +1,12 @@
 /**
  * The live adapter: build a RunnerPort from the real ToolDeps so ReticleRunner drives actual flow
- * replays against the connected app. Thin glue — it wires deps.flows.list, replayNamedFlow, deps.now,
+ * replays against the connected app. Thin glue — it wires the session's flow list, replayNamedFlow, deps.now,
  * and a uuid generator. The ReticleRunner core (tested with a fake port) holds all the orchestration and
  * verdict logic, so this layer carries no decisions.
  */
 import { replayAndLearn } from '../../language/flows/flow-learning.js';
+import { flowsForSession } from '../../language/flows/flow-store-for-session.js';
+import { safeSessionTarget } from '../../memory/project/session-root.js';
 import { defaultRunId } from './default-run-id.js';
 export { defaultRunId } from './default-run-id.js';
 /** Wire a RunnerPort to the live session. Pass sessionId to disambiguate when several tabs are open. */
@@ -12,7 +14,11 @@ export function createRunnerPort(deps, sessionId,
 /** `reticle verify --confirm-dangerous`: this run acknowledges the steps held as destructive. */
 opts = {}) {
     return {
-        listFlows: () => deps.flows.list(),
+        // Resolved as replay resolves it, so every listed name is one replay can load.
+        listFlows: () => {
+            const target = safeSessionTarget(deps, sessionId);
+            return flowsForSession(deps, target).flows.list(target.projectId);
+        },
         replayFlow: (name) => replayAndLearn(deps, {
             flowName: name,
             ...(sessionId === undefined ? {} : { sessionId }),