@reticlehq/server 2.14.0 → 3.2.0

package/dist/flows/verify-change-tools.js

@@ -1,231 +0,0 @@
-import { z } from 'zod';
-import { sessionRoot, sessionProjectId } from '../project/session-root.js';
-import { verdictForSuite } from './verify-change-verdict.js';
-import { attributedFailures } from './attributed-failure.js';
-import { Verified } from '@reticlehq/core';
-import { ReticleTool } from '../tools/tool-names.js';
-import { asNumber, asRecord, asString } from '../tools/tools-helpers.js';
-import { workerCountSchema } from '../tools/numeric-bounds.js';
-import { loadNamedFlows, resolveChangedFiles } from '../cli/cli-flow-commands.js';
-import { affectedSavedFlows } from './flow-sources.js';
-import { FLOW_TOOLS } from './flow-tools.js';
-import { findContradictions } from '../events/contradictions.js';
-import { parseControls } from '../tools/coverage-tools.js';
-import { ReticleCommand, SnapshotMode } from '@reticlehq/core';
-export const VERIFY_CHANGE_TOOLS = [
-    {
-        name: ReticleTool.VERIFY_CHANGE,
-        description: 'Did my change break anything? Give it the files you edited (or `since` for a git ref) and it works out which saved flows cover them, replays exactly those, and answers with one `verified` (yes|no|unknown) plus `because`. `unknown` when NO saved flow covers the change — that is the honest answer, never a green: nothing ran, so nothing was proved. Returns { verified, because, changedFiles, flowsRun, suite, unknownProvenance }.',
-        example: { files: ['src/App.tsx'] },
-        inputSchema: {
-            files: z
-                .array(z.string())
-                .optional()
-                .describe('Changed file paths, repo-relative (e.g. ["src/App.tsx"]).'),
-            since: z
-                .string()
-                .optional()
-                .describe('Git ref to diff against (e.g. "HEAD~1", "main"). Unioned with `files`.'),
-            parallel: workerCountSchema
-                .optional()
-                .describe('Replay this many affected flows at once (needs the browser pool).'),
-            sessionId: z
-                .string()
-                .optional()
-                .describe('OMIT THIS unless you mean a specific tab — Reticle resolves it.'),
-        },
-        outputSchema: {
-            verified: z
-                .string()
-                .describe('yes | no | unknown. `unknown` means the evidence could not decide — most often that no saved flow covers these files, which is NOT a pass.'),
-            because: z.string(),
-            changedFiles: z.array(z.string()),
-            flowsRun: z.array(z.string()),
-            suite: z.unknown().optional(),
-            // Session-EXEMPT: declare the one-shot human feedback ask or a validating profile strips it.
-            feedback_prompt: z.unknown().optional(),
-            unknownProvenance: z.array(z.string()),
-            contradictions: z
-                .array(z.unknown())
-                .optional()
-                .describe('Channels that disagreed DURING the replay. Any entry forces verified:"no" even when every flow passed — a suite that goes green over a failed write is the false green this exists to catch. OMITTED when clean; see `measured` when it could not be looked for.'),
-            untouched: z
-                .array(z.unknown())
-                .optional()
-                .describe('Controls on the page that the covering flows never drove. A green over a small untouched list is stronger evidence than the same green over a large one.'),
-            measured: z
-                .array(z.string())
-                .describe('What was actually looked for. An absent `contradictions` means "none found" ONLY if "contradictions" appears here — otherwise it was never measured.'),
-        },
-        handler: async (deps, args) => {
-            const files = Array.isArray(args['files'])
-                ? args['files'].filter((f) => 'string' === typeof f)
-                : [];
-            const since = asString(args['since']);
-            // The daemon's cwd is not the project — it is wherever the MCP host started it, which for a
-            // globally-registered server is `/` or `$HOME`. `deps.reticleRoot` is the project directory
-            // this daemon was configured with, and it is the right tree to diff.
-            const changed = await resolveChangedFiles(files, since, deps.reticleRoot);
-            const changedFiles = changed.files;
-            // Same root flow_save wrote to. A read that resolved differently would report "no flows
-            // covered this change" over flows that exist, which reads as a clean result rather than
-            // an error, so the disagreement would be invisible.
-            // Both halves of the address from one place. The root was already resolved from the session;
-            // the id used to come from the daemon's cwd, so they named different projects.
-            const sid = asString(args['sessionId']);
-            const flows = await loadNamedFlows(deps.fs, sessionRoot(deps, sid), sessionProjectId(deps, sid));
-            const { affected, unknownProvenance } = affectedSavedFlows(flows, changedFiles);
-            if (0 === changedFiles.length) {
-                return {
-                    verified: Verified.UNKNOWN,
-                    // A git failure and a clean tree both arrive here with no files, and they are opposite
-                    // answers: one means there was nothing to decide about, the other means the question was
-                    // never asked. `unknown` is right either way, but the REASON is what the caller acts on.
-                    because: changed.failed
-                        ? `could not read the diff for \`${String(since)}\`, so nothing was compared: ${changed.reason ?? 'git failed'}`
-                        : 'no changed files were given, so there was nothing to decide about',
-                    changedFiles,
-                    flowsRun: [],
-                    unknownProvenance,
-                    // Nothing was looked for, and the schema requires this field to say so. Omitting it made
-                    // the MCP layer reject the whole response, turning an honest UNKNOWN into a protocol error.
-                    measured: [],
-                };
-            }
-            // The guard: an uncovered change is UNKNOWN. Reporting `yes` here would mean "your change is
-            // fine" on the strength of having run nothing at all.
-            if (0 === affected.length) {
-                return {
-                    verified: Verified.UNKNOWN,
-                    because: `no saved flow covers ${1 === changedFiles.length ? 'this file' : 'these files'} — record one with reticle_record { action: "start" } then reticle_flow_save, or verify by driving the app directly`,
-                    changedFiles,
-                    flowsRun: [],
-                    unknownProvenance,
-                    // No flow ran, so nothing was measured — said explicitly rather than left undefined.
-                    measured: [],
-                };
-            }
-            const provenanceNote = unknownProvenance.length > 0
-                ? ` (${String(unknownProvenance.length)} of them re-run only because Reticle cannot tell which sources they cover)`
-                : '';
-            // Marked BEFORE the replay so the contradiction sweep afterwards reads exactly the window the
-            // flows produced, and never events from whatever the agent did before calling this.
-            const cursor = cursorBeforeReplay(deps, args);
-            const verify = FLOW_TOOLS.find((tool) => tool.name === ReticleTool.FLOW_VERIFY);
-            if (verify === undefined)
-                throw new Error('the whole-suite replay tool is not registered');
-            const suite = asRecord(await verify.handler(deps, {
-                names: affected,
-                ...(asNumber(args['parallel']) === undefined ? {} : { parallel: args['parallel'] }),
-                ...(asString(args['sessionId']) === undefined ? {} : { sessionId: args['sessionId'] }),
-            }));
-            const failed = suite.failed ?? 0;
-            const passed = suite.passed ?? 0;
-            // `unverifiable` is NOT a failure — the suite ran and proved nothing, which is the same fact
-            // this tool answers UNKNOWN for an uncovered change. Treating it as a red emitted a bug_found
-            // that nothing earned. See verify-change-verdict.
-            const verdict = verdictForSuite(String(suite.status), failed);
-            // A NO must be EARNED by a failing flow genuinely tied to the changed files. `affectedSavedFlows`
-            // re-runs any flow whose sources it cannot determine — over-running beats skipping — and those
-            // land in `unknownProvenance`. Judging the change on them produced a negative verdict whose own
-            // explanation admitted the evidence was not tied to the file. See attributed-failure.
-            const failingNames = Array.isArray(suite.failures)
-                ? suite.failures
-                    .map((f) => 'object' === typeof f && f !== null ? asString(asRecord(f)['flow']) : undefined)
-                    .filter((n) => n !== undefined)
-                : // No per-failure detail: the failure is somewhere in the set that ran, so ask the question
-                    // of all of them rather than guessing which.
-                    affected;
-            const attributed = attributedFailures(failingNames, unknownProvenance);
-            const earnedNo = verdict === Verified.NO && attributed.length > 0;
-            const reported = verdict === Verified.NO && !earnedNo ? Verified.UNKNOWN : verdict;
-            if (reported !== Verified.YES) {
-                return {
-                    verified: reported,
-                    because: earnedNo
-                        ? `${String(failed)} of ${String(suite.total ?? affected.length)} covering flows failed, including ${attributed.join(', ')}, which cover the changed files${provenanceNote}`
-                        : verdict === Verified.NO
-                            ? `flows failed, but Reticle cannot tell which sources any of them cover (${failingNames.join(', ')}) — so this says nothing about the files you changed. Re-record them so their sources are stamped, or read the replay yourself`
-                            : `the covering flows ran but proved nothing (${String(suite.status)}) — they assert no observable consequence, so a green from them would not have meant your change is safe${provenanceNote}`,
-                    changedFiles,
-                    flowsRun: affected,
-                    suite,
-                    unknownProvenance,
-                    measured: ['flows'],
-                };
-            }
-            // The suite went green. That is exactly when the remaining two channels are worth reading:
-            // a replay that passes while a write fails is the false green this whole product is about.
-            const extra = await inspectAfterReplay(deps, args, cursor);
-            if (extra.contradictions.length > 0) {
-                const kinds = extra.contradictions.map((c) => c.kind).join(', ');
-                return {
-                    verified: Verified.NO,
-                    because: `every covering flow passed, but channels disagreed during the replay (${kinds}) — a green suite over a failed write is the false green worth looking at${provenanceNote}`,
-                    changedFiles,
-                    flowsRun: affected,
-                    suite,
-                    unknownProvenance,
-                    contradictions: extra.contradictions,
-                    ...(extra.untouched === undefined ? {} : { untouched: extra.untouched }),
-                    measured: extra.measured,
-                };
-            }
-            return {
-                verified: Verified.YES,
-                because: `all ${String(passed)} flows covering these files passed${provenanceNote}${extra.untouched === undefined ? '' : `, with ${String(extra.untouched.length)} controls left undriven`}`,
-                changedFiles,
-                flowsRun: affected,
-                suite,
-                unknownProvenance,
-                ...(extra.untouched === undefined ? {} : { untouched: extra.untouched }),
-                measured: extra.measured,
-            };
-        },
-    },
-];
-/** The event cursor to sweep from, or 0 when there is no readable session (nothing to sweep). */
-function cursorBeforeReplay(deps, args) {
-    try {
-        return deps.sessions.resolve(asString(args['sessionId'])).elapsed();
-    }
-    catch {
-        return 0;
-    }
-}
-/**
- * Read the two channels a suite verdict cannot see: did anything DISAGREE during the replay, and
- * what did the flows never touch.
- *
- * Both are skipped when the flows ran in parallel leased contexts, because the events and driven
- * refs then belong to those leases rather than to the session read here. Reporting "no
- * contradictions" from the wrong session would be a false green produced by the false-green
- * detector, so `measured` states what was actually looked for and the caller is never left to infer
- * it from an absent field.
- */
-async function inspectAfterReplay(deps, args, cursor) {
-    if (asNumber(args['parallel']) !== undefined) {
-        return { contradictions: [], measured: ['flows'] };
-    }
-    try {
-        const session = deps.sessions.resolve(asString(args['sessionId']));
-        const contradictions = findContradictions(session.eventsSince(cursor), {
-            currentDocumentId: session.currentDocumentId,
-            currentEditEpoch: session.currentEditEpoch,
-            appOrigin: session.url,
-            // The replay is the action, and the cursor is where it started.
-            actionSince: cursor,
-        });
-        const snapshot = await session.command(ReticleCommand.SNAPSHOT, {
-            mode: SnapshotMode.INTERACTIVE,
-        });
-        const tree = snapshot.ok ? (asString(asRecord(snapshot.result)['tree']) ?? '') : '';
-        const acted = session.actedRefs();
-        const untouched = parseControls(tree).filter((c) => !acted.has(c.ref));
-        return { contradictions, untouched, measured: ['flows', 'contradictions', 'coverage'] };
-    }
-    catch {
-        // A session that went away after the replay is not evidence of cleanliness.
-        return { contradictions: [], measured: ['flows'] };
-    }
-}

