@reticlehq/server 3.5.0 → 3.7.0

package/dist/memory/intent/open-intents.d.ts

@@ -10,6 +10,12 @@ import type { ToolDeps } from '../../surface/tools/tool-kit.js';
  * is a false accusation rather than an error.
  */
 export declare function openSessionIntents(deps: ToolDeps, sessionId: string | undefined): Promise<Intent[]>;
+/**
+ * A reader of the same ledger, its root resolved NOW. For a verdict drawn after its tab may have
+ * left: a checkout click that takes the page to another origin closes the session, and resolving the
+ * root then refused the whole call with "names no session" instead of grading what was seen.
+ */
+export declare function ledgerFor(deps: ToolDeps, sessionId: string | undefined): () => Promise<Intent[]>;
 /**
  * EVERY intent in the ledger, proved ones included — the denominator the open list is a subset of.
  *

package/dist/memory/intent/open-intents.js

@@ -10,7 +10,16 @@ import { sessionRoot } from '../project/session-root.js';
  * is a false accusation rather than an error.
  */
 export async function openSessionIntents(deps, sessionId) {
-    return new IntentStore(deps.fs, sessionRoot(deps, sessionId), { now: deps.now }).open();
+    return ledgerFor(deps, sessionId)();
+}
+/**
+ * A reader of the same ledger, its root resolved NOW. For a verdict drawn after its tab may have
+ * left: a checkout click that takes the page to another origin closes the session, and resolving the
+ * root then refused the whole call with "names no session" instead of grading what was seen.
+ */
+export function ledgerFor(deps, sessionId) {
+    const root = sessionRoot(deps, sessionId);
+    return () => new IntentStore(deps.fs, root, { now: deps.now }).open();
 }
 /**
  * EVERY intent in the ledger, proved ones included — the denominator the open list is a subset of.

package/dist/memory/intent/settled-words.d.ts

@@ -0,0 +1,24 @@
+import type { IntentShardStore } from './intent-shard-store.js';
+import { IntentStatus } from './intent-shard.js';
+/**
+ * One settled disagreement: the words kept, the words set aside, and who chose — or, with no words
+ * set aside, the status the team settled on the kept words.
+ */
+export interface SettledWords {
+    kept: string;
+    setAside?: string;
+    by?: string;
+    status?: IntentStatus;
+    /** The file the platform holds for the kept words; a record re-sent without it erased it there. */
+    file?: string;
+}
+/** The settled disagreements in the platform's memory entries, read defensively. */
+export declare function settledWordsIn(entries: readonly unknown[]): SettledWords[];
+/** Apply them to the local records; returns how many records changed. */
+export declare function applySettledWords(store: IntentShardStore, settled: readonly SettledWords[]): Promise<number>;
+/**
+ * The agent's recorded request, with each statement a decision set aside replaced by the words kept:
+ * a run reports it as "What was asked", and the run that proved the kept words showed the rejected
+ * ones as its goal. Never throws; no request, nothing to change.
+ */
+export declare function keptWordsInRequest(path: string, settled: readonly SettledWords[]): Promise<void>;

package/dist/memory/intent/settled-words.js

