@reticlehq/server 2.13.1 → 2.14.0

package/dist/honesty/gap-ledger.js

@@ -1,4 +1,4 @@
-import { dedupeGaps } from '@reticlehq/core';
+import { dedupeGaps } from '@reticlehq/core/artifacts';
 /**
  * What this session still cannot see, accumulated across its verdicts.
  *

package/dist/honesty/instrumentation-gaps.d.ts

@@ -1,4 +1,4 @@
-import { type InstrumentationGap } from '@reticlehq/core';
+import { type InstrumentationGap } from '@reticlehq/core/artifacts';
 /**
  * The gaps ONE action revealed, derived from facts the act path already holds.
  *
@@ -75,6 +75,13 @@ export interface ActionInstrumentationFacts {
      * finished, and a bare flag makes them read the same.
      */
     openIntentCount?: number;
+    /**
+     * The page announced that this build has the `data-reticle-source` stamp switched OFF.
+     *
+     * Only `true` means anything: absent is "nobody said", which is every SDK predating the field and
+     * every hand-wired connect. See the HELLO field of the same name.
+     */
+    sourceMappingDisabled?: boolean;
     /**
      * How long the OLDEST open intent has been owed, in ms.
      *

package/dist/honesty/instrumentation-gaps.js

@@ -1,10 +1,20 @@
-import { InstrumentationGapKind, dedupeGaps, instrumentationGap, } from '@reticlehq/core';
+import { InstrumentationGapKind, dedupeGaps, instrumentationGap, } from '@reticlehq/core/artifacts';
 export function gapsForAction(facts) {
     const gaps = [];
     // A red verdict names the control and cannot name the line that renders it. That is the round trip
     // the agent is about to spend, and the one a build plugin removes permanently.
+    //
+    // ...unless the project TURNED THE STAMP OFF, which is a different situation with the opposite
+    // remedy. Reported from the field: a react-three-fiber app disabled `sourceMapping` because the
+    // stamp crashed it to a white screen, and every red verdict afterwards told the reader to install
+    // a build plugin that was already there. Only a definite `false` counts — an SDK that says nothing
+    // is unknown, and reading silence as an opt-out would mute the honest gap for every app that
+    // simply has no source mapping at all.
     if (!facts.pass && facts.source === undefined) {
-        gaps.push(instrumentationGap(InstrumentationGapKind.NO_SOURCE_MAPPING, 'the control that was driven carries no source mapping', 'this verdict can name the control but not the file and line that render it, so finding the code is a separate search', { ...(facts.ref === undefined ? {} : { ref: facts.ref }) }));
+        const off = true === facts.sourceMappingDisabled;
+        gaps.push(instrumentationGap(off ? InstrumentationGapKind.SOURCE_MAPPING_OFF : InstrumentationGapKind.NO_SOURCE_MAPPING, off
+            ? 'source mapping is turned off for this build, so no element carries data-reticle-source'
+            : 'the control that was driven carries no source mapping', 'this verdict can name the control but not the file and line that render it, so finding the code is a separate search', { ...(facts.ref === undefined ? {} : { ref: facts.ref }) }));
     }
     // Asked about state, and there is no state channel to answer from. Deliberately UNLOCATED: a store
     // is registered once at app setup, nowhere near the control that was driven, and nothing in this

package/dist/honesty/observability.d.ts

@@ -1,4 +1,4 @@
-import type { InstrumentationGap } from '@reticlehq/core';
+import type { InstrumentationGap } from '@reticlehq/core/artifacts';
 /**
  * Of the controls this session drove, how many could Reticle fully observe?
  *
@@ -19,7 +19,7 @@ import type { InstrumentationGap } from '@reticlehq/core';
  * happened to be driven would put the number on the wrong thing and make it move for reasons the
  * agent cannot act on. Those gaps are reported alongside, not divided into.
  */
