@reticlehq/server 3.5.0 → 3.7.0

package/dist/judgement/runs/context-tools.js

@@ -6,6 +6,8 @@ import { openSessionIntents } from '../../memory/intent/open-intents.js';
 import { ReticleTool } from '@reticlehq/core';
 import { sessionIdShape } from '../../surface/tools/tool-kit.js';
 import { asString } from '@reticlehq/core';
+import { resumeFromDisk, resumeLines } from './resume.js';
+import { sessionRoot } from '../../memory/project/session-root.js';
 /**
  * What this run has established, asked for by the one party that knows when it is needed.
  *
@@ -19,21 +21,30 @@ import { asString } from '@reticlehq/core';
  */
 /** What the run has established, and where each part of it came from. */
 const CONTEXT_OUTPUT_SCHEMA = {
+    resume: z
+        .string()
+        .optional()
+        .describe('Only with `compact: true`: the whole answer in under ~1k tokens — the tab and route, the request, every claim that FAILED or is NOT PROVED (by its latest verdict), what held, open intents, app notes and the rules. Read it after a compaction instead of trusting your summary.'),
     step: z
         .number()
+        .optional()
         .describe('How many actions this run has dispatched. Counted off the journal, not a counter of its own.'),
     established: z
         .array(z.unknown())
+        .optional()
         .describe('What Reticle OBSERVED, folded and capped, each `{ key, fact, source?, doc?, epoch? }`. `key` is the subject, so re-observing it supersedes rather than appends. Anything seen under a replaced document or a pre-edit epoch is already gone from this list.'),
     proven: z
         .array(z.unknown())
+        .optional()
         .describe('Claims a verdict already settled, each `{ claim, verified, source?, doc?, epoch? }`. Read this before re-driving something: re-proving it is slow, and assuming it is a false green.'),
     gap: z
         .object({})
         .passthrough()
+        .optional()
         .describe('The distance between what was claimed and what held, over THIS session: `{ claims, held, failed, undecided, nothingToProve, undecidedBy, falseGreensCaught, failures }`. `undecidedBy` says WHO can act on each unknown — environment (wait), code (fix the app), harness (fix Reticle or the call), could-not-see (look again). Folded from the same journal as everything else here, so it cannot disagree with it.'),
     remaining: z
         .array(z.string())
+        .optional()
         .describe('The intents from .reticle/intent/ that no verdict has discharged. Derived from the ledger, never a guess at what you meant to do next.'),
 };
 /** The ledger and the live page state this run is folded out of. `[]`/undefined when nothing is connected. */
@@ -59,16 +70,63 @@ async function evidenceFor(deps, sessionId) {
         };
     }
 }