package/dist/honesty/accepted-write.d.ts

@@ -1,17 +0,0 @@
-import { type ReticleEvent } from '@reticlehq/core';
-/**
- * Did a write in this window answer `202 Accepted`?
- *
- * `202` is the only status in HTTP whose meaning is "no outcome yet" — the server took the request
- * and has not finished with it. Folding it into the 2xx success band is how an asynchronous workflow
- * gets a green verdict at exactly the moment nothing has been decided.
- *
- * Measured on a logistics console with server-side reconciliation: a dispatch answered 202, the row
- * optimistically rendered "dispatched", the page settled, every channel agreed — and the server
- * REVERTED it to `held` 1.2 s later. The verdict was not wrong about what it observed. It was early,
- * and nothing in the response said so except the status code nobody was reading.
- *
- * The DEV TOOLCHAIN's own traffic is excluded, on the same rule every other check applies: a verdict
- * about the app must not be decided by a request the app did not make.
- */
-export declare function hasAcceptedWrite(events: readonly ReticleEvent[]): boolean;

package/dist/honesty/accepted-write.js

@@ -1,22 +0,0 @@
-import { EventType, HTTP_ACCEPTED, isDevToolingUrl } from '@reticlehq/core';
-import { asNumber, asString } from '../tools/tools-helpers.js';
-/**
- * Did a write in this window answer `202 Accepted`?
- *
- * `202` is the only status in HTTP whose meaning is "no outcome yet" — the server took the request
- * and has not finished with it. Folding it into the 2xx success band is how an asynchronous workflow
- * gets a green verdict at exactly the moment nothing has been decided.
- *
- * Measured on a logistics console with server-side reconciliation: a dispatch answered 202, the row
- * optimistically rendered "dispatched", the page settled, every channel agreed — and the server
- * REVERTED it to `held` 1.2 s later. The verdict was not wrong about what it observed. It was early,
- * and nothing in the response said so except the status code nobody was reading.
- *
- * The DEV TOOLCHAIN's own traffic is excluded, on the same rule every other check applies: a verdict
- * about the app must not be decided by a request the app did not make.
- */
-export function hasAcceptedWrite(events) {
-    return events.some((e) => e.type === EventType.NET_REQUEST &&
-        asNumber(e.data['status']) === HTTP_ACCEPTED &&
-        !isDevToolingUrl(asString(e.data['url'])));
-}

