@reticlehq/server 3.7.0 → 3.8.1

package/dist/memory/journal/drive-flow.js

@@ -1,5 +1,5 @@
-import { ActionType, PredicateKind, QueryBy, REPLAY_PROGRAM_VERSION, asFlowName, defaultIsSensitiveKey, } from '@reticlehq/core';
-import { clauseOfKind } from '@reticlehq/core';
+import { ActionType, QueryBy, REPLAY_PROGRAM_VERSION, asFlowName, defaultIsSensitiveKey, } from '@reticlehq/core';
+import { journeySentence } from '@reticlehq/core';
 /**
  * What a session drove, saved as a replayable flow — without anybody asking for it.
  *
@@ -23,45 +23,12 @@ const segment = (value, max) => value
     .slice(0, max)
     .replace(/-$/, '');
 /**
- * What this flow PROVED, in a few words, from the first step that claims anything.
- *
- * Ordered by the evidence ladder the rest of the product uses: a signal is the app saying the thing
- * happened in its own words, a request is the next best, a store read is one step removed, and the
- * DOM-shaped claims are the weakest. Naming a flow after the strongest thing it proves is the same
- * judgement the honesty grade makes, reused where a human reads it.
- *
- * Returns '' when a step claims nothing nameable.
+ * What a journey proved, in one sentence, when no step declared why it was driven. An auto-saved
+ * drive was named by its request path and a hash ("drive-get-v1-runs-issues-c69f82") and its file
+ * said nothing about what it was for.
  */