-export interface Observability {
+interface Observability {
     /** Distinct controls driven this session. */
     driven: number;
     /** How many of them Reticle could fully observe. */
@@ -28,10 +28,11 @@ export interface Observability {
     percent?: number;
 }
 export declare function observabilityOf(drivenRefs: Iterable<string>, gaps: readonly InstrumentationGap[]): Observability;
-export interface CoverageRegression {
+interface CoverageRegression {
     was: number;
     now: number;
 }
 export declare function coverageRegressed(best: {
     percent: number;
 } | undefined, current: Observability): CoverageRegression | undefined;
+export {};

package/dist/honesty/tool-hit-rate.d.ts

@@ -47,12 +47,12 @@ export type ToolTier = (typeof ToolTier)[keyof typeof ToolTier];
 /** Which surface would have put this tool in front of an agent, read off that surface's own set. */
 export declare function tierOfTool(tool: string): ToolTier;
 /** How many tools fell in each tier on one side of the called/never-called split. */
-export interface TierCounts {
+interface TierCounts {
     default: number;
     extended: number;
     runOnly: number;
 }
-export interface ToolHitRate {
+interface ToolHitRate {
     /** False when this session carries no ledger — "not watched", never "nothing was called". */
     observed: boolean;
     /** The four-plus-two cells: every tier, called and never-called. Omitted when not observed. */
@@ -84,3 +84,4 @@ export declare function foldToolHitRate(input: {
     calls: ReadonlyMap<string, number> | undefined;
     allTools: readonly string[];
 }): ToolHitRate;
+export {};

package/dist/honesty/uncaptured-bodies.d.ts

@@ -16,6 +16,8 @@ export declare function bodiesNotCaptured(calls: {
     method?: string;
     requestBody?: string;
     responseBody?: string;
-}[]): {
+}[], 
+/** The page SDK's version, so the remedy can check whether it applies. See body-capture-remedy. */
+sdkVersion?: string): {
     bodiesNotCaptured?: string;
 };

package/dist/honesty/uncaptured-bodies.js

@@ -1,3 +1,4 @@
+import { bodyCaptureRemedy } from './body-capture-remedy.js';
 /** Methods that normally carry a payload — the ones where a missing body is worth explaining. */
 const BODY_BEARING_METHODS = new Set(['POST', 'PUT', 'PATCH']);
 /**
@@ -14,7 +15,9 @@ const BODY_BEARING_METHODS = new Set(['POST', 'PUT', 'PATCH']);
  * anywhere in the result, so an app that already captures bodies pays nothing and the field's
  * PRESENCE is the warning.
  */
-export function bodiesNotCaptured(calls) {
+export function bodiesNotCaptured(calls, 
+/** The page SDK's version, so the remedy can check whether it applies. See body-capture-remedy. */
+sdkVersion) {
     const bodyBearing = calls.filter((c) => BODY_BEARING_METHODS.has((c.method ?? '').toUpperCase()));
     if (0 === bodyBearing.length)
         return {};
@@ -32,6 +35,7 @@ export function bodiesNotCaptured(calls) {
         // config they do not have. Remediation that does not apply to the reader's stack is worse than
         // none: it sends them to edit a file that is not there and reads as a tool that does not know
         // what it is looking at.
-        bodiesNotCaptured: 'request/response bodies are NOT being recorded, so an absent body here means UNSEEN, not empty — the payload of these calls was never inspected. Turn it on where your app calls connect(): `reticle.connect({ captureNetworkBodies: true })`, or for the Vite plugin `reticle({ captureNetworkBodies: true })` / VITE_RETICLE_CAPTURE_BODIES=1. Then re-run the action.',
+        bodiesNotCaptured: 'request/response bodies are NOT being recorded, so an absent body here means UNSEEN, not ' +
+            `empty — the payload of these calls was never inspected. ${bodyCaptureRemedy(sdkVersion)}`,
     };
 }

package/dist/honesty/unsettled.d.ts

@@ -38,6 +38,15 @@ export interface UnsettledWindow {
  * agent that never chose that wait cannot be expected to recognise it in a timeout about it.
  */
 export declare function describeWaitTarget(predicate: Predicate): string;
+/**
+ * Did the assertion name a request that is still open?
+ *
+ * `waitForPredicate` reports a miss ("no request to /register") the moment the budget ends, even
+ * when that same POST is sitting in `stillInFlight`. Grading that miss `no` is a race against the
+ * backend, not a defect. Matching is the discriminator: an unrelated poll left open does not pardon
+ * a named URL that never started.
+ */
+export declare function namedNetIsInFlight(predicate: Predicate, stillInFlight: readonly string[]): boolean;
 /**
  * The `because` sentence for an unsettled verdict: the wait, the observation, the next move.
  *

package/dist/honesty/unsettled.js

@@ -52,6 +52,51 @@ export function describeWaitTarget(predicate) {
             return `the absence of ${describeWaitTarget(predicate.predicate)}`;
     }
 }
+/**
+ * Did the assertion name a request that is still open?
+ *
+ * `waitForPredicate` reports a miss ("no request to /register") the moment the budget ends, even
+ * when that same POST is sitting in `stillInFlight`. Grading that miss `no` is a race against the
+ * backend, not a defect. Matching is the discriminator: an unrelated poll left open does not pardon
+ * a named URL that never started.
+ */
+export function namedNetIsInFlight(predicate, stillInFlight) {
+    if (0 === stillInFlight.length)
+        return false;
+    const nets = [];
+    const walk = (p) => {
+        switch (p.kind) {
+            case PredicateKind.ALL_OF:
+            case PredicateKind.ANY_OF:
+                for (const child of p.predicates)
+                    walk(child);
+                return;
+            case PredicateKind.NET: {
+                if (undefined === p.urlContains || 0 === p.urlContains.length)
+                    return;
+                nets.push({
+                    ...(undefined === p.method ? {} : { method: p.method }),
+                    urlContains: p.urlContains,
+                });
+                return;
+            }
+            default:
+                return;
+        }
+    };
+    walk(predicate);
+    return nets.some((net) => stillInFlight.some((label) => inFlightLabelMatchesNet(label, net)));
+}
+function inFlightLabelMatchesNet(label, net) {
+    const space = label.indexOf(' ');
+    if (space <= 0)
+        return false;
+    const method = label.slice(0, space);
+    const url = label.slice(space + 1);
+    if (undefined !== net.method && method.toUpperCase() !== net.method.toUpperCase())
+        return false;
+    return url.includes(net.urlContains);
+}
 /**
  * The `because` sentence for an unsettled verdict: the wait, the observation, the next move.
  *

package/dist/honesty/verified.d.ts

@@ -24,6 +24,14 @@ interface VerifiedInputs {
      * confidently-wrong-by-accident this clause exists to remove.
      */
     observationLost?: boolean;
+    /**
+     * The URL the session was on when observation was lost.
+     *
+     * Only meaningful with `observationLost`. A route that 500s tears the page down mid-wait; naming
+     * the last URL in the verdict is the difference between "install problem" and "the page died on
+     * /X" (#808). Absent when we never knew, which must not invent a route.
+     */
+    lastUrl?: string;
     honesty: HonestyBlock;
     /**
      * Set when the assertion could not be EVALUATED at all — an under-specified call, or nothing
@@ -36,6 +44,15 @@ interface VerifiedInputs {
      * ones are floored at the act's cursor and cannot be satisfied by the past.
      */
     alreadyTrue?: boolean;
+    /**
+     * The `alreadyTrue` match was against a HIDDEN element/text — DOM presence, not something a person
+     * could see on screen. `text`/`element` predicates match presence by default (`visible: true` is
+     * opt-in), so a dialog's content mounted-but-hidden before the click reads identically to content
+     * that was genuinely already showing, and named neither fact (#889). Only changes `because`; the
+     * verdict itself is unchanged; a hidden pre-existing match is exactly as unfalsifiable as a visible
+     * one.
+     */
+    alreadyTrueHiddenMatch?: boolean;
     /** Cross-channel disagreements found in the action's window. */
     contradictions?: readonly {
         kind: string;
@@ -43,7 +60,7 @@ interface VerifiedInputs {
     /** Did a real frame flush before the wait gave up? */
     settled?: boolean;
     /**
-     * The caller NAMED the expected consequence before acting — an `until`/`predicate` of its own,
+     * The caller named a consequence before acting — an `until`/`predicate` of its own,
      * rather than the default "wait for the page to go idle".
      *
      * This is the epistemic core of the tool: a declaration made before the action cannot be
@@ -61,6 +78,12 @@ interface VerifiedInputs {
      * outright. Fixing a false negative must not open a path to a false positive.
      */
     declaredConsequence?: boolean;
+    /**
+     * A net the caller named is still open. `waitForPredicate` reports that as `pass: false` ("no
+     * request to …") the instant the budget ends, which made a cold backend `assertion_failed` and a
+     * warm one `proved`. Absence of a settle is not evidence the request never happened — see #669.
+     */
+    namedRequestInFlight?: boolean;
     /**
      * A write in this window answered `202 Accepted` — the server took the request and has NOT
      * finished processing it.
@@ -76,6 +99,14 @@ interface VerifiedInputs {
      * Empty means nothing went unread.
      */
     outcomeUnread?: readonly string[];
+    /**
+     * The page SDK's version, so the unread-body remedy can check whether it applies.
+     *
+     * This clause is the highest-traffic producer of that advice — every 2xx write whose body went
+     * unread lands here — and it inlined the setting unconditionally, which is what a reporter saw six
+     * times at a repo pinned below the release that introduced it. See body-capture-remedy.ts.
+     */
+    sdkVersion?: string | undefined;
     /**
      * The declared consequence that held does not depend on the response body — an exact string
      * rendered, a store path, a signal, a route, or an element located by role / name / testid. See

package/dist/honesty/verified.js

@@ -1,6 +1,8 @@
-import { ContradictionKind, MUTATING_METHODS, Verified, VerifiedReason, isAbsenceDerived, } from '@reticlehq/core';
+import { bodyCaptureRemedy } from './body-capture-remedy.js';
+import { ContradictionKind, MUTATING_METHODS, Verified, VerifiedReason, isAbsenceDerived, isAdvisory, } from '@reticlehq/core';
 import { HonestyGrade } from './honesty.js';
 import { unsettledBecause } from './unsettled.js';
+import { pageTornDownWhileOn } from '../session/no-session-diagnosis.js';
 export function decideVerified(inputs) {
     const { pass, honesty, contradictions = [], settled, outcomePending, outcomeUnread } = inputs;
     /** The caller named a consequence before acting and it held — see `declaredConsequence`. */
@@ -22,10 +24,13 @@ export function decideVerified(inputs) {
     //
     // UNKNOWN, for the same reason `unclean_capture` is: the evidence is ABSENT, not negative.
     if (true === inputs.observationLost) {
+        const lost = undefined === inputs.lastUrl || '' === inputs.lastUrl
+            ? 'the tab disconnected'
+            : pageTornDownWhileOn(inputs.lastUrl);
         return {
             verified: Verified.UNKNOWN,
             verifiedReason: VerifiedReason.OBSERVATION_LOST,
-            because: 'the tab disconnected while this action was being observed, so its outcome was never ' +
+            because: `${lost} while this action was being observed, so its outcome was never ` +
                 'seen — this says nothing about the app. Call reticle_sessions for the current session ' +
                 '(a reloaded tab keeps its id; a closed one is gone) and repeat the action if it is safe ' +
                 'to repeat',
@@ -49,6 +54,20 @@ export function decideVerified(inputs) {
                 '`until` naming what the action should cause (a signal, a request, a route, or store state)',
         };
     }
+    // ABOVE the failure clause, same reason as observationLost: absence is not evidence.
+    //
+    // A `{ net, urlContains }` miss while that URL is still in `stillInFlight` is a window that
+    // closed early, not a request that never happened. The same result object already named the
+    // in-flight POST; calling it `assertion_failed` contradicted that field and flipped green on a
+    // warm backend. UNKNOWN, and the sentence says to re-check once the request lands.
+    if (false === pass && true === inputs.namedRequestInFlight) {
+        return {
+            verified: Verified.UNKNOWN,
+            verifiedReason: VerifiedReason.WINDOW_CLOSED_EARLY,
+            because: unsettledBecause('the request this assertion named was still in flight when the window closed, so the ' +
+                'consequence was not disproved — it had not finished', inputs.unsettled),
+        };
+    }
     // A failed assertion is the most actionable fact there is; it leads — including over
     // `alreadyTrue`, because a condition that held before AND fails now is a real regression.
     if (false === pass) {
@@ -72,7 +91,11 @@ export function decideVerified(inputs) {
     // every `no` verdict in the field. See ABSENCE_DERIVED_CONTRADICTIONS for why a false negative
     // costs more than it looks: it makes an agent redo work that succeeded, or stop believing the
     // verdict channel, which is the product.
-    const observed = contradictions.filter((c) => !isAbsenceDerived(c.kind));
+    // Advisory findings are dropped from the decision entirely, at both tiers below. They are true and
+    // they ride out in `contradictions`; what they are not is evidence about the consequence the
+    // caller declared, because they concern traffic the assertion never named (#673).
+    const deciding = contradictions.filter((c) => !isAdvisory(c.kind));
+    const observed = deciding.filter((c) => !isAbsenceDerived(c.kind));
     if (observed.length > 0) {
         const kinds = observed.map((c) => c.kind).join(', ');
         return {
@@ -99,7 +122,7 @@ export function decideVerified(inputs) {
     const settlementOnly = declaredHeld &&
         inputs.unsettled !== undefined &&
         !openWrite &&
-        contradictions.every((c) => c.kind === ContradictionKind.REQUEST_NEVER_SETTLED);
+        deciding.every((c) => c.kind === ContradictionKind.REQUEST_NEVER_SETTLED);
     // `signal-without-consequence` gets its own sentence, because the generic one is FALSE for it.
     //
     // That sentence says the window "closed before the app finished" and then explains that a poll or
@@ -108,8 +131,8 @@ export function decideVerified(inputs) {
     // explanation that told the agent to wait longer or assert something else, when the fact to act on
     // was that the app announced a consequence it did not deliver. A right verdict with a wrong reason
     // sends an agent to the wrong place, which costs as much as the wrong verdict did.
-    const signalOnly = contradictions.length > 0 &&
-        contradictions.every((c) => c.kind === ContradictionKind.SIGNAL_WITHOUT_CONSEQUENCE);
+    const signalOnly = deciding.length > 0 &&
+        deciding.every((c) => c.kind === ContradictionKind.SIGNAL_WITHOUT_CONSEQUENCE);
     if (signalOnly) {
         return {
             verified: Verified.UNKNOWN,
@@ -121,8 +144,8 @@ export function decideVerified(inputs) {
                 'the store holds) before trusting it',
         };
     }
-    if (contradictions.length > 0 && !settlementOnly) {
-        const kinds = contradictions.map((c) => c.kind).join(', ');
+    if (deciding.length > 0 && !settlementOnly) {
+        const kinds = deciding.map((c) => c.kind).join(', ');
         return {
             verified: Verified.UNKNOWN,
             // NOT `unsettled`: this clause fires whether or not the page went idle, and naming it after
@@ -171,7 +194,10 @@ export function decideVerified(inputs) {
         return {
             verified: true === settled ? Verified.NO_FAULT : Verified.UNKNOWN,
             verifiedReason: VerifiedReason.ALREADY_TRUE,
-            because: 'the declared consequence was already true before this action, so it proves nothing about it — assert something the action CHANGES (a signal, a request, a route, or store state)',
+            because: 'the declared consequence was already true before this action, so it proves nothing about it — assert something the action CHANGES (a signal, a request, a route, or store state)' +
+                (true === inputs.alreadyTrueHiddenMatch
+                    ? '. That prior match was against a HIDDEN element — this predicate checks DOM presence, not visibility, by default; add `visible: true` if you meant "this is showing", not merely "this exists"'
+                    : ''),
         };
     }
     // Dirty capture is NOT failure. The layer could not see part of the window, so any green is a
@@ -259,7 +285,8 @@ export function decideVerified(inputs) {
             verified: Verified.UNKNOWN,
             verifiedReason: VerifiedReason.OUTCOME_UNREAD,
             because: `a write returned 2xx with a response body that was never recorded (${outcomeUnread.join('; ')}), so its outcome is unread` +
-                ' — a 200 describes the transport, not the result (a batch reports per-item failures in the body, and every GraphQL error is a 200). Enable it where your app calls connect(): `reticle.connect({ captureNetworkBodies: true })`, then re-run',
+                ' — a 200 describes the transport, not the result (a batch reports per-item failures in the body, and every GraphQL error is a 200). ' +
+                bodyCaptureRemedy(inputs.sdkVersion),
         };
     }
     // Never settled: the page may still be moving, so the observation window may have closed early.

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

@@ -1,17 +1,4 @@
-import { type ImpactCounts, type ImpactDefect, type ImpactScope, type ImpactSnapshot } from '@reticlehq/core';
-export interface ImpactPaths {
-    project: string;
-    global: string;
-}
-/**
- * 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.
- */
-export declare function readDashboardUrl(reticleRoot: string): string | undefined;
+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. */
 export declare function readScope(path: string, now: number): ImpactScope;
 /** YYYY-MM-DD in local time - the day boundary a person recognises, not UTC's. */
@@ -46,6 +33,10 @@ export declare class ImpactStore {
         reticleRoot: string;
         projectName?: string;
         now?: () => number;
+        /** Where `~/.reticle` lives. Defaults to the real home; overridden so the shared scope is testable. */
+        globalRoot?: string;
+        /** Reads whether this machine is signed in. Injected so the store stays testable and pure-ish. */
+        account?: () => AccountState;
     });
     /** Notified after every fold, so the HUD can be pushed a fresh snapshot. */
     onChange(fn: () => void): void;

package/dist/impact/impact-store.js

@@ -1,6 +1,7 @@
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { homedir } from 'node:os';
+import { readAccountState } from '../cloud/account-state.js';
 import { ReticleDir, IMPACT_DAILY_BUCKETS, IMPACT_DEFECT_LIMIT, IMPACT_SCHEMA_VERSION, ImpactScopeSchema, addImpactCounts, emptyImpactCounts, emptyImpactRecords, estimateImpactSavings, } from '@reticlehq/core';
 /**
  * Where Reticle keeps the record of what it has done for you.
@@ -18,12 +19,16 @@ const WRITE_DEBOUNCE_MS = 800;
 const CLOUD_LINK_FILE = 'cloud.json';
 /**
  * `reticleRoot` is the project's own `.reticle` directory (what every other store here is handed);
- * the global scope always lives beside the daemon's own state in `~/.reticle`.
+ * the global scope lives beside the daemon's own state in `~/.reticle`.
+ *
+ * `globalRoot` defaults to the home directory and exists to be overridden. Reaching for `homedir()`
+ * implicitly made the machine-wide scope untestable — the one scope with a concurrency bug in it —
+ * so the seam is the fix's precondition, not a test affordance.
  */
-function impactPaths(reticleRoot) {
+function impactPaths(reticleRoot, globalRoot) {
     return {
         project: join(reticleRoot, ReticleDir.IMPACT_FILE),
-        global: join(homedir(), ReticleDir.ROOT, ReticleDir.IMPACT_FILE),
+        global: join(globalRoot, ReticleDir.ROOT, ReticleDir.IMPACT_FILE),
     };
 }
 /**
@@ -34,7 +39,7 @@ function impactPaths(reticleRoot) {
  * 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.
  */
-export function readDashboardUrl(reticleRoot) {
+function readDashboardUrl(reticleRoot) {
     try {
         const raw = JSON.parse(readFileSync(join(reticleRoot, CLOUD_LINK_FILE), 'utf8'));
         if ('object' !== typeof raw || null === raw)
@@ -157,10 +162,23 @@ export class ImpactStore {
     #dashboardUrl;
     #project;
     #global;
+    /**
+     * Deltas folded since the last machine-wide write, kept so the write can be a MERGE.
+     *
+     * The project scope has one writer and can be written wholesale. The machine-wide file is shared
+     * by every daemon on the box, so writing an in-memory copy taken at construction erases whatever a
+     * sibling wrote in between — which is what made the machine streak read LOWER than a single
+     * project's. Replaying these onto whatever is on disk at flush time is what makes the write additive.
+     */
+    #pendingGlobal = [];
     #timer;
     #onChange;
+    #account;
     constructor(opts) {
-        this.#paths = impactPaths(opts.reticleRoot);
+        this.#paths = impactPaths(opts.reticleRoot, opts.globalRoot ?? homedir());
+        // Resolved per snapshot, not cached: a user who runs `reticle login` in another terminal must
+        // see the HUD change without restarting the daemon that is watching their app.
+        this.#account = opts.account ?? (() => readAccountState(homedir(), process.env));
         this.#now = opts.now ?? (() => Date.now());
         this.#projectName = opts.projectName;
         this.#dashboardUrl = readDashboardUrl(opts.reticleRoot);
@@ -175,7 +193,10 @@ export class ImpactStore {
     record(delta, meta = {}) {
         const now = this.#now();
         this.#project = applyDelta(this.#project, delta, now, meta);
+        // Folded in memory so a reader sees it immediately, AND buffered so the durable write can replay
+        // it onto a file a sibling may have moved on since. The in-memory copy is rebased at flush.
         this.#global = applyDelta(this.#global, delta, now, meta);
+        this.#pendingGlobal.push({ delta, now, meta });
         this.#scheduleFlush();
         this.#onChange?.();
     }
@@ -189,6 +210,7 @@ export class ImpactStore {
             snap.projectName = this.#projectName;
         if (this.#dashboardUrl !== undefined)
             snap.dashboardUrl = this.#dashboardUrl;
+        snap.account = this.#account();
         return snap;
     }
     /** Write now (process exit, tests). */
@@ -197,8 +219,29 @@ export class ImpactStore {
             clearTimeout(this.#timer);
             this.#timer = undefined;
         }
+        // One writer: the in-memory copy IS the truth.
         writeScope(this.#paths.project, this.#project);
-        writeScope(this.#paths.global, this.#global);
+        this.#flushGlobal();
+    }
+    /**
+     * Publish this store's contribution to the machine-wide scope WITHOUT discarding anyone else's.
+     *
+     * Re-reads what is on disk and replays only the deltas recorded since the last write, so a sibling
+     * daemon's day survives. The merged result is adopted in memory too, which is what keeps the HUD's
+     * "everything on this machine" honest rather than showing this process's private view forever.
+     *
+     * ponytail: read-modify-write, not locked. Two daemons flushing inside the same read→rename window
+     * can still drop one batch — far rarer than the every-second-flush loss this replaces, and it costs
+     * one debounce window rather than a whole history. Upgrade to a lock file (exclusive `wx` create
+     * plus a stale timeout) if the counters are ever load-bearing for anything but the HUD.
+     */
+    #flushGlobal() {
+        if (0 === this.#pendingGlobal.length)
+            return;
+        const merged = this.#pendingGlobal.reduce((scope, p) => applyDelta(scope, p.delta, p.now, p.meta), readScope(this.#paths.global, this.#now()));
+        writeScope(this.#paths.global, merged);
+        this.#global = merged;
+        this.#pendingGlobal = [];
     }
     #scheduleFlush() {
         if (this.#timer !== undefined)

package/dist/index.js

@@ -3,7 +3,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { resolveProjectCloud } from './cloud/cloud-config.js';
 import { startSyncDaemon } from './cloud/sync-daemon.js';
-import { PROJECT_REGISTRY_FILE, emptyProjectRegistry, parseProjectRegistry, projectCandidates, } from '@reticlehq/core';
+import { PROJECT_REGISTRY_FILE, emptyProjectRegistry, parseProjectRegistry, projectCandidates, } from '@reticlehq/core/artifacts';
 import { discoverProjectConfigs } from './cli/config-discovery.js';
 import { projectCandidatesFrom, resolveArtifactRoot, } from './project/artifact-root.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';

package/dist/input/network-detail.d.ts

@@ -1,4 +1,4 @@
-import { type RedactionPolicy, type ReticleEvent } from '@reticlehq/core';
+import { URL_RAW, type RedactionPolicy, type ReticleEvent } from '@reticlehq/core';
 /**
  * CDP-authoritative network detail. Wherever the daemon has a CDP connection — whether it launched
  * the browser or attached to one someone else started — `page.on('response')` sees the FULL response:
@@ -9,7 +9,23 @@ import { type RedactionPolicy, type ReticleEvent } from '@reticlehq/core';
  * `page.on` attachment is thin Playwright glue (exercised e2e, like the pool launcher).
  */
 export interface NetworkDetail {
+    /**
+     * The URL as the agent reads it, redacted by the same rule the in-page observer applies.
+     *
+     * It arrives raw from the driver, exactly like the headers and the request body below, and it
+     * carries credentials just as routinely: a presigned upload, an OAuth callback, a single-use reset
+     * link. Redacting the other two and not this one left the one field nobody had to parse to read.
+     */
     url: string;
+    /**
+     * The URL before redaction, present only when redaction rewrote it.
+     *
+     * The grader-only match haystack, the same field and the same contract as on a NET_REQUEST: it is
+     * how `urlContains` still matches a public path segment the heuristic rewrote, and how the merge
+     * below pairs this detail with the request the SDK reported. `withoutUrlRaw` strips it before any
+     * event is rendered to an agent.
+     */
+    [URL_RAW]?: string;
     method?: string;
     status: number;
     headers: Record<string, string>;
@@ -24,6 +40,15 @@ export interface NetworkDetail {
      * window.fetch frame at all), rewrites requests invisibly. Available on the DRIVE path only.
      */
     requestBody?: string;
+    /**
+     * Present, and only ever `true`, when the bound above cut the captured body short.
+     *
+     * The same field and the same contract the in-page observer already emits. A shortened body an
+     * agent cannot tell apart from a whole one is the false green this project exists to prevent: a
+     * `net` assertion over a payload that was cut reads as an absence of the thing that was cut off.
+     * Omitted when the whole body fits, so the caveat means something when it appears.
+     */
+    requestBodyTruncated?: boolean;
     /**
      * The document that ISSUED the request, which is what identifies the session it belongs to.
      *