toolroll 0.9.103 → 0.9.105

package/dist/peek.d.ts

@@ -1,110 +0,0 @@
-/**
- * The live peek's NATIVE reader (attended finding 7, CRITICAL): the whole
- * point of this module is what it does not do. No git invocation ever has
- * the agent's worktree as its working tree; nothing here consults
- * gitattributes, hooks, clean/process filters, or external diff drivers —
- * the mechanisms finding 7 proved can execute repository-configured
- * commands. Change detection is a git-blob sha1 computed IN PROCESS against
- * the frozen base tree.
- *
- * Two layers, deliberately separated: the PURE core (sha1, parsers,
- * aggregation — bytes in, structures out) and ONE I/O function,
- * observeWorktree — descriptor-DISCIPLINED, not descriptor-confined: Node
- * has no openat, so traversal is by pathname and a same-UID attacker
- * renaming ancestors mid-walk can misdirect it (round-3 finding 44 owns
- * the honest disclosure). What IS held: files open O_NOFOLLOW|O_NONBLOCK
- * and must fstat as regular files on the root's device before a byte is
- * read; reads go through that descriptor, bounded to the accepted size,
- * with growth re-checked after; directories must prove the root's device
- * before descent; symlinks are never followed; `.git` is never entered;
- * every cap is explicit; unreadable corners make the look PARTIAL rather
- * than silently narrower. Guarding, caching, and serving stay with their
- * owners (serve.ts).
- */
-/** git's own blob identity: sha1 over "blob <len>\0" + bytes. Computing it
- * here is what lets change detection never ask git about a working tree. */
-export declare function gitBlobSha1(bytes: Buffer): string;
-/**
- * New-file readability WITHOUT suppression (round-1 finding 19: ignore
- * parsing is gone — a pattern match can HIDE a name, and patterns are
- * agent-influencable). Aggregation only: a first path segment holding more
- * than `groupAt` new files collapses to one row stating its exact count;
- * everything else lists; the row cap saturates with exact totals. No name
- * is ever dropped silently — the numbers always add up.
- */
-export type NewFileRow = {
-    label: string;
-    count: number;
-    collapsed: boolean;
-};
-export declare function aggregateNewNames(paths: readonly string[], groupAt?: number, rowCap?: number): {
-    rows: NewFileRow[];
-    total: number;
-    renderedFiles: number;
-};
-/**
- * The base-tree snapshot parser (round-1 finding 15's demands, applied to
- * OUR OWN format anyway): every entry is proved shaped before use —
- * relative path with no dot-dot/backslash/control bytes, a known mode,
- * a 40-hex sha, a bounded non-negative size. Anything else refuses the
- * whole snapshot; a partial base is not a base.
- */
-export type BaseTreeEntry = {
-    path: string;
-    mode: string;
-    sha: string;
-    size: number;
-};
-/**
- * The enveloped snapshot document (round-2 finding 26): entries alone are
- * not a snapshot — the envelope binds schema version, repository, run, and
- * the exact base OID, and the CONSUMER (not readVerifiedArtifact) proves
- * those against the run row plus capture_status/truncated before any walk.
- */
-export type BaseTreeSnapshot = {
-    repo: string;
-    run: number;
-    base: string;
-    entries: BaseTreeEntry[];
-};
-export declare function encodeBaseTreeSnapshot(snapshot: BaseTreeSnapshot): string;
-export declare function parseBaseTreeSnapshot(json: string, entryCap?: number): BaseTreeSnapshot | null;
-export declare function parseBaseTree(json: string, entryCap?: number): BaseTreeEntry[] | null;
-export type PeekLimits = {
-    /** Walk abandons past this many entries — a typed refusal, not a guess. */
-    maxEntries: number;
-    /** Combined cap across changed+deleted+unchecked rows (finding 38). */
-    maxRows: number;
-    /** Files larger than this are compared by size only, and say so. */
-    maxFileBytes: number;
-    /** Total bytes hashed per observation; past it, remaining files go unverified. */
-    maxHashedBytes: number;
-    /** Wall budget, checked between files — over it, a partial look, never a hang. */
-    deadlineMs: number;
-};
-export declare const PEEK_LIMITS: PeekLimits;
-export type PeekRow = {
-    kind: "changed" | "deleted" | "unchecked";
-    path: string;
-    detail: string;
-};
-export type Observation = {
-    ok: true;
-    rows: PeekRow[];
-    newPaths: string[];
-    /** Non-null when the look is partial, saying why in plain words. */
-    partial: string | null;
-    scanned: number;
-} | {
-    ok: false;
-    reason: string;
-};
-/**
- * One best-effort observation of a working tree against its frozen base
- * (v2 brief §2). Descriptor-confined throughout: directories via opendir
- * handles, files via O_NOFOLLOW descriptors, sizes from fstat on the OPEN
- * descriptor (never a path-racy stat), bytes hashed through the same
- * descriptor. Symlinks are typed by lstat-equivalent dirent info and never
- * opened. Nothing here writes, spawns, or evaluates anything.
- */
-export declare function observeWorktree(root: string, base: readonly BaseTreeEntry[], limits?: PeekLimits): Promise<Observation>;

