toolroll 0.9.104 → 0.9.105

package/dist/plan.d.ts

@@ -1,188 +0,0 @@
-/**
- * The planner's terminal handoff, parsed with the 422 rule: fail closed,
- * every problem reported at once, stable reasons, caps and control-character
- * rejection on every string — because a plan payload reaches terminals, the
- * approve card, and the builder's brief (Codex planning review, question 2:
- * the scope proposal is authority-bearing, so it gets the park discipline).
- */
-import { type AcceptanceCriterion } from "./scope.js";
-import { type ContractIssue } from "./contracts/contract.js";
-export type PlanProblem = {
-    reason: string;
-    message: string;
-};
-export type ParsedPlan = {
-    goal: string;
-    outOfScope: string | null;
-    touches: string[];
-    /** v39: the rubric the planner drafts alongside the goal — mandatory,
-     * because the planner is a scope-producing road like any other (the
-     * scope text names it explicitly). A malformed or empty rubric fails
-     * the whole plan the same way a missing goal always has. */
-    acceptance: AcceptanceCriterion[];
-    /** The plan document, markdown, rendered fenced-inert everywhere. */
-    plan: string;
-    /** Why the filed contract must change (contract handoff, task 1): a
-     * planner that proposes different goal/outOfScope/touches/acceptance
-     * than the operator filed says so HERE, or the plan is malformed. Null
-     * when the plan reproduces the filed terms, or when none were filed. */
-    amendment: string | null;
-};
-/** A deliberately small execution plan. The signed scope remains the
- * authority; this is the durable road the builder is expected to follow.
- * Fixed sections make the handoff scannable in the console and prevent the
- * planner from hiding the useful parts in a long essay. */
-export type ExecutionPlanDocument = {
-    approach: string;
-    milestones: string[];
-    dependencies: string[];
-    risks: string[];
-    proof: string[];
-};
-export type ExecutionPlanDocumentResult = {
-    ok: true;
-    document: ExecutionPlanDocument;
-} | {
-    ok: false;
-    problems: PlanProblem[];
-};
-/** Parse the planner's human-readable artifact without executing Markdown.
- * Older free-form plan artifacts remain renderable through the caller's
- * fallback, while every newly accepted planner handoff uses this shape. */
-export declare function parseExecutionPlanDocument(raw: string): ExecutionPlanDocumentResult;
-/**
- * The inverse of `parseExecutionPlanDocument`: the canonical fenced-section
- * markdown for a document the parser already admitted.
- *
- * A builder's revision proposal arrives as free-form text that the parser
- * validates and reduces to this shape; what gets STORED — and later
- * hash-verified, re-read, and quoted into the next brief — is rendered back
- * from that validated shape, never the agent's raw bytes (the scout
- * report's rule, and settleProof's). `parseExecutionPlanDocument` composed
- * with this function is the identity on every document the parser admits:
- * sections in their fixed order, one bullet per item, nothing else.
- */
-export declare function renderExecutionPlanDocument(document: ExecutionPlanDocument): string;
-export type PlanParseResult = {
-    ok: true;
-    plan: ParsedPlan;
-} | {
-    ok: false;
-    problems: PlanProblem[];
-};
-/**
- * A contract issue as a plan problem (`contractProblemOf`): the reason keeps the codes the rest of the code relies on
- * — `missing-goal`, `bad-touches`, `plan-too-long`, `amendment-too-long`, `acceptance-too-many` — so repair eligibility
- * (document-only problems) and durable outcomes read the same as before the contract.
- */
-export declare const planProblemOf: (issue: ContractIssue) => PlanProblem;
-/**
- * The planner's handoff, read against the plan contract (src/contracts/plan.ts): fail closed, every problem at once,
- * each one naming its path (`acceptance[0].evidence[0]: must be one of ...`). A plan saved before plans carried
- * `version` reads as it always did.
- */
-export declare function parsePlan(raw: string): PlanParseResult;
-export type MilestoneState = "pending" | "current" | "completed" | "blocked";
-export type Milestone = {
-    id: string;
-    description: string;
-};
-/**
- * A milestone's identity is its position plus a short hash of its
- * normalized text — stable across re-reads of the same revision, but a
- * milestone whose wording changes materially becomes a NEW identity rather
- * than silently inheriting stale completion state from a differently-worded
- * predecessor.
- */
-export declare function milestoneId(index: number, description: string): string;
-export declare function milestonesOf(document: ExecutionPlanDocument): Milestone[];
-export type ProgressEntry = {
-    id: string;
-    state: MilestoneState;
-    note: string | null;
-};
-/** The builder's atomic progress checkpoint: every milestone in the plan
- * revision it received, exactly once each, bound to that revision's exact
- * hash so a checkpoint can never be misread against a different plan. */
-export type ProgressSnapshot = {
-    revisionHash: string;
-    milestones: ProgressEntry[];
-};
-export type ProgressParseResult = {
-    ok: true;
-    snapshot: ProgressSnapshot;
-} | {
-    ok: false;
-    problems: PlanProblem[];
-};
-export declare const PROGRESS_LIMITS: {
-    readonly payload: number;
-    readonly note: 300;
-    readonly milestones: 12;
-};
-/** Parse a progress checkpoint written by a running build. `expectedRevisionHash`
- * and `knownIds` come from the plan revision the build's brief actually
- * named — a snapshot naming a different revision, an unknown milestone id,
- * a missing milestone, or more than one "current" milestone fails closed
- * with every problem at once, the same 422 rule as the plan itself. */
-export declare function parseProgressSnapshot(raw: string, expectedRevisionHash: string, knownIds: readonly string[]): ProgressParseResult;
-/** Whether a checkpoint transition is a legitimate update or a regression:
- * once a milestone is completed it never reverts — an agent restating an
- * old snapshot (a stale pulse, a retried read) must never erase progress
- * that a later, newer checkpoint already recorded. */
-export declare function isMilestoneRegression(previous: MilestoneState | undefined, next: MilestoneState): boolean;
-export type PlanRevisionProposal = {
-    /** The complete replacement plan document — the same shape the planner
-     * itself produces, never a diff, so a revision is always fully readable
-     * on its own. */
-    document: ExecutionPlanDocument;
-    /** Why: the named dependency, risk, or implementation assumption the
-     * repository evidence invalidated. */
-    reason: string;
-    /** Where: a path, commit, or command output the operator (or a later
-     * reader) can go re-check. */
-    evidenceLink: string;
-};
-export type PlanRevisionProposalParseResult = {
-    ok: true;
-    proposal: PlanRevisionProposal;
-} | {
-    ok: false;
-    problems: PlanProblem[];
-};
-export declare const REVISION_LIMITS: {
-    readonly payload: number;
-    readonly reason: 2000;
-    readonly evidenceLink: 500;
-};
-/** Parse the builder's terminal revision-proposal file: a complete
- * replacement plan document plus the evidence that invalidated the one it
- * was given. One proposal per build — the caller enforces that by never
- * offering the agent more than one nonce-named path to write. */
-export declare function parsePlanRevisionProposal(raw: string): PlanRevisionProposalParseResult;
-/** The exact authority a build's approval rests on: the signed scope
- * (goal, out-of-scope, touches, acceptance, permissions, quality, budget —
- * everything folded into the scope digest) plus publication authority
- * (branch vs. report). A plan revision may only auto-resume when this is
- * byte-identical to what it was when the build started; anything else
- * stays paused for a person, named. */
-export type AuthoritySnapshot = {
-    scopeDigest: string;
-    deliverable: "branch" | "report";
-};
-export declare function authoritySnapshotDigest(snapshot: AuthoritySnapshot): string;
-export type AuthorityChangeField = "signed-scope" | "publication-authority";
-export type RevisionAuthorityCheck = {
-    kind: "plan-only";
-} | {
-    kind: "authority-change";
-    changed: AuthorityChangeField[];
-};
-/** Classify a revision against the complete authority snapshot the build
- * actually started under. Everything the builder's own proposal can name is
- * plan-only by construction (it carries no scope fields at all) — this
- * check exists as the defense against the world moving underneath a live
- * build: if the signed scope or publication authority changed by any other
- * road while the build ran, the revision is never auto-applied, whatever it
- * proposes. */
-export declare function classifyRevisionAuthority(previous: AuthoritySnapshot, current: AuthoritySnapshot): RevisionAuthorityCheck;

