toolroll 0.9.104 → 0.9.105

package/dist/test-infra.d.ts

@@ -1,34 +0,0 @@
-/** The product's entry points: the CLI binary, the processes it starts by file name, and the browser bundles. */
-export declare const PRODUCT_ENTRIES: readonly string[];
-/** A specifier reached from the tests that names no repository file and no known package: `prefix` is the repository
- * path it might name (a folder or file stem), or null when it might name anything. */
-export type Unresolved = {
-    from: string;
-    specifier: string | null;
-    prefix: string | null;
-};
-export type TestInfrastructure = {
-    infra: Set<string>;
-    unresolved: Unresolved[];
-    /** What the product's entry points reach (trusted product code, by Alex's decision). */
-    product: Set<string>;
-};
-/**
- * The infrastructure among `files` (path → text: the tree's sources, and its tsconfig.json and package.json): reachable
- * from a test root — every test file, every file under `test/`, every vitest config and its setup files — not itself a
- * test, and not reachable from PRODUCT_ENTRIES; plus every specifier reached from a test root that couldn't be resolved.
- */
-export declare function testInfrastructure(files: ReadonlyMap<string, string>, allPaths?: ReadonlySet<string>): TestInfrastructure;
-/**
- * Whether a changed path is something an unresolved specifier might name. A computed one (no prefix) might name anything
- * the other rules don't already trust: any source file that is neither a test nor product code.
- */
-export declare function mightName(open: Unresolved, path: string, found: TestInfrastructure): boolean;
-/** Whether a path is a test file by any extension a test runner could be pointed at, not only those run today. */
-export declare const isTestPath: (path: string) => boolean;
-/**
- * Why a new test file can't carry on what it imports, or null (docs/plans/trusted-release-reports.md, H4). A test file is
- * never infrastructure here, so nothing else looks at an edge between two of them, and importing one runs its top level
- * (its `vi.mock`s and hooks included) in the importer. A computed import might name one, so it refuses too.
- */
-export declare function testImportProblem(path: string, text: string): string | null;

package/dist/test-temp.d.ts

@@ -1,40 +0,0 @@
-/** In a suite's temp root: who made it (scripts/suite-lifecycle.mjs). */
-export declare const OWNER_FILE = ".toolroll-temp-owner";
-export type TempOwner = {
-    pid: number;
-    startedAt: number;
-};
-/** Name prefixes of what tests, journeys and scripts leave in the temp folder. */
-export declare const TEST_TEMP_PREFIXES: readonly string[];
-/** Who made a temp root, from its owner file; null when it has none (older suites, scripts, Playwright). */
-export declare function tempOwner(path: string): TempOwner | null;
-export declare function isTestTemp(name: string): boolean;
-/** Where they collect: the temp folder (and /tmp, where some scripts write). */
-export declare function tempRoots(): string[];
-export type TempLeftover = {
-    path: string;
-    touchedAt: number;
-};
-/** Every test temp folder in `roots`, and which of them nothing has touched for a day. */
-export declare function testTempFolders(roots: readonly string[], now: Date): {
-    all: TempLeftover[];
-    stale: TempLeftover[];
-};
-export type RemoveOptions = {
-    /** Whether a temp root's owner (by its owner file) is still running: its root stays, however old it looks. */
-    ownerAlive?: (owner: TempOwner) => boolean;
-    /** At most this many go in one pass (a sweep after weeks can find 100,000); `more` says some were left. */
-    max?: number;
-    /** Something live work uses (storage-sweep.ts): asked right before each folder goes; true keeps it. */
-    spare?: (path: string) => boolean;
-};
-/**
- * Remove the test temp folders nothing has touched for a day; each is looked at again right before it goes (still a
- * folder of its own, not a link, still directly in its temp folder, still a day untouched, its owner gone, nothing
- * live using it). Removal never holds the event loop: a worker's heartbeats keep beating while thousands go.
- */
-export declare function removeStaleTestTemp(roots: readonly string[], now: Date, options?: RemoveOptions): Promise<{
-    removed: string[];
-    failed: string[];
-    more: boolean;
-}>;

package/dist/text-limits.d.ts