package/dist/honesty/already-true.d.ts

@@ -1,16 +0,0 @@
-import type { Predicate } from '../events/predicate.js';
-export declare function readsDomState(predicate: Predicate): boolean;
-/**
- * #889: an `already_true` verdict says the declared consequence held before the action, so nothing
- * was proven — but a `text`/`element` predicate matches DOM presence by default, not visibility (a
- * caller has to pass `visible: true` to ask for that). A dialog's content mounted-but-hidden before
- * the click therefore reads as "already true", identically to genuinely-visible content that was
- * already on screen — and the `already_true` message named neither which node it matched nor that
- * the match was invisible, which is what made it read as proof of nothing rather than as the
- * mid-load/hidden-mount trap it actually was.
- *
- * True only when the predicate itself did not ask for a state (an explicit `visible`/other state
- * constraint already means the caller saw and handled this) AND every matched element is hidden —
- * one visible match among several is a fair, ordinary read and is left alone.
- */
-export declare function alreadyTrueHiddenMatch(predicate: Predicate, evidence: unknown): boolean;

package/dist/honesty/already-true.js

@@ -1,89 +0,0 @@
-/**
- * Which predicates can be satisfied by something that was already true before the action.
- *
- * Event-based kinds (net, signal, console, animation, settled) are evaluated against the
- * event buffer floored at the act's own cursor, so a stale event cannot satisfy them — that floor is
- * why `act_and_wait` can trust them at all.
- *
- * `element` and `text` read the LIVE DOM, `route` can fall back to the current route, and `state` reads
- * live store memory via STATE_READ — where no event floor applies. A condition that held before the
- * click holds after it and passes instantly, whatever the action did. Measured in the field: a click
- * asserted with `{ kind: 'text', contains: 'Parallel Routes' }` returned `verified: "yes"` in 478ms
- * against `routeChanges: 0`, because the predicate matched the nav link that was already on screen —
- * the real navigation landed 1.8 seconds later. Similarly, a pre-existing store value (e.g. cart.count == 3)
- * satisfies an inert action if not checked before dispatch.
- *
- * So these are the kinds worth evaluating BEFORE the act, to find out whether the green means
- * anything.
- */
-import { PredicateKind } from '@reticlehq/core';
-export function readsDomState(predicate) {
-    switch (predicate.kind) {
-        // ROUTE is here, and it did not used to be. It was purely event-based — satisfiable only by a
-        // navigation inside the act's window, and therefore unable to be answered by the past — so it
-        // sat with the floored kinds below.
-        //
-        // It gained a fallback to the CURRENT route for the case where the window holds no route change,
-        // which is what makes "did the session survive a reload?" answerable at all. Without a
-        // before-check that fallback is a guaranteed green: the app is already on /login, the click's
-        // handler is broken, nothing navigates, and an assertion that the action reached /login passes
-        // on the strength of it having been there all along. A bare `{ kind: 'route' }` becomes
-        // unconditionally true, because there is always a current route.
-        //
-        // One extra query on the act path buys `already_true`, reported as UNKNOWN with the reason
-        // rather than as a pass. The fallback removed a false red; this is what stops it becoming a
-        // false green, and that is the trade this codebase never makes.
-        //
-        // STATE is here for the same reason: it is evaluated via STATE_READ against live in-memory stores
-        // rather than through the floored event buffer. If the store already holds the expected value
-        // before dispatch, an inert click would immediately pass post-dispatch on the pre-existing state.
-        // Evaluating before dispatch routes that pre-existing condition into already_true.
-        case PredicateKind.ELEMENT:
-        case PredicateKind.TEXT:
-        case PredicateKind.ROUTE:
-        case PredicateKind.STATE:
-            return true;
-        case PredicateKind.ALL_OF:
-        case PredicateKind.ANY_OF:
-            return predicate.predicates.some(readsDomState);
-        case PredicateKind.NOT:
-            return readsDomState(predicate.predicate);
-        default:
-            return false;
-    }
-}
-/** True when `value` looks like an element/text predicate's passing evidence — an array of descriptors. */
-function isDescriptorArray(value) {
-    if (!Array.isArray(value))
-        return false;
-    return value.every((v) => {
-        if ('object' !== typeof v || null === v)
-            return false;
-        return 'boolean' === typeof v['visible'];
-    });
-}
-/**
- * #889: an `already_true` verdict says the declared consequence held before the action, so nothing
- * was proven — but a `text`/`element` predicate matches DOM presence by default, not visibility (a
- * caller has to pass `visible: true` to ask for that). A dialog's content mounted-but-hidden before
- * the click therefore reads as "already true", identically to genuinely-visible content that was
- * already on screen — and the `already_true` message named neither which node it matched nor that
- * the match was invisible, which is what made it read as proof of nothing rather than as the
- * mid-load/hidden-mount trap it actually was.
- *
- * True only when the predicate itself did not ask for a state (an explicit `visible`/other state
- * constraint already means the caller saw and handled this) AND every matched element is hidden —
- * one visible match among several is a fair, ordinary read and is left alone.
- */
-export function alreadyTrueHiddenMatch(predicate, evidence) {
-    if (predicate.kind !== PredicateKind.ELEMENT && predicate.kind !== PredicateKind.TEXT) {
-        return false;
-    }
-    if (predicate.kind === PredicateKind.ELEMENT && predicate.state !== undefined)
-        return false;
-    if (predicate.kind === PredicateKind.TEXT && true === predicate.visible)
-        return false;
-    if (!isDescriptorArray(evidence) || 0 === evidence.length)
-        return false;
-    return evidence.every((el) => !el.visible);
-}