package/dist/plane-review.d.ts

@@ -1,54 +0,0 @@
-import type { Store } from "./store.js";
-export type PlaneProblem = {
-    /** Stable across days: the same problem tomorrow has the same key. Only [a-z0-9/._-]. */
-    key: string;
-    title: string;
-    /** One line: how many, in the last 24 hours. */
-    summary: string;
-    count: number;
-    runs: number[];
-    /** Short excerpts, secrets hidden, at most EVIDENCE_LINES. */
-    evidence: string[];
-};
-export declare const REVIEW_HOURS = 24;
-/** A person's wait this long is mentioned in the review's summary line. */
-export declare const LONG_WAIT_DAYS = 3;
-export declare const RUN_CAUSES: readonly ["provider", "sign-in", "check", "timeout", "no-handoff", "stuck-lease", "orphaned", "no-change", "other"];
-export type RunCause = (typeof RUN_CAUSES)[number];
-/** Anything shaped like a key is hidden; one short line. */
-export declare function excerpt(text: string | null | undefined, cap?: number): string;
-/** Why one finished run is a problem, or null when it isn't. */
-export declare function runCause(run: {
-    outcome: string | null;
-    reason: string | null;
-    terminalClass: string | null;
-    handoff: string | null;
-    check: string | null;
-    stopped: boolean;
-}): RunCause | "plan-limit" | null;
-/**
- * Every problem worth fixing in the `REVIEW_HOURS` before `now`, worst first.
- * `canSee(repo)` says which projects' work counts (a run or task with no
- * project counts only when every project may be seen).
- */
-export declare function reviewPlane(store: Store, now: Date, canSee?: (repo: string | null) => boolean): PlaneProblem[];
-/**
- * Results nobody has opened, and tasks waiting on a person's answer, approval or hold, for over `LONG_WAIT_DAYS`
- * before `now`. Counted for the review's summary line only; they are never problems.
- */
-export declare function longPersonWaits(store: Store, now: Date, canSee?: (repo: string | null) => boolean): {
-    results: number;
-    tasks: number;
-};
-/** "3 results have waited over 3 days for you." — or null when nothing has. */
-export declare function longWaitWords(waits: {
-    results: number;
-    tasks: number;
-}): string | null;
-/** A problem as a card's details (or a day's note on a card it joins). */
-export declare function problemText(problem: PlaneProblem, day: string): string;
-/** The card's opening details: the day's evidence, and what it is. */
-export declare function problemCard(problem: PlaneProblem, day: string): {
-    title: string;
-    description: string;
-};