@@ -1,297 +0,0 @@
-/**
- * Text limits, in one place, and the one way a limit is met: a model is told the exact limit before it writes, an
- * answer still over it is asked once to shorten (one repair turn), and an answer still over after that is kept whole
- * in the record and linked, never chopped. Chat platforms' own message limits are met by splitting across messages.
- *
- * Limits apply when text is written. Reading never re-validates length, so a runtime with lower limits (0.9.23 to
- * 0.9.26) still opens a store holding longer text (scripts/upgrade-path.mjs, the rollback leg).
- */
-/** UTF-16 code units, the JavaScript and HTML maxlength measure, unless a name says bytes. */
-export declare const TEXT_LIMITS: {
-    /** A task's goal and its out-of-scope text. */
-    readonly goal: 8000;
-    readonly goalBytes: 32000;
-    /** Revise feedback, steering and decision notes. */
-    readonly note: 4000;
-    readonly noteBytes: 16000;
-    /** A flow work zone's instructions; nothing is held back for the card's details (they are attached when long). */
-    readonly flowInstructions: 8000;
-    /** A flow's zones and steps (src/contracts/flow.ts): a zone's name, a step's id as written, and a reference to another step. */
-    readonly flowTitle: 60;
-    readonly flowStepId: 32;
-    readonly flowRef: 60;
-    /** A Message zone's message, or the comment an Update zone leaves. */
-    readonly flowMessage: 1000;
-    /** Who decides a "Person decides" zone (a sign-in name), and the subagent who works a zone, as written. */
-    readonly flowDecider: 64;
-    readonly flowSubagent: 40;
-    /** A Build zone's other project: its path. */
-    readonly flowRepo: 1000;
-    /** A script's or subagent's answer, a choice's button, a Sort zone's answer and what it means, its question, and a score's level. */
-    readonly flowAnswer: 40;
-    readonly flowChoice: 40;
-    readonly flowSortMeans: 200;
-    readonly flowSortQuestion: 300;
-    readonly flowSortLevel: 120;
-    /** A Web request zone's address, one header's value and the body it sends (an email's body too). */
-    readonly flowUrl: 2000;
-    readonly flowHeader: 500;
-    readonly flowBody: 8000;
-    /** An email's recipients and subject. */
-    readonly flowEmailTo: 500;
-    readonly flowEmailSubject: 200;
-    /** A tool zone's tool (MCP server), its function, and the arguments as JSON. */
-    readonly flowToolServer: 64;
-    readonly flowToolName: 100;
-    readonly flowToolArgs: 4000;
-    /** A wait or reminder said in words ("3 days"), and a time zone's name. */
-    readonly flowDuration: 40;
-    readonly flowTimeZone: 60;
-    /** A flow's name, and a flow file's about line, needs, parameter questions and answers, and scripts. */
-    readonly flowName: 80;
-    readonly flowFileAbout: 600;
-    readonly flowFileNeed: 80;
-    readonly flowParameter: 200;
-    readonly flowScriptAbout: 160;
-    readonly flowScriptBody: 20000;
-    readonly flowScriptFile: 200;
-    /** A trigger's settings: a button's label and questions, a schedule and the card it makes, GitHub, Linear, webhook and email terms. */
-    readonly triggerButton: 40;
-    readonly triggerQuestion: 80;
-    readonly triggerSchedule: 80;
-    readonly triggerTitle: 200;
-    readonly triggerDescription: 2000;
-    readonly triggerGithubRepo: 140;
-    readonly triggerLabel: 50;
-    readonly triggerBranch: 100;
-    readonly triggerTeam: 12;
-    readonly triggerState: 40;
-    readonly triggerWebhookTitle: 120;
-    readonly triggerWebhookField: 80;
-    /** v126: a Sentry or Vercel project (or Vercel team) a signed webhook is scoped to. */
-    readonly triggerWebhookScope: 120;
-    readonly triggerFolder: 100;
-    readonly triggerSender: 300;
-    readonly triggerSubject: 100;
-    /** A schedule's secrets written as one line ("API_KEY, CRM_TOKEN"). */
-    readonly triggerSecrets: 500;
-    /** A card the lead adds to a flow: its title and description; a script it saves inline. */
-    readonly flowCardTitle: 200;
-    readonly flowCardDescription: 4000;
-    readonly flowScriptInline: 1600;
-    /** A research report's summary, in UTF-8 bytes. */
-    readonly reportSummary: 2500;
-    /** A scout's whole report file (src/contracts/scout-report.ts), in UTF-8 bytes. */
-    readonly reportPayloadBytes: number;
-    /** A report's document (markdown), in UTF-8 bytes. */
-    readonly reportDocumentBytes: number;
-    /** A report's title, and a follow-up's or an item's title, in UTF-8 bytes. */
-    readonly reportTitleBytes: 200;
-    /** Why an item fits, in UTF-8 bytes. */
-    readonly reportWhyBytes: 1000;
-    /** A web address a report cites, in UTF-8 bytes. */
-    readonly reportUrlBytes: 2000;
-    /** A screenshot's caption and its file name, in UTF-8 bytes. */
-    readonly reportCaptionBytes: 300;
-    /** What one flow step passes on to the steps after it. */
-    readonly stageOutput: 12000;
-    /** The planner's whole handoff file, in UTF-8 bytes. */
-    readonly planPayloadBytes: number;
-    /** The plan document (markdown), in UTF-8 bytes. */
-    readonly planDocumentBytes: number;
-    /** The plan document's Approach section. */
-    readonly planApproach: 2000;
-    /** One Milestones, Dependencies, Risks or Proof item in the plan document. */
-    readonly planItem: 600;
-    /** One path a plan expects to touch. */
-    readonly planTouch: 200;
-    /** How many paths a task's scope may say it touches (a plan says at most 32 of them). A count, not a length. */
-    readonly scopeTouches: 50;
-    /** Why a task was sized as it was, as its sealed route keeps it. */
-    readonly sizeReason: 300;
-    /** A planner's amendment note: why the filed contract must change. */
-    readonly planAmendment: 1000;
-    /** An acceptance criterion's id, statement and advisory how, in UTF-8 bytes. */
-    readonly acceptanceIdBytes: 40;
-    readonly acceptanceStatementBytes: 1000;
-    readonly acceptanceHowBytes: 500;
-    /** A builder's whole proof file, in UTF-8 bytes. */
-    readonly proofPayloadBytes: number;
-    /** A proof criterion's id, in UTF-8 bytes. */
-    readonly proofCriterionIdBytes: 40;
-    /** How a proof criterion was met, in UTF-8 bytes. */
-    readonly proofHowBytes: 500;
-    /** One proof line — a criterion statement, evidence ref, check command or summary, changed path, caveat, or
-     * screenshot path or caption — in UTF-8 bytes. */
-    readonly proofLineBytes: 300;
-    /** The task sizing classifier's reason (src/contracts/task-sizing.ts). */
-    readonly sizingReason: 160;
-    /** A review comment's or build-review finding's path, and its note or failure scenario (src/contracts/review-findings.ts). */
-    readonly reviewPath: 300;
-    readonly reviewNote: 500;
-    /** A parked decision (src/contracts/decision.ts): its recap and question, an option's id, label and consequence, and who it is for. */
-    readonly decisionRecap: 2000;
-    readonly decisionQuestion: 2000;
-    readonly decisionOptionId: 40;
-    /** A decision's recommendation: an option's id, optionally followed by ": " and why. */
-    readonly decisionRecommendation: 500;
-    readonly decisionLabel: 120;
-    readonly decisionConsequence: 500;
-    readonly decisionAssignee: 120;
-    /** A subagent's turn (src/contracts/subagent-turn.ts): the answer it picks (and each option it offers), its question, its reason and what it remembers. */
-    readonly subagentAnswer: 60;
-    readonly subagentQuestion: 600;
-    readonly subagentReason: 400;
-    readonly subagentRemember: 300;
-    /** The lead's tools and the MCP gateway (src/contracts/lead-tools.ts, gateway-tools.ts): a task's id as a tool names
-     * it, a task's title and one path it touches, and a project's path as the gateway names it (an assignment brief or
-     * project context, and the rest of the gateway). */
-    readonly taskRef: 64;
-    readonly taskTitle: 200;
-    readonly taskTouch: 200;
-    readonly projectPath: 4096;
-    readonly gatewayRepo: 800;
-    /** A project-context query, a check-log search, a memory search, a task search and a changed file's path. */
-    readonly contextQuery: 1000;
-    readonly logSearch: 120;
-    readonly memorySearch: 300;
-    readonly taskSearch: 200;
-    readonly diffPath: 300;
-    /** A hold's or cancel's reason, an answer's rationale and option, a worker's name, an agent change's reason, a
-     * provider and model name, how a task's checks were asked for, and an ISO time a recap counts from. */
-    readonly proposalReason: 200;
-    readonly answerRationale: 400;
-    readonly answerOption: 64;
-    readonly workerName: 60;
-    readonly agentWhy: 400;
-    readonly agentProvider: 20;
-    readonly agentModel: 120;
-    readonly checksWords: 80;
-    readonly recapSince: 30;
-    /** A shared action's fields as the lead proposes them (propose_action). */
-    readonly actionSample: 800;
-    readonly actionContent: 12000;
-    readonly actionTitle: 120;
-    readonly actionName: 40;
-    readonly actionCommand: 400;
-    readonly actionUrl: 500;
-    readonly actionSecret: 64;
-    readonly actionAbout: 240;
-    /** A subagent change (propose_subagent): a soul section's title, a routine's schedule, a tool, an action, a limit's
-     * field, a name, a soul file, a note, a choice and text. */
-    readonly subagentSection: 60;
-    readonly subagentSchedule: 80;
-    readonly subagentTool: 40;
-    readonly subagentAction: 64;
-    readonly subagentName: 40;
-    readonly subagentSoul: 12000;
-    readonly subagentNote: 300;
-    readonly subagentChoice: 60;
-    readonly subagentText: 2000;
-    /** A project knowledge reference id, a promise and why it is released, what the lead remembers (its text, a
-     * decision's reason and source), a person's name, and a question to the owner with its options. */
-    readonly knowledgeReference: 20;
-    readonly promise: 240;
-    readonly rememberText: 240;
-    readonly rememberWhy: 2000;
-    readonly rememberSource: 200;
-    readonly personName: 80;
-    readonly ownerQuestion: 200;
-    readonly ownerOption: 40;
-    /** A gateway filing's idempotency key. */
-    readonly idempotencyKey: 64;
-    /** The lead's catch-up bundle (src/contracts/lead-context.ts), in UTF-8 bytes, and the lines it clips: an open promise,
-     * a confirmed correction, the end of changed instructions a correction shows, and what an open proposal is about. */
-    readonly leadContextBytes: 8000;
-    readonly leadPromise: 160;
-    readonly leadCorrection: 300;
-    readonly leadCorrectionInstructions: 240;
-    readonly leadProposalAbout: 120;
-    /** Project knowledge (src/contracts/project-knowledge.ts), in UTF-8 bytes: the instructions (also the memory pass's
-     * budget for them), a reference's title, path and text, the context a run gets, the decision lines in it, and the
-     * repository excerpts added when at least the minimum is left. */
-    readonly knowledgeInstructionsBytes: 4000;
-    readonly knowledgeTitleBytes: 120;
-    readonly knowledgePathBytes: 300;
-    readonly knowledgeReferenceBytes: 12000;
-    readonly knowledgeContextBytes: 24000;
-    readonly knowledgeDecisionsBytes: 1500;
-    readonly knowledgeRepositoryBytes: 6000;
-    readonly knowledgeRepositoryMinBytes: 3000;
-    /** A project decision (src/contracts/project-memory.ts), in UTF-8 bytes: the choice, why, who decided, where it came
-     * from, and why it was retired. */
-    readonly decisionClaimBytes: 240;
-    readonly decisionWhyBytes: 2000;
-    readonly decisionByBytes: 80;
-    readonly decisionSourceBytes: 200;
-    readonly decisionRetireBytes: 500;
-    /** A skill package (src/contracts/project-skills.ts): its name, description, requirements and source in UTF-8 bytes,
-     * a file's path, SKILL.md, one file, the package and the enabled selection in bytes; a test's sample request and
-     * feedback in characters and bytes. */
-    readonly skillNameBytes: 64;
-    readonly skillDescriptionBytes: 1024;
-    readonly skillRequirementsBytes: 500;
-    readonly skillSourceBytes: 500;
-    readonly skillPath: 240;
-    readonly skillBodyBytes: number;
-    readonly skillFileBytes: number;
-    readonly skillPackageBytes: number;
-    readonly skillSelectionBytes: number;
-    readonly skillSample: 800;
-    readonly skillSampleBytes: 4000;
-    readonly skillFeedback: 500;
-    readonly skillFeedbackBytes: 2000;
-    /** The memory pass (src/contracts/memory-pass.ts): one session's trace, and in its verdict an effect, a mistake and
-     * the instruction it proposes. */
-    readonly memoryTrace: 40000;
-    readonly memoryEffect: 300;
-    readonly memoryMistake: 300;
-    readonly memoryInstruction: 240;
-    /** A Telegram button's callback_data, in UTF-8 bytes: Telegram refuses a button with more. */
-    readonly telegramCallbackDataBytes: 64;
-};
-export type TextLimitKey = keyof typeof TEXT_LIMITS;
-/** One chat message on each platform. Longer text is split across messages, never cut. Teams: the text one Adaptive Card
- * holds, well inside its 28 KB message. */
-export declare const PLATFORM_LIMITS: {
-    readonly telegram: 4096;
-    readonly discord: 2000;
-    readonly slack: 4000;
-    readonly teams: 6000;
-};
-export type Platform = keyof typeof PLATFORM_LIMITS;
-/** The line a model reads before it writes a field with a limit. */
-export declare function limitRule(what: string, limit: number, unit?: "characters" | "bytes", shorten?: boolean): string;
-/** One field over its limit: what it is, its limit, and how long it came back. */
-export type Overrun = {
-    field: string;
-    limit: number;
-    length: number;
-    unit?: "characters" | "bytes";
-};
-/** How long a text is in a limit's unit. */
-export declare const lengthIn: (text: string, unit?: "characters" | "bytes") => number;
-/** The fields of `values` over their limits. */
-export declare function overruns(values: Record<string, string>, limits: Record<string, number>, unit?: "characters" | "bytes"): Overrun[];
-/** The repair turn's ask: each field over its limit, by how much, and the same answer again within it. */
-export declare function shortenAsk(over: readonly Overrun[]): string;
-/**
- * Ask, check, and ask once more to shorten. `write` gets null the first time and the shorten ask the second.
- * The second answer is returned whatever its length: the caller keeps it whole (and links it when it must).
- */
-export declare function writeWithin<T>(write: (shorten: string | null) => Promise<T>, check: (answer: T) => Overrun[]): Promise<{
-    answer: T;
-    over: Overrun[];
-    repaired: boolean;
-}>;
-/**
- * Text passed on under a limit: whole when it fits; otherwise kept whole in the record named by `where` and passed on
- * as a pointer to it. Never a cut.
- */
-export declare function passOn(text: string, limit: number, where: {
-    label: string;
-    href: string | null;
-}, holds?: string): {
-    text: string;
-    kept: boolean;
-};