package/dist/people-audit-ui.d.ts

@@ -1,16 +0,0 @@
-import { type AuditAction } from "./remote-audit.js";
-import type { ApiTokenRow } from "./store.js";
-import { type Html } from "./html.js";
-/** The old look; the page is built from the kit now. Kept for chrome.ts, which still concatenates it. */
-export declare const PEOPLE_AUDIT_CSS = "";
-export type PersonAuditView = {
-    name: string;
-    tokens: readonly ApiTokenRow[];
-    actions: readonly AuditAction[];
-    /** The token name the actions are filtered to, if any. */
-    token: string | null;
-    nextCursor: string | null;
-    now: Date;
-};
-export declare const personHref: (name: string, more?: Record<string, string>) => string;
-export declare function personAuditHtml(view: PersonAuditView): Html;

package/dist/person-proof.d.ts

@@ -1,2 +0,0 @@
-/** Whether a recorded proof is a person's. A runtime string: a missing, corrupt or future value is never a person. */
-export declare function personProof(proof: string | null | undefined): boolean;

package/dist/phase-routing.d.ts

@@ -1,401 +0,0 @@
-/**
- * Explainable phase routing (v47), sized since v2.
- *
- * WHICH agent plans, builds, repairs, and reviews a task is decided here,
- * once, from signed facts — never guessed from a model's name and never
- * re-decided behind an approval's back. The policy is a small table over
- * explicit inputs:
- *
- *   size         — how big a change the task is (small / medium / large, risky or not)
- *   quality      — the evidence policy the scope signs (default / strict)
- *   evidence     — what the acceptance rubric demands (screenshots, …)
- *   publication  — how far the plane may carry the result unattended
- *   candidates   — the operator's CONFIGURED routine and strong agents
- *   overrides    — an approver's explicit per-phase choice, recorded
- *   pins         — a routine firing's or plan request's pinned pair
- *
- * and its output is one canonical ROUTE: four legs, each with an exact
- * provider AND an exact model id, which tier it came from, whether a
- * person overrode it, and plain-English reasons. The same inputs always
- * yield the same route and the same words — `recommendRoute` is pure, so
- * the surfaces (CLI, task page, chat) render one projection rather than
- * three.
- *
- * EXACTNESS is the law of this module: a candidate, an override, a pin,
- * and every frozen leg name an exact model id — "the harness default"
- * is not a term an approval can bind. A configuration that cannot make a
- * leg exact (no model configured, a cross-provider repair row, gemini on
- * the review phase) becomes a stated PROBLEM on that leg, and the scope
- * files unresolved with those words; nothing is guessed or substituted.
- *
- * Strength is never inferred: "strong" means the operator named a strong
- * candidate for that phase (`config set <phase> --tier strong …`). With
- * none configured, a demanding task still routes to the configured
- * default and SAYS so — and its posture reads as economical, because that
- * is what actually runs. Provider readiness is a runner's observation,
- * not a term — it rides beside the route (ready / unavailable / unknown),
- * it is stated wherever the route is shown, and an unavailable provider
- * is never substituted: admission halts with the reason.
- *
- * Every route carries `risk: "routine"`: the declared risk level was
- * removed in v115 (size does that job), and older sealed routes keep
- * whatever risk they were recommended for, read back exactly.
- *
- * Approval seals the route (`approvedRouteJson`); its digest folds into
- * the scope digest of EVERY route filed since v47 — routine-shaped routes
- * included — so a task-level route edit stales the approval exactly as a
- * goal edit does, while a global configuration change can never rewrite a
- * sealed route. Only a row proven to predate v47 (no route era) reads as
- * a legacy approval governed by its sealed profile alone.
- */
-import type { EvidenceKind } from "./contracts/acceptance-terms.js";
-import { MODEL_ID_SHAPE, PLAIN_ROUTE_VERSION, RISKS, ROUTE_VERSION, type PhaseRoute, type RouteLeg, type RouteOverride, type RouteVersion, type TaskSizing } from "./contracts/route.js";
-import type { Phase, ProviderId } from "./provider.js";
-import type { QualityMode } from "./quality.js";
-/** The sealed route's shape is its contract (contracts/route.ts); these are its types. */
-export type { PhaseRoute, RouteLeg, RouteOverride, RouteVersion, TaskSizing };
-export { MODEL_ID_SHAPE };
-export declare const PROVIDER_ID_LIST: readonly ProviderId[];
-/** The same exactness for callers outside this policy (the profile
- * rehydrator): one shape, one definition. */
-export declare function exactModelId(v: unknown): v is string;
-/** v2 adds the task's size (small / medium / large, risky or not), the
- * light tier, and plan headroom. A v1 route — sealed before sizing — still
- * reads back exactly and keeps its own digest domain. */
-export { PLAIN_ROUTE_VERSION, ROUTE_VERSION };
-/** The durable route ERA a scope row carries once it was filed under this
- * policy: NULL on a row proven to predate v47 (legacy — the sealed profile
- * alone governs), this value on every row filed since. A row with an era
- * and no readable route is corrupt and fails closed. The era marks a ROUTED
- * row; which route version it holds rides in the snapshot itself. */
-export declare const ROUTE_ERA = 1;
-export declare const PHASES: readonly Phase[];
-/** The risk words a route sealed before v115 may carry (history); every route since says `routine`. */
-export type RiskLevel = (typeof RISKS)[number];
-export declare function isRiskLevel(value: unknown): value is RiskLevel;
-/** How big a change the task is, sized once at filing (by the classifier,
- * by the description when it cannot answer, or by a person). */
-export type TaskSize = TaskSizing["size"];
-export declare const TASK_SIZES: readonly TaskSize[];
-export type SizeSource = TaskSizing["source"];
-export declare function isTaskSize(value: unknown): value is TaskSize;
-/** Whether a task makes no plan: a small change that is not risky (on an
- * older route sealed at elevated or high risk, it always planned). */
-export declare function makesNoPlan(size: TaskSizing | null | undefined, risk: RiskLevel): boolean;
-/** Where a size came from, in words. */
-export declare function sizeSourceWords(source: SizeSource): string;
-export declare function riskTitle(risk: RiskLevel): string;
-/** A runner's non-spending observation of one provider. `unknown` is a
- * real answer (claude has no login probe that does not spend) and is never
- * upgraded to ready. */
-export type ReadinessState = "ready" | "unavailable" | "unknown";
-export type ReadinessObservation = {
-    provider: ProviderId;
-    state: ReadinessState;
-    /** The probe's own words: "not logged in", "`codex` is not installed"… */
-    reason: string;
-    /** Which non-spending check produced this: version, identity, key, none. */
-    probe: string;
-    observedAt: string;
-    runner: string;
-};
-export type CandidateTier = "light" | "routine" | "strong";
-/** An exact agent: provider and model id, both required. */
-export type ExactSpec = {
-    provider: ProviderId;
-    model: string;
-};
-export type RouteCandidate = ExactSpec & {
-    /** Where the candidate was read from — provenance words, never a term. */
-    source: string;
-};
-export type PhaseCandidates = {
-    /** The operator's named LIGHT (fast) builder (`config set build --tier
-     * light …`), or null/absent when none is configured. A small change
-     * builds on it. Never inferred; the plan phase has none (a small change
-     * makes no plan). */
-    light?: RouteCandidate | null;
-    routine: RouteCandidate;
-    /** The operator's named strong agent for this phase, or null when none
-     * is configured. Never inferred. */
-    strong: RouteCandidate | null;
-    /** v2: a tier may hold one more candidate per OTHER provider (`config
-     * set <phase> [--tier …] --also --provider … --model …`) — e.g. a
-     * routine builder on claude and on codex. At filing the one whose
-     * provider has more plan room runs. Each list holds providers other
-     * than its tier's own candidate, at most one each. */
-    alternates?: Partial<Record<CandidateTier, readonly RouteCandidate[]>>;
-};
-/** The repair phase's candidates: with no repair row configured the
- * routine candidate is null and the leg INHERITS the build leg's exact
- * pair (repairs resume the builder's session). */
-export type RepairCandidates = {
-    routine: RouteCandidate | null;
-    strong: RouteCandidate | null;
-};
-export type RouteCandidates = {
-    plan: PhaseCandidates;
-    build: PhaseCandidates;
-    repair: RepairCandidates;
-    review: PhaseCandidates;
-};
-/** The evidence kinds an acceptance rubric demands — `scope.ts` owns the
- * full type; the policy only needs the names. */
-export type RouteEvidenceKind = EvidenceKind;
-/** How far the plane may carry a result without a person: no publication
- * grant at all, a grant whose merges wait for a human (notify), or a live
- * mode that merges by itself (automerge). */
-export type PublicationAuthority = "none" | "notify" | "automerge";
-/** How much of one provider's plan is used, as it last said: the 5-hour
- * window and the weekly window, in percent; null when unknown. */
-export type ProviderRoom = {
-    provider: ProviderId;
-    fiveHour: number | null;
-    weekly: number | null;
-};
-/** Above these a provider has no headroom: even a candidate one tier
- * stronger on another provider takes the phase. Below them, a tier's
- * candidates on different providers still go to the one with more room. */
-export declare const HEADROOM_FIVE_HOUR_LIMIT = 80;
-export declare const HEADROOM_WEEKLY_LIMIT = 90;
-/** The latest plan-window readings as headroom: a window whose reset time
- * has passed counts as empty; a reading older than its own window is
- * unknown. Weekly is the plan-wide week (`seven_day`), else the fullest
- * model-specific week. */
-export declare function headroomFrom(limits: readonly {
-    provider: string;
-    window: string;
-    usedPercent: number;
-    windowMinutes: number | null;
-    resetsAt: string | null;
-    observedAt: string;
-}[], now: Date): ProviderRoom[];
-export type RouteInput = {
-    qualityMode: QualityMode;
-    evidence: readonly RouteEvidenceKind[];
-    publication: PublicationAuthority;
-    candidates: RouteCandidates;
-    overrides: readonly RouteOverride[];
-    /** Pinned exact pairs beat everything: a routine firing's build pin, a
-     * plan request's plan pin, and — when an explicit approved profile files
-     * the scope — its repair model on the build provider. */
-    pins?: {
-        plan?: ExactSpec | null;
-        build?: ExactSpec | null;
-        repair?: ExactSpec | null;
-    };
-    /** How big the change is (v2): small builds on the light tier with no
-     * plan; large or risky plans and builds on the strong tier. */
-    size?: TaskSizing | null;
-    /** Each provider's plan headroom at filing (v2): when a tier has
-     * candidates on more than one provider, the one with more room runs; a
-     * provider past its limits gives way even to a stronger tier. */
-    headroom?: readonly ProviderRoom[];
-    /** Results routing (route v3, docs/plans/results-routing.md slice 2): the project's live earned rules, and the two
-     * eligibility facts the route itself doesn't carry (a release or candidate task; declared paths that touch the
-     * project's protected paths). Absent or null: no rule applies. */
-    earned?: EarnedInput | null;
-};
-/** One live earned rule, as routing reads it: which project-size cohort it covers, the exact Claude model it builds
- * on, and the configured builder it was earned against (a configuration change pauses the rule; a mismatch here
- * skips it all the same). */
-export type EarnedRule = {
-    id: number;
-    generation: number;
-    cohortSize: "small" | "medium";
-    provider: ProviderId;
-    model: string;
-    configured: {
-        provider: string;
-        model: string | null;
-    };
-};
-/** A live trial (results routing slice 3): try a cheaper Claude model on the next `limit` eligible tasks of one
- * cohort, each still approved by a person. `reservation` is this filing's place in it (route-store.ts
- * reserveTrialPlace): its id, or null when every place is taken, so the configured builder runs it. */
-export type EarnedTrial = EarnedRule & {
-    limit: number;
-    reservation: number | null;
-};
-export type EarnedInput = {
-    rules: readonly EarnedRule[];
-    release: boolean;
-    protected: boolean;
-    trial?: EarnedTrial | null;
-};
-export declare function specWords(spec: {
-    provider: string;
-    model: string;
-}): string;
-/**
- * The recommendation: pure, deterministic, table-driven. Same inputs,
- * same route, same words. Every leg it returns is exact; a leg the
- * configuration cannot make runnable carries a `problem` instead of a
- * guess.
- */
-export declare function recommendRoute(input: RouteInput): PhaseRoute;
-/**
- * THE BUILD LEG'S ONE PRECEDENCE ORDER (results routing, docs/plans/results-routing.md slice 2), pure:
- *
- *   pin > person override > trial > earned rule > configured row (light / routine / strong by size)
- *   > headroom move
- *
- * Headroom moves only a configured leg, never a rule's or a trial's: their evidence is about one exact model. A rule
- * or trial whose provider is past the headroom limits is skipped for this filing, and its reason says so. A trial
- * applies only with a place reserved for this task (slice 3). A rule or trial applies only to an
- * eligible task — small or medium, not risky, default quality, no screenshot or manual-review evidence, not a
- * merging mode, not a release or candidate, nothing protected declared — and only over the configured builder it was
- * earned against. Its leg says how it was selected (`selection`), so the route seals as version 3 and every later
- * check reads the sealed selection, never the current rules or the reason text.
- */
-export declare function selectBuildLeg(input: RouteInput, configured: {
-    spec: RouteCandidate;
-    tier: CandidateTier;
-    reasons: string[];
-}): {
-    leg: RouteLeg;
-    moved: boolean;
-};
-/** The earned rule this task's build takes (pure): null when none could apply (no rule for its size, or the task
- * isn't eligible), or a rule skipped for this filing with the words why. */
-export declare function earnedRuleFor(input: RouteInput, configured: {
-    spec: RouteCandidate;
-    tier: CandidateTier;
-}): {
-    kind: "rule";
-    rule: EarnedRule;
-} | {
-    kind: "skipped";
-    reason: string;
-} | null;
-/** The trial this task's build takes (pure, results routing slice 3): null when none could apply (no live trial for
- * its size, or the task isn't eligible: the same facts an earned rule needs), a trial with this task's place, or a
- * trial skipped for this filing with the words why (another configured builder, no place left, no headroom). */
-export declare function trialFor(input: RouteInput, configured: {
-    spec: RouteCandidate;
-    tier: CandidateTier;
-}): {
-    kind: "trial";
-    trial: EarnedTrial & {
-        reservation: number;
-    };
-} | {
-    kind: "skipped";
-    reason: string;
-} | null;
-export declare function legOf(route: PhaseRoute, phase: Phase): RouteLeg;
-/** Every stated problem on the route, in phase order — a non-empty list
- * means the scope files unresolved with these words. */
-export declare function routeProblems(route: PhaseRoute): string[];
-/** Whether two exact pairs are the same agent. */
-export declare function sameSpec(a: {
-    provider: string;
-    model: string | null;
-}, b: {
-    provider: string;
-    model: string | null;
-}): boolean;
-/** The stored snapshot bytes: the version rides IN the snapshot. */
-export declare function canonicalRouteJson(route: PhaseRoute): string;
-/** sha256 over a domain-separated canonical encoding, truncated to the
- * same 128 bits every other safety digest here uses. Its own domain, so a
- * route digest can never collide with a profile or chain digest. */
-export declare function routeDigestOf(route: PhaseRoute): string;
-/** Strict rehydration of a stored route through the route contract — every
- * field type-proved, every model an exact non-empty string, nothing unknown;
- * anything unexpected is null, never a guess. A null from a row that carries
- * a route era is a corrupt seal. */
-export declare function routeFromJson(json: string | null): PhaseRoute | null;
-/** Why a stored route does not read, as path-named lines (`legs[1].model: …`); null when it reads. */
-export declare function routeJsonProblem(json: string): string | null;
-/** Strict parse of an override list (the route contract's): one per phase,
- * every field proved, every model exact, in phase order. */
-export declare function parseOverrides(raw: unknown): RouteOverride[] | null;
-/** The stored override list (a task-level column). Malformed reads as
- * null — the caller files the scope unresolved rather than routing as if
- * nobody had overridden anything. */
-export declare function overridesFromJson(json: string | null): RouteOverride[] | null;
-export declare function canonicalOverridesJson(overrides: readonly RouteOverride[]): string | null;
-export type ReadinessLookup = (provider: ProviderId) => (Pick<ReadinessObservation, "state" | "reason" | "runner" | "observedAt"> & Partial<Pick<ReadinessObservation, "probe">>) | null;
-export type RouteLegProjection = RouteLeg & {
-    readiness: ReadinessState;
-    readinessReason: string | null;
-    readinessRunner: string | null;
-    observedAt: string | null;
-    /** One line every surface prints for this leg. */
-    words: string;
-};
-export type RouteProjection = {
-    digest: string;
-    risk: RiskLevel;
-    riskTitle: string;
-    posture: PhaseRoute["posture"];
-    postureWords: string;
-    demands: string[];
-    legs: RouteLegProjection[];
-    /** The compact plain-English line: who does what, and whether any of
-     * them is a stronger-than-default agent. */
-    summary: string;
-    /** True when any leg is known-unavailable — admission halts, nothing
-     * substitutes. */
-    halted: boolean;
-    /** Every stated leg problem, phase-prefixed. */
-    problems: string[];
-    /** The size the route was made for (v2), or null. */
-    size: TaskSizing | null;
-    /** The plain line an approval card leads with — "Small change: fast
-     * model, no plan" — or null on an unsized route. */
-    sizeWords: string | null;
-    /** Why it was sized so, and by whom, or null. */
-    sizeReason: string | null;
-};
-/** What actually runs: stronger agents only when a leg draws from one. */
-export declare function postureWords(route: Pick<PhaseRoute, "legs">): string;
-/** The size line, plainly: what the size does to this route. */
-export declare function sizeWords(route: Pick<PhaseRoute, "legs" | "size" | "risk">): string | null;
-export declare function readinessWords(state: ReadinessState, reason: string | null): string;
-export declare function chosenWords(leg: Pick<RouteLeg, "chosen" | "tier">): string;
-/**
- * The one-line Agents summary every surface can show above the details:
- * agents grouped by identical pair, in phase order — "claude · sonnet
- * plans, builds, and repairs; claude · opus reviews" — with the posture
- * said honestly (stronger agents only when one is actually selected).
- */
-export declare function agentsSummary(route: Pick<PhaseRoute, "legs"> & {
-    size?: TaskSizing | null;
-    risk?: RiskLevel;
-}): string;
-export declare function legLine(leg: RouteLegProjection): string;
-/** The one projection CLI, task page, and chat all render from. */
-export declare function projectRoute(route: PhaseRoute, readiness: ReadinessLookup): RouteProjection;
-/** The approval-card lines: one route header, one line per leg, then the
- * reasons indented — identical bytes on every text surface. */
-export declare function routeWords(projection: RouteProjection, indent?: string): string[];
-/** The empty readiness lookup: every provider unknown. */
-export declare const NO_READINESS: ReadinessLookup;
-/** How a run's provenance names the leg it spent as: the frozen leg's own
- * word, and `legacy` for a run governed by a pre-routing approval. Before
- * v115, `legacy` also named a watched session's run, and `fallback` an
- * approved fallback entry's; those rows still read back. */
-export type RouteChosen = RouteLeg["chosen"] | "legacy" | "fallback";
-export declare const ROUTE_CHOSEN: readonly RouteChosen[];
-/** One run's route provenance: the exact provider and model that ran,
- * under which route (or legacy profile) digest, as which leg. */
-export type RouteStamp = {
-    routeDigest: string;
-    phase: Phase;
-    provider: string;
-    model: string | null;
-    chosen: RouteChosen;
-};
-/** A run's role, as the route phase it spends as: a scout runs the build
- * leg's agent (the same sealed profile a build proves against). */
-export declare function phaseOfRole(role: "builder" | "repair" | "planner" | "scout" | "reviewer"): Phase;
-/**
- * Strict proof of a route stamp's SHAPE, before anything about it is
- * believed: a known phase and provenance word, a known provider, a
- * non-empty digest, and an exact model on every stamp except a legacy
- * one (a pre-routing profile may carry no model). Anything else is the
- * words for why — admission refuses on them, never coerces.
- */
-export declare function routeStampProblem(stamp: unknown): string | null;