package/dist/planner-source.d.ts

@@ -1,225 +0,0 @@
-/**
- * The planner's SOURCE: exactly what was filed for a task at the moment a
- * planning attempt starts — the scope's goal, exclusions, touches, and the
- * whole rubric (ids, statements, evidence kinds, advisory how), its
- * execution terms, the revision brief when the task revises reviewed work,
- * and the operator's earlier answers — captured losslessly as quoted data.
- *
- * Filed intent is DATA, never authorization: nothing here approves, and a
- * planner reading it gains no authority it did not already have. What it
- * gains is the operator's actual words, so a short title can no longer
- * become a title-derived guess that silently drops the UI evidence, the
- * exclusions, or a criterion somebody wrote down (contract handoff plan,
- * task 1).
- *
- * Three facts ride the same record:
- *
- *   identity   `sourceDigest` — a digest over the CONTRACT part (scope
- *              digest and terms, task-level terms, the revision brief's
- *              artifact and hash). The planner run is stamped with it, a
- *              same-session correction inherits it through its parent, a
- *              resumed decision re-derives it, and the plan ingestion
- *              re-derives it INSIDE its transaction: a source that moved
- *              while the planner ran refuses the draft rather than
- *              overwriting the newer terms.
- *   bounds     one explicit byte cap on the whole quoted record. Over it,
- *              the attempt refuses in words BEFORE any provider spend —
- *              a brief that silently trimmed a criterion would be the very
- *              loss this module exists to prevent.
- *   changes    `contractChangesOf` — the mechanical additions, changes,
- *              and removals between the filed terms and what a planner
- *              drafted. A plan that changes filed terms must SAY so with an
- *              explicit amendment; the approval shows every change either
- *              way and binds exactly the terms the operator accepts.
- *
- * Pure primitives plus one store-reading assembler. No spawning, no
- * transactions of its own: the fenced finalizers in claim.ts seal.
- */
-import type { Store } from "./store.js";
-import type { Scope } from "./scope.js";
-import type { QualityMode } from "./quality.js";
-import type { RiskLevel } from "./phase-routing.js";
-import { type ContractChange, type ContractTerms } from "./contract-changes.js";
-import { canonicalJsonUndefinedAsNull } from "./canonical-json.js";
-export declare const PLANNER_SOURCE_VERSION = 1;
-export declare const PLANNER_SOURCE_LIMITS: {
-    /** The whole recorded source before lossless prompt fencing. Equal to
-     * the evidence cap for its artifact kind, so a recorded source is never
-     * truncated: what the record holds is exactly what the planner read. */
-    readonly bytes: number;
-    /** A planner's amendment note: why the filed contract must change. */
-    readonly amendment: 1000;
-    /** Earlier answers quoted into the brief. */
-    readonly answers: 5;
-    /** Terms that exceed the entire handoff cap cannot fit regardless of the plan's size. Do not reserve a maximum-
-     * sized plan here: a shorter document can carry larger valid terms. The final payload still enforces its byte cap. */
-    readonly handoffTerms: number;
-};
-export type PlannerContractScope = ContractTerms & {
-    /** The filed row's digest — the exact bytes the terms carry today. */
-    digest: string;
-    terms: {
-        riskLevel: RiskLevel;
-        qualityMode: QualityMode;
-        budgetMicrousd: number | null;
-        /** The resolved build agent, when the filing resolved one. */
-        agent: {
-            provider: string;
-            model: string;
-        } | null;
-        profile: Scope["profile"];
-        routeJson: string | null;
-        chainJson: string | null;
-        profileState: "resolved" | "unresolved" | null;
-        unresolvedReason: string | null;
-    };
-    /** A scope the planner is asked about is never approved (requestPlan
-     * refuses that), but it may have been approved once and then rewritten
-     * — the operator's earlier yes is context worth quoting. */
-    approval: {
-        state: "none" | "changed";
-        approvedDigest: string | null;
-        approvedBy: string | null;
-    };
-    proposedVia: import("./scope.js").ScopeAuthor | null;
-};
-export type PlannerContract = {
-    /** null: no scope was filed — the title is the only filed intent, and
-     * the planner drafts the contract from scratch (the legacy road). */
-    scope: PlannerContractScope | null;
-    task: {
-        id: string;
-        title: string;
-        repo: string | null;
-        routeOverrides: import("./store.js").TaskRef["routeOverrides"];
-        agentPin: {
-            provider: string | null;
-            model: string | null;
-        };
-        planPin: {
-            provider: string | null;
-            model: string | null;
-        };
-        deliverable: "branch" | "report";
-        riskLevel: RiskLevel | null;
-        qualityMode: QualityMode | null;
-        permissionMode: string | null;
-    };
-    /** The revision brief this task builds against, by artifact identity
-     * and hash (the content is quoted separately, from a verified read). */
-    revision: {
-        of: string;
-        briefArtifact: number;
-        briefSha256: string;
-    } | null;
-};
-export type PlannerAnswer = {
-    question: string;
-    choice: string;
-    note: string | null;
-};
-export type PlannerSource = {
-    version: typeof PLANNER_SOURCE_VERSION;
-    taskId: string;
-    title: string;
-    contract: PlannerContract;
-    /** sha256 over the canonical contract — the source identity. */
-    sourceDigest: string;
-    /** The verified brief text, when `contract.revision` names one. */
-    revisionBrief: string | null;
-    answers: PlannerAnswer[];
-    /** v126: the outside event the work started from, from the task's own kept source (task-source.ts): its sender's
-     * data, never an instruction. Absent for every other task, so their recorded bytes are what they always were. */
-    outsideReference?: string;
-};
-/** Stable JSON for hashing and equality only — no filling, no trimming. */
-export declare const canonicalContractJson: typeof canonicalJsonUndefinedAsNull;
-export declare function plannerSourceDigest(contract: PlannerContract): string;
-/**
- * The contract part, read from the store alone — no file I/O — so the plan
- * ingestion can re-derive it inside its own transaction and compare
- * digests. The revision brief enters by artifact id and sha256: the row
- * is immutable, and the hash is what a verified read proves against.
- */
-export declare function plannerContractOf(store: Store, taskId: string): {
-    ok: true;
-    contract: PlannerContract;
-} | {
-    ok: false;
-    reason: "no-task" | "revision-brief";
-    message: string;
-};
-export type PlannerSourceResult = {
-    ok: true;
-    source: PlannerSource;
-    bytes: number;
-} | {
-    ok: false;
-    reason: "no-task" | "revision-brief" | "oversized" | "too-long";
-    message: string;
-};
-/**
- * Everything a planning attempt is given, assembled once per attempt from
- * the store and the verified evidence root, and measured against the byte
- * cap BEFORE anything is leased or spent. A brief that cannot be read is a
- * refusal in words (the builder's rule for the same artifact), never a
- * plan drafted without half its contract.
- */
-export declare function plannerSourceOf(store: Store, root: string, taskId: string, answers: readonly PlannerAnswer[]): PlannerSourceResult;
-/**
- * The dispatch diagnosis's read of the same gate, from the store alone:
- * why the next pass would refuse to plan this task before spending — the
- * revision brief unreadable, the filed request over the byte cap, or terms
- * the planner's handoff cannot carry. The size is a floor (the brief's
- * stored bytes, before JSON quoting), so a "yes" here is certain and the
- * dispatch refusal itself stays the exact word. Null when nothing here
- * stands in the way.
- */
-export declare function plannerSourceProblemOf(store: Store, taskId: string): {
-    title: string;
-    detail: string;
-} | null;
-/**
- * Whether the planner can hand the filed terms back (contracts/plan.ts): it must reproduce the goal, exclusions,
- * touches and criteria in its handoff, so terms its handoff cannot carry would end every attempt as a malformed plan.
- * This names the problem before any workspace, run or provider spend instead: the actual size, the limit, and what to
- * shorten. Null when the terms fit.
- */
-export declare function plannerHandoffProblemOf(terms: ContractTerms): string | null;
-/** The exact bytes recorded as evidence; prompt fencing preserves the JSON value. */
-export declare function encodePlannerSource(source: PlannerSource): Buffer;
-/** Read a recorded source back; null when the bytes are not one. */
-export declare function decodePlannerSource(content: Buffer): PlannerSource | null;
-export { contractChangesOf, type ContractChange, type ContractTerms } from "./contract-changes.js";
-/** One line per change, for terminals, notifications, and validation messages. */
-export declare function describeContractChanges(changes: readonly ContractChange[]): string[];
-/**
- * The ingestion record written beside the plan document: the filed terms
- * the attempt started from, what the planner proposed, the explicit
- * amendment (or its absence), and the mechanical changes between the two.
- * The task and approval views read this to show what the yes would accept.
- */
-export type PlanContractRecord = {
-    version: typeof PLANNER_SOURCE_VERSION;
-    sourceDigest: string;
-    /** The recorded source artifact of the same run, when the write succeeded. */
-    sourceArtifact: number | null;
-    filed: ContractTerms | null;
-    /** What landed as the scope row. A view proves the record is still the
-     * CURRENT draft by comparing these terms to the row — an operator's
-     * later edit makes the record history, not a claim about the row. */
-    proposed: ContractTerms;
-    amendment: string | null;
-    changes: ContractChange[];
-};
-export declare function encodePlanContractRecord(record: PlanContractRecord): Buffer;
-export declare function decodePlanContractRecord(content: Buffer): PlanContractRecord | null;
-/**
- * One line, prefixed, with nothing that can end the block or start a new
- * rule — the builder's fence, applied to the planner's quoted source. The
- * source is quoted as pretty-printed JSON, so every control character an
- * operator's text carries arrives as a visible JSON escape: lossless, and
- * still one physical line per JSON line.
- */
-export declare function fenceSourceLine(text: string): string;
-export declare function plannerSourceBlock(source: PlannerSource): string[];