package/dist/tidy.d.ts

@@ -1,130 +0,0 @@
-import { type Store } from "./store.js";
-import type { WorkSummaryAccess } from "./work-summary.js";
-export type TidyRule = "release" | "routine" | "ci" | "finished";
-/** The preview's groups, in order. "finished" is a person's own choice only; tidy never applies it on its own. */
-export declare const TIDY_GROUPS: readonly {
-    rule: TidyRule;
-    label: string;
-}[];
-export declare const TIDY_DEFAULT_DAYS = 14;
-/** At most this many tasks are put away automatically per pass. */
-export declare const TIDY_PASS_LIMIT = 25;
-/** One task tidy would put away: its family's current task, every version that goes with it (`members`, task_ref ids),
- * why, and under which rule. */
-export type TidyItem = {
-    rule: TidyRule;
-    taskId: string;
-    title: string;
-    repo: string | null;
-    reason: string;
-    updatedAt: string;
-    members: number[];
-};
-/** What the release journals say about one release task (release.ts writes them; read only). */
-export type ReleaseFact = {
-    taskId: string;
-    version: string;
-    product: string;
-    candidate: string;
-    superseded: boolean;
-    done: boolean;
-    published: boolean;
-    stopped: boolean;
-};
-/** Every release journal's facts, or why they can't be trusted: one unreadable journal leaves the release rule out. */
-export type ReleaseFacts = {
-    facts: ReleaseFact[];
-    problem: string | null;
-};
-/** Reads `releases/*.json` under the plane's state folder (the database's folder), written only by `toolroll release`.
- * A symlink, a non-file, an oversized or unreadable journal makes the whole answer untrusted (`problem`), so the
- * release rule then puts nothing away: a journal it can't read might be the one that says a release is in flight. */
-export declare function readReleaseFacts(stateDir: string): ReleaseFacts;
-/** The release journals beside this database (its folder is the plane's state folder). An in-memory or relative
- * database has no state folder, so the release rule stays off rather than reading whatever folder it runs in. */
-export declare function releaseFactsFor(databaseFile: string): ReleaseFacts;
-/** -1, 0 or 1: numeric parts first, then a release above any of its pre-releases. */
-export declare function compareVersions(a: string, b: string): number;
-/** The failing runs older "Checks failed" cards of this trigger name (their own GitHub run links) that aren't on record
- * yet, newest first, at most `limit`: the checks trigger reads each from GitHub so tidy can tell where it ran. */
-export declare function unprovenNoticeRuns(store: Store, trigger: number, repo: string, limit?: number): number[];
-/** A completed workflow run on the watched branch, as the checks trigger read it from GitHub (its poll through the
- * person's own gh login, or its signed webhook): kept once per run. Only a push to the watched branch of the watched
- * repository counts (a pull request from a fork whose branch is also called main does not). */
-export declare function recordBranchCheckRun(store: Store, watched: {
-    repo: string;
-    branch: string;
-}, run: {
-    id?: number | undefined;
-    name?: string | undefined;
-    head_sha?: string | undefined;
-    head_branch?: string | undefined;
-    conclusion?: string | undefined;
-    created_at?: string | undefined;
-    event?: string | undefined;
-    head_repository?: {
-        full_name?: string | undefined;
-    } | undefined;
-}, now: Date): boolean;
-/** What tidy would put away now, in group order, oldest first within a group. `days`: also offer finished tasks
- * untouched that long (a person's preview only); null is tidy's own automatic rules. `access`: whose lists. */
-export declare function tidyPreview(store: Store, now: Date, input: {
-    releases: ReleaseFacts;
-    days: number | null;
-    access?: WorkSummaryAccess;
-}): TidyItem[];
-/** The preview's identity: exactly which tasks under which rules, for how many days. A person's confirmation names it. */
-export declare function tidyDigest(items: readonly TidyItem[], days: number | null): string;
-/** The preview in its groups (empty ones left out), with each group's label. */
-export declare function tidyGroups(items: readonly TidyItem[], days: number): {
-    rule: TidyRule;
-    label: string;
-    items: TidyItem[];
-}[];
-/** A day count from a person (1–365), or the default. */
-export declare function tidyDays(raw: string | null | undefined): number | null;
-export type TidyApply = {
-    ok: true;
-    archived: TidyItem[];
-    skipped: {
-        taskId: string;
-        message: string;
-    }[];
-} | {
-    ok: false;
-    reason: "changed" | "outside" | "empty";
-    message: string;
-    items: TidyItem[];
-    digest: string;
-};
-/** A person puts away exactly what they previewed (or the ticked part of it), in one write transaction that recomputes
- * the preview and refuses when its digest moved or a ticked task isn't in it. */
-export declare function applyTidy(store: Store, now: Date, input: {
-    by: string;
-    days: number;
-    digest: string;
-    only: readonly string[] | null;
-    releases: ReleaseFacts;
-    access?: WorkSummaryAccess;
-}): TidyApply;
-/** Tidy on its own (the worker's reconcile pass): its automatic rules only, at most `limit` tasks, in one write
- * transaction. Idempotent: what is put away is skipped next time, and a restored task is never put away again. */
-export declare function runTidy(store: Store, now: Date, releases: ReleaseFacts, limit?: number, access?: WorkSummaryAccess): TidyItem[];
-/** Whether this person may still put away or restore work in this project, read under the write lock (check and write
- * together): an active approver who can see it. Null when they may; otherwise why not. */
-export declare function approverStandsNow(store: Store, name: string, repo: string | null): string | null;
-/** The repository of a task's family, from its first version (all versions share it). */
-export declare function familyRepoOf(store: Store, refs: readonly number[]): string | null;
-/** "Archived by tidy: <reason>" or "Archived by <person>: <reason>": the one sentence every surface shows. */
-export declare function archivedWords(archived: {
-    by: string;
-    byKind: "person" | "tidy";
-    reason: string;
-}): string;
-/** The release journals beside the store's own database file (none for an in-memory one). */
-export declare function releaseFactsOf(store: Store): ReleaseFacts;
-/** The lists one person sees, for tidy: every project for an unrestricted account, otherwise exactly theirs. The CLI's
- * preview (`--as <name>`) and its apply read the same scope, so the same records give the same digest. */
-export declare function accessOf(store: Store, name: string): WorkSummaryAccess;
-/** Narrows `access` to the caller's own lens (a remote person's project limit): never wider. No lens: unchanged. */
-export declare function withinLens(access: WorkSummaryAccess, lens: readonly string[] | null): WorkSummaryAccess;