@@ -0,0 +1,130 @@
+/**
+ * Decisions made on the dashboard, brought down to the record of the person whose words were set
+ * aside.
+ *
+ * A maintainer settled a disagreement by keeping the team's words; the author's own record still
+ * said hers, agreed, and her daemon re-sent it every minute, so the same decision was made three
+ * times. The platform returns each memory entry with the decisions taken on it; a local record
+ * whose statement one of them set aside takes the words that were kept, and says who decided.
+ */
+import { readFile, writeFile } from 'node:fs/promises';
+import { asRecord, asString } from '@reticlehq/core';
+import { IntentStatus } from './intent-shard.js';
+/** How settled each status is; a record is only ever raised along it, never lowered. */
+const RANK = {
+    [IntentStatus.PROPOSED]: 0,
+    [IntentStatus.AGREED]: 1,
+    [IntentStatus.PROVED]: 2,
+    [IntentStatus.STALE]: 1,
+};
+/** A status the platform settled, read defensively; proposed settles nothing. */
+const settledStatus = (value) => [IntentStatus.AGREED, IntentStatus.PROVED, IntentStatus.STALE].find((s) => s === value);
+const str = (value) => {
+    const text = asString(value);
+    return text === undefined || 0 === text.length ? undefined : text;
+};
+/** The settled disagreements in the platform's memory entries, read defensively. */
+export function settledWordsIn(entries) {
+    return entries.flatMap((raw) => {
+        const entry = asRecord(raw);
+        const kept = str(entry['statement']);
+        const decisions = entry['decisions'];
+        const status = settledStatus(entry['status']);
+        const file = str(entry['sourceFile']);
+        if (kept === undefined)
+            return [];
+        const settled = status === undefined ? [] : [{ kept, status }];
+        if (!Array.isArray(decisions))
+            return settled;
+        return decisions
+            .flatMap((d) => {
+            const setAside = str(asRecord(asRecord(d)['setAside'])['statement']);
+            const by = str(asRecord(d)['byEmail']);
+            return setAside === undefined || setAside === kept
+                ? []
+                : [
+                    {
+                        kept,
+                        setAside,
+                        ...(by === undefined ? {} : { by }),
+                        ...(file === undefined ? {} : { file }),
+                    },
+                ];
+        })
+            .concat(settled);
+    });
+}
+/** Where the record's words now come from. */
+const decidedBy = (by) => `decided on the dashboard${by === undefined ? '' : ` by ${by}`}`;
+/** Apply them to the local records; returns how many records changed. */
+export async function applySettledWords(store, settled) {
+    if (0 === settled.length)
+        return 0;
+    let changed = 0;
+    for (const record of await store.all()) {
+        // The team settled these very words: the record takes that status, so this machine never
+        // re-sends them as proposed and undoes the decision. Raised only, never lowered.
+        const status = settled.find((s) => s.status !== undefined && s.kept === record.statement)?.status;
+        if (status !== undefined && RANK[status] > RANK[record.status]) {
+            const raised = await store.upsert(record.id, (existing) => existing, {
+                status,
+                source: decidedBy(undefined),
+            });
+            if (raised?.status === status)
+                changed += 1;
+            continue;
+        }
+        const decision = settled.find((s) => s.setAside === record.statement);
+        if (decision === undefined)
+            continue;
+        const next = await store.upsert(record.id, (existing) => 
+        // The check bound to the words set aside proves nothing about the words kept.
+        existing === undefined
+            ? undefined
+            : {
+                ...withoutBinding(existing),
+                statement: decision.kept,
+                // The files were the set-aside words'; the kept words carry the platform's.
+                surface: {
+                    ...existing.surface,
+                    files: decision.file === undefined ? [] : [decision.file],
+                },
+            }, { source: decidedBy(decision.by) });
+        if (next?.statement === decision.kept)
+            changed += 1;
+    }
+    return changed;
+}
+/** A record with its bound check taken off: the words it was bound to were set aside. */
+function withoutBinding(record) {
+    const { binding: _dropped, ...rest } = record;
+    return rest;
+}
+/**
+ * The agent's recorded request, with each statement a decision set aside replaced by the words kept:
+ * a run reports it as "What was asked", and the run that proved the kept words showed the rejected
+ * ones as its goal. Never throws; no request, nothing to change.
+ */
+export async function keptWordsInRequest(path, settled) {
+    const decided = settled.filter((s) => s.setAside !== undefined);
+    if (0 === decided.length)
+        return;
+    try {
+        const raw = JSON.parse(await readFile(path, 'utf8'));
+        const statements = Array.isArray(raw['statements']) ? raw['statements'] : [];
+        let changed = false;
+        const next = statements.map((s) => {
+            const statement = asRecord(s);
+            const kept = decided.find((d) => d.setAside === statement['text'])?.kept;
+            if (kept === undefined)
+                return s;
+            changed = true;
+            return { ...statement, text: kept };
+        });
+        if (changed)
+            await writeFile(path, `${JSON.stringify({ ...raw, statements: next }, null, 2)}\n`);
+    }
+    catch {
+        // No request recorded, or one this cannot read: nothing to correct.
+    }
+}