package/dist/planner.d.ts

@@ -1,76 +0,0 @@
-import type { ProviderId } from "./contracts/provider.js";
-import type { Store } from "./store.js";
-import { type ParsedDecision, type Problem } from "./decision.js";
-import { type ParsedPlan, type PlanProblem } from "./plan.js";
-import { type Runner } from "./builder.js";
-import { type PlannerSource } from "./planner-source.js";
-export type PlanRequest = {
-    /** v105: what's left of a monthly budget this API-key work counts toward (the CLI's own cap), when one does. */
-    maxBudgetUsd?: number;
-    taskId: string;
-    taskTitle: string;
-    taskRef: number;
-    runner: string;
-    leaseId: string;
-    /** The runner's credential for the credentialed pulse (arc 2 finding 33);
-     * absent, the beat keeps the unauthenticated touch. */
-    runnerToken?: string;
-    runId: number;
-    worktree: string;
-    branch: string;
-    now: Date;
-    clock?: () => Date;
-    model?: string;
-    /** The harness this planning session runs on. */
-    provider?: ProviderId;
-    maxTurns?: number;
-    timeoutMs?: number;
-    pulseMs?: number;
-    onProviderSpawn?: (pid: number) => void;
-    permissionMode?: string;
-    evidenceRoot?: string;
-    agent?: Runner;
-    git?: Runner;
-    /** Answered questions from earlier planning rounds, for the brief. */
-    answers?: readonly {
-        question: string;
-        choice: string;
-        note: string | null;
-    }[];
-    /** The filed request this attempt plans for (contract handoff, task 1):
-     * recorded as evidence by the caller BEFORE any spend, quoted whole into
-     * the brief, and the contract a drafted plan is checked against — a
-     * plan that changes filed terms without an explicit amendment is
-     * malformed. The same source rides every same-session correction. */
-    source: PlannerSource;
-};
-export type PlanOutcome = {
-    ok: true;
-    parked: {
-        decision: ParsedDecision;
-        artifactIds: number[];
-        repairRunId: number | null;
-    };
-} | {
-    ok: true;
-    drafted: {
-        plan: ParsedPlan;
-        artifact: {
-            key: string;
-            bytesOriginal: number;
-            bytesStored: number;
-            truncated: boolean;
-            sha256: string;
-            capture: string;
-        } | null;
-        repairRunId: number | null;
-    };
-} | {
-    ok: false;
-    /** malformed → straight incident; everything else → a planning strike. */
-    kind: "malformed" | "failure";
-    reason: string;
-    message: string;
-    problems?: (Problem | PlanProblem)[];
-};
-export declare function plan(store: Store, request: PlanRequest): Promise<PlanOutcome>;