package/dist/plain-schema.d.ts

@@ -1,23 +0,0 @@
-/** v153 (docs/plans/plain-toolroll.md Phase 2): the tables the authority slices own, new tables only. Kept apart so
- * store.ts loads them without loading the roads that use them. */
-/** A vanished build's one charge per run, and the episode its automatic retries stay inside (vanished-retry.ts). */
-export declare const VANISHED_SCHEMA = "\nCREATE TABLE IF NOT EXISTS vanished_charge (\n  run        INTEGER PRIMARY KEY REFERENCES run(id),\n  task_ref   INTEGER NOT NULL REFERENCES task_ref(id),\n  charged_at TEXT NOT NULL,\n  settled_at TEXT\n);\nCREATE INDEX IF NOT EXISTS vanished_charge_open ON vanished_charge (task_ref) WHERE settled_at IS NULL;\nCREATE TABLE IF NOT EXISTS retry_episode (\n  task_ref          INTEGER PRIMARY KEY REFERENCES task_ref(id),\n  retries           INTEGER NOT NULL DEFAULT 0 CHECK (retries >= 0),\n  reserved_microusd INTEGER NOT NULL DEFAULT 0 CHECK (reserved_microusd >= 0),\n  stopped           TEXT CHECK (stopped IS NULL OR stopped IN ('no-budget', 'attempts', 'spend')),\n  stopped_run       INTEGER,\n  started_at        TEXT NOT NULL,\n  updated_at        TEXT NOT NULL\n);\n";
-/** A check-only authorization (check-only.ts): one automatic run of the approved check on one exact commit. The unique
- * key is the cap: one per (commit, command digest), however many workers race. Written only from the approval that
- * built that commit; it seals nothing and starts no agent. */
-export declare const CHECK_ONLY_SCHEMA = "\nCREATE TABLE IF NOT EXISTS check_authorization (\n  id             INTEGER PRIMARY KEY AUTOINCREMENT,\n  task_ref       INTEGER NOT NULL REFERENCES task_ref(id),\n  run            INTEGER NOT NULL REFERENCES run(id),\n  candidate      TEXT NOT NULL CHECK (length(candidate) = 40),\n  command_digest TEXT NOT NULL,\n  level          TEXT NOT NULL CHECK (level IN ('quick', 'full')),\n  check_access   TEXT NOT NULL,\n  scope_digest   TEXT NOT NULL,\n  written_at     TEXT NOT NULL,\n  expires_at     TEXT NOT NULL,\n  used_at        TEXT,\n  used_request   INTEGER,\n  closed_at      TEXT,\n  UNIQUE (task_ref, candidate, command_digest)\n);\nCREATE INDEX IF NOT EXISTS check_authorization_open ON check_authorization (expires_at) WHERE used_at IS NULL AND closed_at IS NULL;\n";
-/** Whether this computer's own builder is meant to be running, and with what (builder-restart.ts): set by `background
- * on` and `up`, cleared by `background off` and `stop`. `builder_restart` is every automatic restart Toolroll tried. */
-export declare const BUILDER_SERVICE_SCHEMA = "\nCREATE TABLE IF NOT EXISTS builder_service (\n  id             INTEGER PRIMARY KEY CHECK (id = 1),\n  desired        TEXT NOT NULL CHECK (desired IN ('running', 'stopped')),\n  build          TEXT NOT NULL,\n  schema_version INTEGER NOT NULL,\n  set_by         TEXT NOT NULL,\n  set_at         TEXT NOT NULL\n);\nCREATE TABLE IF NOT EXISTS builder_restart (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n  at TEXT NOT NULL\n);\n";
-/** A fast start's form as it was rendered (fast-start.ts): what the person typed and what the classifier said, kept here
- * so Build files exactly that, whatever a form posts. Used once. */
-export declare const FAST_PREVIEW_SCHEMA = "\nCREATE TABLE IF NOT EXISTS fast_preview (\n  id          TEXT PRIMARY KEY,\n  actor       TEXT NOT NULL,\n  via         TEXT NOT NULL,\n  task_id     TEXT NOT NULL,\n  repo        TEXT NOT NULL,\n  title       TEXT NOT NULL,\n  permission  TEXT,\n  sizing_json TEXT NOT NULL,\n  digest      TEXT NOT NULL,\n  created_at  TEXT NOT NULL,\n  expires_at  TEXT NOT NULL,\n  consumed_at TEXT\n);\n";
-/** The one new route Toolroll proposed for a task whose sealed one no longer matches (route-change.ts): the line a person
- * reads, bound to the exact route digest it describes. */
-export declare const ROUTE_CHANGE_SCHEMA = "\nCREATE TABLE IF NOT EXISTS route_change (\n  task_ref        INTEGER PRIMARY KEY REFERENCES task_ref(id),\n  scope_digest    TEXT NOT NULL,\n  to_route_digest TEXT NOT NULL,\n  words           TEXT NOT NULL,\n  created_at      TEXT NOT NULL\n);\n";
-/** v153's columns: a fast start's marker and start window on the task (both NULL on saved rows) and the project setting
- * Small tasks start right away (NULL: the default). */
-export declare const V153_ADDED_COLUMNS: Readonly<Record<string, Readonly<Record<string, {
-    definition: string;
-    saved: string;
-}>>>>;