package/dist/memory/journal/drive-flow.d.ts

@@ -19,6 +19,8 @@ export interface TapeStep {
     endPage?: string;
     /** The intent the agent declared on this action. The first one names the journey. */
     intent?: string;
+    /** Recorder-internal: network mocks were active when it ran (#1459). Never written to disk. */
+    mocked?: true;
 }
 /** The compiled shape a flow store accepts. Structural, for the same reason as `TapeStep`. */
 export interface DriveProgram {
@@ -56,6 +58,13 @@ export declare const DRIVE_FLOW_PREFIX = "drive-";
  * see FlowStore.saveJourney.
  */
 export declare function driveFlowName(route?: string, steps?: readonly TapeStep[]): FlowName;
+/** Why session end saved no flow, as reported on the `flow_recorded` step. */
+export declare const DriveFlowSkipReason: {
+    /** The drive declared no consequence, so a saved flow could never go red. */
+    readonly NO_DECLARED_CONSEQUENCE: "no_declared_consequence";
+    /** What it proved rested on network mocks the flow would not carry (#1459). */
+    readonly DRIVEN_UNDER_NETWORK_MOCKS: "driven_under_network_mocks";
+};
 export interface DriveFlowOutcome {
     /** The flows that were written — one per journey the session contained. */
     readonly saved?: readonly string[];
@@ -68,6 +77,13 @@ export interface DriveFlowOutcome {
      * "the agent drove and proved nothing" stays visible instead of looking like nothing happened.
      */
     readonly unprovenSteps?: number;
+    /**
+     * Steps of journeys that proved something and were NOT saved because they ran while network
+     * mocks were active (#1459). Such a journey replays against the real backend, so it either fails
+     * for a reason unrelated to the change or passes on data the original check never saw, and the
+     * flow file holds no trace of the precondition. Counted, so "not saved" has a reason.
+     */
+    readonly mockedSteps?: number;
 }
 /** A flow per journey, so two journeys in one session are two regression tests rather than one. */
 export declare function driveFlowsFrom(tape: {

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

@@ -87,6 +87,13 @@ export function driveFlowName(route, steps = []) {
     const parts = [lead, ...('' !== why || 0 === leg.length ? [] : [leg])].filter((p) => '' !== p);
     return asFlowName(`${DRIVE_FLOW_PREFIX}${0 === parts.length ? 'journey' : parts.join('-')}`);
 }
+/** Why session end saved no flow, as reported on the `flow_recorded` step. */
+export const DriveFlowSkipReason = {
+    /** The drive declared no consequence, so a saved flow could never go red. */
+    NO_DECLARED_CONSEQUENCE: 'no_declared_consequence',
+    /** What it proved rested on network mocks the flow would not carry (#1459). */
+    DRIVEN_UNDER_NETWORK_MOCKS: 'driven_under_network_mocks',
+};
 /**
  * Turn this session's ambient tape into a flow, when it is worth one.
  *
@@ -143,24 +150,48 @@ function typesASecret(step) {
     const field = QueryBy.TESTID === by ? step.args['value'] : step.args['name'];
     return 'string' === typeof field && defaultIsSensitiveKey(field);
 }
+/**
+ * The tape without the attempts an agent made again. An action that declared nothing, followed at
+ * once by the same action on the same control that did, is a retry: saved, the flow clicked sign-in
+ * twice, the second click found no form, and every replay of it failed. A step repeated with the
+ * same declaration both times (a double submit on purpose) is two steps, and stays two.
+ */
+function withoutRetries(steps) {
+    return steps.filter((step, i) => {
+        const next = steps[i + 1];
+        if (next === undefined || step.expect !== undefined || next.expect === undefined)
+            return true;
+        // Tried again where it was tried: a page later it is a step of the journey, not a retry.
+        if (step.route !== next.route || step.page !== next.page || step.mocked !== next.mocked)
+            return true;
+        const { expect: _declared, ...again } = next.args;
+        const { expect: _none, ...first } = step.args;
+        return step.tool !== next.tool || JSON.stringify(first) !== JSON.stringify(again);
+    });
+}
 /** A flow per journey, so two journeys in one session are two regression tests rather than one. */
 export function driveFlowsFrom(tape) {
     if (tape === undefined || 0 === tape.steps.length)
         return { programs: [], outcome: {} };
     const programs = [];
     let unproven = 0;
-    for (const segment of segmentsByRoute(tape.steps)) {
+    let mocked = 0;
+    for (const segment of segmentsByRoute(withoutRetries(tape.steps))) {
         if (!carriesAnAssertion(segment.steps)) {
             unproven += segment.steps.length;
             continue;
         }
+        if (segment.steps.some((step) => true === step.mocked)) {
+            mocked += segment.steps.length;
+            continue;
+        }
         const startPath = segment.route ?? tape.startPath;
         programs.push({
             name: driveFlowName(startPath, segment.steps),
             version: REPLAY_PROGRAM_VERSION,
             // The route is recorder-internal and has no business on disk — `startPath` is where the
             // on-disk flow says the same thing, in the field replay actually reads.
-            steps: segment.steps.map(({ route: _route, ...step }) => step),
+            steps: segment.steps.map(({ route: _route, mocked: _mocked, ...step }) => step),
             ...(startPath === undefined ? {} : { startPath }),
         });
     }
@@ -169,6 +200,7 @@ export function driveFlowsFrom(tape) {
         outcome: {
             ...(0 === programs.length ? {} : { saved: programs.map((p) => p.name) }),
             ...(0 === unproven ? {} : { unprovenSteps: unproven }),
+            ...(0 === mocked ? {} : { mockedSteps: mocked }),
         },
     };
 }

package/dist/memory/journal/drive-run-flush.d.ts

@@ -26,6 +26,8 @@ export interface FlushableSession {
 export interface DriveRunFlushDeps<S extends FlushableSession> {
     /** Find the live session a verdict came from, or undefined when it has already gone. */
     resolve: (sessionId: string) => S | undefined;
+    /** Every live session: a Harness note rewrites them all, since it does not say which tab drove. */
+    all?: () => readonly S[];
     /** Write this session's run artifact. The same call teardown makes. */
     write: (session: S) => Promise<void>;
     /** Injected so the test does not wait three real seconds. */

package/dist/memory/journal/drive-run-flush.js

@@ -20,8 +20,9 @@
  * the last verdicts of a session are the ones somebody is waiting on.
  */
 import { HookEvent } from '@reticlehq/core/hooks';
-import { onHook } from '../../hooks/hook-bus.js';
+import { onHook, onPendingWrites } from '../../hooks/hook-bus.js';
 import { log } from '../../log.js';
+import { onHarnessNoted } from '../../judgement/runs/drive-run.js';
 /** Long enough to collapse a burst of verdicts, short enough that a human reads it as "live". */
 const FLUSH_DEBOUNCE_MS = 3_000;
 /**
@@ -55,10 +56,7 @@ export function attachDriveRunFlush(deps) {
             log(`drive run flush failed: ${message}`);
         }
     };
-    const off = onHook(HookEvent.VERDICT, (payload) => {
-        const sessionId = 'sessionId' in payload ? payload.sessionId : undefined;
-        if (sessionId === undefined)
-            return;
+    const schedule = (sessionId) => {
         const existing = pending.get(sessionId);
         if (existing !== undefined)
             clearTimeout(existing);
@@ -69,11 +67,28 @@ export function attachDriveRunFlush(deps) {
         // obligation, and holding the process open for it would make `reticle` feel broken on exit.
         timer.unref?.();
         pending.set(sessionId, timer);
+    };
+    const off = onHook(HookEvent.VERDICT, (payload) => {
+        const sessionId = 'sessionId' in payload ? payload.sessionId : undefined;
+        if (sessionId !== undefined)
+            schedule(sessionId);
     });
+    // A Harness drive is graded after its last verdict: rewrite the runs so the grade reaches them.
+    // ponytail: every live session, since a note names a drive, not a tab; drives end rarely.
+    const offNoted = onHarnessNoted(() => {
+        for (const session of deps.all?.() ?? [])
+            schedule(session.id);
+    });
+    const flushAll = async () => {
+        await Promise.all([...pending.keys()].map(flush));
+    };
+    const unregister = onPendingWrites(flushAll);
     return {
         flushNow: flush,
         stop: () => {
             off();
+            unregister();
+            offNoted();
             for (const timer of pending.values())
                 clearTimeout(timer);
             pending.clear();

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

@@ -113,13 +113,13 @@ export declare const RouteEnvelopeSchema: z.ZodObject<{
             m2: number;
             max: number;
         };
-        netErrors: {
+        consoleErrors: {
             count: number;
             mean: number;
             m2: number;
             max: number;
         };
-        consoleErrors: {
+        netErrors: {
             count: number;
             mean: number;
             m2: number;
@@ -138,13 +138,13 @@ export declare const RouteEnvelopeSchema: z.ZodObject<{
             m2: number;
             max: number;
         };
-        netErrors: {
+        consoleErrors: {
             count: number;
             mean: number;
             m2: number;
             max: number;
         };
-        consoleErrors: {
+        netErrors: {
             count: number;
             mean: number;
             m2: number;
@@ -167,13 +167,13 @@ export declare const RouteEnvelopeSchema: z.ZodObject<{
             m2: number;
             max: number;
         };
-        netErrors: {
+        consoleErrors: {
             count: number;
             mean: number;
             m2: number;
             max: number;
         };
-        consoleErrors: {
+        netErrors: {
             count: number;
             mean: number;
             m2: number;
@@ -196,13 +196,13 @@ export declare const RouteEnvelopeSchema: z.ZodObject<{
             m2: number;
             max: number;
         };
-        netErrors: {
+        consoleErrors: {
             count: number;
             mean: number;
             m2: number;
             max: number;
         };
-        consoleErrors: {
+        netErrors: {
             count: number;
             mean: number;
             m2: number;

package/dist/memory/journal/journal-recorder.js

@@ -1,5 +1,7 @@
-import { EventAttribution, JOURNAL_FILE_VERSION, } from '@reticlehq/core';
+import { ActionType, EventAttribution, REDACTED_VALUE, JOURNAL_FILE_VERSION, } from '@reticlehq/core';
 import { isSelfObservation } from './self-observation.js';
+import { currentDrivenBy } from '../../hooks/driven-by.js';
+import { callerClientName } from '../../hooks/coding-agents.js';
 import { log } from '../../log.js';
 /**
  * Logged the FIRST time a journal write is lost, and never again for that recorder.
@@ -12,6 +14,36 @@ import { log } from '../../log.js';
  * produce one line per batch.
  */
 const JOURNAL_WRITE_LOST = 'journal_write_lost';
+/** The actions whose arguments carry what was typed. */
+const TYPING_ACTIONS = new Set([ActionType.FILL, ActionType.TYPE]);
+const TYPED_KEYS = ['value', 'text'];
+/**
+ * The arguments as the journal keeps them: every typed value replaced, at any depth (a sequence's
+ * steps too). A fill's arguments kept a typed password in clear in `actions.jsonl`; the page cannot
+ * tell the daemon which field was secret before the call is written, and nothing reads a typed value
+ * back from the journal — the run fold reads the ref, the target and the action — so none is kept.
+ */
+function withoutTypedInput(args) {
+    if (Array.isArray(args))
+        return args.map(withoutTypedInput);
+    if ('object' !== typeof args || null === args)
+        return args;
+    const record = args;
+    const typing = TYPING_ACTIONS.has(String(record['action']));
+    const out = {};
+    for (const [key, value] of Object.entries(record)) {
+        const typed = typing && TYPED_KEYS.includes(key) && 'string' === typeof value;
+        out[key] = typed ? REDACTED_VALUE : withoutTypedInput(value);
+    }
+    if (typing && 'object' === typeof record['args'] && null !== record['args']) {
+        const inner = { ...record['args'] };
+        for (const key of TYPED_KEYS)
+            if ('string' === typeof inner[key])
+                inner[key] = REDACTED_VALUE;
+        out['args'] = inner;
+    }
+    return out;
+}
 const DEFAULT_FLUSH_AT = 64;
 /**
  * Owns action-window attribution and batched, order-preserving journaling — the durable half of the
@@ -65,7 +97,14 @@ export class JournalRecorder {
     }
     /** Open an attribution window. One action is active at a time (the agent drives sequentially). */
     beginAction(actionId, tool, args) {
-        this.#active = { actionId, tool, args, tStart: this.#now() };
+        this.#active = {
+            actionId,
+            tool,
+            args: withoutTypedInput(args),
+            tStart: this.#now(),
+            drivenBy: currentDrivenBy(),
+            agent: callerClientName(),
+        };
     }
     /** Close the active window: persist its buffered events, then the action record. No-op if none active. */
     finishAction(effect, settled, settledInMs) {
@@ -86,6 +125,8 @@ export class JournalRecorder {
                 : { from: active.seqFrom, to: active.seqTo },
             tRange: { from: active.tStart, to: this.#now() },
             at: active.tStart,
+            ...(active.drivenBy === undefined ? {} : { drivenBy: active.drivenBy }),
+            ...(active.agent === undefined ? {} : { agent: active.agent }),
         };
         this.#enqueueFlush();
         this.#chain = this.#chain
@@ -115,7 +156,7 @@ export class JournalRecorder {
             v: JOURNAL_FILE_VERSION,
             actionId,
             tool,
-            args,
+            args: withoutTypedInput(args),
             effect,
             // No window was opened, so no event carries this id: `seqRange` is omitted rather than
             // invented, because any range here would claim an attribution that never happened. `tRange` is
@@ -123,6 +164,14 @@ export class JournalRecorder {
             // of zero, which is exactly how much time this action attributed events over.
             tRange: { from: at, to: at },
             at,
+            ...(() => {
+                const by = currentDrivenBy();
+                return by === undefined ? {} : { drivenBy: by };
+            })(),
+            ...(() => {
+                const agent = callerClientName();
+                return agent === undefined ? {} : { agent };
+            })(),
         };
         this.#enqueueFlush();
         this.#chain = this.#chain

package/dist/memory/journal/on-disk/retention.d.ts

@@ -11,6 +11,13 @@ export declare const DEFAULT_DIFF_RETENTION = 10;
  * for the one case where delivery was refused and somebody has to file the report by hand.
  */
 export declare const DEFAULT_FEEDBACK_RETENTION = 20;
+/** Harness plans kept on disk: the platform keeps every one, this machine the recent ones. */
+export declare const DEFAULT_PLAN_RETENTION = 50;
+/**
+ * Keep the step screenshots of at most this many runs. A run's are looked at while it is fresh, or
+ * on the platform it was synced to; the byte budget below is what bounds a single long one.
+ */
+export declare const DEFAULT_STEP_SHOT_RUN_RETENTION = 50;
 /**
  * The TOTAL the evidence tier of one `.reticle/` may occupy, across sessions, runs, overlay diffs
  * and feedback copies together.
@@ -141,5 +148,6 @@ export declare function pruneEvidenceBudget(fs: FileSystemPort, root: string, bu
  * Capped from here rather than from the writer, which lives in an area this file does not own. A
  * retention rule is the same rule whether the directory holds journals, diffs or reports.
  */
+export declare function prunePlans(fs: FileSystemPort, root: string, retention?: number): Promise<void>;
 export declare function pruneFeedback(fs: FileSystemPort, root: string, retention?: number): Promise<void>;
 export {};

package/dist/memory/journal/on-disk/retention.js

@@ -1,5 +1,5 @@
 import { basename, join } from 'node:path';
-import { ReticleDir } from '@reticlehq/core';
+import { ReticleDir, STEP_SCREENSHOT } from '@reticlehq/core';
 import { reticleDirPaths, visualDir } from '../../project/dir/reticle-dir.js';
 import { EVIDENCE_DIRS } from './workspace-tiers.js';
 /** Keep at most this many session journals on disk; older ones are pruned by recency. */
@@ -14,6 +14,13 @@ export const DEFAULT_DIFF_RETENTION = 10;
  * for the one case where delivery was refused and somebody has to file the report by hand.
  */
 export const DEFAULT_FEEDBACK_RETENTION = 20;
+/** Harness plans kept on disk: the platform keeps every one, this machine the recent ones. */
+export const DEFAULT_PLAN_RETENTION = 50;
+/**
+ * Keep the step screenshots of at most this many runs. A run's are looked at while it is fresh, or
+ * on the platform it was synced to; the byte budget below is what bounds a single long one.
+ */
+export const DEFAULT_STEP_SHOT_RUN_RETENTION = 50;
 const DIFF_SUFFIX = '.diff.png';
 const PNG_SUFFIX = '.png';
 /**
@@ -171,7 +178,12 @@ export async function pruneVisualDiffs(fs, root, retention = DEFAULT_DIFF_RETENT
     for (const dir of await visualDirs(fs, root)) {
         await pruneByRecency(fs, dir, retention, isDiff);
     }
+    // Step screenshots are evidence of one run each, read in the minutes after it or synced with it;
+    // the oldest runs' directories go whole.
+    await pruneByRecency(fs, stepShotRunsDir(root), DEFAULT_STEP_SHOT_RUN_RETENTION);
 }
+/** `visual/runs/`, the parent of every run's step screenshots. */
+const stepShotRunsDir = (root) => join(root, ReticleDir.VISUAL_SUBDIR, STEP_SCREENSHOT.RUNS_DIR);
 /** `visual/` plus its per-runtime subdirectories. Empty when nothing has been captured yet. */
 async function visualDirs(fs, root) {
     const top = visualDir(root);
@@ -179,7 +191,8 @@ async function visualDirs(fs, root) {
     try {
         // A per-runtime subdirectory is anything here that is not itself a PNG.
         for (const entry of await fs.readdir(top)) {
-            if (!entry.endsWith(PNG_SUFFIX))
+            // `runs/` holds step screenshots, not baselines, and is bounded on its own.
+            if (!entry.endsWith(PNG_SUFFIX) && STEP_SCREENSHOT.RUNS_DIR !== entry)
                 dirs.push(join(top, entry));
         }
     }
@@ -228,6 +241,20 @@ async function collectEvidence(fs, root) {
     for (const under of EVIDENCE_DIRS) {
         const isVisual = ReticleDir.VISUAL_SUBDIR === under;
         const dirs = isVisual ? await visualDirs(fs, root) : [join(root, under)];
+        // Each run's step screenshots are one evidence entry, evicted whole, oldest first.
+        if (isVisual) {
+            const runs = stepShotRunsDir(root);
+            for (const name of await fs.readdir(runs).catch(() => [])) {
+                const path = join(runs, name);
+                try {
+                    const { mtimeMs } = await fs.stat(path);
+                    entries.push({ path, under, sizeBytes: await sizeOf(fs, path), mtimeMs });
+                }
+                catch {
+                    /* unreadable entry — skip */
+                }
+            }
+        }
         for (const dir of dirs) {
             let names;
             try {
@@ -287,6 +314,9 @@ export async function pruneEvidenceBudget(fs, root, budgetBytes = DEFAULT_EVIDEN
  * Capped from here rather than from the writer, which lives in an area this file does not own. A
  * retention rule is the same rule whether the directory holds journals, diffs or reports.
  */
+export async function prunePlans(fs, root, retention = DEFAULT_PLAN_RETENTION) {
+    await pruneByRecency(fs, join(root, ReticleDir.PLANS_SUBDIR), retention);
+}
 export async function pruneFeedback(fs, root, retention = DEFAULT_FEEDBACK_RETENTION) {
     await pruneByRecency(fs, join(root, ReticleDir.FEEDBACK_SUBDIR), retention);
 }

package/dist/memory/journal/on-disk/startup-maintenance.js

@@ -1,4 +1,4 @@
-import { pruneEvidenceBudget, pruneFeedback, pruneSessions, pruneVisualDiffs, } from './retention.js';
+import { pruneEvidenceBudget, pruneFeedback, prunePlans, pruneSessions, pruneVisualDiffs, } from './retention.js';
 import { DEFAULT_RETAIN } from './retain-policy.js';
 export async function pruneWorkspace(fs, root, live, options = {}) {
     const retain = { ...DEFAULT_RETAIN, ...options };
@@ -9,6 +9,8 @@ export async function pruneWorkspace(fs, root, live, options = {}) {
     await pruneVisualDiffs(fs, root, retain.visual);
     // Write-only local copies of reports the outbox already carries.
     await pruneFeedback(fs, root, retain.feedback);
+    // The recent plans are what somebody reads back; the platform holds every one.
+    await prunePlans(fs, root);
     // LAST, and the one that was missing: the only bound that limits SIZE rather than count.
     await pruneEvidenceBudget(fs, root, retain.budgetBytes, live);
 }

package/dist/memory/journal/on-disk/workspace-tiers.js

@@ -45,6 +45,8 @@ export const WORKSPACE_TIERS = {
     [ReticleDir.VISUAL_SUBDIR]: localDir,
     // Write-only: a local copy of what was already sent. The outbox is the record.
     [ReticleDir.FEEDBACK_SUBDIR]: localDir,
+    // What the Harness planned on this machine, and how it went. The platform keeps the team's copy.
+    [ReticleDir.PLANS_SUBDIR]: localDir,
     [ReticleDir.PROJECT_FILE]: localFile,
     [ReticleDir.AMBIENT_FILE]: localFile,
     [ReticleDir.ENVELOPES_FILE]: localFile,
@@ -52,6 +54,13 @@ export const WORKSPACE_TIERS = {
     // What THIS machine's drives covered, and the best each level reached — the gate's ratchet.
     [ReticleDir.COVERAGE_FILE]: localFile,
     [ReticleDir.TIERS_FILE]: localFile,
+    // The user's request in their own words: it leaves only with `shareRequests`, never by git push.
+    [ReticleDir.REQUEST_FILE]: localFile,
+    // How to target this app, learned from corrected failures: a teammate's agent needs it too.
+    [ReticleDir.APP_NOTES_FILE]: sharedFile,
+    [ReticleDir.PLATFORM_MOMENTS_FILE]: localFile,
+    // Notes a human pinned in the HUD: free text about the page. The team reads them on the platform.
+    [ReticleDir.NOTES_FILE]: localFile,
     // The user's own record of what Reticle did for them, on THIS machine.
     [ReticleDir.IMPACT_FILE]: localFile,
     // This machine's conversation with the server. Its own doc comment says why committing it is
@@ -72,10 +81,6 @@ export const WORKSPACE_TIERS = {
     // credential, so it is safe to commit — the same reasoning that puts `cloud.json` here while its
     // API key stays in ~/.reticle.
     [ReticleDir.HOOKS_FILE]: sharedFile,
-    // What a drive types into each labelled field. Committed for two reasons: a replay must send
-    // exactly what the recording sent or it is not a replay, and a value a model wrote once should be
-    // reviewable and editable by the team rather than regenerated differently on every machine.
-    [ReticleDir.FILL_VALUES_FILE]: sharedFile,
 };
 function namesWhere(match) {
     return Object.entries(WORKSPACE_TIERS)