@reticlehq/server 3.6.0 → 3.7.0

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

@@ -22,19 +22,40 @@
  * outcome is four-valued now, so all four are recorded, and the run verdict counts an undetermined
  * check as neither a pass nor a failure -- which is what those words already meant everywhere else.
  */
+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 { JournalVerdictEffectSchema, RunAgentKind, RunFramework, RunProfile, RunTrigger, RunFlowStatus, Verified, } from '@reticlehq/core';
+import { currentShotRun } 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';
 /** The author of record when no MCP peer introduced itself. Mirrors verification-sync's default. */
 const UNNAMED_AGENT = 'reticle-mcp';
+/**
+ * The one MCP client every stamped action came from. Two clients in one tab is undefined, never a
+ * pick: crediting either would put the other's verdicts under its name.
+ */
+function soleAgent(actions) {
+    const named = new Set(actions.flatMap((action) => (action.agent === undefined ? [] : [action.agent])));
+    return 1 === named.size ? [...named][0] : undefined;
+}
+/**
+ * What a verdict required and what it saw, as the journal keeps them for its check. One place, so
+ * the act and assert paths cannot keep different halves.
+ */
+export function checkWords(verdict) {
+    return {
+        ...(verdict.expected === undefined ? {} : { expected: verdict.expected }),
+        ...(verdict.observed === undefined ? {} : { observed: verdict.observed }),
+    };
+}
 /** Every verdict a verification tool recorded on this session's actions, in order. */
 function verdicts(actions) {
     const out = [];
     for (const action of actions) {
         const parsed = JournalVerdictEffectSchema.safeParse(action.effect);
         if (parsed.success)
-            out.push(parsed.data);
+            out.push({ ...parsed.data, actionId: action.actionId });
     }
     return out;
 }
@@ -66,6 +87,87 @@ export function driveRunId(sessionId) {
     const candidate = `${DRIVE_RUN_PREFIX}${sessionId}`;
     return isValidRunId(candidate) ? candidate : defaultRunId();
 }