package/dist/tier-report.d.ts

@@ -1,44 +0,0 @@
-/**
- * What sized routing saved (v2 routing), for `toolroll spend`: each task's
- * tier (recorded on the task when its route is filed), how long it took
- * from its first run to its first result, and whether it used a planner —
- * grouped by tier, with what the light tier saved: the plans small changes
- * skipped, results that came sooner, and spend below the everyday tier.
- */
-import type { SpendItem } from "./spend.js";
-import type { Database } from "./store.js";
-export type TierTask = {
-    taskId: string;
-    tier: string;
-    size: string | null;
-    planRuns: number;
-    minutesToResult: number | null;
-    microusd: number;
-};
-export type TierRow = {
-    tier: string;
-    tasks: number;
-    results: number;
-    medianMinutesToResult: number | null;
-    planRuns: number;
-    microusd: number;
-};
-export type TierSaved = {
-    /** Small changes that built with no planner run. */
-    plansSkipped: number;
-    /** Those skipped plans at this month's median planner run, in minutes; null when no planner run was measured. */
-    planMinutesSaved: number | null;
-    /** How much sooner a light result came than an everyday one (medians), in minutes; null without both. */
-    minutesSoonerEach: number | null;
-    /** Light tasks' spend below the everyday tier's average task, in micro-USD; null when either is unpriced or $0. */
-    microusdSaved: number | null;
-};
-export type TierReport = {
-    tasks: TierTask[];
-    rows: TierRow[];
-    saved: TierSaved;
-};
-/** Every routed task with a run in [from, to), by tier, and what the light tier saved. `items` are the month's spend. */
-export declare function tierReport(db: Database, from: string, to: string, items: readonly SpendItem[]): TierReport;
-/** The spend report's lines: one per tier, then what the tiers saved. Empty when no routed task ran this month. */
-export declare function tierLines(report: TierReport, usd: (microusd: number) => string): string[];