+/** The resume block for the live session, or the newest one on disk when none is connected. */
+async function resumeFor(deps, sessionId, actions) {
+    let live;
+    try {
+        const session = deps.sessions.resolve(sessionId);
+        live = { id: session.id, url: session.url, cursor: session.elapsed() };
+    }
+    catch {
+        live = undefined;
+    }
+    let root;
+    try {
+        root = sessionRoot(deps, live?.id);
+    }
+    catch {
+        // No project can be named for this call: the live journal is all there is to fold.
+        return resumeLines({ actions, openIntents: [], notes: [] });
+    }
+    return resumeFromDisk({
+        root,
+        now: deps.now(),
+        fs: deps.fs,
+        // The live journal; with nothing connected there is no live one to fold, and the CLI's
+        // `reticle context --compact` is the reader for a session that has gone.
+        readActions: () => Promise.resolve(actions),
+        ...(live === undefined
+            ? {}
+            : { sessionId: live.id, route: routeOf(live.url), cursor: live.cursor }),
+    });
+}
+/** The path of a page URL, or the URL as given. */
+function routeOf(url) {
+    try {
+        return new URL(url).pathname;
+    }
+    catch {
+        return url;
+    }
+}
 export const CONTEXT_TOOLS = [
     {
         name: ReticleTool.CONTEXT,
         description: 'What THIS run has already established, so you do not rediscover it. Call it when your own copy is gone: right after a compaction, at the top of a fresh sub-agent, or at the start of a turn you did not begin. Returns `established` (what Reticle OBSERVED, with the source file:line where one was reported), `proven` (claims a verdict already settled, so you neither re-prove them nor assume them) and `remaining` (the intents from .reticle/intent/ that nothing has discharged). It is a FOLD over the journal, never a second store, so it cannot disagree with the ledger. Bounded and superseding rather than accumulating, and anything observed under a replaced document or before your last source edit is already dropped rather than presented as current. Only what Reticle observed goes in: it never reports what you intended or believed.',
         example: {},
-        inputSchema: { ...sessionIdShape },
+        inputSchema: {
+            compact: z
+                .boolean()
+                .optional()
+                .describe('After a compaction: one bounded `resume` text instead of the structured fold.'),
+            ...sessionIdShape,
+        },
         outputSchema: CONTEXT_OUTPUT_SCHEMA,
         handler: async (deps, args) => {
             const sessionId = asString(args['sessionId']);
             const evidence = await evidenceFor(deps, sessionId);
+            if (true === args['compact'])
+                return { resume: (await resumeFor(deps, sessionId, evidence.actions)).join('\n') };
             const context = runContextFor({
                 ...evidence,
                 intents: await openSessionIntents(deps, sessionId),

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

@@ -6,3 +6,6 @@ import { type RunId } from '@reticlehq/core';
  * flow-replay stack would be a cycle.
  */
 export declare function defaultRunId(): RunId;
+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,3 +1,4 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { randomUUID } from 'node:crypto';
 import { asRunId } from '@reticlehq/core';
 /**
@@ -9,3 +10,18 @@ import { asRunId } from '@reticlehq/core';
 export function defaultRunId() {
     return asRunId(randomUUID());
 }
+/**
+ * The run a replay's step screenshots belong to, carried across every await under it.
+ *
+ * A suite's run id used to be minted after its flows had replayed, so a screenshot taken during a
+ * step had no run to be filed under. The verify paths now mint the id first and run the replays
+ * inside it; a capture outside any of them belongs to the session's own drive run.
+ */
+const current = new AsyncLocalStorage();
+export function withShotRun(runId, fn) {
+    return current.run(runId, fn);
+}
+/** The run being replayed now, or undefined outside a verify. */
+export function currentShotRun() {
+    return current.getStore();
+}

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

@@ -22,9 +22,11 @@
  * 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 { RunFramework, type JournalAction } from '@reticlehq/core';
+import { RunFramework, type VerdictStatus, type JournalAction, type RunDisparity } from '@reticlehq/core';
 import type { VerificationRunInput } from './artifact/build-verification-run.js';
 export interface DriveRunDeps {
+    /** The project's folder name, for a tab that reported no project id. */
+    projectName?: string | undefined;
     runId: string;
     /** The project this session belonged to, for the dashboard's row. */
     projectId?: string | undefined;
@@ -38,7 +40,24 @@ export interface DriveRunDeps {
      * Absent when nobody was counting edits, which must not be reported as "the first round".
      */
     editEpoch?: number | undefined;
+    /** Where each agent session in the tab ended (`agentEndCounts`): each is folded on its own. */
+    agentEnds?: readonly number[];
+    /** What the agent claimed at each of those ends (`agentEndClaims`), by the same index. */
+    agentClaims?: readonly (VerdictStatus | undefined)[];
+    /** The agent's own claim for this run, carried beside the graded verdict. */
+    agentClaim?: VerdictStatus | 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 declare function checkWords(verdict: {
+    expected?: string;
+    observed?: string;
+}): {
+    expected?: string;
+    observed?: string;
+};
 /**
  * The run id for a session's drive: stable, so the session rewrites its own row.
  *
@@ -52,6 +71,26 @@ export interface DriveRunDeps {
  * for that session rather than refusing to record it.
  */
 export declare function driveRunId(sessionId: string): string;
+/** The run the agent's session now open in this tab is kept under. */
+export declare function agentRunId(sessionId: string): string;
+/**
+ * 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 declare function runIdOfCall(sessionId: string): string;
+/** The ends recorded for a tab, as counts of the agent's own actions, for the fold. */
+export declare function agentEndCounts(sessionId: string): number[];
+/** What the agent claimed at each end of a tab, by the index `agentEndCounts` uses. */
+export declare function agentEndClaims(sessionId: string): (VerdictStatus | undefined)[];
+/**
+ * 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 declare function endAgentSession(sessionId: string, actions: readonly JournalAction[], at: number | undefined, claim?: VerdictStatus): {
+    actions: JournalAction[];
+    runId: string;
+    wallMs?: number;
+};
 /**
  * Fold a session's journal into a run, or return undefined when there is nothing honest to report.
  *
@@ -59,3 +98,34 @@ export declare function driveRunId(sessionId: string): string;
  * artifact are the caller's job, which is what keeps the verdict rules testable without a disk.
  */
 export declare function driveRunFrom(actions: readonly JournalAction[], deps: DriveRunDeps): VerificationRunInput | undefined;
+/** What a Harness run says drove it, in the dashboard's "Driven by" line. */
+export declare function harnessAgentId(driver: string): string;
+/**
+ * The id of the run a Harness drive syncs as, so whoever started the drive can find it again (the
+ * platform's chat folds the run into the check it asked for). Undefined for an id no run can carry.
+ */
+export declare function harnessRunId(harness: string): string | undefined;
+/**
+ * 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 declare function onHarnessNoted(listener: () => void): () => void;
+/**
+ * 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 declare function noteHarnessSpan(harness: string, ms: number): void;
+export declare function noteHarnessGoal(harness: string, met: boolean | undefined): void;
+/**
+ * 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 declare function noteHarnessDisparity(harness: string, found: readonly RunDisparity[]): void;
+/**
+ * Every run a session's journal holds: the connected agent's drive, and one per Harness drive.
+ *
+ * They used to be one. A Harness drive dispatches through the same tools in the same tab, so its
+ * verdicts folded into the agent's run, and the dashboard showed one blended row that credited the
+ * agent with what the Harness proved and named neither.
+ */
+export declare function driveRunsFrom(actions: readonly JournalAction[], deps: DriveRunDeps): VerificationRunInput[];

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, } 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,5 +252,196 @@ 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. */
+const HARNESS_RUN_PREFIX = 'harness-';
+/** What a Harness run says drove it, in the dashboard's "Driven by" line. */
+export function harnessAgentId(driver) {
+    return 'server' === driver ? 'Reticle Harness (platform)' : `Reticle Harness (${driver})`;
+}
+/**
+ * The id of the run a Harness drive syncs as, so whoever started the drive can find it again (the
+ * platform's chat folds the run into the check it asked for). Undefined for an id no run can carry.
+ */
+export function harnessRunId(harness) {
+    const candidate = `${HARNESS_RUN_PREFIX}${harness}`;
+    return isValidRunId(candidate) ? candidate : undefined;
+}
+/** The journey a Harness drive was named for, or what it did when nobody named one. */
+// 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"; 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;
+    const before = goalsMissed.get(harness);
+    if (false === before)
+        return;
+    if (MAX_GOALS_HELD <= goalsMissed.size && !goalsMissed.has(harness)) {
+        const oldest = goalsMissed.keys().next().value;
+        if (oldest !== undefined)
+            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, graded by
+ * `driveFlowStatus`: failed only on a check that came back no.
+ */
+function harnessRunFrom(by, actions, deps) {
+    const input = driveRunFrom(actions, {
+        ...deps,
+        runId: harnessRunId(by.harness) ?? defaultRunId(),
+    });
+    if (input === undefined)
+        return undefined;
+    // 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,
+        checks,
+        ...(disparities.has(by.harness) ? { disparity: [...(disparities.get(by.harness) ?? [])] } : {}),
+        durationMs,
+        agent: { id: harnessAgentId(by.driver), kind: RunAgentKind.CODING_AGENT },
+        trigger: {
+            kind: RunTrigger.EDIT,
+            note: `driven by the Harness${by.persona === undefined ? '' : `: ${by.persona}`}`,
+        },
+        flows: [
+            {
+                name: by.persona ?? UNNAMED_JOURNEY,
+                status,
+                steps: actions.length,
+                durationMs,
+            },
+        ],
     };
 }
+/**
+ * Every run a session's journal holds: the connected agent's drive, and one per Harness drive.
+ *
+ * They used to be one. A Harness drive dispatches through the same tools in the same tab, so its
+ * verdicts folded into the agent's run, and the dashboard showed one blended row that credited the
+ * agent with what the Harness proved and named neither.
+ */
+export function driveRunsFrom(actions, deps) {
+    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;
+        if (by === undefined)
+            continue;
+        const held = drives.get(by.harness) ?? { by, actions: [] };
+        held.actions.push(action);
+        drives.set(by.harness, held);
+    }
+    return [
+        ...sessions,
+        ...[...drives.values()].map((drive) => harnessRunFrom(drive.by, drive.actions, deps)),
+    ].filter((run) => run !== undefined);
+}

package/dist/judgement/runs/repair-prompt.js

@@ -46,7 +46,7 @@ function deviationHeadline(deviation) {
     return undefined;
 }
 export function buildRepairPacket(replay) {
-    if (replay.status === ReplayStatus.OK)
+    if (replay.status === ReplayStatus.OK || replay.status === ReplayStatus.UNVERIFIABLE)
         return undefined;
     const decision = replay.decision;
     const baseActual = decision?.whatChanged ?? replay.error?.message ?? 'the flow failed';

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[]>;