import { z } from 'zod';
/**
 * The impact record: what Reticle has actually done for this user, and what that is worth.
 *
 * Everything here is derived from calls that really happened - the dispatch chokepoint counts them
 * - and is stored locally. Two kinds of number live in this file and they are NOT interchangeable:
 *
 *   MEASURED  - counted from real calls (tokens returned, verdicts, defects, sessions, minutes).
 *   ESTIMATED - a comparison against a run that did not happen (tokens/minutes SAVED). Every one of
 *               these carries the baseline it is measured against, because a saving without its
 *               denominator is not a claim, it is a slogan - and this project has already been
 *               bitten by publishing one ("2574x cheaper" compares against an LLM re-drive, not a
 *               compiled suite).
 *
 * The UI must render the two differently and must never present an estimate as a count.
 */
/** Storage + wire version for the impact record. Bump on any breaking shape change. */
export declare const IMPACT_SCHEMA_VERSION = 1;
/** How many daily buckets a store keeps - enough for a month's chart plus a fortnight of slack. */
export declare const IMPACT_DAILY_BUCKETS = 45;
/** Counts of things that actually happened. Every field is a tally, never an estimate. */
export declare const ImpactCountsSchema: z.ZodObject<{
    /** Session-bound tool calls that reached a handler. */
    calls: z.ZodNumber;
    /** Calls that produced a verdict (act_and_wait / assert). */
    verdicts: z.ZodNumber;
    /** Verdicts that came back verified:"yes". */
    passed: z.ZodNumber;
    /** Verdicts that came back verified:"no" - a defect the agent would otherwise have called done. */
    failed: z.ZodNumber;
    /** Verdicts Reticle could not decide. Shown, not hidden: an unknown is not a pass. */
    unknown: z.ZodNumber;
    /** Refusals - a drive Reticle declined rather than faking. */
    refusals: z.ZodNumber;
    /** Notes a human pinned to the page. */
    marks: z.ZodNumber;
    /** Distinct sessions seen. */
    sessions: z.ZodNumber;
    /** Tokens Reticle returned to the agent (estimated per call at ~4 chars/token, then summed). */
    tokensReturned: z.ZodNumber;
    /** Wall-clock milliseconds spent inside tool calls. */
    drivingMs: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    sessions: number;
    unknown: number;
    passed: number;
    failed: number;
    calls: number;
    verdicts: number;
    refusals: number;
    marks: number;
    tokensReturned: number;
    drivingMs: number;
}, {
    sessions: number;
    unknown: number;
    passed: number;
    failed: number;
    calls: number;
    verdicts: number;
    refusals: number;
    marks: number;
    tokensReturned: number;
    drivingMs: number;
}>;
export type ImpactCounts = z.infer<typeof ImpactCountsSchema>;
/** One day's slice of the same counters, keyed by ISO date, for the chart. */
export declare const ImpactDaySchema: z.ZodObject<{
    /** YYYY-MM-DD, local to the machine that recorded it. */
    date: z.ZodString;
    counts: z.ZodObject<{
        /** Session-bound tool calls that reached a handler. */
        calls: z.ZodNumber;
        /** Calls that produced a verdict (act_and_wait / assert). */
        verdicts: z.ZodNumber;
        /** Verdicts that came back verified:"yes". */
        passed: z.ZodNumber;
        /** Verdicts that came back verified:"no" - a defect the agent would otherwise have called done. */
        failed: z.ZodNumber;
        /** Verdicts Reticle could not decide. Shown, not hidden: an unknown is not a pass. */
        unknown: z.ZodNumber;
        /** Refusals - a drive Reticle declined rather than faking. */
        refusals: z.ZodNumber;
        /** Notes a human pinned to the page. */
        marks: z.ZodNumber;
        /** Distinct sessions seen. */
        sessions: z.ZodNumber;
        /** Tokens Reticle returned to the agent (estimated per call at ~4 chars/token, then summed). */
        tokensReturned: z.ZodNumber;
        /** Wall-clock milliseconds spent inside tool calls. */
        drivingMs: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        sessions: number;
        unknown: number;
        passed: number;
        failed: number;
        calls: number;
        verdicts: number;
        refusals: number;
        marks: number;
        tokensReturned: number;
        drivingMs: number;
    }, {
        sessions: number;
        unknown: number;
        passed: number;
        failed: number;
        calls: number;
        verdicts: number;
        refusals: number;
        marks: number;
        tokensReturned: number;
        drivingMs: number;
    }>;
}, "strip", z.ZodTypeAny, {
    date: string;
    counts: {
        sessions: number;
        unknown: number;
        passed: number;
        failed: number;
        calls: number;
        verdicts: number;
        refusals: number;
        marks: number;
        tokensReturned: number;
        drivingMs: number;
    };
}, {
    date: string;
    counts: {
        sessions: number;
        unknown: number;
        passed: number;
        failed: number;
        calls: number;
        verdicts: number;
        refusals: number;
        marks: number;
        tokensReturned: number;
        drivingMs: number;
    };
}>;
export type ImpactDay = z.infer<typeof ImpactDaySchema>;
/** Bests worth beating. Gamification, entirely local. */
export declare const ImpactRecordsSchema: z.ZodObject<{
    /** Longest single session, in ms. */
    longestRunMs: z.ZodNumber;
    /** Most verdicts in one day. */
    bestVerdictDay: z.ZodNumber;
    /** Most defects caught in one day. */
    bestDefectDay: z.ZodNumber;
    /** Consecutive days with at least one verdict, up to and including today. */
    streakDays: z.ZodNumber;
    /** Longest such streak ever. */
    bestStreakDays: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    longestRunMs: number;
    bestVerdictDay: number;
    bestDefectDay: number;
    streakDays: number;
    bestStreakDays: number;
}, {
    longestRunMs: number;
    bestVerdictDay: number;
    bestDefectDay: number;
    streakDays: number;
    bestStreakDays: number;
}>;
export type ImpactRecords = z.infer<typeof ImpactRecordsSchema>;
/**
 * A saving, with the comparison that produced it.
 *
 * `basis` names what the number is measured AGAINST, in the user's own words, and it is rendered
 * next to the figure. No basis, no number.
 */
export declare const ImpactEstimateSchema: z.ZodObject<{
    value: z.ZodNumber;
    basis: z.ZodString;
}, "strip", z.ZodTypeAny, {
    value: number;
    basis: string;
}, {
    value: number;
    basis: string;
}>;
export type ImpactEstimate = z.infer<typeof ImpactEstimateSchema>;
export declare const ImpactSavingsSchema: z.ZodObject<{
    /** Tokens not spent, vs looking at the app the way an agent without Reticle has to. */
    tokens: z.ZodObject<{
        value: z.ZodNumber;
        basis: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        value: number;
        basis: string;
    }, {
        value: number;
        basis: string;
    }>;
    /** Minutes not spent, vs the re-prompt cycle a false green costs. */
    minutes: z.ZodObject<{
        value: z.ZodNumber;
        basis: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        value: number;
        basis: string;
    }, {
        value: number;
        basis: string;
    }>;
}, "strip", z.ZodTypeAny, {
    tokens: {
        value: number;
        basis: string;
    };
    minutes: {
        value: number;
        basis: string;
    };
}, {
    tokens: {
        value: number;
        basis: string;
    };
    minutes: {
        value: number;
        basis: string;
    };
}>;
export type ImpactSavings = z.infer<typeof ImpactSavingsSchema>;
/**
 * How many recent defects a scope remembers.
 *
 * Small on purpose. `counts.failed` already says HOW MANY defects there have been; this list exists
 * so the HUD can say WHICH ONES, and a panel in the corner of somebody's app is not a triage queue.
 * Ten is enough to recognise what is currently broken and short enough that the record stays a
 * counters file rather than becoming a log.
 */