package/dist/token-notices.d.ts

@@ -1,11 +0,0 @@
-import type { Store } from "./store.js";
-export declare const TOKEN_NOTICE_KIND = "api-token-expiry";
-export declare function tokenNoticePass(store: Store, now: Date): {
-    sent: {
-        token: string;
-        days: number;
-    }[];
-    ended: number;
-};
-/** The loop beside the console: a pass a minute. */
-export declare function startTokenNotices(store: Store, everyMs?: number): () => void;

package/dist/tokens-cli.d.ts

@@ -1,21 +0,0 @@
-import type { Store } from "./store.js";
-export declare const TOKENS_ACTIONS: readonly ["create", "list", "revoke", "rotate"];
-/** The most a piped password may be: a password, not a file. */
-export declare const PASSWORD_STDIN_BYTES = 4096;
-export type TokensCliContext = {
-    store: Store;
-    write: (line: string) => void;
-    json: boolean;
-    clock: () => Date;
-    /** Who runs this: a remote caller (an API token, over /api/cli or /mcp) and the lead never manage tokens. */
-    caller: "local" | "remote" | "lead";
-    /** The remembered local login's name only (never its password): the default for --as. */
-    rememberedName: string | null;
-    /** Whether someone is at this terminal to answer a prompt. */
-    interactive: () => boolean;
-    ask: (question: string) => Promise<string>;
-    askHidden: (question: string) => Promise<string>;
-    /** Standard input, read whole up to `limit` bytes; null past the limit. */
-    readStdin: (limit: number) => Promise<string | null>;
-};
-export declare function runTokensCommand(positional: readonly string[], flags: ReadonlyMap<string, string | true>, context: TokensCliContext): Promise<number>;