package/dist/plain-words.d.ts

@@ -1,20 +0,0 @@
-/** One vocabulary for the words Toolroll writes (docs/plans/plain-toolroll.md, "The words"): each row is a word or
- * phrase product copy never says, and what it says instead. Matching is by whole word and ignores case.
- *
- * Product copy is the text Toolroll writes. Preserved content (goals, requirements, notes, agent reports, issue text,
- * commit messages and the exact terms a consent shows) is never rewritten to satisfy this table. Code, the database,
- * `--json`, the agent contract and the audit page's hash detail keep their own words. */
-export type PlainWord = {
-    never: string;
-    pattern: RegExp;
-    say: string;
-};
-export declare const PLAIN_WORDS: readonly PlainWord[];
-/** The words, for messages and tests. */
-export declare const BANNED_WORDS: readonly string[];
-/** Every banned word in `text`, as the table names it. */
-export declare function bannedWordsIn(text: string): string[];
-/** Whether `text` says any word product copy never says. */
-export declare const hasInternalWords: (text: string) => boolean;
-/** A plan's version as Details shows it: a short handle, never the whole digest. */
-export declare const planVersionWords: (digest: string) => string;

package/dist/plan-auto.d.ts

@@ -1,25 +0,0 @@
-import type { Store } from "./store.js";
-import { type UnattendedGrant } from "./flow-unattended.js";
-export declare const PLAN_AUTO_SCHEMA = "CREATE TABLE IF NOT EXISTS plan_authorization (\n  task_id TEXT PRIMARY KEY REFERENCES task(id),\n  source_digest TEXT NOT NULL,\n  scope_digest TEXT NOT NULL,\n  mode_digest TEXT NOT NULL,\n  signed_by TEXT NOT NULL,\n  created_at TEXT NOT NULL\n);";
-/** Join the console's authority-free proposal to the authenticated filing
- * road in one transaction. Planning defers the seal until verified ingestion. */
-export declare function applyModeToNewFiling(store: Store, taskId: string, actor: string, now: Date): void;
-/** Called only by credentialed operator roads, never by proposal/intake
- * code. This authorizes the exact filed contract, not arbitrary future
- * planner text. Rewrites, mode renewal, expiry and revocation fail closed. */
-export declare function authorizePlanUnderMode(store: Store, taskId: string, actor: string, now: Date): boolean;
-/**
- * A flow card's new filing under its flow's "runs on its own" grant (flow-unattended.ts), inside the engine's filing
- * transaction, which has just proved the grant covers this card. A plain build that plans is pre-authorized for an
- * unchanged plan only; anything else is sealed now, under a distinct `grant` basis. False (the filing then waits for a
- * person, as it always did) when the filed terms aren't the safe, fixed ones the grant was signed for.
- */
-export declare function sealFlowFilingUnderGrant(store: Store, taskId: string, grant: UnattendedGrant, card: {
-    flow: number;
-    id: number;
-}, now: Date): boolean;
-/** Read-side status only; finalization still proves the authority anew. */
-export declare function planAutoPending(store: Store, taskId: string, now: Date): boolean;
-/** Inside the verified planner finalization transaction, after the source,
- * artifact, contract changes and lease fence have all been checked. */
-export declare function sealUnchangedPlanUnderMode(store: Store, taskId: string, sourceDigest: string, runId: number, eligible: boolean, now: Date): boolean;

package/dist/plan-login.d.ts

@@ -1,14 +0,0 @@
-import type { Billing } from "./spend.js";
-/** How Codex says it's signed in (`codex login status`): a ChatGPT sign-in is its plan; a key or Bedrock is a key;
- * null when it says neither (not signed in, or it didn't answer). */
-export declare function codexLoginBilling(binary: string, omitEnv: readonly string[], env?: Record<string, string | undefined>): Promise<Billing | null>;
-/** Providers whose CLI can say, live and machine-readably, that the credential a run will use is a plan. */
-export declare const PLAN_LOGIN_PROVABLE: ReadonlySet<string>;
-/**
- * How Claude says it is signed in (`claude auth status --json`), read with the run's own environment so it reads the
- * credential the child will use. Strict: a plan only for a first-party claude.ai login with a named subscription; any
- * other shape, a key, a cloud provider or no answer is not a plan.
- */
-export declare function claudeLoginBilling(binary: string, omitEnv: readonly string[], env: Record<string, string | undefined>): Promise<Billing | null>;
-/** The live plan proof for a provider, or null where none exists (the caller refuses). */
-export declare function livePlanLogin(provider: string, binary: string, omitEnv: readonly string[], env: Record<string, string | undefined>): Promise<Billing | null>;