export declare const IMPACT_DEFECT_LIMIT = 10;
/**
 * One defect, as the HUD shows it.
 *
 * Recorded at the moment a verdict comes back verified:"no" - so it is a thing that actually failed
 * a declared consequence, never a heuristic read of the page afterwards.
 */
export declare const ImpactDefectSchema: z.ZodObject<{
    /** When it was caught (epoch ms). */
    at: z.ZodNumber;
    /** One line naming what failed, in the words the verdict used. */
    title: z.ZodString;
    /** Why it failed, when the verdict said. */
    detail: z.ZodOptional<z.ZodString>;
    /** `file:line` of the element that was acted on, so the reader can go straight there. */
    source: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    at: number;
    title: string;
    source?: string | undefined;
    detail?: string | undefined;
}, {
    at: number;
    title: string;
    source?: string | undefined;
    detail?: string | undefined;
}>;
export type ImpactDefect = z.infer<typeof ImpactDefectSchema>;
/** One scope of the record: this project, or everything on this machine. */
export declare const ImpactScopeSchema: z.ZodObject<{
    counts: z.ZodObject<{
        /** Session-bound tool calls that reached a handler. */
        calls: z.ZodNumber;
        /** Calls that produced a verdict (act_and_wait / assert). */
        verdicts: z.ZodNumber;
        /** Verdicts that came back verified:"yes". */
        passed: z.ZodNumber;
        /** Verdicts that came back verified:"no" - a defect the agent would otherwise have called done. */
        failed: z.ZodNumber;
        /** Verdicts Reticle could not decide. Shown, not hidden: an unknown is not a pass. */
        unknown: z.ZodNumber;
        /** Refusals - a drive Reticle declined rather than faking. */
        refusals: z.ZodNumber;
        /** Notes a human pinned to the page. */
        marks: z.ZodNumber;
        /** Distinct sessions seen. */
        sessions: z.ZodNumber;
        /** Tokens Reticle returned to the agent (estimated per call at ~4 chars/token, then summed). */
        tokensReturned: z.ZodNumber;
        /** Wall-clock milliseconds spent inside tool calls. */
        drivingMs: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        sessions: number;
        unknown: number;
        passed: number;
        failed: number;
        calls: number;
        verdicts: number;
        refusals: number;
        marks: number;
        tokensReturned: number;
        drivingMs: number;
    }, {
        sessions: number;
        unknown: number;
        passed: number;
        failed: number;
        calls: number;
        verdicts: number;
        refusals: number;
        marks: number;
        tokensReturned: number;
        drivingMs: number;
    }>;
    days: z.ZodArray<z.ZodObject<{
        /** YYYY-MM-DD, local to the machine that recorded it. */
        date: z.ZodString;
        counts: z.ZodObject<{
            /** Session-bound tool calls that reached a handler. */
            calls: z.ZodNumber;
            /** Calls that produced a verdict (act_and_wait / assert). */
            verdicts: z.ZodNumber;
            /** Verdicts that came back verified:"yes". */
            passed: z.ZodNumber;
            /** Verdicts that came back verified:"no" - a defect the agent would otherwise have called done. */
            failed: z.ZodNumber;
            /** Verdicts Reticle could not decide. Shown, not hidden: an unknown is not a pass. */
            unknown: z.ZodNumber;
            /** Refusals - a drive Reticle declined rather than faking. */
            refusals: z.ZodNumber;
            /** Notes a human pinned to the page. */
            marks: z.ZodNumber;
            /** Distinct sessions seen. */
            sessions: z.ZodNumber;
            /** Tokens Reticle returned to the agent (estimated per call at ~4 chars/token, then summed). */
            tokensReturned: z.ZodNumber;
            /** Wall-clock milliseconds spent inside tool calls. */
            drivingMs: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            sessions: number;
            unknown: number;
            passed: number;
            failed: number;
            calls: number;
            verdicts: number;
            refusals: number;
            marks: number;
            tokensReturned: number;
            drivingMs: number;
        }, {
            sessions: number;
            unknown: number;
            passed: number;
            failed: number;
            calls: number;
            verdicts: number;
            refusals: number;
            marks: number;
            tokensReturned: number;
            drivingMs: number;
        }>;
    }, "strip", z.ZodTypeAny, {
        date: string;
        counts: {
            sessions: number;
            unknown: number;
            passed: number;
            failed: number;
            calls: number;
            verdicts: number;
            refusals: number;
            marks: number;
            tokensReturned: number;
            drivingMs: number;
        };
    }, {
        date: string;
        counts: {
            sessions: number;
            unknown: number;
            passed: number;
            failed: number;
            calls: number;
            verdicts: number;
            refusals: number;
            marks: number;
            tokensReturned: number;
            drivingMs: number;
        };
    }>, "many">;
    records: z.ZodObject<{
        /** Longest single session, in ms. */
        longestRunMs: z.ZodNumber;
        /** Most verdicts in one day. */
        bestVerdictDay: z.ZodNumber;
        /** Most defects caught in one day. */
        bestDefectDay: z.ZodNumber;
        /** Consecutive days with at least one verdict, up to and including today. */
        streakDays: z.ZodNumber;
        /** Longest such streak ever. */
        bestStreakDays: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        longestRunMs: number;
        bestVerdictDay: number;
        bestDefectDay: number;
        streakDays: number;
        bestStreakDays: number;
    }, {
        longestRunMs: number;
        bestVerdictDay: number;
        bestDefectDay: number;
        streakDays: number;
        bestStreakDays: number;
    }>;
    savings: z.ZodObject<{
        /** Tokens not spent, vs looking at the app the way an agent without Reticle has to. */
        tokens: z.ZodObject<{
            value: z.ZodNumber;
            basis: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            value: number;
            basis: string;
        }, {
            value: number;
            basis: string;
        }>;
        /** Minutes not spent, vs the re-prompt cycle a false green costs. */
        minutes: z.ZodObject<{
            value: z.ZodNumber;
            basis: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            value: number;
            basis: string;
        }, {
            value: number;
            basis: string;
        }>;
    }, "strip", z.ZodTypeAny, {
        tokens: {
            value: number;
            basis: string;
        };
        minutes: {
            value: number;
            basis: string;
        };
    }, {
        tokens: {
            value: number;
            basis: string;
        };
        minutes: {
            value: number;
            basis: string;
        };
    }>;
    /** When this scope first recorded anything (epoch ms). */
    since: z.ZodNumber;
    /**
     * The most recent defects, newest first. Defaulted rather than required: a record written by an
     * older build has no such field, and a counters file that fails to parse loses the whole history.
     */
    defects: z.ZodDefault<z.ZodArray<z.ZodObject<{
        /** When it was caught (epoch ms). */
        at: z.ZodNumber;
        /** One line naming what failed, in the words the verdict used. */
        title: z.ZodString;
        /** Why it failed, when the verdict said. */
        detail: z.ZodOptional<z.ZodString>;
        /** `file:line` of the element that was acted on, so the reader can go straight there. */
        source: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        at: number;
        title: string;
        source?: string | undefined;
        detail?: string | undefined;
    }, {
        at: number;
        title: string;
        source?: string | undefined;
        detail?: string | undefined;
    }>, "many">>;
}, "strip", z.ZodTypeAny, {
    since: number;
    counts: {
        sessions: number;
        unknown: number;
        passed: number;
        failed: number;
        calls: number;
        verdicts: number;
        refusals: number;
        marks: number;
        tokensReturned: number;
        drivingMs: number;
    };
    days: {
        date: string;
        counts: {
            sessions: number;
            unknown: number;
            passed: number;
            failed: number;
            calls: number;
            verdicts: number;
            refusals: number;
            marks: number;
            tokensReturned: number;
            drivingMs: number;
        };
    }[];
    records: {
        longestRunMs: number;
        bestVerdictDay: number;
        bestDefectDay: number;
        streakDays: number;
        bestStreakDays: number;
    };
    savings: {
        tokens: {
            value: number;
            basis: string;
        };
        minutes: {
            value: number;
            basis: string;
        };
    };
    defects: {
        at: number;
        title: string;
        source?: string | undefined;
        detail?: string | undefined;
    }[];
}, {
    since: number;
    counts: {
        sessions: number;
        unknown: number;
        passed: number;
        failed: number;
        calls: number;
        verdicts: number;
        refusals: number;
        marks: number;
        tokensReturned: number;
        drivingMs: number;
    };
    days: {
        date: string;
        counts: {
            sessions: number;
            unknown: number;
            passed: number;
            failed: number;
            calls: number;
            verdicts: number;
            refusals: number;
            marks: number;
            tokensReturned: number;
            drivingMs: number;
        };
    }[];
    records: {
        longestRunMs: number;
        bestVerdictDay: number;
        bestDefectDay: number;
        streakDays: number;
        bestStreakDays: number;
    };
    savings: {
        tokens: {
            value: number;
            basis: string;
        };
        minutes: {
            value: number;
            basis: string;
        };
    };
    defects?: {
        at: number;
        title: string;
        source?: string | undefined;
        detail?: string | undefined;
    }[] | undefined;
}>;
export type ImpactScope = z.infer<typeof ImpactScopeSchema>;
/** What the HUD receives: this project, and the machine-wide total. */
/**
 * Whether this machine is signed in to a Reticle workspace, as the HUD is allowed to know it.
 *
 * Deliberately small, because it is pushed to a BROWSER: a token here would be a token in the DOM of
 * the user's own app, readable by anything else running on it. There is no field for one and the
 * reader is tested for never emitting one.
 *
 * `org`, `email` and `host` are present only when signed in. `host` matters because a self-hosted
 * install is not app.reticle.sh, and telling that user to visit a host they do not use is worse than
 * silence.
 *
 * `email` IS personal data, and it is here because a capsule that cannot name who you are does not
 * answer the question it exists to answer -- an org name is shared by a whole team. It is rendered
 * only inside the account menu, never in the always-visible capsule, so it reaches the DOM on the
 * same terms as the org name and no sooner. It stays OPTIONAL because no cloud sends it yet: the
 * device flow returns `{ status, token, org }` and the session file stores `{ url, token, orgName }`,
 * so today every reader takes the absent branch.
 */
