@reticlehq/server 3.6.0 → 3.7.0

package/dist/memory/impact/account-watch.js

@@ -12,8 +12,14 @@
 import { unwatchFile, watchFile } from 'node:fs';
 /** How often each watched file is stat'ed. A second reads as live to somebody switching windows. */
 export const ACCOUNT_WATCH_INTERVAL_MS = 1_000;
-export function watchAccountFiles(onChange, intervalMs = ACCOUNT_WATCH_INTERVAL_MS) {
+/** How often `onTick` re-reads what has no file to watch; the platform config is polled as often. */
+export const HUD_REFRESH_MS = 30_000;
+export function watchAccountFiles(onChange, intervalMs = ACCOUNT_WATCH_INTERVAL_MS, 
+/** The rest of the platform's side of the HUD, which has no file to watch: run every 30s. */
+onTick) {
     const watched = new Set();
+    const ticker = onTick === undefined ? undefined : setInterval(onTick, HUD_REFRESH_MS);
+    ticker?.unref();
     const listener = () => {
         onChange();
     };
@@ -26,9 +32,28 @@ export function watchAccountFiles(onChange, intervalMs = ACCOUNT_WATCH_INTERVAL_
             watchFile(path, { persistent: false, interval: intervalMs }, listener);
         },
         close() {
+            if (ticker !== undefined)
+                clearInterval(ticker);
             for (const path of watched)
                 unwatchFile(path, listener);
             watched.clear();
         },
     };
 }
+/** What each tab was last sent by `pushIfMoved`, so an unchanged snapshot is not sent again. */
+const sent = new WeakMap();
+/**
+ * Push a tab its impact snapshot, or, with `ifChanged`, only when it moved since this last pushed it.
+ *
+ * The daemon re-reads every tab on a timer so the platform's side of the HUD (sync status, runs on
+ * the dashboard, days left) reaches an idle tab without a tool call; resending an unchanged snapshot
+ * on every tick would repaint every HUD for nothing.
+ */
+export function pushIfMoved(tab, read, ifChanged) {
+    const snapshot = read();
+    const json = JSON.stringify(snapshot);
+    if (ifChanged && sent.get(tab) === json)
+        return;
+    sent.set(tab, json);
+    tab.pushImpact(() => snapshot, true);
+}

package/dist/memory/impact/impact-store.d.ts

@@ -1,5 +1,4 @@
-import { type OfferSource } from '../cloud/harness-offer.js';
-import type { ConfigSource } from '../cloud/harness-config.js';
+import { type ConfigSource } from '../cloud/harness-config.js';
 import { type NoticesSource } from '../cloud/hud-notices-source.js';
 import { type ImpactCounts, type ImpactDefect, type AccountState, type ImpactScope, type ImpactSnapshot } from '@reticlehq/core';
 /** Read a scope, tolerating absence and corruption: a broken file starts over rather than throwing. */
@@ -49,8 +48,6 @@ export declare class ImpactStore {
         globalRoot?: string;
         /** Reads whether this machine is signed in. Injected so the store stays testable and pure-ish. */
         account?: () => AccountState;
-        /** Where the workspace stands with the free harness offer. Injected so no test touches a network. */
-        offer?: OfferSource;
         config?: ConfigSource;
         /** The HUD rail's notices. Defaults to the daemon's cached copy of the published file. */
         notices?: NoticesSource;

package/dist/memory/impact/impact-store.js

@@ -1,9 +1,11 @@
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
-import { describeSync, overallStatus, readSyncSummary } from '../project/sync-status.js';
+import { SyncStatus, dashboardRunUrl, describeSync, keyRefusalAtLastSync, overallStatus, readSyncSummary, } from '../project/sync-status.js';
+import { describeUnsynced, unsentFlowCount, unsentRunCount, } from '../cloud/unsynced-roots.js';
+import { readDashboardUrl } from '../project/sync-status.js';
 import { dirname, join } from 'node:path';
 import { homedir } from 'node:os';
 import { readAccountState } from '../cloud/account-state.js';
-import { harnessOfferSource } from '../cloud/harness-offer.js';
+import { configForHud } from '../cloud/harness-config.js';
 import { hudNoticesSource } from '../cloud/hud-notices-source.js';
 import { selectNotices } from '@reticlehq/core/hud';
 import { ReticleDir, IMPACT_DAILY_BUCKETS, IMPACT_DEFECT_LIMIT, IMPACT_SCHEMA_VERSION, ImpactScopeSchema, addImpactCounts, emptyImpactCounts, emptyImpactRecords, estimateImpactSavings, } from '@reticlehq/core';
@@ -34,26 +36,6 @@ function impactPaths(reticleRoot, globalRoot) {
         global: join(globalRoot, ReticleDir.ROOT, ReticleDir.IMPACT_FILE),
     };
 }