package/dist/policy-ui.d.ts

@@ -1,22 +0,0 @@
-/**
- * Settings → Policy (sprint 8): the organisation policy — allowed providers,
- * models and tools, and the permission ceiling — and its history from the
- * action ledger. Anyone signed in reads it; an instance operator changes it
- * with their password.
- */
-import { type Html } from "./html.js";
-import type { LedgerEntry } from "./action-ledger.js";
-import { type SavedPolicy } from "./policy.js";
-/** The old look; the page is built from the kit now. Kept for chrome.ts, which still concatenates it. */
-export declare const POLICY_CSS = "";
-export type PolicyView = {
-    policy: SavedPolicy;
-    history: LedgerEntry[];
-    canChange: boolean;
-    /** The project tools here, as a hint for the tools list. */
-    toolNames: string[];
-};
-export declare function policyHtml(view: PolicyView, outcome: {
-    said?: string | null;
-    problem?: string | null;
-}): Html;

package/dist/policy.d.ts

@@ -1,92 +0,0 @@
-import type { Database } from "./store.js";
-import type { ExecutionProfile } from "./scope.js";
-export type PermissionLevel = "safe" | "standard" | "escalated";
-export declare const PERMISSION_LEVELS: readonly PermissionLevel[];
-export declare const POLICY_PROVIDERS: readonly ["claude", "codex", "gemini", "openrouter", "opencode", "cursor", "cline", "qwen", "goose"];
-export type PolicyProvider = (typeof POLICY_PROVIDERS)[number];
-/** The policy as saved: null lists allow everything of their kind. */
-export type OrgPolicy = {
-    providers: PolicyProvider[] | null;
-    models: string[] | null;
-    tools: string[] | null;
-    ceiling: PermissionLevel;
-};
-export type SavedPolicy = OrgPolicy & {
-    updatedBy: string | null;
-    updatedAt: string | null;
-};
-export declare const OPEN_POLICY: OrgPolicy;
-/** v105 keeps its version: the policy is a table of its own, made beside the spend tables. One row, or none. */
-export declare const POLICY_SCHEMA = "\nCREATE TABLE IF NOT EXISTS org_policy (\n  id             INTEGER PRIMARY KEY CHECK (id = 1),\n  providers_json TEXT,\n  models_json    TEXT,\n  tools_json     TEXT,\n  ceiling        TEXT NOT NULL DEFAULT 'escalated' CHECK (ceiling IN ('safe', 'standard', 'escalated')),\n  updated_by     TEXT NOT NULL,\n  updated_at     TEXT NOT NULL\n);\n";
-/** The policy in force. A missing table (a database not yet opened by this build) reads as open. */
-export declare function readPolicy(db: Database): SavedPolicy;
-export declare const PROVIDER_NAMES: Record<PolicyProvider, string>;
-export declare const LEVEL_NAMES: Record<PermissionLevel, string>;
-export declare const LEVEL_HINTS: Record<PermissionLevel, string>;
-/** Where a refusal sends people. */
-export declare const WHERE = "An instance operator can change it in Settings \u2192 Policy.";
-/** A provider id as the policy knows it: chat and key variants count as their provider. */
-export declare function policyProvider(provider: string): PolicyProvider | null;
-/** Each rule in words, for the page, the command and the ledger. */
-export declare function policyParts(policy: OrgPolicy): {
-    providers: string;
-    models: string;
-    tools: string;
-    ceiling: string;
-};
-export declare function isOpen(policy: OrgPolicy): boolean;
-/** Whether a model id matches an entry: the same id (any case), or a prefix ending in `*`. */
-export declare function modelMatches(entry: string, model: string): boolean;
-/** Why the policy stops an agent on this provider and model, or null. A default model ("default", or none) can't be
- * checked against a model list, so a list stops it. */
-export declare function agentRefusal(policy: OrgPolicy, provider: string, model: string | null): string | null;
-/** Why the policy stops agents using a project tool, or null. */
-export declare function toolRefusal(policy: OrgPolicy, tool: string): string | null;
-export declare const levelAbove: (level: PermissionLevel, ceiling: PermissionLevel) => boolean;
-/** The level a profile runs at. */
-export declare function levelOfProfile(profile: ExecutionProfile): PermissionLevel;
-/** A level's words for one provider: "Full access", "Auto", "Accept edits". */
-export declare function levelWords(profile: ExecutionProfile): string;
-export type CeilingVerdict = {
-    ok: true;
-    profile: ExecutionProfile;
-    lowered: null;
-} | {
-    ok: true;
-    profile: ExecutionProfile;
-    lowered: string;
-} | {
-    ok: false;
-    message: string;
-};
-/** Hold a profile to the ceiling: as it is, lowered (and the words say so), or refused (and the words say why). */
-export declare function underCeiling(policy: OrgPolicy, profile: ExecutionProfile): CeilingVerdict;
-/** Why the ceiling stops a planner, scout or native coding session on this provider, or null. They carry no sealed
- * profile to lower: on Claude and Gemini they edit only (Safe); on Codex and OpenRouter they run in the workspace
- * sandbox (Standard), those providers' lowest. */
-export declare function sessionCeilingRefusal(policy: OrgPolicy, provider: string, what: string): string | null;
-/** Everything the policy says about a profile before it runs: refused (words), or what runs and any lowering. */
-export declare function profileVerdict(policy: OrgPolicy, profile: ExecutionProfile): CeilingVerdict;
-/** At approval, a person signs exact terms: anything above the ceiling is refused with words (a new filing is lowered). */
-export declare function approvalRefusal(policy: OrgPolicy, profiles: readonly ExecutionProfile[], legs?: readonly {
-    provider: string;
-    model: string | null;
-}[]): string | null;
-/** Read a list typed by a person: commas or new lines, trimmed, no repeats; blank is "any". */
-export declare function parseList(text: string | null | undefined): string[] | null;
-/** Check a policy before it's saved. */
-export declare function checkPolicy(input: {
-    providers: readonly string[] | null;
-    models: readonly string[] | null;
-    tools: readonly string[] | null;
-    ceiling: string;
-}): {
-    ok: true;
-    policy: OrgPolicy;
-} | {
-    ok: false;
-    problem: string;
-};
-/** The providers ticked on the policy form: every provider the policy knows ticked (and nothing unknown) means "any"
- * (null), so a provider added later is allowed too; anything else is the list as ticked, for checkPolicy to check. */
-export declare function chosenProviders(chosen: readonly string[]): string[] | null;

package/dist/prepared-evidence.d.ts

@@ -1,17 +0,0 @@
-import { type ParsedProof } from './proof.js';
-export declare const PREPARED_EVIDENCE_FILE = "standing-orders.evidence.json";
-/** Read flags: --no-lazy-fetch where git has it; a partial clone is refused where it doesn't (teardown-git.ts). */
-export declare const preparedEvidenceGit: () => string[];
-export type PreparedEvidence = {
-    proof: ParsedProof;
-    files: {
-        path: string;
-        sha256: string;
-        cap: number;
-    }[];
-};
-/** Reads immutable Git objects; local/untracked files cannot fill a missing entry. */
-export declare function readPreparedEvidence(repo: string, candidate: string, required?: boolean): PreparedEvidence | null;
-export declare function preparedScreenshotMatches(inventory: PreparedEvidence, path: string, bytes: Buffer): boolean;
-/** After checkout/setup, read without following links and mint this worker's receipt. */
-export declare function writePreparedEvidence(worktree: string, nonceFile: string, inventory: PreparedEvidence): void;