export declare const AccountStateSchema: z.ZodObject<{
    signedIn: z.ZodBoolean;
    org: z.ZodOptional<z.ZodString>;
    email: z.ZodOptional<z.ZodString>;
    host: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    signedIn: boolean;
    email?: string | undefined;
    org?: string | undefined;
    host?: string | undefined;
}, {
    signedIn: boolean;
    email?: string | undefined;
    org?: string | undefined;
    host?: string | undefined;
}>;
export type AccountState = z.infer<typeof AccountStateSchema>;
/** The grant Harness credits came from: sign-up, the card-started trial, or a paid plan. */
export declare const CreditKind: {
    readonly FREE: "free";
    readonly TRIAL: "trial";
    readonly PAID: "paid";
};
export type CreditKind = (typeof CreditKind)[keyof typeof CreditKind];
/**
 * What the platform says about autonomous driving for this project.
 *
 * Mirrors `PlatformModelConfig` on the server side; both are the same wire answer read by different
 * layers. Kept here because it crosses daemon -> browser, which is what makes it a wire type.
 */
export declare const HarnessConfigSchema: z.ZodObject<{
    provider: z.ZodString;
    /** The switch somebody set. Off for a new project: the Harness is opt-in. */
    harnessEnabled: z.ZodBoolean;
    /** Whether this workspace may drive on OUR model spend. Never folded into the switch. */
    harnessEntitled: z.ZodBoolean;
    /** Whether the selected provider has a usable platform key. Older daemons may omit it. */
    providerReady: z.ZodOptional<z.ZodBoolean>;
    /** Harness credits used and held this 30 days; one is one Harness decision. Absent: unbounded or unknown. */
    credits: z.ZodOptional<z.ZodObject<{
        used: z.ZodNumber;
        limit: z.ZodNumber;
        /** The grant they came from. Optional on the wire: an older platform omits it. */
        kind: z.ZodOptional<z.ZodEnum<["free", "trial", "paid"]>>;
        /** Whole days the grant has left, counted by the daemon from the platform's end date. */
        daysLeft: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        used: number;
        limit: number;
        kind?: "free" | "trial" | "paid" | undefined;
        daysLeft?: number | undefined;
    }, {
        used: number;
        limit: number;
        kind?: "free" | "trial" | "paid" | undefined;
        daysLeft?: number | undefined;
    }>>;
    /** The platform this answer came from, so the HUD's links go there and not to the hosted one. */
    platformUrl: z.ZodOptional<z.ZodString>;
    /**
     * The platform's own Harness coverage gate, which it enforces. The HUD prefers it to the daemon's
     * local score; absent from an older platform, which leaves the local score to decide.
     */
    gate: z.ZodOptional<z.ZodObject<{
        unlocked: z.ZodBoolean;
        /** floor(score × 100); absent before any app reported. */
        percent: z.ZodOptional<z.ZodNumber>;
        reason: z.ZodOptional<z.ZodString>;
        prompt: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        unlocked: boolean;
        reason?: string | undefined;
        percent?: number | undefined;
        prompt?: string | undefined;
    }, {
        unlocked: boolean;
        reason?: string | undefined;
        percent?: number | undefined;
        prompt?: string | undefined;
    }>>;
    /** The plan in force: which grant, trial days left, seats. Absent from a platform that sent none. */
    plan: z.ZodOptional<z.ZodObject<{
        kind: z.ZodEnum<["free", "trial", "paid"]>;
        daysLeft: z.ZodOptional<z.ZodNumber>;
        seats: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        kind: "free" | "trial" | "paid";
        daysLeft?: number | undefined;
        seats?: number | undefined;
    }, {
        kind: "free" | "trial" | "paid";
        daysLeft?: number | undefined;
        seats?: number | undefined;
    }>>;
    /** Harness runs the platform holds for this project. Absent: the platform did not say. */
    harnessRuns: z.ZodOptional<z.ZodNumber>;
    /** Memory entries the platform holds for this project. Absent: the platform did not say. */
    memoryEntries: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    provider: string;
    harnessEnabled: boolean;
    harnessEntitled: boolean;
    plan?: {
        kind: "free" | "trial" | "paid";
        daysLeft?: number | undefined;
        seats?: number | undefined;
    } | undefined;
    providerReady?: boolean | undefined;
    credits?: {
        used: number;
        limit: number;
        kind?: "free" | "trial" | "paid" | undefined;
        daysLeft?: number | undefined;
    } | undefined;
    platformUrl?: string | undefined;
    gate?: {
        unlocked: boolean;
        reason?: string | undefined;
        percent?: number | undefined;
        prompt?: string | undefined;
    } | undefined;
    harnessRuns?: number | undefined;
    memoryEntries?: number | undefined;
}, {
    provider: string;
    harnessEnabled: boolean;
    harnessEntitled: boolean;
    plan?: {
        kind: "free" | "trial" | "paid";
        daysLeft?: number | undefined;
        seats?: number | undefined;
    } | undefined;
    providerReady?: boolean | undefined;
    credits?: {
        used: number;
        limit: number;
        kind?: "free" | "trial" | "paid" | undefined;
        daysLeft?: number | undefined;
    } | undefined;
    platformUrl?: string | undefined;
    gate?: {
        unlocked: boolean;
        reason?: string | undefined;
        percent?: number | undefined;
        prompt?: string | undefined;
    } | undefined;
    harnessRuns?: number | undefined;
    memoryEntries?: number | undefined;
}>;
export type HarnessConfig = z.infer<typeof HarnessConfigSchema>;
/** The Harness drive running in this tab's project, so the panel can show progress and Stop. */
export declare const HarnessDriveSchema: z.ZodObject<{
    runId: z.ZodString;
    steps: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    steps: number;
    runId: string;
}, {
    steps: number;
    runId: string;
}>;
export type HarnessDrive = z.infer<typeof HarnessDriveSchema>;
/** The longest note a person can send their coding agent from the HUD. */
export declare const AGENT_NOTE_MAX = 500;
/** How many of a tab's latest notes the HUD shows. */
export declare const AGENT_NOTES_SHOWN = 5;
/** A note sent to the coding agent from this tab. `seen` only once an agent's tool call took it. */
export declare const AgentNoteSchema: z.ZodObject<{
    text: z.ZodString;
    seen: z.ZodBoolean;
    /** Which agent took it, when the daemon knows. */
    by: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    text: string;
    seen: boolean;
    by?: string | undefined;
}, {
    text: string;
    seen: boolean;
    by?: string | undefined;
}>;
export type AgentNote = z.infer<typeof AgentNoteSchema>;
/** The coding agents attached to the daemon now (friendly names), and this tab's latest notes. */
export declare const AgentLinkSchema: z.ZodObject<{
    agents: z.ZodArray<z.ZodString, "many">;
    notes: z.ZodArray<z.ZodObject<{
        text: z.ZodString;
        seen: z.ZodBoolean;
        /** Which agent took it, when the daemon knows. */
        by: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        text: string;
        seen: boolean;
        by?: string | undefined;
    }, {
        text: string;
        seen: boolean;
        by?: string | undefined;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    notes: {
        text: string;
        seen: boolean;
        by?: string | undefined;
    }[];
    agents: string[];
}, {
    notes: {
        text: string;
        seen: boolean;
        by?: string | undefined;
    }[];
    agents: string[];
}>;
export type AgentLink = z.infer<typeof AgentLinkSchema>;
export declare const ImpactSnapshotSchema: z.ZodObject<{
    schemaVersion: z.ZodNumber;
    project: z.ZodObject<{
        counts: z.ZodObject<{
            /** Session-bound tool calls that reached a handler. */
            calls: z.ZodNumber;
            /** Calls that produced a verdict (act_and_wait / assert). */
            verdicts: z.ZodNumber;
            /** Verdicts that came back verified:"yes". */
            passed: z.ZodNumber;
            /** Verdicts that came back verified:"no" - a defect the agent would otherwise have called done. */
            failed: z.ZodNumber;
            /** Verdicts Reticle could not decide. Shown, not hidden: an unknown is not a pass. */
            unknown: z.ZodNumber;
            /** Refusals - a drive Reticle declined rather than faking. */
            refusals: z.ZodNumber;
            /** Notes a human pinned to the page. */
            marks: z.ZodNumber;
            /** Distinct sessions seen. */
            sessions: z.ZodNumber;
            /** Tokens Reticle returned to the agent (estimated per call at ~4 chars/token, then summed). */
            tokensReturned: z.ZodNumber;
            /** Wall-clock milliseconds spent inside tool calls. */
            drivingMs: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            sessions: number;
            unknown: number;
            passed: number;
            failed: number;
            calls: number;
            verdicts: number;
            refusals: number;
            marks: number;
            tokensReturned: number;
            drivingMs: number;
        }, {
            sessions: number;
            unknown: number;
            passed: number;
            failed: number;
            calls: number;
            verdicts: number;
            refusals: number;
            marks: number;
            tokensReturned: number;
            drivingMs: number;
        }>;
        days: z.ZodArray<z.ZodObject<{
            /** YYYY-MM-DD, local to the machine that recorded it. */
            date: z.ZodString;
            counts: z.ZodObject<{
                /** Session-bound tool calls that reached a handler. */
                calls: z.ZodNumber;
                /** Calls that produced a verdict (act_and_wait / assert). */
                verdicts: z.ZodNumber;
                /** Verdicts that came back verified:"yes". */
                passed: z.ZodNumber;
                /** Verdicts that came back verified:"no" - a defect the agent would otherwise have called done. */
                failed: z.ZodNumber;
                /** Verdicts Reticle could not decide. Shown, not hidden: an unknown is not a pass. */
                unknown: z.ZodNumber;
                /** Refusals - a drive Reticle declined rather than faking. */
                refusals: z.ZodNumber;
                /** Notes a human pinned to the page. */
                marks: z.ZodNumber;
                /** Distinct sessions seen. */
                sessions: z.ZodNumber;
                /** Tokens Reticle returned to the agent (estimated per call at ~4 chars/token, then summed). */
                tokensReturned: z.ZodNumber;
                /** Wall-clock milliseconds spent inside tool calls. */
                drivingMs: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                sessions: number;
                unknown: number;
                passed: number;
                failed: number;
                calls: number;
                verdicts: number;
                refusals: number;
                marks: number;
                tokensReturned: number;
                drivingMs: number;
            }, {
                sessions: number;
                unknown: number;
                passed: number;
                failed: number;
                calls: number;
                verdicts: number;
                refusals: number;
                marks: number;
                tokensReturned: number;
                drivingMs: number;
            }>;
        }, "strip", z.ZodTypeAny, {
            date: string;
            counts: {
                sessions: number;
                unknown: number;
                passed: number;
                failed: number;
                calls: number;
                verdicts: number;
                refusals: number;
                marks: number;
                tokensReturned: number;
                drivingMs: number;
            };
        }, {
            date: string;
            counts: {
                sessions: number;
                unknown: number;
                passed: number;
                failed: number;
                calls: number;
                verdicts: number;
                refusals: number;
                marks: number;
                tokensReturned: number;
                drivingMs: number;
            };
        }>, "many">;
        records: z.ZodObject<{
            /** Longest single session, in ms. */
            longestRunMs: z.ZodNumber;
            /** Most verdicts in one day. */
            bestVerdictDay: z.ZodNumber;
            /** Most defects caught in one day. */
            bestDefectDay: z.ZodNumber;
            /** Consecutive days with at least one verdict, up to and including today. */
            streakDays: z.ZodNumber;
            /** Longest such streak ever. */
            bestStreakDays: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            longestRunMs: number;
            bestVerdictDay: number;
            bestDefectDay: number;
            streakDays: number;
            bestStreakDays: number;
        }, {
            longestRunMs: number;
            bestVerdictDay: number;
            bestDefectDay: number;
            streakDays: number;
            bestStreakDays: number;
        }>;
        savings: z.ZodObject<{
            /** Tokens not spent, vs looking at the app the way an agent without Reticle has to. */
            tokens: z.ZodObject<{
                value: z.ZodNumber;
                basis: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                value: number;
                basis: string;
            }, {
                value: number;
                basis: string;
            }>;
            /** Minutes not spent, vs the re-prompt cycle a false green costs. */
            minutes: z.ZodObject<{
                value: z.ZodNumber;
                basis: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                value: number;
                basis: string;
            }, {
                value: number;
                basis: string;
            }>;
        }, "strip", z.ZodTypeAny, {
            tokens: {
                value: number;
                basis: string;
            };
            minutes: {
                value: number;
                basis: string;
            };
        }, {
            tokens: {
                value: number;
                basis: string;
            };
            minutes: {
                value: number;
                basis: string;
            };
        }>;
        /** When this scope first recorded anything (epoch ms). */
        since: z.ZodNumber;
        /**
         * The most recent defects, newest first. Defaulted rather than required: a record written by an
         * older build has no such field, and a counters file that fails to parse loses the whole history.
         */
        defects: z.ZodDefault<z.ZodArray<z.ZodObject<{
            /** When it was caught (epoch ms). */
            at: z.ZodNumber;
            /** One line naming what failed, in the words the verdict used. */
            title: z.ZodString;
            /** Why it failed, when the verdict said. */
            detail: z.ZodOptional<z.ZodString>;
            /** `file:line` of the element that was acted on, so the reader can go straight there. */
            source: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            at: number;
            title: string;
            source?: string | undefined;
            detail?: string | undefined;
        }, {
            at: number;
            title: string;
            source?: string | undefined;
            detail?: string | undefined;
        }>, "many">>;
    }, "strip", z.ZodTypeAny, {
        since: number;
        counts: {
            sessions: number;
            unknown: number;
            passed: number;
            failed: number;
            calls: number;
            verdicts: number;
            refusals: number;
            marks: number;
            tokensReturned: number;
            drivingMs: number;
        };
        days: {
            date: string;
            counts: {
                sessions: number;
                unknown: number;
                passed: number;
                failed: number;
                calls: number;
                verdicts: number;
                refusals: number;
                marks: number;
                tokensReturned: number;
                drivingMs: number;
            };
        }[];
        records: {
            longestRunMs: number;
            bestVerdictDay: number;
            bestDefectDay: number;
            streakDays: number;
            bestStreakDays: number;
        };
        savings: {
            tokens: {
                value: number;
                basis: string;
            };
            minutes: {
                value: number;
                basis: string;
            };
        };
        defects: {
            at: number;
            title: string;
            source?: string | undefined;
            detail?: string | undefined;
        }[];
    }, {
        since: number;
        counts: {
            sessions: number;
            unknown: number;
            passed: number;
            failed: number;
            calls: number;
            verdicts: number;
            refusals: number;
            marks: number;
            tokensReturned: number;
            drivingMs: number;
        };
        days: {
            date: string;
            counts: {
                sessions: number;
                unknown: number;
                passed: number;
                failed: number;
                calls: number;
                verdicts: number;
                refusals: number;
                marks: number;
                tokensReturned: number;
                drivingMs: number;
            };
        }[];
        records: {
            longestRunMs: number;
            bestVerdictDay: number;
            bestDefectDay: number;
            streakDays: number;
            bestStreakDays: number;
        };
        savings: {
            tokens: {
                value: number;
                basis: string;
            };
            minutes: {
                value: number;
                basis: string;
            };
        };
        defects?: {
            at: number;
            title: string;
            source?: string | undefined;
            detail?: string | undefined;
        }[] | undefined;
    }>;
    global: z.ZodObject<{
        counts: z.ZodObject<{
            /** Session-bound tool calls that reached a handler. */
            calls: z.ZodNumber;
            /** Calls that produced a verdict (act_and_wait / assert). */
            verdicts: z.ZodNumber;
            /** Verdicts that came back verified:"yes". */
            passed: z.ZodNumber;
            /** Verdicts that came back verified:"no" - a defect the agent would otherwise have called done. */
            failed: z.ZodNumber;
            /** Verdicts Reticle could not decide. Shown, not hidden: an unknown is not a pass. */
            unknown: z.ZodNumber;
            /** Refusals - a drive Reticle declined rather than faking. */
            refusals: z.ZodNumber;
            /** Notes a human pinned to the page. */
            marks: z.ZodNumber;
            /** Distinct sessions seen. */
            sessions: z.ZodNumber;
            /** Tokens Reticle returned to the agent (estimated per call at ~4 chars/token, then summed). */
            tokensReturned: z.ZodNumber;
            /** Wall-clock milliseconds spent inside tool calls. */
            drivingMs: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            sessions: number;
            unknown: number;
            passed: number;
            failed: number;
            calls: number;
            verdicts: number;
            refusals: number;
            marks: number;
            tokensReturned: number;
            drivingMs: number;
        }, {
            sessions: number;
            unknown: number;
            passed: number;
            failed: number;
            calls: number;
            verdicts: number;
            refusals: number;
            marks: number;
            tokensReturned: number;
            drivingMs: number;
        }>;
        days: z.ZodArray<z.ZodObject<{
            /** YYYY-MM-DD, local to the machine that recorded it. */
            date: z.ZodString;
            counts: z.ZodObject<{
                /** Session-bound tool calls that reached a handler. */
                calls: z.ZodNumber;
                /** Calls that produced a verdict (act_and_wait / assert). */
                verdicts: z.ZodNumber;
                /** Verdicts that came back verified:"yes". */
                passed: z.ZodNumber;
                /** Verdicts that came back verified:"no" - a defect the agent would otherwise have called done. */
                failed: z.ZodNumber;
                /** Verdicts Reticle could not decide. Shown, not hidden: an unknown is not a pass. */
                unknown: z.ZodNumber;
                /** Refusals - a drive Reticle declined rather than faking. */
                refusals: z.ZodNumber;
                /** Notes a human pinned to the page. */
                marks: z.ZodNumber;
                /** Distinct sessions seen. */
                sessions: z.ZodNumber;
                /** Tokens Reticle returned to the agent (estimated per call at ~4 chars/token, then summed). */
                tokensReturned: z.ZodNumber;
                /** Wall-clock milliseconds spent inside tool calls. */
                drivingMs: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                sessions: number;
                unknown: number;
                passed: number;
                failed: number;
                calls: number;
                verdicts: number;
                refusals: number;
                marks: number;
                tokensReturned: number;
                drivingMs: number;
            }, {
                sessions: number;
                unknown: number;
                passed: number;
                failed: number;
                calls: number;
                verdicts: number;
                refusals: number;
                marks: number;
                tokensReturned: number;
                drivingMs: number;
            }>;
        }, "strip", z.ZodTypeAny, {
            date: string;
            counts: {
                sessions: number;
                unknown: number;
                passed: number;
                failed: number;
                calls: number;
                verdicts: number;
                refusals: number;
                marks: number;
                tokensReturned: number;
                drivingMs: number;
            };
        }, {
            date: string;
            counts: {
                sessions: number;
                unknown: number;
                passed: number;
                failed: number;
                calls: number;
                verdicts: number;
                refusals: number;
                marks: number;
                tokensReturned: number;
                drivingMs: number;
            };
        }>, "many">;
        records: z.ZodObject<{
            /** Longest single session, in ms. */
            longestRunMs: z.ZodNumber;
            /** Most verdicts in one day. */
            bestVerdictDay: z.ZodNumber;
            /** Most defects caught in one day. */
            bestDefectDay: z.ZodNumber;
            /** Consecutive days with at least one verdict, up to and including today. */
            streakDays: z.ZodNumber;
            /** Longest such streak ever. */
            bestStreakDays: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            longestRunMs: number;
            bestVerdictDay: number;
            bestDefectDay: number;
            streakDays: number;
            bestStreakDays: number;
        }, {
            longestRunMs: number;
            bestVerdictDay: number;
            bestDefectDay: number;
            streakDays: number;
            bestStreakDays: number;
        }>;
        savings: z.ZodObject<{
            /** Tokens not spent, vs looking at the app the way an agent without Reticle has to. */
            tokens: z.ZodObject<{
                value: z.ZodNumber;
                basis: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                value: number;
                basis: string;
            }, {
                value: number;
                basis: string;
            }>;
            /** Minutes not spent, vs the re-prompt cycle a false green costs. */
            minutes: z.ZodObject<{
                value: z.ZodNumber;
                basis: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                value: number;
                basis: string;
            }, {
                value: number;
                basis: string;
            }>;
        }, "strip", z.ZodTypeAny, {
            tokens: {
                value: number;
                basis: string;
            };
            minutes: {
                value: number;
                basis: string;
            };
        }, {
            tokens: {
                value: number;
                basis: string;
            };
            minutes: {
                value: number;
                basis: string;
            };
        }>;
        /** When this scope first recorded anything (epoch ms). */
        since: z.ZodNumber;
        /**
         * The most recent defects, newest first. Defaulted rather than required: a record written by an
         * older build has no such field, and a counters file that fails to parse loses the whole history.
         */
        defects: z.ZodDefault<z.ZodArray<z.ZodObject<{
            /** When it was caught (epoch ms). */
            at: z.ZodNumber;
            /** One line naming what failed, in the words the verdict used. */
            title: z.ZodString;
            /** Why it failed, when the verdict said. */
            detail: z.ZodOptional<z.ZodString>;
            /** `file:line` of the element that was acted on, so the reader can go straight there. */
            source: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            at: number;
            title: string;
            source?: string | undefined;
            detail?: string | undefined;
        }, {
            at: number;
            title: string;
            source?: string | undefined;
            detail?: string | undefined;
        }>, "many">>;
    }, "strip", z.ZodTypeAny, {
        since: number;
        counts: {
            sessions: number;
            unknown: number;
            passed: number;
            failed: number;
            calls: number;
            verdicts: number;
            refusals: number;
            marks: number;
            tokensReturned: number;
            drivingMs: number;
        };
        days: {
            date: string;
            counts: {
                sessions: number;
                unknown: number;
                passed: number;
                failed: number;
                calls: number;
                verdicts: number;
                refusals: number;
                marks: number;
                tokensReturned: number;
                drivingMs: number;
            };
        }[];
        records: {
            longestRunMs: number;
            bestVerdictDay: number;
            bestDefectDay: number;
            streakDays: number;
            bestStreakDays: number;
        };
        savings: {
            tokens: {
                value: number;
                basis: string;
            };
            minutes: {
                value: number;
                basis: string;
            };
        };
        defects: {
            at: number;
            title: string;
            source?: string | undefined;
            detail?: string | undefined;
        }[];
    }, {
        since: number;
        counts: {
            sessions: number;
            unknown: number;
            passed: number;
            failed: number;
            calls: number;
            verdicts: number;
            refusals: number;
            marks: number;
            tokensReturned: number;
            drivingMs: number;
        };
        days: {
            date: string;
            counts: {
                sessions: number;
                unknown: number;
                passed: number;
                failed: number;
                calls: number;
                verdicts: number;
                refusals: number;
                marks: number;
                tokensReturned: number;
                drivingMs: number;
            };
        }[];
        records: {
            longestRunMs: number;
            bestVerdictDay: number;
            bestDefectDay: number;
            streakDays: number;
            bestStreakDays: number;
        };
        savings: {
            tokens: {
                value: number;
                basis: string;
            };
            minutes: {
                value: number;
                basis: string;
            };
        };
        defects?: {
            at: number;
            title: string;
            source?: string | undefined;
            detail?: string | undefined;
        }[] | undefined;
    }>;
    /** Project name, for the report's title row. */
    projectName: z.ZodOptional<z.ZodString>;
    /**
     * Where the full, triageable list of these defects lives - present only when this project is
     * linked to a Reticle Cloud workspace. Absent is the normal case and the HUD simply shows its
     * short list without a link: the free tool is complete on its own.
     */
    dashboardUrl: z.ZodOptional<z.ZodString>;
    /**
     * Whether this machine is signed in. Absent on an SDK/daemon pair too old to send it, which the
     * HUD must read as "unknown", never as "signed out" — prompting a signed-in user to sign in is the
     * kind of nag that gets a dev-only HUD switched off for good.
     */
    account: z.ZodOptional<z.ZodObject<{
        signedIn: z.ZodBoolean;
        org: z.ZodOptional<z.ZodString>;
        email: z.ZodOptional<z.ZodString>;
        host: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        signedIn: boolean;
        email?: string | undefined;
        org?: string | undefined;
        host?: string | undefined;
    }, {
        signedIn: boolean;
        email?: string | undefined;
        org?: string | undefined;
        host?: string | undefined;
    }>>;
    /**
     * The harness switch and whether this workspace may drive on our spend.
     *
     * Two fields, never one, and the HUD renders them differently: `harnessEnabled` is a switch the
     * person owns, `harnessEntitled` is a fact about their account. A panel that collapsed them would
     * show "off" to somebody whose free months lapsed and invite them to turn on something they no
     * longer have.
     *
     * Absent means the daemon has not heard -- an offline machine, an unlinked project, an older
     * platform -- and the panel shows no control at all rather than guessing. Showing a switch that
     * cannot be honoured is worse than showing none.
     */
    harnessConfig: z.ZodOptional<z.ZodObject<{
        provider: z.ZodString;
        /** The switch somebody set. Off for a new project: the Harness is opt-in. */
        harnessEnabled: z.ZodBoolean;
        /** Whether this workspace may drive on OUR model spend. Never folded into the switch. */
        harnessEntitled: z.ZodBoolean;
        /** Whether the selected provider has a usable platform key. Older daemons may omit it. */
        providerReady: z.ZodOptional<z.ZodBoolean>;
        /** Harness credits used and held this 30 days; one is one Harness decision. Absent: unbounded or unknown. */
        credits: z.ZodOptional<z.ZodObject<{
            used: z.ZodNumber;
            limit: z.ZodNumber;
            /** The grant they came from. Optional on the wire: an older platform omits it. */
            kind: z.ZodOptional<z.ZodEnum<["free", "trial", "paid"]>>;
            /** Whole days the grant has left, counted by the daemon from the platform's end date. */
            daysLeft: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            used: number;
            limit: number;
            kind?: "free" | "trial" | "paid" | undefined;
            daysLeft?: number | undefined;
        }, {
            used: number;
            limit: number;
            kind?: "free" | "trial" | "paid" | undefined;
            daysLeft?: number | undefined;
        }>>;
        /** The platform this answer came from, so the HUD's links go there and not to the hosted one. */
        platformUrl: z.ZodOptional<z.ZodString>;
        /**
         * The platform's own Harness coverage gate, which it enforces. The HUD prefers it to the daemon's
         * local score; absent from an older platform, which leaves the local score to decide.
         */
        gate: z.ZodOptional<z.ZodObject<{
            unlocked: z.ZodBoolean;
            /** floor(score × 100); absent before any app reported. */
            percent: z.ZodOptional<z.ZodNumber>;
            reason: z.ZodOptional<z.ZodString>;
            prompt: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            unlocked: boolean;
            reason?: string | undefined;
            percent?: number | undefined;
            prompt?: string | undefined;
        }, {
            unlocked: boolean;
            reason?: string | undefined;
            percent?: number | undefined;
            prompt?: string | undefined;
        }>>;
        /** The plan in force: which grant, trial days left, seats. Absent from a platform that sent none. */
        plan: z.ZodOptional<z.ZodObject<{
            kind: z.ZodEnum<["free", "trial", "paid"]>;
            daysLeft: z.ZodOptional<z.ZodNumber>;
            seats: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            kind: "free" | "trial" | "paid";
            daysLeft?: number | undefined;
            seats?: number | undefined;
        }, {
            kind: "free" | "trial" | "paid";
            daysLeft?: number | undefined;
            seats?: number | undefined;
        }>>;
        /** Harness runs the platform holds for this project. Absent: the platform did not say. */
        harnessRuns: z.ZodOptional<z.ZodNumber>;
        /** Memory entries the platform holds for this project. Absent: the platform did not say. */
        memoryEntries: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        provider: string;
        harnessEnabled: boolean;
        harnessEntitled: boolean;
        plan?: {
            kind: "free" | "trial" | "paid";
            daysLeft?: number | undefined;
            seats?: number | undefined;
        } | undefined;
        providerReady?: boolean | undefined;
        credits?: {
            used: number;
            limit: number;
            kind?: "free" | "trial" | "paid" | undefined;
            daysLeft?: number | undefined;
        } | undefined;
        platformUrl?: string | undefined;
        gate?: {
            unlocked: boolean;
            reason?: string | undefined;
            percent?: number | undefined;
            prompt?: string | undefined;
        } | undefined;
        harnessRuns?: number | undefined;
        memoryEntries?: number | undefined;
    }, {
        provider: string;
        harnessEnabled: boolean;
        harnessEntitled: boolean;
        plan?: {
            kind: "free" | "trial" | "paid";
            daysLeft?: number | undefined;
            seats?: number | undefined;
        } | undefined;
        providerReady?: boolean | undefined;
        credits?: {
            used: number;
            limit: number;
            kind?: "free" | "trial" | "paid" | undefined;
            daysLeft?: number | undefined;
        } | undefined;
        platformUrl?: string | undefined;
        gate?: {
            unlocked: boolean;
            reason?: string | undefined;
            percent?: number | undefined;
            prompt?: string | undefined;
        } | undefined;
        harnessRuns?: number | undefined;
        memoryEntries?: number | undefined;
    }>>;
    /** The drive running now, when there is one. Absent: nothing is driving. */
    harnessDrive: z.ZodOptional<z.ZodObject<{
        runId: z.ZodString;
        steps: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        steps: number;
        runId: string;
    }, {
        steps: number;
        runId: string;
    }>>;
    /** Who is coding against this daemon, and what this tab said to them. Absent: an older daemon. */
    agent: z.ZodOptional<z.ZodObject<{
        agents: z.ZodArray<z.ZodString, "many">;
        notes: z.ZodArray<z.ZodObject<{
            text: z.ZodString;
            seen: z.ZodBoolean;
            /** Which agent took it, when the daemon knows. */
            by: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            text: string;
            seen: boolean;
            by?: string | undefined;
        }, {
            text: string;
            seen: boolean;
            by?: string | undefined;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        notes: {
            text: string;
            seen: boolean;
            by?: string | undefined;
        }[];
        agents: string[];
    }, {
        notes: {
            text: string;
            seen: boolean;
            by?: string | undefined;
        }[];
        agents: string[];
    }>>;
    /**
     * The rail's notices, already chosen for this machine by the daemon (see `hud-notices.ts`).
     * Absent means the daemon has nothing newer than the SDK's bundled slides, which then show.
     *
     * Loose here on purpose: this schema is on every page's first load, and the full notice schema
     * (link rules, id pattern) is not. The lazily loaded panel validates each notice with
     * `HudNoticeSchema` from `@reticlehq/core/hud` before rendering it.
     */
    notices: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
    /**
     * Reticle Coverage: each level's percentage from the project's coverage ledger (`reached` routes,
     * `proved` controls, `executed` code, ...). Numbers only. Absent until something was measured.
     */
    coverage: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
    /**
     * Where this project's work stands with the platform (status, runs on it, waiting, refused, last
     * push, and the sentence describing it). Loose here, shaped by the daemon's sync-status.
     */
    sync: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    /**
     * How much of THIS tab's app Reticle sees, and the prompt that asks a coding agent to close the
     * rest (`covered`, `total`, `missing`, `prompt`). Loose here, shaped by the daemon's coverageOf.
     */
    instrumentation: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    schemaVersion: number;
    project: {
        since: number;
        counts: {
            sessions: number;
            unknown: number;
            passed: number;
            failed: number;
            calls: number;
            verdicts: number;
            refusals: number;
            marks: number;
            tokensReturned: number;
            drivingMs: number;
        };
        days: {
            date: string;
            counts: {
                sessions: number;
                unknown: number;
                passed: number;
                failed: number;
                calls: number;
                verdicts: number;
                refusals: number;
                marks: number;
                tokensReturned: number;
                drivingMs: number;
            };
        }[];
        records: {
            longestRunMs: number;
            bestVerdictDay: number;
            bestDefectDay: number;
            streakDays: number;
            bestStreakDays: number;
        };
        savings: {
            tokens: {
                value: number;
                basis: string;
            };
            minutes: {
                value: number;
                basis: string;
            };
        };
        defects: {
            at: number;
            title: string;
            source?: string | undefined;
            detail?: string | undefined;
        }[];
    };
    global: {
        since: number;
        counts: {
            sessions: number;
            unknown: number;
            passed: number;
            failed: number;
            calls: number;
            verdicts: number;
            refusals: number;
            marks: number;
            tokensReturned: number;
            drivingMs: number;
        };
        days: {
            date: string;
            counts: {
                sessions: number;
                unknown: number;
                passed: number;
                failed: number;
                calls: number;
                verdicts: number;
                refusals: number;
                marks: number;
                tokensReturned: number;
                drivingMs: number;
            };
        }[];
        records: {
            longestRunMs: number;
            bestVerdictDay: number;
            bestDefectDay: number;
            streakDays: number;
            bestStreakDays: number;
        };
        savings: {
            tokens: {
                value: number;
                basis: string;
            };
            minutes: {
                value: number;
                basis: string;
            };
        };
        defects: {
            at: number;
            title: string;
            source?: string | undefined;
            detail?: string | undefined;
        }[];
    };
    agent?: {
        notes: {
            text: string;
            seen: boolean;
            by?: string | undefined;
        }[];
        agents: string[];
    } | undefined;
    sync?: Record<string, unknown> | undefined;
    account?: {
        signedIn: boolean;
        email?: string | undefined;
        org?: string | undefined;
        host?: string | undefined;
    } | undefined;
    instrumentation?: Record<string, unknown> | undefined;
    projectName?: string | undefined;
    dashboardUrl?: string | undefined;
    harnessConfig?: {
        provider: string;
        harnessEnabled: boolean;
        harnessEntitled: boolean;
        plan?: {
            kind: "free" | "trial" | "paid";
            daysLeft?: number | undefined;
            seats?: number | undefined;
        } | undefined;
        providerReady?: boolean | undefined;
        credits?: {
            used: number;
            limit: number;
            kind?: "free" | "trial" | "paid" | undefined;
            daysLeft?: number | undefined;
        } | undefined;
        platformUrl?: string | undefined;
        gate?: {
            unlocked: boolean;
            reason?: string | undefined;
            percent?: number | undefined;
            prompt?: string | undefined;
        } | undefined;
        harnessRuns?: number | undefined;
        memoryEntries?: number | undefined;
    } | undefined;
    harnessDrive?: {
        steps: number;
        runId: string;
    } | undefined;
    notices?: unknown[] | undefined;
    coverage?: Record<string, number> | undefined;
}, {
    schemaVersion: number;
    project: {
        since: number;
        counts: {
            sessions: number;
            unknown: number;
            passed: number;
            failed: number;
            calls: number;
            verdicts: number;
            refusals: number;
            marks: number;
            tokensReturned: number;
            drivingMs: number;
        };
        days: {
            date: string;
            counts: {
                sessions: number;
                unknown: number;
                passed: number;
                failed: number;
                calls: number;
                verdicts: number;
                refusals: number;
                marks: number;
                tokensReturned: number;
                drivingMs: number;
            };
        }[];
        records: {
            longestRunMs: number;
            bestVerdictDay: number;
            bestDefectDay: number;
            streakDays: number;
            bestStreakDays: number;
        };
        savings: {
            tokens: {
                value: number;
                basis: string;
            };
            minutes: {
                value: number;
                basis: string;
            };
        };
        defects?: {
            at: number;
            title: string;
            source?: string | undefined;
            detail?: string | undefined;
        }[] | undefined;
    };
    global: {
        since: number;
        counts: {
            sessions: number;
            unknown: number;
            passed: number;
            failed: number;
            calls: number;
            verdicts: number;
            refusals: number;
            marks: number;
            tokensReturned: number;
            drivingMs: number;
        };
        days: {
            date: string;
            counts: {
                sessions: number;
                unknown: number;
                passed: number;
                failed: number;
                calls: number;
                verdicts: number;
                refusals: number;
                marks: number;
                tokensReturned: number;
                drivingMs: number;
            };
        }[];
        records: {
            longestRunMs: number;
            bestVerdictDay: number;
            bestDefectDay: number;
            streakDays: number;
            bestStreakDays: number;
        };
        savings: {
            tokens: {
                value: number;
                basis: string;
            };
            minutes: {
                value: number;
                basis: string;
            };
        };
        defects?: {
            at: number;
            title: string;
            source?: string | undefined;
            detail?: string | undefined;
        }[] | undefined;
    };
    agent?: {
        notes: {
            text: string;
            seen: boolean;
            by?: string | undefined;
        }[];
        agents: string[];
    } | undefined;
    sync?: Record<string, unknown> | undefined;
    account?: {
        signedIn: boolean;
        email?: string | undefined;
        org?: string | undefined;
        host?: string | undefined;
    } | undefined;
    instrumentation?: Record<string, unknown> | undefined;
    projectName?: string | undefined;
    dashboardUrl?: string | undefined;
    harnessConfig?: {
        provider: string;
        harnessEnabled: boolean;
        harnessEntitled: boolean;
        plan?: {
            kind: "free" | "trial" | "paid";
            daysLeft?: number | undefined;
            seats?: number | undefined;
        } | undefined;
        providerReady?: boolean | undefined;
        credits?: {
            used: number;
            limit: number;
            kind?: "free" | "trial" | "paid" | undefined;
            daysLeft?: number | undefined;
        } | undefined;
        platformUrl?: string | undefined;
        gate?: {
            unlocked: boolean;
            reason?: string | undefined;
            percent?: number | undefined;
            prompt?: string | undefined;
        } | undefined;
        harnessRuns?: number | undefined;
        memoryEntries?: number | undefined;
    } | undefined;
    harnessDrive?: {
        steps: number;
        runId: string;
    } | undefined;
    notices?: unknown[] | undefined;
    coverage?: Record<string, number> | undefined;
}>;
export type ImpactSnapshot = z.infer<typeof ImpactSnapshotSchema>;
/** Empty counters - the starting point for a fresh store and the identity for merges. */
export declare function emptyImpactCounts(): ImpactCounts;
export declare function emptyImpactRecords(): ImpactRecords;
/** Add one delta into a running total. Pure; the store owns persistence. */
export declare function addImpactCounts(base: ImpactCounts, delta: Partial<ImpactCounts>): ImpactCounts;