-function provedSlug(steps) {
-    for (const step of steps) {
-        const expect = step.expect;
-        if (expect === undefined)
-            continue;
-        // A predicate names its kind, so the slug reads the tree rather than probing a struct. The
-        // signal wins over the request for the same reason it always did: it is the app saying what it
-        // did, which is the strongest thing a name can carry.
-        const signal = clauseOfKind(expect, PredicateKind.SIGNAL);
-        if (signal?.name !== undefined)
-            return segment(signal.name, 32);
-        const netClause = clauseOfKind(expect, PredicateKind.NET);
-        if (netClause !== undefined) {
-            const method = segment(netClause.method ?? '', 6);
-            const where = segment(netClause.urlContains ?? '', 24);
-            const joined = [method, where].filter((part) => '' !== part).join('-');
-            if ('' !== joined)
-                return joined;
-        }
-        const state = clauseOfKind(expect, PredicateKind.STATE);
-        if (state !== undefined)
-            return segment(state.path, 32);
-        const route = clauseOfKind(expect, PredicateKind.ROUTE);
-        if (route?.pathname !== undefined)
-            return segment(route.pathname, 24);
-        const text = clauseOfKind(expect, PredicateKind.TEXT);
-        if (text?.contains !== undefined)
-            return segment(text.contains, 24);
-    }
-    return '';
+function provedSentence(steps) {
+    return journeySentence(steps.flatMap((step) => (step.expect === undefined ? [] : [step.expect])));
 }
 /** Every auto-saved flow's name starts here, which is what lets a merge tell them from hand-named ones. */
 export const DRIVE_FLOW_PREFIX = 'drive-';
@@ -81,7 +48,7 @@ export function driveFlowName(route, steps = []) {
     const intent = steps.find((step) => step.intent !== undefined)?.intent;
     const leg = segment(route ?? '', 24);
     const why = intent === undefined ? '' : segment(intent, 48);
-    const lead = '' !== why ? why : provedSlug(steps);
+    const lead = '' !== why ? why : segment(provedSentence(steps) ?? '', 48);
     // Minted here: every character has just been forced through `segment`, so this IS the validated
     // boundary the brand is meant to be created at.
     const parts = [lead, ...('' !== why || 0 === leg.length ? [] : [leg])].filter((p) => '' !== p);
@@ -186,7 +153,10 @@ export function driveFlowsFrom(tape) {
             continue;
         }
         const startPath = segment.route ?? tape.startPath;
+        const declared = segment.steps.some((step) => step.intent !== undefined);
+        const built = declared ? undefined : provedSentence(segment.steps);
         programs.push({
+            ...(built === undefined ? {} : { intent: built, intentDerived: true }),
             name: driveFlowName(startPath, segment.steps),
             version: REPLAY_PROGRAM_VERSION,
             // The route is recorder-internal and has no business on disk — `startPath` is where the

package/dist/memory/journal/envelope-store.js

@@ -7,7 +7,7 @@ import { RouteEnvelopeSchema } from './envelope.js';
 const ENVELOPE_FILE_VERSION = 1;
 const EnvelopeFileSchema = z.object({
     version: z.literal(ENVELOPE_FILE_VERSION),
-    routes: z.record(RouteEnvelopeSchema),
+    routes: z.record(z.string(), RouteEnvelopeSchema),
 });
 /**
  * Persists the learned per-route envelopes at `.reticle/envelopes.json`. Local, single-project statistics

package/dist/memory/journal/envelope.d.ts

@@ -41,175 +41,27 @@ export declare const RouteEnvelopeSchema: z.ZodObject<{
             mean: z.ZodNumber;
             m2: z.ZodNumber;
             max: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        }, {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        }>;
+        }, z.core.$strip>;
         net: z.ZodObject<{
             count: z.ZodNumber;
             mean: z.ZodNumber;
             m2: z.ZodNumber;
             max: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        }, {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        }>;
+        }, z.core.$strip>;
         netErrors: z.ZodObject<{
             count: z.ZodNumber;
             mean: z.ZodNumber;
             m2: z.ZodNumber;
             max: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        }, {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        }>;
+        }, z.core.$strip>;
         consoleErrors: z.ZodObject<{
             count: z.ZodNumber;
             mean: z.ZodNumber;
             m2: z.ZodNumber;
             max: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        }, {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        }>;
-    }, "strip", z.ZodTypeAny, {
-        net: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-        durationMs: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-        consoleErrors: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-        netErrors: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-    }, {
-        net: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-        durationMs: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-        consoleErrors: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-        netErrors: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-    }>;
-}, "strip", z.ZodTypeAny, {
-    route: string;
-    samples: number;
-    stats: {
-        net: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-        durationMs: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-        consoleErrors: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-        netErrors: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-    };
-}, {
-    route: string;
-    samples: number;
-    stats: {
-        net: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-        durationMs: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-        consoleErrors: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-        netErrors: {
-            count: number;
-            mean: number;
-            m2: number;
-            max: number;
-        };
-    };
-}>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 export declare function emptyEnvelope(route: string): RouteEnvelope;
 /** Fold one observed segment into the envelope as a new sample. */
 export declare function addSegmentToEnvelope(envelope: RouteEnvelope, segment: SegmentRollup): RouteEnvelope;

package/dist/memory/journal/episode-log.d.ts

@@ -0,0 +1,107 @@
+import { type DrivenBy, type ReticleEvent } from '@reticlehq/core';
+/** Per-record schema version, the same convention as the journal's. */
+export declare const EPISODE_FILE_VERSION = 1;
+export declare const EpisodeRecordKind: {
+    readonly START: "start";
+    readonly CALL: "call";
+};
+export type EpisodeRecordKind = (typeof EpisodeRecordKind)[keyof typeof EpisodeRecordKind];
+/** One field past this many characters keeps its head and is named in the record's `truncated`. */
+export declare const MAX_EPISODE_FIELD_CHARS = 200000;
+/** The id for calls that came over no MCP connection (the CLI, the programmatic invoker). */
+export declare const UNATTACHED_EPISODE = "unattached";
+/** The repository as the episode found it. `failed` says why git could not answer. */
+export type GitAtStart = {
+    head: string;
+    changed: {
+        file: string;
+        added: number | null;
+        removed: number | null;
+    }[];
+    moreChanged?: number;
+} | {
+    failed: string;
+};
+export interface EpisodeCallInput {
+    tool: string;
+    args: Record<string, unknown>;
+    /** Wall-clock ms, from the caller's injected clock. */
+    startedAt: number;
+    endedAt: number;
+    result?: unknown;
+    error?: string;
+    sessionId?: string;
+    agent?: string;
+    drivenBy?: DrivenBy;
+    /** The events the page emitted between the call's start and its end, already attributed. */
+    effect?: readonly ReticleEvent[];
+    /** The coding agent's own session id, as its MCP server announced it. */
+    agentSession?: string;
+}
+interface EpisodeLogDeps {
+    /** The project's `.reticle` root. */
+    root: string;
+    episodeId: string;
+    now: () => number;
+    /** Injected for the tests; the real one asks git in the project directory. */
+    git?: (projectDir: string) => Promise<GitAtStart>;
+    /** False when the journal is switched off: nothing is written. */
+    enabled?: boolean;
+}
+export interface EpisodeLog {
+    record: (call: EpisodeCallInput) => void;
+    /** Wait for every queued line to reach the disk. */
+    flush: () => Promise<void>;
+}
+export declare function episodePath(root: string, episodeId: string): string;
+/** HEAD and the uncommitted change against it, per file. Never throws. */
+export declare function gitAtStart(projectDir: string): Promise<GitAtStart>;
+export declare function createEpisodeLog(deps: EpisodeLogDeps): EpisodeLog;
+export declare function setEpisodeLogEnabled(enabled: boolean): void;
+/** Wait until every queued line of every open episode is on the disk. */
+export declare function flushEpisodeLogs(): Promise<void>;
+/** Append one call to its episode. The entry point the tool dispatcher uses. */
+export declare function recordEpisodeCall(root: string, attachId: string | undefined, now: () => number, call: EpisodeCallInput): void;
+/**
+ * May an episode leave this machine? Only when the project opted in (`"sync": { "episodes": true }`
+ * in `cloud.json`) AND the platform says the workspace consented to share its data. Unknown consent
+ * is no consent. No sync path calls this yet: there is no platform endpoint to receive an episode.
+ */
+export declare function episodesMaySync(cloud: {
+    config: unknown;
+    policy: {
+        episodes?: boolean;
+    };
+}, workspaceConsent: boolean | undefined): boolean;
+/** The record kinds the agent hooks write beside the daemon's (`reticle hook tool`). */
+export declare const AgentRecordKind: {
+    readonly TOOL: "agent_tool";
+    readonly MODEL: "agent_model";
+    readonly STOP: "agent_stop";
+};
+/** An agent hook's file: `agent-<session>.jsonl`, beside the daemon's episodes. */
+export declare const AGENT_FILE_PREFIX = "agent-";
+/**
+ * The agent's model and the claim that closed the run's turn, from the agent hooks' records in
+ * this project's episodes. The turn is the run's: its claim is the first `agent_stop` at or after
+ * the run's last Reticle call (from its episode, else its `createdAt`); a later stop belongs to a
+ * later turn. The model is the newest `agent_model` record, or the `model` a tool or stop record
+ * carried, at or before that point.
+ *
+ * Whose records: the run's own agent session (`agentSession`, announced by its MCP server) when it
+ * names one. Otherwise the same agent's, by name, and only when they all come from one session:
+ * two sessions of one agent in a project and no session on the run is unknown, never a guess.
+ */
+export declare function agentContextFor(root: string, run: {
+    episodeId?: unknown;
+    createdAt?: unknown;
+    agent?: unknown;
+    agentSession?: unknown;
+}): {
+    model?: string;
+    claim?: {
+        text: string;
+        at: number;
+    };
+};
+export {};

package/dist/memory/journal/episode-log.js

@@ -0,0 +1,302 @@
+/**
+ * The episode log: every tool call an agent made, in full, and what each one did to the app.
+ *
+ * `.reticle/episodes/<episodeId>.jsonl`, one file per agent connection and project. The first line
+ * says where the work started (the git HEAD, the uncommitted change, the user's request); every
+ * line after it is one call: the tool, its arguments, its whole result or error, when it started
+ * and ended, the tab it drove, the agent that made it, and the events the page emitted while it ran.
+ *
+ * The journal (`sessions/<id>/`) keeps the page's events and the actions that drove it, but not the
+ * reads, not the results, and not the calls made before a tab connected. Together they are the
+ * trajectory: what the agent was asked, what it did, what it was told, and what the app did.
+ *
+ * LOCAL ONLY. No file in `episodes/` is sent. The sync reads two values from the agent hooks' files
+ * (`agentContextFor`): the agent's model, and its closing message, which a run carries only when the
+ * project shares requests. An upload of the files would go through `episodesMaySync`, which needs
+ * both an explicit project opt-in and a workspace that consented to share its data. It obeys the journal switch (`RETICLE_JOURNAL`, `"journal": false`).
+ */
+import { execFile } from 'node:child_process';
+import { appendFile, mkdir } from 'node:fs/promises';
+import { readFileSync, readdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { promisify } from 'node:util';
+import { ReticleDir } from '@reticlehq/core';
+import { PromptContextSchema } from '@reticlehq/core/artifacts';
+import { withoutTypedInput } from './journal-recorder.js';
+import { noteEpisode } from '../../hooks/episode-stamp.js';
+const run = promisify(execFile);
+/** Per-record schema version, the same convention as the journal's. */
+export const EPISODE_FILE_VERSION = 1;
+export const EpisodeRecordKind = { START: 'start', CALL: 'call' };
+/** One field past this many characters keeps its head and is named in the record's `truncated`. */
+export const MAX_EPISODE_FIELD_CHARS = 200_000;
+/** A page can emit thousands of events in one call; past this many the record keeps the first ones. */
+const MAX_EFFECT_EVENTS = 500;
+/** A checkout with a huge uncommitted change keeps the first files and says how many more. */
+const MAX_CHANGED_FILES = 500;
+const GIT_TIMEOUT_MS = 5_000;
+/** The id for calls that came over no MCP connection (the CLI, the programmatic invoker). */
+export const UNATTACHED_EPISODE = 'unattached';
+export function episodePath(root, episodeId) {
+    return join(root, ReticleDir.EPISODES_SUBDIR, `${episodeId}.jsonl`);
+}
+/** The value as kept: whole, or its first characters when its JSON is too long. */
+function capped(value) {
+    const text = JSON.stringify(value ?? null);
+    return text.length > MAX_EPISODE_FIELD_CHARS
+        ? { value: { head: text.slice(0, MAX_EPISODE_FIELD_CHARS) }, cut: true }
+        : { value, cut: false };
+}
+function effectOf(events) {
+    const counts = {};
+    for (const e of events) {
+        counts[e.type] = (counts[e.type] ?? 0) + 1;
+    }
+    const seqs = events.map((e) => e.seq).filter((s) => s !== undefined);
+    return {
+        counts,
+        ...(0 === seqs.length ? {} : { seqRange: { from: Math.min(...seqs), to: Math.max(...seqs) } }),
+        events: events.slice(0, MAX_EFFECT_EVENTS),
+        ...(events.length > MAX_EFFECT_EVENTS ? { moreEvents: events.length - MAX_EFFECT_EVENTS } : {}),
+    };
+}
+/** HEAD and the uncommitted change against it, per file. Never throws. */
+export async function gitAtStart(projectDir) {
+    try {
+        const opts = { cwd: projectDir, timeout: GIT_TIMEOUT_MS };
+        const head = (await run('git', ['rev-parse', 'HEAD'], opts)).stdout.trim();
+        const numstat = (await run('git', ['diff', '--numstat', 'HEAD'], opts)).stdout;
+        const all = numstat
+            .split('\n')
+            .filter((line) => line.trim().length > 0)
+            .map((line) => {
+            const [added = '', removed = '', ...file] = line.split('\t');
+            const count = (n) => (/^\d+$/.test(n) ? Number(n) : null);
+            return { file: file.join('\t'), added: count(added), removed: count(removed) };
+        });
+        return {
+            head,
+            changed: all.slice(0, MAX_CHANGED_FILES),
+            ...(all.length > MAX_CHANGED_FILES ? { moreChanged: all.length - MAX_CHANGED_FILES } : {}),
+        };
+    }
+    catch (error) {
+        return {
+            failed: error instanceof Error ? (error.message.split('\n')[0] ?? '') : String(error),
+        };
+    }
+}
+function requestIn(root) {
+    try {
+        const parsed = PromptContextSchema.safeParse(JSON.parse(readFileSync(join(root, ReticleDir.REQUEST_FILE), 'utf8')));
+        return parsed.success ? parsed.data : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function createEpisodeLog(deps) {
+    const path = episodePath(deps.root, deps.episodeId);
+    const git = deps.git ?? gitAtStart;
+    let chain = Promise.resolve();
+    let n = 0;
+    const append = (line) => {
+        // A log that cannot be written never fails the call it describes.
+        chain = chain
+            .then(async () => appendFile(path, `${JSON.stringify(await line())}\n`))
+            .catch(() => undefined);
+    };
+    return {
+        record: (call) => {
+            if (false === deps.enabled) {
+                return;
+            }
+            noteEpisode(deps.root, deps.episodeId, {
+                ...(call.sessionId === undefined ? {} : { sessionId: call.sessionId }),
+                ...(call.agentSession === undefined ? {} : { agentSession: call.agentSession }),
+            });
+            n += 1;
+            if (1 === n) {
+                // The start is taken at the first call: that is when the agent began working through us.
+                const at = deps.now();
+                const request = requestIn(deps.root);
+                append(async () => {
+                    await mkdir(dirname(path), { recursive: true });
+                    return {
+                        v: EPISODE_FILE_VERSION,
+                        kind: EpisodeRecordKind.START,
+                        episodeId: deps.episodeId,
+                        at,
+                        ...(call.agent === undefined ? {} : { agent: call.agent }),
+                        ...(call.agentSession === undefined ? {} : { agentSession: call.agentSession }),
+                        git: await git(dirname(deps.root)).then((found) => {
+                            if ('head' in found) {
+                                noteEpisode(deps.root, deps.episodeId, { head: found.head });
+                            }
+                            return found;
+                        }),
+                        ...(request === undefined ? {} : { request }),
+                    };
+                });
+            }
+            const args = capped(withoutTypedInput(call.args));
+            const outcome = call.error === undefined ? capped(call.result) : undefined;
+            const truncated = [
+                ...(args.cut ? ['args'] : []),
+                ...(true === outcome?.cut ? ['result'] : []),
+            ];
+            const record = {
+                v: EPISODE_FILE_VERSION,
+                kind: EpisodeRecordKind.CALL,
+                n,
+                tool: call.tool,
+                args: args.value,
+                ...(outcome === undefined ? { error: call.error } : { result: outcome.value }),
+                startedAt: call.startedAt,
+                endedAt: call.endedAt,
+                ...(call.sessionId === undefined ? {} : { sessionId: call.sessionId }),
+                ...(call.agent === undefined ? {} : { agent: call.agent }),
+                ...(call.drivenBy === undefined ? {} : { drivenBy: call.drivenBy }),
+                ...(call.effect === undefined || 0 === call.effect.length
+                    ? {}
+                    : { effect: effectOf(call.effect) }),
+                ...(0 === truncated.length ? {} : { truncated }),
+            };
+            append(() => Promise.resolve(record));
+        },
+        flush: () => chain,
+    };
+}
+/** One log per project root and connection, for the daemon's lifetime. */
+const open = new Map();
+/**
+ * Set at start from the journal switch, by `attachJournal`, which both daemon paths call. Off until
+ * then, so a process that never started a daemon (a test, a library caller) writes nothing.
+ */
+let enabledInDaemon = false;
+export function setEpisodeLogEnabled(enabled) {
+    enabledInDaemon = enabled;
+}
+/** Wait until every queued line of every open episode is on the disk. */
+export async function flushEpisodeLogs() {
+    await Promise.all([...open.values()].map((log) => log.flush()));
+}
+/** Append one call to its episode. The entry point the tool dispatcher uses. */
+export function recordEpisodeCall(root, attachId, now, call) {
+    if (!enabledInDaemon) {
+        return;
+    }
+    const episodeId = attachId ?? UNATTACHED_EPISODE;
+    const key = `${root}\n${episodeId}`;
+    let log = open.get(key);
+    if (log === undefined) {
+        log = createEpisodeLog({
+            root,
+            episodeId,
+            now,
+            enabled: enabledInDaemon,
+        });
+        open.set(key, log);
+    }
+    log.record(call);
+}
+/**
+ * May an episode leave this machine? Only when the project opted in (`"sync": { "episodes": true }`
+ * in `cloud.json`) AND the platform says the workspace consented to share its data. Unknown consent
+ * is no consent. No sync path calls this yet: there is no platform endpoint to receive an episode.
+ */
+export function episodesMaySync(cloud, workspaceConsent) {
+    return null !== cloud.config && true === cloud.policy.episodes && true === workspaceConsent;
+}
+/** The record kinds the agent hooks write beside the daemon's (`reticle hook tool`). */
+export const AgentRecordKind = {
+    TOOL: 'agent_tool',
+    MODEL: 'agent_model',
+    STOP: 'agent_stop',
+};
+/** An agent hook's file: `agent-<session>.jsonl`, beside the daemon's episodes. */
+export const AGENT_FILE_PREFIX = 'agent-';
+const isJson = (value) => 'object' === typeof value && null !== value && !Array.isArray(value);
+function readLines(path) {
+    try {
+        return readFileSync(path, 'utf8')
+            .split('\n')
+            .flatMap((line) => {
+            try {
+                const parsed = JSON.parse(line);
+                return isJson(parsed) ? [parsed] : [];
+            }
+            catch {
+                return [];
+            }
+        });
+    }
+    catch {
+        return [];
+    }
+}
+/** The same agent: a hook names it `cursor`, an MCP handshake `cursor-vscode`. */
+const sameAgent = (hook, run) => {
+    if ('string' !== typeof hook || 0 === hook.length) {
+        return false;
+    }
+    const a = hook.toLowerCase();
+    const b = run.toLowerCase();
+    return a.includes(b) || b.includes(a);
+};
+/** The hook file of one agent session: the id as the hook wrote it into the file name. */
+const agentFileOf = (session) => `${AGENT_FILE_PREFIX}${session.replace(/[^\w-]/g, '_')}.jsonl`;
+/**
+ * The agent's model and the claim that closed the run's turn, from the agent hooks' records in
+ * this project's episodes. The turn is the run's: its claim is the first `agent_stop` at or after
+ * the run's last Reticle call (from its episode, else its `createdAt`); a later stop belongs to a
+ * later turn. The model is the newest `agent_model` record, or the `model` a tool or stop record
+ * carried, at or before that point.
+ *
+ * Whose records: the run's own agent session (`agentSession`, announced by its MCP server) when it
+ * names one. Otherwise the same agent's, by name, and only when they all come from one session:
+ * two sessions of one agent in a project and no session on the run is unknown, never a guess.
+ */
+export function agentContextFor(root, run) {
+    const agentId = isJson(run.agent) ? run.agent['id'] : undefined;
+    if ('string' !== typeof agentId) {
+        return {};
+    }
+    const dir = join(root, ReticleDir.EPISODES_SUBDIR);
+    let files;
+    try {
+        files = readdirSync(dir);
+    }
+    catch {
+        return {};
+    }
+    const calls = 'string' === typeof run.episodeId ? readLines(join(dir, `${run.episodeId}.jsonl`)) : [];
+    const ends = calls.map((c) => c['endedAt']).filter((t) => 'number' === typeof t);
+    const createdAt = 'number' === typeof run.createdAt ? run.createdAt : 0;
+    const lastCall = 0 < ends.length ? Math.max(...ends) : createdAt;
+    const own = 'string' === typeof run.agentSession ? agentFileOf(run.agentSession) : undefined;
+    const bySession = files
+        .filter((file) => (own === undefined ? file.startsWith(AGENT_FILE_PREFIX) : own === file))
+        .map((file) => readLines(join(dir, file)).filter((r) => own !== undefined || sameAgent(r['agent'], agentId)))
+        .filter((lines) => 0 < lines.length);
+    if (1 < bySession.length) {
+        return {};
+    }
+    const records = bySession
+        .flat()
+        .map((r) => ({ r, at: 'number' === typeof r['at'] ? r['at'] : Number(r['endedAt'] ?? 0) }))
+        .sort((a, b) => a.at - b.at);
+    const stop = records.find(({ r, at }) => AgentRecordKind.STOP === r['kind'] && at >= lastCall);
+    const until = stop?.at ?? lastCall;
+    const model = records
+        .filter(({ r, at }) => at <= until && 'string' === typeof r['model'])
+        .map(({ r }) => r['model'])
+        .at(-1);
+    const message = isJson(stop?.r['message']) ? stop?.r['message']['head'] : undefined;
+    return {
+        ...(model === undefined ? {} : { model }),
+        ...(stop === undefined || 'string' !== typeof message
+            ? {}
+            : { claim: { text: message, at: stop.at } }),
+    };
+}