package/dist/honesty/blind-spots.d.ts

@@ -1,133 +0,0 @@
-/**
- * Blind-spot register — the never-silent statement of what the layer CANNOT see. Closed shadow roots,
- * cross-origin iframes, and virtualized-unmounted rows are documented limits; a result that touched one
- * says so (`coverage: partial — 2 cross-origin frames unobserved`) instead of implying it saw everything.
- * Pure formatting over the counted blind spots the observers report.
- */
-export { BlindSpotKind } from '@reticlehq/core';
-import { BlindSpotKind, type ReticleEvent } from '@reticlehq/core';
-interface BlindSpot {
-    kind: BlindSpotKind;
-    count: number;
-}
-/**
- * Whether the observation window saw everything it was asked about.
- *
- * NOT core's VerdictStatus, which happens to spell one of its values 'partial' too: that one grades
- * a verification RUN (some flows passed, some failed), this one grades what could be OBSERVED. Two
- * meanings behind one string is exactly how a comparison ends up reading the wrong field, so they
- * stay separate vocabularies.
- */
-export declare const Coverage: {
-    readonly FULL: "full";
-    readonly PARTIAL: "partial";
-};
-export type Coverage = (typeof Coverage)[keyof typeof Coverage];
-interface CoverageStatement {
-    coverage: Coverage;
-    /** Present only when partial — the human/agent-legible list of what went unobserved. */
-    note?: string;
-    spots: BlindSpot[];
-}
-/**
- * Blind spots that IMPEACH the capture, as opposed to bounding what it covers.
- *
- * The distinction decides whether a verdict is downgraded to UNKNOWN or merely carries a caveat, and
- * conflating them breaks the tool in one direction or the other:
- *
- *  - **Impeaching**: events were DROPPED, so the window itself is a sample and any claim over it may
- *    be a false negative. Nothing observed can be trusted to be complete.
- *  - **Bounding**: a region is structurally unobservable — a cross-origin frame, a closed shadow
- *    root, the 9,970 virtualized rows that were never rendered. What WAS observed is completely and
- *    correctly observed; there is simply a boundary, and it is usually permanent.
- *
- * Treating the second kind as impeaching made every verdict on any virtualized list UNKNOWN — which
- * is most data-heavy software, permanently. A tool that answers "unknown" to everything is as
- * useless as one that answers "yes" to everything, and it is the same failure: a verdict that does
- * not depend on the evidence.
- */
-export declare function impeachesCapture(kind: BlindSpotKind): boolean;
-/** Compose the coverage statement. `full` (no note) when nothing was unobserved. */
-export declare function buildCoverageStatement(spots: readonly BlindSpot[]): CoverageStatement;
-/**
- * Reduce a window's BLIND_SPOT events to one spot per kind — the LATEST reported count wins (the sensor
- * emits only on change, so the last value is the live count). This is how a result's coverage is derived
- * from what the SDK observed during the action, with no extra round-trip.
- */
-export declare function blindSpotsFromEvents(events: readonly ReticleEvent[]): BlindSpot[];
-/**
- * Drop Electron-only coverage rows unless this session is actually an Electron renderer.
- *
- * The kinds live in the same vocabulary as "no store registered", so listing whatever is present
- * reported a Vite + React tab as an un-instrumented Electron renderer. The session already knows
- * the runtime (PAGE_HEALTH). Unknown runtime (older SDK) keeps the rows — dropping them would hide
- * a real missing-preload warning.
- */
-export declare function spotsForRuntime(spots: readonly BlindSpot[], runtime: string | undefined): BlindSpot[];
-/**
- * Blind spots from the session's remembered LEVEL state rather than from a window of events.
- *
- * The SDK emits BLIND_SPOT only when the count changes, so a page that mounted cross-origin frames at
- * load announces them once and is silent thereafter. Deriving coverage from one act's window then
- * reports "full" for a page a third of which is unobservable — and the act tool's own description
- * tells harnesses to gate on that block. Ask the session what is true now instead of inferring it
- * from what happened to be said recently.
- *
- * `runtime` gates Electron-only kinds (see `spotsForRuntime`) so a web session cannot inherit them
- * from the coverage vocabulary.
- */
-export declare function blindSpotsFromState(state: Readonly<Record<string, number>>, runtime?: string): BlindSpot[];
-/**
- * The narrow slice of a predicate the absence-blind-spot check needs.
- *
- * Kept minimal to avoid pulling the full Predicate type (and its transitive deps) into the
- * honesty module. Anything that quacks like this works.
- */
-interface AbsencePredicate {
-    kind: string;
-    absent?: boolean;
-    query?: {
-        scope?: unknown;
-    };
-    predicate?: AbsencePredicate;
-}
-/**
- * When an absence assertion targets a page with regions Reticle cannot observe, "the element is
- * absent" means only "it is absent in what I CAN see". Returns a note when that distinction
- * matters, undefined otherwise.
- *
- * Fires on three blind-spot kinds:
- *   - CROSS_ORIGIN_IFRAME (only when the predicate is scoped to a frame region)
- *   - VIRTUALIZED_UNMOUNTED — a row that was never rendered could hold the element
- *   - CLOSED_SHADOW_ROOT — a subtree Reticle cannot see into
- */
-export declare function absenceBlindSpotNote(predicate: AbsencePredicate, spots: readonly BlindSpot[]): string | undefined;
-/** The impeaching note for a transport gap, or undefined when the window was intact. */
-export declare function transportGapNote(events: readonly ReticleEvent[]): string | undefined;
-/**
- * Is the state channel dark?
- *
- * Nothing subscribed means NO state change is observed, so an empty `stateDiffs` is a statement
- * about Reticle rather than about the app. Derived here, once, because two callers now need it —
- * the act path's causal summary and the instrumentation-gap surface — and a second spelling of this
- * predicate would eventually disagree with the first about what "unwatched" means.
- */
-export declare function isStateUnwatched(spots: readonly BlindSpot[]): boolean;
-/**
- * Does a passing verdict on this predicate REST on the window being complete?
- *
- * Only an absence claim does. A positive assertion that passed found its evidence, and events aged
- * out elsewhere in the buffer do not unmake it. An absence claim concluded "nothing is there" — and
- * the thing the buffer dropped is precisely the disproof, so "absent" degrades to "absent in what I
- * still hold".
- *
- * The distinction is not optional. Scarce-loss is recorded for AGE eviction too, so `lostSince(0)`
- * is true on any session older than the 60s cutoff; impeaching every verdict over a caller-chosen
- * window would make `unknown` the answer to everything, which this repo has already paid for once.
- */
-export declare function restsOnCompleteWindow(predicate: {
-    kind: string;
-    absent?: boolean;
-    count?: number;
-    predicate?: unknown;
-}): boolean;