+/** The run of the `segment`th agent session in a tab: the tab's id first, then `-2`, `-3`… */
+function segmentRunId(base, segment) {
+    if (0 === segment)
+        return base;
+    const id = `${base}-${String(segment + 1)}`;
+    return isValidRunId(id) ? id : base;
+}
+/**
+ * Where each agent session in a tab ended: how many of the agent's own actions the tab held then,
+ * and the tab's clock. Every agent session in a tab wrote one run id, so a later end overwrote the
+ * earlier run on the dashboard.
+ * ponytail: daemon memory; a restart forgets the ends and the next fold is one run, as before.
+ */
+const agentEnds = new Map();
+/** The agent's own actions: the Harness drives in the same tab are runs of their own. */
+const agentsOwn = (actions) => actions.filter((action) => action.drivenBy === undefined);
+/** The run the agent's session now open in this tab is kept under. */
+export function agentRunId(sessionId) {
+    return segmentRunId(driveRunId(sessionId), agentEnds.get(sessionId)?.length ?? 0);
+}
+/**
+ * The run the current call lands in: the flow being replayed, else the Harness drive, else the
+ * agent session open in the tab. One answer for a call's screenshot and an intent its check proves.
+ */
+export function runIdOfCall(sessionId) {
+    const scoped = currentShotRun();
+    if (scoped !== undefined)
+        return scoped;
+    const by = currentDrivenBy();
+    const harness = by === undefined ? undefined : harnessRunId(by.harness);
+    return harness ?? agentRunId(sessionId);
+}
+/** The ends recorded for a tab, as counts of the agent's own actions, for the fold. */
+export function agentEndCounts(sessionId) {
+    return (agentEnds.get(sessionId) ?? []).map((end) => end.count);
+}
+/** What the agent claimed at each end of a tab, by the index `agentEndCounts` uses. */
+export function agentEndClaims(sessionId) {
+    return (agentEnds.get(sessionId) ?? []).map((end) => end.claim);
+}
+/**
+ * An agent session ends: its own actions since the previous end, the run they are kept under, and
+ * how long it ran. Recorded, so what the agent drives next is the next session's.
+ */
+export function endAgentSession(sessionId, actions, at, claim) {
+    const own = agentsOwn(actions);
+    const ends = agentEnds.get(sessionId) ?? [];
+    const last = ends.at(-1);
+    const runId = agentRunId(sessionId);
+    ends.push({
+        count: own.length,
+        at: at ?? last?.at ?? 0,
+        ...(claim === undefined ? {} : { claim }),
+    });
+    agentEnds.set(sessionId, ends);
+    // The end splits the tab's runs: written again now, not when the tab disconnects, so the run this
+    // end names is on disk (and the dashboard) while the tab stays open.
+    tellNoted();
+    const mine = own.slice(Math.min(last?.count ?? 0, own.length));
+    const wallMs = at === undefined ? undefined : wallOf(mine, last?.at, at);
+    return { actions: mine, runId, ...(wallMs === undefined ? {} : { wallMs }) };
+}
+/**
+ * How long a session ran, `since` the previous end (else its first action) to `end`, on the tab's
+ * clock, which restarts at every page load: an action stamped before the one ahead of it starts a
+ * new stretch, and the stretches add up. Measured from the last load alone, a ten-second session
+ * that navigated read "1.2s". ponytail: the gap between a reload and the next action is not counted.
+ */
+function wallOf(actions, since, end) {
+    let start = since ?? actions[0]?.tRange.from ?? end;
+    let prev = start;
+    let total = 0;
+    for (const action of actions) {
+        if (action.at < prev) {
+            total += prev - start;
+            start = action.tRange.from;
+        }
+        prev = action.at;
+    }
+    return total + (prev <= end ? end - start : prev - start + end);
+}
 /**
  * Fold a session's journal into a run, or return undefined when there is nothing honest to report.
  *
@@ -74,12 +176,27 @@ export function driveRunId(sessionId) {
  */
 export function driveRunFrom(actions, deps) {
     const found = verdicts(actions);
+    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);
         checks.push({
             predicate: verdict.claim,
             status: verdict.verified,
-            ...(verdict.source === undefined ? {} : { evidence: { source: verdict.source } }),
+            actionId: verdict.actionId,
+            ...(intent === undefined || 0 === intent.length ? {} : { intent }),
+            // Where it was written, and on a miss the calls of its window: what an issue page shows.
+            ...(verdict.source === undefined && verdict.net === undefined
+                ? {}
+                : {
+                    evidence: {
+                        ...(verdict.source === undefined ? {} : { source: verdict.source }),
+                        ...(verdict.net === undefined ? {} : { net: verdict.net }),
+                    },
+                }),
+            // What it required and what it saw, so a failed check can say both on the platform.
+            ...(verdict.expected === undefined ? {} : { expected: verdict.expected }),
+            ...(verdict.observed === undefined ? {} : { observed: verdict.observed }),
             // Carried through rather than recomputed. These were established at the moment the verdict
             // was made and written down then; a run built later cannot know any of them, and inferring
             // them here would be inventing evidence about evidence.
@@ -114,10 +231,14 @@ export function driveRunFrom(actions, deps) {
         durationMs: spanOf(actions),
         profile: RunProfile.DEV,
         project: {
-            name: deps.projectId ?? UNNAMED_AGENT,
+            // Never the daemon's own name: a tab that reported no project is named by its folder.
+            name: deps.projectId ?? deps.projectName ?? UNNAMED_AGENT,
             framework: deps.framework ?? RunFramework.OTHER,
         },
-        agent: { id: deps.agentId ?? UNNAMED_AGENT, kind: RunAgentKind.CODING_AGENT },
+        agent: {
+            id: deps.agentId ?? soleAgent(actions) ?? UNNAMED_AGENT,
+            kind: RunAgentKind.CODING_AGENT,
+        },
         trigger: {
             kind: RunTrigger.EDIT,
             note: 'driven live through the Reticle tools',
@@ -131,6 +252,7 @@ export function driveRunFrom(actions, deps) {
         // about what was WRONG, and a fold that guessed at anomalies would be inventing findings — the
         // failure this artifact is supposed to make impossible. Checks are the evidence here.
         evidence: { consoleErrors: [], networkAnomalies: [], stateAssertions: [], timeline: [] },
+        ...(deps.agentClaim === undefined ? {} : { agentClaim: deps.agentClaim }),
     };
 }
 /** Marks a run as one Harness drive, so it never collides with the session's own `drive-` run. */
@@ -148,16 +270,46 @@ export function harnessRunId(harness) {
     return isValidRunId(candidate) ? candidate : undefined;
 }
 /** The journey a Harness drive was named for, or what it did when nobody named one. */
-const UNNAMED_JOURNEY = 'Harness drive';
+// Never "Harness drive": that read as the title of every unnamed drive's flow and finding.
+const UNNAMED_JOURNEY = 'Exploring the app';
 /** Goal verdicts kept for the drives a session has not yet been graded on. */
 const MAX_GOALS_HELD = 200;
 const goalsMissed = new Map();
 /**
  * What the Harness judged of a drive's goal, noted the moment the drive finishes, before its
  * session ends and is graded. A drive whose checks held but whose goal was not reached synced as
- * "Proved" while the drive itself said it had failed. Unmet once is unmet: a later journey of the
- * same drive reaching its goal does not undo it.
+ * "Proved"; it is not proved. Unmet once is unmet: a later journey of the same drive reaching its
+ * goal does not undo it.
+ */
+/** Told when a Harness drive's goal or comparison is noted, or an agent session ends, so its run is written again. */
+const noted = new Set();
+/**
+ * Hear about every Harness note. A drive is graded after its last verdict, and the run that verdict
+ * flushed never carried the grade: live, the platform filed a failed check instead of "Hard to find".
  */
+export function onHarnessNoted(listener) {
+    noted.add(listener);
+    return () => noted.delete(listener);
+}
+const tellNoted = () => {
+    for (const listener of noted)
+        listener();
+};
+/** How long each Harness drive took, timed by the drive on the injected clock. */
+const spans = new Map();
+/**
+ * The drive's own measure of how long it ran. The span of one tab's journal is not it: a lane in a
+ * leased browser left only the grade's assert in the tab, and its run read "Took 0 ms".
+ */
+export function noteHarnessSpan(harness, ms) {
+    if (MAX_GOALS_HELD <= spans.size && !spans.has(harness)) {
+        const oldest = spans.keys().next().value;
+        if (oldest !== undefined)
+            spans.delete(oldest);
+    }
+    spans.set(harness, Math.max(0, ms));
+    tellNoted();
+}
 export function noteHarnessGoal(harness, met) {
     if (met === undefined)
         return;
@@ -170,11 +322,42 @@ export function noteHarnessGoal(harness, met) {
             goalsMissed.delete(oldest);
     }
     goalsMissed.set(harness, met);
+    tellNoted();
+}
+/** How each Harness drive's goals compared with the agent's verdicts, until its run is folded. */
+const disparities = new Map();
+/**
+ * Noted when a drive is graded, like its goal: its run artifact carries the comparison, so the
+ * platform can file a goal the agent proved and the Harness could not find.
+ */
+export function noteHarnessDisparity(harness, found) {
+    if (0 === found.length)
+        return;
+    if (MAX_GOALS_HELD <= disparities.size && !disparities.has(harness)) {
+        const oldest = disparities.keys().next().value;
+        if (oldest !== undefined)
+            disparities.delete(oldest);
+    }
+    disparities.set(harness, found);
+    tellNoted();
+}
+/** The phrase `describeWaitTarget` opens a route claim with, as the journal records it. */
+const ROUTE_CLAIM = 'a route change';
+const ABSENCE_OF = 'the absence of ';
+/**
+ * Whether a recorded check claimed nothing but a route (or leaving one): the Harness driver's guess
+ * about where a click goes, which `harness/route-guess.ts` explains. Kept here because a run fold
+ * reads the journal's words, not the predicate.
+ */
+function claimsOnlyRoute(claim, kind) {
+    if (PredicateKind.ROUTE === kind)
+        return true;
+    return PredicateKind.NOT === kind && claim.startsWith(`${ABSENCE_OF}${ROUTE_CLAIM}`);
 }
 /**
  * One Harness drive, as its own run: named for the journey it was asked to complete, and credited to
- * the Harness rather than to the agent whose tab it shared. The journey reads as one flow, failed
- * when any check it declared came back no, passed when one came back yes and none failed.
+ * the Harness rather than to the agent whose tab it shared. The journey reads as one flow, graded by
+ * `driveFlowStatus`: failed only on a check that came back no.
  */
 function harnessRunFrom(by, actions, deps) {
     const input = driveRunFrom(actions, {
@@ -183,16 +366,40 @@ function harnessRunFrom(by, actions, deps) {
     });
     if (input === undefined)
         return undefined;
-    const statuses = input.checks.map((check) => check.status);
-    const status = statuses.includes(Verified.NO) || false === goalsMissed.get(by.harness)
-        ? RunFlowStatus.FAIL
-        : statuses.includes(Verified.YES)
-            ? RunFlowStatus.PASS
-            : RunFlowStatus.SKIPPED;
+    // The driver's own wrong guess about where a click goes is not a failed check of the app; nor is
+    // its second press of a control whose claim already held (Save again on a field the app emptied).
+    const refOf = new Map(actions.map((a) => [a.actionId, asString(asRecord(a.args)['ref'])]));
+    const heldBefore = new Set();
+    const checks = input.checks.map((check) => {
+        const ref = check.actionId === undefined ? undefined : refOf.get(check.actionId);
+        const key = ref === undefined ? undefined : `${ref}|${check.predicate}`;
+        const repress = Verified.NO === check.status && key !== undefined && heldBefore.has(key);
+        if (Verified.YES === check.status && key !== undefined)
+            heldBefore.add(key);
+        return Verified.NO === check.status && (repress || claimsOnlyRoute(check.predicate, check.kind))
+            ? { ...check, status: Verified.UNKNOWN, reason: VerifiedReason.INCONCLUSIVE }
+            : check;
+    });
+    // A passive check that read too early is not counted: the one rule (superseded-checks.ts).
+    const superseded = supersededChecks(input.checks.map((c) => ({
+        key: c.predicate,
+        passive: false === c.declaredBeforeActing,
+        held: Verified.YES === c.status,
+        failed: Verified.NO === c.status,
+    })));
+    const count = (verified) => checks.filter((check, at) => verified === check.status && !superseded.has(at)).length;
+    const status = driveFlowStatus({
+        held: count(Verified.YES),
+        failed: count(Verified.NO),
+        goalMet: goalsMissed.get(by.harness),
+    });
     const first = actions.reduce((min, action) => Math.min(min, action.at), Number.MAX_SAFE_INTEGER);
+    const durationMs = spans.get(by.harness) ?? Math.max(0, input.durationMs - first);
     return {
         ...input,
-        durationMs: Math.max(0, input.durationMs - first),
+        checks,
+        ...(disparities.has(by.harness) ? { disparity: [...(disparities.get(by.harness) ?? [])] } : {}),
+        durationMs,
         agent: { id: harnessAgentId(by.driver), kind: RunAgentKind.CODING_AGENT },
         trigger: {
             kind: RunTrigger.EDIT,
@@ -203,7 +410,7 @@ function harnessRunFrom(by, actions, deps) {
                 name: by.persona ?? UNNAMED_JOURNEY,
                 status,
                 steps: actions.length,
-                durationMs: Math.max(0, input.durationMs - first),
+                durationMs,
             },
         ],
     };
@@ -216,7 +423,14 @@ function harnessRunFrom(by, actions, deps) {
  * agent with what the Harness proved and named neither.
  */
 export function driveRunsFrom(actions, deps) {
-    const own = actions.filter((action) => action.drivenBy === undefined);
+    const own = agentsOwn(actions);
+    // Each agent session in the tab is its own run: cut at the ends `reticle_session {end}` recorded.
+    const cuts = [0, ...(deps.agentEnds ?? []).map((n) => Math.min(n, own.length)), own.length];
+    const sessions = cuts.slice(1).map((to, i) => driveRunFrom(own.slice(cuts[i] ?? 0, to), {
+        ...deps,
+        runId: segmentRunId(deps.runId, i),
+        agentClaim: deps.agentClaims?.[i],
+    }));
     const drives = new Map();
     for (const action of actions) {
         const by = action.drivenBy;
@@ -227,7 +441,7 @@ export function driveRunsFrom(actions, deps) {
         drives.set(by.harness, held);
     }
     return [
-        driveRunFrom(own, deps),
+        ...sessions,
         ...[...drives.values()].map((drive) => harnessRunFrom(drive.by, drive.actions, deps)),
     ].filter((run) => run !== undefined);
 }

package/dist/judgement/runs/resume.d.ts

@@ -0,0 +1,44 @@
+import { type JournalAction } from '@reticlehq/core';
+import type { ToolDeps } from '../../surface/tools/tool-kit.js';
+/** The primer, short form. The full one lives in the agent's rules file (CLAUDE.md / AGENTS.md). */
+export declare const RESUME_PRIMER: readonly string[];
+export interface ResumeFacts {
+    actions: readonly JournalAction[];
+    /** Intents the ledger still owes (statements). */
+    openIntents: readonly string[];
+    /** The user's request as declared with reticle_intent, if one is current. */
+    request?: string | undefined;
+    /** The tab this was about, and where it is now. */
+    sessionId?: string | undefined;
+    route?: string | undefined;
+    /** The cursor to observe from. */
+    cursor?: number | undefined;
+    /** What this app's notes say (hints for targeting; never evidence). */
+    notes: readonly string[];
+}
+/** Each claim's LATEST verdict, in the order the claims were first made. */
+export declare function latestVerdicts(actions: readonly JournalAction[]): {
+    claim: string;
+    verified: string;
+    observed?: string;
+}[];
+/** The resume block, as lines. */
+export declare function resumeLines(facts: ResumeFacts): string[];
+/** The session whose action ledger was written most recently, if any. */
+export declare function newestSessionId(root: string): string | undefined;
+/** The user's request, when one was declared recently enough to be this session's. */
+export declare function recentRequest(root: string, now: number): string | undefined;
+/**
+ * Everything the resume block needs, read from disk — no daemon, which is what a SessionStart hook
+ * has the moment after a compaction. The caller supplies the journal reader: the MCP tool holds the
+ * live journal, the CLI reads the newest session's ledger.
+ */
+export declare function resumeFromDisk(input: {
+    root: string;
+    now: number;
+    fs: ToolDeps['fs'];
+    readActions: (sessionId: string) => Promise<readonly JournalAction[]>;
+    sessionId?: string | undefined;
+    route?: string | undefined;
+    cursor?: number | undefined;
+}): Promise<string[]>;

package/dist/judgement/runs/resume.js

@@ -0,0 +1,137 @@
+/**
+ * The resume block: what an agent needs back after its context was compacted, in under ~1k tokens.
+ *
+ * Reticle holds the memory, never the agent. After a compaction the agent's copy of the session is a
+ * summary written by a model, and a summary is exactly where "the checkout step failed" becomes
+ * "checkout was tested". So this is folded from the daemon's OWN records — the journal on disk, the
+ * intent ledger, the declared request, the app notes — and a claim whose latest verdict is not `yes`
+ * is listed as failed or not proved, however the agent remembers it.
+ *
+ * Served two ways from this one fold: `reticle_context { compact: true }` over MCP, and
+ * `reticle context --compact` at the terminal (no daemon needed), which a Claude Code SessionStart
+ * hook with matcher `compact` prints straight back into the fresh context.
+ */
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { JournalVerdictEffectSchema, ReticleDir, Verified, } from '@reticlehq/core';
+import { PromptContextSchema } from '@reticlehq/core/artifacts';
+import { IntentStore } from '../../memory/intent/intent-store.js';
+import { readAppNotes } from '../../surface/tools/agent/app-notes.js';
+/** How many claims of each state are named before the rest are counted. Bounds the block. */
+const SHOWN = 5;
+/** Any one line, capped: the block must stay well under ~1k tokens whatever the journal holds. */
+const LINE_MAX = 160;
+/** The primer, short form. The full one lives in the agent's rules file (CLAUDE.md / AGENTS.md). */
+export const RESUME_PRIMER = [
+    'Only verified:"yes" passes; "unknown" and "no-fault" are neither pass nor fail.',
+    'Declare the consequence before acting: reticle_act_and_wait { target, action, until }. Several steps: one reticle_act { steps: [{ target, action, expect }] }, last expect = end state.',
+    'Text is exact-case (ignoreCase only when case does not matter); target by testid or role+name. On a failure read expected/observed/nearest first; never weaken a check.',
+];
+function cap(text) {
+    const one = text.replace(/\s+/g, ' ').trim();
+    return one.length > LINE_MAX ? `${one.slice(0, LINE_MAX - 1)}…` : one;
+}
+function listed(label, items) {
+    if (0 === items.length)
+        return [];
+    const shown = items.slice(-SHOWN).map((item) => `  - ${cap(item)}`);
+    const more = items.length - Math.min(items.length, SHOWN);
+    return [
+        `${label} (${String(items.length)}):`,
+        ...(more > 0 ? [`  … ${String(more)} earlier`] : []),
+        ...shown,
+    ];
+}
+/** Each claim's LATEST verdict, in the order the claims were first made. */
+export function latestVerdicts(actions) {
+    const latest = new Map();
+    for (const action of actions) {
+        const parsed = JournalVerdictEffectSchema.safeParse(action.effect);
+        if (!parsed.success)
+            continue;
+        const { claim, verified, observed } = parsed.data;
+        latest.set(claim, { claim, verified, ...(observed === undefined ? {} : { observed }) });
+    }
+    return [...latest.values()];
+}
+/** The resume block, as lines. */
+export function resumeLines(facts) {
+    const verdicts = latestVerdicts(facts.actions);
+    const failed = verdicts
+        .filter((v) => Verified.NO === v.verified)
+        .map((v) => (v.observed === undefined ? v.claim : `${v.claim} — saw: ${v.observed}`));
+    const unproved = verdicts
+        .filter((v) => Verified.YES !== v.verified && Verified.NO !== v.verified)
+        .map((v) => `${v.claim} (${v.verified})`);
+    const held = verdicts.filter((v) => Verified.YES === v.verified).map((v) => v.claim);
+    const where = [
+        facts.sessionId === undefined ? undefined : `tab ${facts.sessionId}`,
+        facts.route === undefined ? undefined : `on ${facts.route}`,
+        facts.cursor === undefined ? undefined : `cursor ${String(facts.cursor)}`,
+    ].filter((p) => p !== undefined);
+    return [
+        `Reticle resume${0 === where.length ? '' : ` — ${where.join(', ')}`}. This is the daemon's record, not a summary: trust it over your memory.`,
+        ...(facts.request === undefined ? [] : [`Asked: ${cap(facts.request)}`]),
+        `Claims: ${String(held.length)} proved · ${String(failed.length)} failed · ${String(unproved.length)} not proved.`,
+        ...listed('FAILED — not done', failed),
+        ...listed('NOT PROVED — not done', unproved),
+        ...listed('Proved', held),
+        ...listed('Intents still owed', facts.openIntents),
+        ...listed('App notes (hints for targeting, never evidence)', facts.notes),
+        'Rules:',
+        ...RESUME_PRIMER.map((line) => `  - ${line}`),
+    ];
+}
+/** How long a declared request counts as this session's task (matches next-step.ts). */
+const REQUEST_FRESH_MS = 6 * 60 * 60 * 1000;
+/** The session whose action ledger was written most recently, if any. */
+export function newestSessionId(root) {
+    const dir = join(root, ReticleDir.SESSIONS_SUBDIR);
+    if (!existsSync(dir))
+        return undefined;
+    let newest;
+    for (const id of readdirSync(dir)) {
+        const ledger = join(dir, id, ReticleDir.JOURNAL_ACTIONS_FILE);
+        if (!existsSync(ledger))
+            continue;
+        const at = statSync(ledger).mtimeMs;
+        if (newest === undefined || at > newest.at)
+            newest = { id, at };
+    }
+    return newest?.id;
+}
+/** The user's request, when one was declared recently enough to be this session's. */
+export function recentRequest(root, now) {
+    try {
+        const parsed = PromptContextSchema.safeParse(JSON.parse(readFileSync(join(root, ReticleDir.REQUEST_FILE), 'utf8')));
+        if (!parsed.success || parsed.data.request === undefined)
+            return undefined;
+        const at = parsed.data.at;
+        return at !== undefined && now - at <= REQUEST_FRESH_MS ? parsed.data.request : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Everything the resume block needs, read from disk — no daemon, which is what a SessionStart hook
+ * has the moment after a compaction. The caller supplies the journal reader: the MCP tool holds the
+ * live journal, the CLI reads the newest session's ledger.
+ */
+export async function resumeFromDisk(input) {
+    const sessionId = input.sessionId ?? newestSessionId(input.root);
+    // Asked even with no session on disk: a caller holding the live journal answers from it.
+    const actions = await input.readActions(sessionId ?? '').catch(() => []);
+    const open = await new IntentStore(input.fs, input.root, { now: () => input.now })
+        .open()
+        .catch(() => []);
+    return resumeLines({
+        actions,
+        openIntents: open.map((intent) => intent.statement),
+        request: recentRequest(input.root, input.now),
+        sessionId,
+        route: input.route,
+        cursor: input.cursor,
+        notes: readAppNotes(input.root),
+    });
+}

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

@@ -14,6 +14,7 @@ import { boundFlowName, RunFlowStatus, VerifyPhase, } from '@reticlehq/core';
 import { buildVerificationRun, } from './artifact/build-verification-run.js';
 import { mapReplayToFlowResult } from './artifact/replay-mapping.js';
 import { buildRepairPackets } from './repair-prompt.js';
+import { withShotRun } from './default-run-id.js';
 import { buildRisks, classifyChangedFiles, } from './risk-classify.js';
 export class ReticleRunner {
     #port;
@@ -44,6 +45,8 @@ export class ReticleRunner {
         // Announced BEFORE the loop: "step 3" without "of 12" does not answer the only question a
         // person watching is actually asking, which is whether to keep waiting.
         emit({ phase: VerifyPhase.FLOWS_FOUND, total, at: this.#port.now() });
+        // Minted first, so each replayed step's screenshot is filed under the run it belongs to.
+        const runId = this.#port.newRunId();
         const replays = [];
         const flows = [];
         for (const [index, name] of names.entries()) {
@@ -55,7 +58,7 @@ export class ReticleRunner {
                 name: boundFlowName(name),
                 at: start,
             });
-            const replay = await this.#port.replayFlow(name);
+            const replay = await withShotRun(runId, () => this.#port.replayFlow(name));
             replays.push(replay);
             const mapped = mapReplayToFlowResult(replay, this.#port.now() - start);
             flows.push(mapped);
@@ -75,7 +78,7 @@ export class ReticleRunner {
         const risks = buildRisks(changedFiles, opts.policy);
         const failurePackets = buildRepairPackets(replays);
         const input = {
-            runId: this.#port.newRunId(),
+            runId,
             durationMs: flows.reduce((sum, f) => sum + f.durationMs, 0),
             profile: opts.profile,
             project: opts.project,

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

@@ -8,4 +8,8 @@ import type { ToolDeps } from '../../surface/tools/tool-kit.js';
 import type { RunnerPort } from './reticle-runner.js';
 export { defaultRunId } from './default-run-id.js';
 /** Wire a RunnerPort to the live session. Pass sessionId to disambiguate when several tabs are open. */
-export declare function createRunnerPort(deps: ToolDeps, sessionId?: string): RunnerPort;
+export declare function createRunnerPort(deps: ToolDeps, sessionId?: string, 
+/** `reticle verify --confirm-dangerous`: this run acknowledges the steps held as destructive. */
+opts?: {
+    confirmDangerous?: boolean;
+}): RunnerPort;

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

@@ -8,10 +8,16 @@ import { replayAndLearn } from '../../language/flows/flow-learning.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. */
-export function createRunnerPort(deps, sessionId) {
+export function createRunnerPort(deps, sessionId, 
+/** `reticle verify --confirm-dangerous`: this run acknowledges the steps held as destructive. */
+opts = {}) {
     return {
         listFlows: () => deps.flows.list(),
-        replayFlow: (name) => replayAndLearn(deps, sessionId !== undefined ? { flowName: name, sessionId } : { flowName: name }),
+        replayFlow: (name) => replayAndLearn(deps, {
+            flowName: name,
+            ...(sessionId === undefined ? {} : { sessionId }),
+            ...(true === opts.confirmDangerous ? { confirmDangerous: true } : {}),
+        }),
         now: () => deps.now(),
         newRunId: defaultRunId,
     };

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

@@ -8,6 +8,8 @@ export interface TimedReplay {
     /** The flow file that was replayed, so the synced run can carry its recording. */
     flow?: FlowFile;
 }
+/** 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";
 /**
  * Persist the suite's run artifact and best-effort mirror it to the cloud. Never throws into the verify
  * tool — a disk or network failure is logged and swallowed so the verdict the agent asked for is