package/dist/tool-broker.d.ts

@@ -1,52 +0,0 @@
-import type { ToolSpec } from "./contracts/integration-metadata.js";
-/** One tool a launch may use: its values (never leaving this process) and, for research, the only actions it offers. */
-export type BrokeredTool = {
-    spec: ToolSpec;
-    values: Record<string, string>;
-    actions?: readonly string[];
-};
-export type BrokerOptions = {
-    /** Where a local server's environment comes from (the launch's): only SERVER_ENV's names are taken from it. */
-    env?: NodeJS.ProcessEnv;
-    omitEnv?: readonly string[];
-    /** Toolroll's own settings for a local server (the run's isolated database), passed as they are. */
-    pass?: Readonly<Record<string, string>>;
-    /** Where a local server starts: a folder the build can't write (never its checkout). */
-    cwd?: string;
-    /** Folders the build writes (its checkout, its caches): a server whose command, or a path it's given, resolves inside
-     * one is never started, since it would run the build's own bytes outside the build's limits. */
-    untrusted?: readonly string[];
-    /** Why a local server may not start unwrapped (no fence for it here), read when it would; null when it may. */
-    unwrapped?: () => string | null;
-    /** How a local server is started inside its run's fence, read when it starts (the fence is fixed after the tools). */
-    wrap?: () => ((file: string, args: readonly string[], cwd?: string) => {
-        file: string;
-        args: string[];
-        env?: Record<string, string>;
-    }) | null;
-};
-export type ToolBroker = {
-    /** The launch's token: the agent's only key to its tools. */
-    token: string;
-    url: (name: string) => string;
-    /** Its loopback port: the one a confined network leaves reachable for its agent (agent-fence.ts NetworkFence). */
-    port: number;
-    /** The local servers running now (the fence tests read them). */
-    pids: () => number[];
-    /** Revoke the token, stop every server, close the port. */
-    close: () => void;
-};
-/** What a local server inherits from the launch: enough to run and find its tools, and nothing that could be
- * another tool's or a provider's secret. Its own configured values are added after. */
-export declare const SERVER_ENV: readonly string[];
-/** A local server's environment: the allowlisted names from `base` (and its LC_* locale), less `omit`, then `pass`,
- * then the tool's own values. */
-export declare function serverEnv(base: NodeJS.ProcessEnv, omit: readonly string[], pass: Readonly<Record<string, string>>, values: Readonly<Record<string, string>>): NodeJS.ProcessEnv;
-/**
- * The first of a server's command and path-like arguments that resolves inside an untrusted folder (a build's checkout
- * or caches), or null. The command is resolved as spawn would: a path against `cwd`, a bare name through PATH; an
- * argument counts when it names an existing path (relative to `cwd`) or is written as one (`./x`, `../x`, `/x`).
- */
-export declare function workspaceBytes(command: string, args: readonly string[], cwd: string | undefined, path: string | undefined, untrusted: readonly string[]): string | null;
-/** Start one launch's broker on a loopback port. */
-export declare function startToolBroker(tools: readonly BrokeredTool[], options?: BrokerOptions): Promise<ToolBroker>;

package/dist/tool-launcher.d.ts

@@ -1 +0,0 @@
-export {};