-/**
- * Where this project's dashboard lives, if `reticle link` recorded one.
- *
- * Read from the link file rather than derived from the API url, because the API origin and the
- * console origin are different hosts in every deployment that is not a laptop. Synchronous and
- * best-effort, like every other read in this file: a missing or malformed link file means no link
- * in the HUD, never a failed tool call.
- */
-function readDashboardUrl(reticleRoot) {
-    try {
-        const raw = JSON.parse(readFileSync(join(reticleRoot, ReticleDir.CLOUD_LINK_FILE), 'utf8'));
-        if ('object' !== typeof raw || null === raw)
-            return undefined;
-        const value = raw['dashboardUrl'];
-        return 'string' === typeof value && value.length > 0 ? value : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
 function emptyScope(now) {
     const counts = emptyImpactCounts();
     return {
@@ -243,8 +225,6 @@ export class ImpactStore {
     #timer;
     #onChange;
     #account;
-    /** Where this workspace stands with the free harness offer. Cached; see harness-offer.ts. */
-    #offer;
     #config;
     #notices;
     #sdkVersion;
@@ -259,9 +239,6 @@ export class ImpactStore {
         this.#projectName = opts.projectName;
         this.#dashboardUrl = readDashboardUrl(opts.reticleRoot);
         this.#root = opts.reticleRoot;
-        // The claim happens in the console, so the link this project was linked to IS the claim link —
-        // built here rather than in the HUD, which has no way to know where this project points.
-        this.#offer = opts.offer ?? harnessOfferSource(process.env, () => this.#dashboardUrl);
         this.#notices =
             opts.notices ??
                 hudNoticesSource({
@@ -275,11 +252,30 @@ export class ImpactStore {
         this.#project = readScope(this.#paths.project, now);
         this.#global = readScope(this.#paths.global, now);
     }
-    #syncStatus() {
+    #syncStatus(dashboardUrl) {
         const now = this.#now();
         if (this.#sync !== undefined && now - this.#sync.at < SYNC_STATUS_EVERY_MS)
             return this.#sync.value;
+        // Not linked: one line when runs or flows sit here that nothing will send, and nothing otherwise.
+        // `pending` counts both, so the HUD's existing "N not sent" includes a flow saved with no run.
+        if (dashboardUrl === undefined) {
+            const runs = unsentRunCount(this.#root);
+            const flows = unsentFlowCount(this.#root, false);
+            const value = 0 === runs + flows
+                ? undefined
+                : {
+                    status: SyncStatus.LOCAL_ONLY,
+                    pending: runs + flows,
+                    runs,
+                    flows,
+                    said: describeUnsynced({ root: this.#root, runs, flows, linked: false }, dirname(this.#root)),
+                };
+            this.#sync = { at: now, value };
+            return value;
+        }
         const summary = readSyncSummary(this.#root, true);
+        const refusal = keyRefusalAtLastSync(this.#root);
+        const latest = summary.latestOnPlatform;
         const value = {
             status: overallStatus(summary),
             runs: summary.runs,
@@ -287,7 +283,11 @@ export class ImpactStore {
             pending: summary.pending,
             refused: summary.refused.length + summary.refusedMore,
             ...(summary.lastPushAt === undefined ? {} : { lastPushAt: summary.lastPushAt }),
+            // The run that just synced, on its own page — the HUD's "see it in your dashboard".
+            ...(latest === undefined ? {} : { runUrl: dashboardRunUrl(dashboardUrl, latest) }),
             said: describeSync(summary, now),
+            // The HUD's chip: a refused key is not "0 waiting".
+            ...(refusal === undefined ? {} : { keyRefused: refusal }),
         };
         this.#sync = { at: now, value };
         return value;
@@ -320,21 +320,10 @@ export class ImpactStore {
         if (this.#dashboardUrl !== undefined)
             snap.dashboardUrl = this.#dashboardUrl;
         snap.account = this.#account();
-        const cfgForOffer = this.#config.read();
-        const offer = this.#offer.read();
-        // Joined here because this is the one place that holds BOTH the offer and the platform config.
-        // The card reads the offer, so readiness has to travel on it rather than being re-derived in a
-        // presenter that has no business knowing what a provider key is.
-        if (offer !== undefined && cfgForOffer !== undefined)
-            offer.drivable = cfgForOffer.providerReady;
-        // Absent means "we have not heard", which the HUD renders as nothing at all. Never defaulted to
-        // `{claimed:false}`: that would advertise the offer to everyone who is offline.
-        if (offer !== undefined)
-            snap.harnessOffer = offer;
         // Absent stays absent: the HUD reads that as "we have not heard" and renders no control.
         const cfg = this.#config.read();
         if (cfg !== undefined)
-            snap.harnessConfig = cfg;
+            snap.harnessConfig = configForHud(cfg, this.#now());
         // Chosen here, where the account and the entitlement are both known. Absent when nothing applies,
         // so the HUD falls back to the slides bundled with the SDK.
         const notices = selectNotices(this.#notices.read(), {
@@ -350,8 +339,9 @@ export class ImpactStore {
             snap.coverage = coverage;
         // Only for a linked project: an unlinked one has nothing on the platform, and the HUD already
         // offers the way to link it.
-        if (this.#dashboardUrl !== undefined)
-            snap.sync = this.#syncStatus();
+        const sync = this.#syncStatus(this.#dashboardUrl);
+        if (sync !== undefined)
+            snap.sync = sync;
         return snap;
     }
     /** Write now (process exit, tests). */

package/dist/memory/intent/inline-intent.d.ts

@@ -55,6 +55,7 @@ export declare function dischargeInlineIntent(deps: ToolDeps, sessionId: string
     verdictId: string;
     grade: string;
     at: number;
+    runId?: string;
 }, 
 /** `file:line` of the element this verdict acted on, when there was one. */
 sourceLabel?: string): Promise<void>;

package/dist/memory/intent/intent-shard-store.js

@@ -25,7 +25,7 @@ import { IntentFileSchema, IntentState, amendIntent, isActionLabel, } from '@ret
 import { IntentDir, ReticleDir } from '@reticlehq/core';
 import { reticleDirPaths } from '../project/dir/reticle-dir.js';
 import { withFileLock } from '../project/file-lock.js';
-import { subjectFor } from './intent-subject.js';
+import { subjectFor, UNSORTED_SUBJECT } from './intent-subject.js';
 import { emptyShard, indexFrom, IntentShardSchema, IntentStatus, recordFromIntent, serialise, shardsFrom, statusFromState, } from './intent-shard.js';
 import { writeFileAtomic } from '../project/fs/write-atomic.js';
 const JSON_SUFFIX = '.json';
@@ -199,13 +199,25 @@ export class IntentShardStore {
         const subject = flow !== undefined
             ? subjectFor({ surface: { flow } })
             : (facts.subject ??
-                existing?.subject ??
+                // `unsorted` is the absence of a subject, so new evidence may still file the record.
+                (UNSORTED_SUBJECT === existing?.subject ? undefined : existing?.subject) ??
                 subjectFor({ surface: next.surface, binding: next.binding }));
         const why = facts.why ?? existing?.why;
         const source = facts.source ?? existing?.source;
+        // New words keep no check bound to the old ones: a later green on it would "prove" words it
+        // never tested. A binding the change brings with it stands.
+        const kept = existing !== undefined && existing.statement !== next.statement
+            ? { ...existing, binding: undefined }
+            : existing;
+        // Bound only while a check is bound: a record whose check was taken off (new words, a decision)
+        // said `bound` with none, and a check naming it then proved nothing and said nothing.
+        const merged = { ...kept, ...next };
+        const state = IntentState.BOUND === merged.state && merged.binding === undefined
+            ? IntentState.DECLARED
+            : merged.state;
         return {
-            ...existing,
-            ...next,
+            ...merged,
+            state,
             subject,
             status: this.#statusOf(next, existing, facts.status),
             updatedAt: this.#clock.now(),

package/dist/memory/intent/intent-shard.d.ts

@@ -63,14 +63,17 @@ declare const IntentRecordSchema: z.ZodObject<{
         verdictId: z.ZodString;
         grade: z.ZodString;
         at: z.ZodNumber;
+        runId: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         at: number;
         grade: string;
         verdictId: string;
+        runId?: string | undefined;
     }, {
         at: number;
         grade: string;
         verdictId: string;
+        runId?: string | undefined;
     }>>;
     amended: z.ZodOptional<z.ZodArray<z.ZodObject<{
         statement: z.ZodString;
@@ -112,6 +115,7 @@ declare const IntentRecordSchema: z.ZodObject<{
         at: number;
         grade: string;
         verdictId: string;
+        runId?: string | undefined;
     } | undefined;
     amended?: {
         at: number;
@@ -137,6 +141,7 @@ declare const IntentRecordSchema: z.ZodObject<{
         at: number;
         grade: string;
         verdictId: string;
+        runId?: string | undefined;
     } | undefined;
     amended?: {
         at: number;
@@ -170,14 +175,17 @@ export declare const IntentShardSchema: z.ZodObject<{
             verdictId: z.ZodString;
             grade: z.ZodString;
             at: z.ZodNumber;
+            runId: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             at: number;
             grade: string;
             verdictId: string;
+            runId?: string | undefined;
         }, {
             at: number;
             grade: string;
             verdictId: string;
+            runId?: string | undefined;
         }>>;
         amended: z.ZodOptional<z.ZodArray<z.ZodObject<{
             statement: z.ZodString;
@@ -219,6 +227,7 @@ export declare const IntentShardSchema: z.ZodObject<{
             at: number;
             grade: string;
             verdictId: string;
+            runId?: string | undefined;
         } | undefined;
         amended?: {
             at: number;
@@ -244,6 +253,7 @@ export declare const IntentShardSchema: z.ZodObject<{
             at: number;
             grade: string;
             verdictId: string;
+            runId?: string | undefined;
         } | undefined;
         amended?: {
             at: number;
@@ -272,6 +282,7 @@ export declare const IntentShardSchema: z.ZodObject<{
             at: number;
             grade: string;
             verdictId: string;
+            runId?: string | undefined;
         } | undefined;
         amended?: {
             at: number;
@@ -301,6 +312,7 @@ export declare const IntentShardSchema: z.ZodObject<{
             at: number;
             grade: string;
             verdictId: string;
+            runId?: string | undefined;
         } | undefined;
         amended?: {
             at: number;

package/dist/memory/intent/intent-store.d.ts

@@ -48,5 +48,6 @@ export declare class IntentStore {
         verdictId: string;
         grade: string;
         at: number;
+        runId?: string;
     }): Promise<boolean>;
 }

package/dist/memory/intent/intent-tools.js

@@ -7,6 +7,7 @@ import { reticleDirPaths } from '../project/dir/reticle-dir.js';
 import { IntentStore } from './intent-store.js';
 import { IntentShardStore } from './intent-shard-store.js';
 import { IntentStatus } from './intent-shard.js';
+import { UNSORTED_SUBJECT } from './intent-subject.js';
 import { ReticleDir, ReticleTool, apiKeyFrom } from '@reticlehq/core';
 import { sessionIdShape } from '../../surface/tools/tool-kit.js';
 import { PredicateSchema } from '@reticlehq/engine/question/predicate/predicate.js';
@@ -107,6 +108,11 @@ export const INTENT_TOOLS = [
                 .optional()
                 .describe('declare only: statements not stored, and why.'),
             path: z.string().optional().describe('Where the ledger was written.'),
+            filesNotFound: z.array(z.string()).optional().describe('surface.files not in the project'),
+            noSubject: z
+                .object({ ids: z.array(z.string()), fix: z.string() })
+                .optional()
+                .describe('declare only: intents filed under nothing, and how to file them'),
             entries: z
                 .array(z.unknown())
                 .optional()
@@ -172,17 +178,51 @@ export const INTENT_TOOLS = [
             if (!Array.isArray(raw) || 0 === raw.length) {
                 throw new Error(`${ReticleTool.INTENT} declare: \`intents\` must be a non-empty array of { id, statement }, got ${raw === undefined ? 'nothing' : JSON.stringify(raw)} — nothing was stored`);
             }
-            const entries = raw;
+            const { entries, missing } = await withExistingFiles(deps, dirname(root), raw);
             const declared = await store.declare(entries);
             // Said, not swallowed: an agent that declared something and finds nothing stored would
             // otherwise conclude the ledger lost it.
             const refused = entries
                 .filter((entry) => isActionLabel(entry.statement))
                 .map((entry) => ({ id: entry.id, reason: STEP_LABEL_REFUSAL }));
-            return { intents: declared, ...(0 === refused.length ? {} : { refused }), path: root };
+            // Asked, not refused: prose with nowhere to live is still worth keeping, but an agent
+            // looking for it later finds it by its subject, and the Memory page warns about these.
+            const unsorted = declared
+                .filter((intent) => UNSORTED_SUBJECT === intent.subject)
+                .map((intent) => intent.id);
+            return {
+                intents: declared,
+                ...(0 === refused.length ? {} : { refused }),
+                // Named, never kept as a fact's source: a path that is not in the project is a guess.
+                ...(0 === missing.length ? {} : { filesNotFound: missing }),
+                ...(0 === unsorted.length ? {} : { noSubject: { ids: unsorted, fix: NO_SUBJECT_FIX } }),
+                path: root,
+            };
         },
     },
 ];
+/**
+ * The entries with each `surface.files` path that is not in the project left out, and those paths.
+ * An agent declared `src/pages/SavedItems.tsx` for `src/views/SavedItems.tsx`, and the dashboard
+ * showed the wrong file as the fact's source.
+ */
+async function withExistingFiles(deps, projectDir, entries) {
+    const missing = [];
+    const kept = await Promise.all(entries.map(async (entry) => {
+        const surface = entry.surface;
+        if (!Array.isArray(surface?.files))
+            return entry;
+        const files = [];
+        for (const file of surface.files)
+            if ('string' === typeof file && (await deps.fs.exists(join(projectDir, file))))
+                files.push(file);
+            else if ('string' === typeof file)
+                missing.push(file);
+        return { ...entry, surface: { ...surface, files } };
+    }));
+    return { entries: kept, missing };
+}
+const NO_SUBJECT_FIX = 'Nothing says what these are about, so an agent looking for them cannot find them: declare each again with surface.route (the page it is about) or surface.flow.';
 const MAX_REQUEST = 20_000;
 const MAX_STATEMENT = 500;
 const MAX_STATEMENTS = 100;

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: {