toolroll 0.9.104 → 0.9.105

package/dist/dispatch.d.ts

@@ -1,123 +0,0 @@
-/**
- * One read-side answer to "will this task run?"
- *
- * The atomic claim remains the authority. This module owns the task-local
- * predicates that claim re-proves under its write transaction, then layers
- * fleet observations on top for people and agents reading the queue. A
- * diagnosis can go stale; it can never grant a lease.
- */
-import { type Runner } from "./runner.js";
-import { type ChatSnapshot, type ReviewRequestOrigin, type ReviewRetryState, type Store, type TaskState } from "./store.js";
-export declare const DEFAULT_MAX_OPEN_DECISIONS = 5;
-export type TaskReadinessBlocker = {
-    code: "unknown-task";
-    message: string;
-} | {
-    code: "state";
-    state: TaskState;
-    message: string;
-} | {
-    code: "hold";
-    ownerKind: string;
-    until: string | null;
-    message: string;
-} | {
-    code: "dependency";
-    blockerId: string;
-    blockerState: TaskState;
-    message: string;
-} | {
-    code: "archived";
-    message: string;
-};
-export type DispatchAction = "open-result" | "retry-task" | "place-task" | "write-scope" | "select-agent" | "approve-scope" | "answer-decision" | "unhold" | "inspect-hold" | "repair-dependency" | "repair-capability" | "start-worker"
-/** v50: ask for the bounded explicit review retry (`task review <run>`
- * or the console's Retry review). */
- | "retry-review"
-/** v52: resume the exact stopped attempt (`task resume <id> --run <n>`
- * or the console's Resume). */
- | "resume-run";
-export type DispatchDiagnosisCode = "updating" | "complete" | "needs-verification" | "proof-refuted" | "review-pending" | "reviewing" | "review-failed"
-/** v50: every root review attempt ended without a review; nothing retries. */
- | "review-exhausted" | "cancelled" | "failed" | "running" | "vanished-run" | "retry-scheduled" | "waiting-decision" | "waiting-incident" | "held" | "storage-blocked"
-/** v52: an operator stopped one exact attempt; only resuming it lifts the pause. */
- | "stopped" | "waiting-dependency" | "terminal-dependency" | "needs-project" | "needs-scope" | "needs-agent-profile" | "needs-approval" | "missing-requirement" | "no-worker-registered" | "no-worker-online" | "worker-at-capacity" | "provider-quota"
-/** The provider's sign-in stopped working; its dispatch is paused. */
- | "signed-out" | "planning-ready" | "planner-source" | "scouting-ready" | "ready";
-export type DispatchDiagnosis = {
-    /** The four-state Never Stuck contract. */
-    condition: "running" | "retrying" | "waiting" | "terminal";
-    code: DispatchDiagnosisCode;
-    summary: string;
-    detail: string;
-    action: DispatchAction | null;
-    /** When the machine already knows the next automatic wake. */
-    nextAt: string | null;
-    /** The phase an eventual claim would dispatch. */
-    role: "builder" | "planner" | "scout" | null;
-    blockerTaskId: string | null;
-    /** v50: the finished build's bounded review-retry status — null until a
-     * review was ever asked for, and on every task that is not done. */
-    review: ReviewDispatchView | null;
-};
-/** The typed review-retry facts a dispatch reader gets (v50): the source
- * build, the projection's state word, how many root attempts ran and how
- * many explicit retries remain, and the latest attempt's recorded reason. */
-export type ReviewDispatchView = {
-    sourceRun: number;
-    state: ReviewRetryState["state"];
-    /** The attempt running, queued, or most recently ended (1..cap); null before any. */
-    attempt: number | null;
-    cap: number;
-    retriesUsed: number;
-    retriesRemaining: number;
-    /** The most recently ended root attempt's run id and stored reason. */
-    latestRun: number | null;
-    latestReason: string | null;
-    interrupted: boolean;
-    /** The open ask, when one is queued: who asked and how it was produced
-     * (explicit-only retries: a retry is always an operator's ask; an
-     * automatic producer queues attempt 1 only). */
-    queued: {
-        requestedBy: string;
-        origin: ReviewRequestOrigin;
-    } | null;
-};
-/**
- * Task state, active holds, and unfinished dependencies in the exact order
- * acquireIfReady checks them. The claim path calls this while holding its
- * write transaction; read surfaces call it only as a snapshot.
- */
-export declare function taskReadinessBlocker(store: Store, taskRef: number, now: Date): TaskReadinessBlocker | null;
-/** The exact live approval predicate used by both the scheduler survey and
- * the atomic claim. Mode-backed approvals count only while their signer and
- * mode still stand. */
-export declare function scopeApprovedForDispatch(store: Store, taskRef: number, now: Date): boolean;
-/** The phase the ordinary dispatch loop would choose before it resolves an
- * agent. */
-export declare function dispatchRoleFor(store: Store, taskRef: number, now: Date): "builder" | "planner" | "scout";
-/** The first requirement this task fails, in words, or null. */
-export declare function missingCapability(store: Store, taskRef: number, dispatchRepo: string | null, now: Date): string | null;
-/** The read-side lifecycle answer. Project access limits dependency detail, never the readiness gate. */
-/** The builders that may take work in `repo`, as dispatch decides: registered and not retired (`all`), bound to the
- * project (`eligible`; only the assigned one when a task names one), and checking in now (`alive`). The first-run
- * "Builder connected" step reads the same answer, so it is done only when a task there could start. */
-export declare function buildersFor(store: Store, repo: string, now: Date, assignedRunner?: string | null): {
-    all: Runner[];
-    eligible: Runner[];
-    alive: Runner[];
-};
-/** Whether a task in `repo` could start for want of nothing but a person: a live builder bound to it. */
-export declare function builderReadyFor(store: Store, repo: string | null, now: Date): boolean;
-/** The project the first-run "Builder connected" step speaks for, on Chat and the board alike: the open one; else the
- * saved project of the first filed task the viewer may see (All projects); else, only before any task exists, the
- * first managed project. Null when tasks exist but none sits in a project the viewer may see: then nothing says done. */
-export declare function firstRunBuilderRepo(store: Store, selected: string | null, visible: (repo: string | null) => boolean, managed: readonly string[]): string | null;
-export declare function diagnoseTaskDispatch(store: Store, taskId: string, now: Date, readableRepos?: readonly string[] | null): DispatchDiagnosis | null;
-export declare function diagnosisIsDispatchable(diagnosis: DispatchDiagnosis | null): boolean;
-/** Attach the same lifecycle answer to the bounded fleet snapshot used by
- * both direct chat and the long-running lead. */
-export declare function withDispatchDiagnoses(store: Store, snapshot: ChatSnapshot, now: Date): ChatSnapshot;
-/** When a backed-off task tries again, as a person reads it: "in under a minute", "in 3 minutes", or a later day's
- * time in UTC (the console's own clock words, when-html.ts shortWhen). */
-export declare function retryWhenWords(until: string, now: Date): string;

package/dist/dispose.d.ts

@@ -1,194 +0,0 @@
-import { STORAGE_HOLD_PREFIX } from "./needs-you.js";
-import { type FailureClass } from "./claim.js";
-import type { BuildResult } from "./builder.js";
-import type { ClosedState, Store } from "./store.js";
-import { type ProofVerdict } from "./proof.js";
-/**
- * Which road is disposing. 'tick' = the unattended loop: full task
- * completion, strikes, quota, publication. 'standalone' = the one-off
- * `build` command: run records only — no task state, no strikes, no
- * publication (its historical shape).
- */
-export type DisposePolicy = "tick" | "standalone";
-export type DisposeContext = {
-    store: Store;
-    policy: DisposePolicy;
-    /** The lease this attempt ran under; undefined only on the standalone road. */
-    leaseId: string | undefined;
-    runId: number;
-    taskId: string;
-    taskRef: number;
-    runner: string;
-    /** The canonical repo, for the publication grant lookup (tick policy). */
-    repo: string;
-    branch: string;
-    /** task_ref.origin — the publication selector consults it. */
-    origin: string;
-    provider: string;
-    model: string | null;
-    /** Where the attempt's tree lives — failure records name it. */
-    worktreePath: string;
-    /** The same evidence root the builder used. */
-    evidenceRoot?: string;
-    clock: () => Date;
-};
-export type Disposition = {
-    kind: "parked";
-    decisionId: number;
-} | {
-    kind: "park-fenced";
-} | {
-    kind: "disowned";
-} | {
-    kind: "built";
-    committed: boolean;
-    noChange: boolean;
-} | {
-    kind: "built-fenced";
-} | {
-    kind: "skipped";
-    reason: "unapproved" | "scope-changed";
-} | {
-    kind: "fenced";
-} | {
-    kind: "malformed";
-    sealed: boolean;
-} | {
-    kind: "failed";
-    failureClass: FailureClass;
-    disposition: string | null;
-    strikes: number | null;
-    sealed: boolean;
-    /** The state sealed when strikes ran out on a task a person had already closed (disposition "closed"): it is
-     * kept, with no incident, hold or page. Null for every other ending. */
-    closedState: ClosedState | null;
-}
-/** The standalone road's simple record: outcome written, nothing else. */
- | {
-    kind: "recorded";
-    outcome: "failed" | "refused";
-}
-/** v52: an operator's stop won before terminal settlement — the attempt
- * is sealed as interrupted with its work preserved, its own stop
- * settled, no strike and no retry. `stopRun` names the exact stopped
- * run (this one, or the owning ancestor whose stop it inherited). */
- | {
-    kind: "stopped";
-    stopRun: number;
-    requeued: boolean;
-}
-/** The service stopped or restarted while the attempt ran (no one stopped
- * the task): its work is preserved, the run ends as interrupted, and the
- * task is back in the queue — no strike, no backoff — so the next builder
- * pass resumes it from the kept work. */
- | {
-    kind: "handed-back";
-    requeued: boolean;
-} | {
-    kind: "invariant";
-    reason: string;
-};
-/** A committed build whose approved check passed gets the project's one
- * automatic review when its review switch is on (build-review.ts). No-change
- * results and failed checks go straight to the person, as before. */
-export declare function maybeRequestAutoReview(store: Store, repo: string, runId: number, committed: boolean, noChange: boolean, now: Date, root?: string): void;
-export declare function disposeBuildOutcome(context: DisposeContext, result: BuildResult): Disposition;
-/** How long a task waits after the storage check couldn't finish before it tries again on its own. */
-export declare const STORAGE_RETRY_MS: number;
-export { STORAGE_HOLD_PREFIX };
-/**
- * The storage HOLD: the check couldn't finish, so no launch can be fenced
- * now. The task waits STORAGE_RETRY_MS and tries again on its own (a person
- * who allowed access in Privacy & Security needn't do more), and "Try again"
- * (unhold) lifts it at once. One message per task an hour, with the words.
- */
-export declare function holdForStorage(store: Store, args: {
-    taskRef: number;
-    taskId: string;
-    message: string;
-}, now: Date): void;
-/**
- * The stale-approval HOLD, shared by the post-build disposition above and
- * the tick's pre-admission refusal (v48 integrity): a pre-routing row
- * whose sealed profile no longer matches what would resolve is refused
- * BEFORE any run row exists — held under the backoff the approval door
- * lifts, paged once per approval — so the fail-closed admission never
- * turns into a refusal every pass.
- */
-export declare function holdStaleApproval(store: Store, args: {
-    taskRef: number;
-    taskId: string;
-    message: string;
-}, now: Date): void;
-/** The public, envelope-documented name for each stop — distinct from the
- * store's own short `repair_chain.outcome` word (the DB enum is a
- * different namespace; these are the CLI/console-facing reason tokens,
- * registered in envelope.ts's DOCUMENTED_REASONS). */
-export type RepairStopReason = "repair-attempts-spent" | "repair-no-progress" | "repair-refused-integrity";
-/**
- * The chain's happy exit (v40): the instant one of its own attempts
- * reaches `verified` or `attested`, the chain is done. Checked at every
- * completed build's own verdict-save point — not only after a review —
- * since a review can never UPGRADE a verdict past what `adjudicate`
- * already found (foldReview's monotonicity), so only the structural save
- * can ever produce one of these two words.
- */
-export declare function maybeSettleRepairChain(store: Store, taskId: string, verdict: ProofVerdict, now: Date): void;
-/**
- * Run the approved gate again on the SAME commit (v70): a new attempt whose
- * prepared candidate is the last attempt's head. The machine checks the
- * commit out (no agent), seals a fresh diff, receipt and proof, and the
- * ordinary review follows. Used by `task regate` (an operator's yes) and by
- * the automatic single rerun after a failure the change did not cause.
- */
-export type RegateRefusal = "no-task" | "no-attempt" | "accepted-result" | "published" | "claimed" | "not-approved" | "not-rejected";
-export declare function regateTask(store: Store, taskId: string, now: Date, approval: {
-    kind: "operator";
-    name: string;
-    token: string;
-} | {
-    kind: "mode";
-    name: string;
-    modeDigest: string;
-} | {
-    kind: "release";
-    name: string;
-}): {
-    ok: true;
-    run: number;
-    head: string;
-} | {
-    ok: false;
-    reason: RegateRefusal;
-    message: string;
-};
-export type RepairTrigger = {
-    kind: "drafted";
-    draftTaskId: string;
-    attempt: number;
-    approved: boolean;
-} | {
-    kind: "stopped";
-    reason: RepairStopReason;
-}
-/** The check runs once more on the same commit, with no agent: the failure looked unrelated to the change. */
- | {
-    kind: "rerun";
-} | {
-    kind: "none";
-};
-/**
- * An explicitly requested repair from saved check or historical review findings.
- * Automatic calls are retired. Composes at
- * most one durable revision draft naming exactly the unmet criterion ids,
- * inheriting the source scope and rubric verbatim — or settles the chain
- * at one of its four independent stops (integrity, no-progress, attempts
- * cap; the fourth — existing spend/run rails — is the ordinary tick's own
- * job once a mode-approved draft dispatches as a normal builder run).
- *
- * Never dispatches anything itself: a mode-authorized draft is
- * auto-APPROVED here, but still builds through the ordinary tick, under
- * the ordinary rails and strikes — this function only ever composes a
- * task and, at most, one scope approval.
- */
-export declare function maybeTriggerRepair(store: Store, repo: string, evidenceRoot: string, sourceRunId: number, verdict: ProofVerdict, now: Date, cause?: "review" | "verification", automatic?: boolean): RepairTrigger;

package/dist/doctor.d.ts

@@ -1,67 +0,0 @@
-import { type SupervisorRunner } from "./daemon.js";
-/** Something that holds a credential a build could read, by name only, and what the owner does about it. */
-export type DoctorFinding = {
-    where: string;
-    names: string[];
-    steps: string[];
-};
-/** Something the doctor could not read: never taken for clean. */
-export type DoctorUnreadable = {
-    where: string;
-    problem: string;
-    steps: string[];
-};
-export type DoctorReport = {
-    ok: boolean;
-    checked: string[];
-    findings: DoctorFinding[];
-    unreadable: DoctorUnreadable[];
-    notes: string[];
-    /** The sandbox every build runs in (sandbox-runtime.ts): Anthropic's sandbox-runtime, its version, and why it can't
-     * sandbox here (null when it can). */
-    sandbox?: {
-        engine: string;
-        version: string;
-        problem: string | null;
-    };
-    /** The installed git against Toolroll's floor (git-floor.ts): null when it is new enough (or unreadable). */
-    git?: {
-        floor: string;
-        problem: string | null;
-    };
-};
-export type DoctorDeps = {
-    platform?: NodeJS.Platform;
-    home?: string;
-    uid?: number;
-    /** Runs the read-only supervisor and process queries (launchctl, systemctl, ps). */
-    run?: SupervisorRunner;
-    /** Where Linux keeps its process files (a test's stand-in). */
-    procRoot?: string;
-    /** The doctor's own environment: the terminal a `toolroll up` would start from. */
-    env?: NodeJS.ProcessEnv;
-    /** The installed git's floor problem (a test's stand-in for git-floor.ts installedGitFloorProblem). */
-    gitFloorProblem?: string | null;
-};
-/** The names among `pairs` that hold a credential: a provider key, a credential-looking name, or a key-shaped value.
- * Values are only tested here and never leave. */
-export declare function credentialNames(pairs: Iterable<readonly [string, string]>): string[];
-/** A running process's environment names (never values) that hold a credential: macOS through `ps -E`, which reads
- * KERN_PROCARGS2; Linux from /proc/<pid>/environ. */
-export declare function processCredentialNames(pid: number, deps: {
-    platform: NodeJS.Platform;
-    run: SupervisorRunner;
-    procRoot?: string;
-}): Promise<{
-    ok: true;
-    names: string[];
-} | {
-    ok: false;
-    problem: string;
-}>;
-/** Audit what Toolroll's service holds. Reads only; the report names variables, never their values. */
-export declare function auditServiceEnvironment(deps?: DoctorDeps): Promise<DoctorReport>;
-/** The report as the owner reads it: one state, then each finding with its steps; detail after. */
-export declare function doctorLines(report: DoctorReport): string[];
-export declare const DOCTOR_HELP = "toolroll doctor [--json]\nChecks that Toolroll's service holds no API key, token or password a build could read: its service definitions, what `daemon install` writes, the environment its manager hands it, and its running process. Reads only: it names what it finds and the steps to fix it, and never changes a file or restarts anything.";
-export declare function runDoctorCommand(argv: readonly string[], write: (line: string) => void, deps?: DoctorDeps): Promise<number>;

package/dist/easy-start-args.d.ts

@@ -1,13 +0,0 @@
-/** Which invocations are an easy start (easy-start.ts), kept apart so the CLI's entry decides without loading it. */
-export type EasyStartArgs = {
-    web: boolean;
-    projectRoot: string | null;
-};
-/** The flags bare `toolroll` takes at a terminal (--web, --project-root <dir>), or null: not an easy start. */
-export declare function easyStartArgs(argv: readonly string[]): EasyStartArgs | null;
-/** Whether this invocation is an easy start: only those flags, a person at a terminal, no coding agent. */
-export declare function easyStartApplies(argv: readonly string[], facts: {
-    stdin: boolean;
-    stdout: boolean;
-    agent: boolean;
-}): boolean;

package/dist/easy-start.d.ts

@@ -1,77 +0,0 @@
-import { type AttachProof } from "./console-instance.js";
-import type { TuiExit, TuiSession } from "./tui-contract.js";
-export { easyStartApplies, easyStartArgs, type EasyStartArgs } from "./easy-start-args.js";
-import type { EasyStartArgs } from "./easy-start-args.js";
-/** The `up` this process started and owns. */
-export type OwnedUp = {
-    pid: number;
-    exited: Promise<number | null>;
-    running(): boolean;
-    stop(): void;
-    tail(): readonly string[];
-};
-export type EasyStartSeams = {
-    databaseFile: string;
-    cwd: string;
-    write: (line: string) => void;
-    /** Prove this database's console live (read only). */
-    prove: () => Promise<AttachProof>;
-    /** Local mode as saved now: on, off, or no database yet (a new install). */
-    localMode: () => "on" | "off" | "absent";
-    serviceInstalled: () => boolean;
-    /** Start the installed background service through its supervisor and prove its console. */
-    startService: () => Promise<AttachProof>;
-    /** `up` (with these arguments) as an ordinary child of this process. */
-    spawnUp: (args: readonly string[]) => OwnedUp;
-    /** `up` (with these arguments) in this terminal, until it stops: today's foreground start. */
-    runUpForeground: (args: readonly string[]) => Promise<number>;
-    openBrowser: (url: string) => void | Promise<void>;
-    /** A local owner's one-time sign-in address from the live console (the socket `link` verb). */
-    requestLink: () => Promise<{
-        ok: true;
-        url: string;
-    } | {
-        ok: false;
-        message: string;
-    }>;
-    /** The terminal UI, in this process, as the local owner, until the person quits. */
-    openTui: (session: TuiSession) => Promise<TuiExit>;
-    /** `background on`, handing over from the `up` this process owns (when it owns one). */
-    backgroundOn: (foreground: {
-        controllerPid: number;
-        restart: () => Promise<void>;
-    } | null) => Promise<{
-        ok: boolean;
-        message: string;
-    }>;
-    backgroundAsked: () => boolean;
-    recordBackgroundAnswer: (yes: boolean) => void;
-    /** This folder's repository, whether it is added, and adding it (only when attaching to a running console). */
-    findRepo: (cwd: string) => Promise<string | null>;
-    enrolled: (repo: string) => Promise<boolean>;
-    admit: (repo: string) => Promise<number>;
-    sleep?: (ms: number) => Promise<void>;
-    startTimeoutMs?: number;
-};
-/**
- * Bare `toolroll` ("start") or `toolroll open` ("open") at a person's terminal. Resolves with the exit code once the
- * screen (or the foreground `up`, or the browser hand-off) is done.
- */
-export declare function runEasyStart(mode: "start" | "open", args: EasyStartArgs, seams: EasyStartSeams): Promise<number>;
-/** `up` as an ordinary child of this process: its output kept (last lines, for a failed start), never on the screen. */
-export declare function spawnOwnedUp(args: readonly string[], options: {
-    cwd: string;
-    databaseFile: string;
-    entry?: string;
-}): OwnedUp;
-/** The real seams, for this installation's database. */
-export declare function defaultEasyStartSeams(options: {
-    databaseFile: string;
-    write: (line: string) => void;
-    build: string;
-    cwd?: string;
-    operate?: import("./operate.js").OperateOptions;
-    admit: (repo: string) => Promise<number>;
-}): EasyStartSeams;
-/** Local mode as saved, read only: "absent" with no database yet; an older database has none ("off"). */
-export declare function localModeRead(file: string): "on" | "off" | "absent";

package/dist/egress.d.ts

@@ -1,121 +0,0 @@
-import { type Lookup } from "./scout-net.js";
-/** The policy's shape version: a worker enforces the versions it knows and refuses any other. */
-export declare const NETWORK_POLICY_VERSION = 1;
-/** `allowlist`: only the snapshot's hosts, through the run's proxy. `open`: anywhere (an approver's explicit choice). */
-export type NetworkMode = "allowlist" | "open";
-/**
- * What a build may reach on this machine's own loopback. Linux gives every build a loopback of its own, so this only
- * matters on macOS, where one loopback serves everything and the sandbox can't admit some local ports while refusing
- * others: `proxy-only` (the default) admits nothing local but the run's own proxy and tool broker; `any` admits every
- * local service on this Mac — local test servers, and also anything else listening here — an approver's explicit choice.
- */
-export type LoopbackMode = "any" | "proxy-only";
-/** The network a scope was approved with (sealed in its execution profile). */
-export type NetworkProfile = {
-    version: 1;
-    mode: NetworkMode;
-    hosts: string[];
-    loopback: LoopbackMode;
-};
-/** A project's own network setting (an approver's): what new scopes of it are written with. */
-export type ProjectNetwork = {
-    mode: NetworkMode;
-    hosts: string[];
-    loopback: LoopbackMode;
-};
-export declare const PROJECT_NETWORK_DEFAULT: ProjectNetwork;
-/** At most this many hosts a project adds (a list longer than this is a different policy: open). */
-export declare const MAX_NETWORK_HOSTS = 200;
-/** At most this many in a sealed snapshot: the project's, plus its provider's and every registry's. */
-export declare const MAX_SNAPSHOT_HOSTS: number;
-/**
- * A host as a policy names it: lowercase ASCII (an international name in its punycode form), no trailing dot, at
- * least two labels, each 1–63 letters, digits or hyphens; or `*.` and such a name, for every name under it. Never an
- * IP address, a port, a path or a bare top-level name. Null when it is none of these.
- */
-export declare function normalizeHost(input: string): string | null;
-/** Whether `host` (as a client named it) is one a policy's list admits: an exact name, or a name under a `*.` entry. */
-export declare function hostAllowed(host: string, hosts: readonly string[]): boolean;
-/**
- * Each provider's own hosts (catalog version 1): its model API and the sign-in refresh its CLI needs. Codex starts
- * its harness outside its command sandbox, so its hosts matter only to what its commands may reach. An ACP agent
- * talks to whatever model service it was set up with; its row names the hosts its own service uses.
- */
-export declare const PROVIDER_HOSTS: Readonly<Record<string, readonly string[]>>;
-/** A package ecosystem a project's files name, and the registry hosts its installs read from. */
-export type Ecosystem = "npm" | "python" | "rust" | "go" | "ruby" | "jvm";
-export declare const REGISTRY_HOSTS: Readonly<Record<Ecosystem, readonly string[]>>;
-/** The ecosystems a list of repository paths names (requirements-*.txt counts as Python). */
-export declare function ecosystemsOf(paths: readonly string[]): Ecosystem[];
-/**
- * The ecosystems the project's own checkout names: its files a few folders deep, read straight from the folder the
- * plane registered (which no build can write: agent-fence.ts taskBoundary), never a build's worktree. No process is
- * started and nothing in the repository runs. An unreadable folder names none: its builds reach the provider and the
- * project's own hosts only.
- */
-export declare function repositoryEcosystems(repo: string): Ecosystem[];
-/** The network a new scope is written with: the project's setting, its provider's hosts and its ecosystems' registries. */
-export declare function resolveNetwork(provider: string, project: ProjectNetwork, ecosystems: readonly Ecosystem[]): NetworkProfile;
-/** The network of a launch nothing sealed one for (a planner, a check): its provider's own hosts and nothing else. */
-export declare function providerOnlyNetwork(provider: string): NetworkProfile;
-/**
- * The network an approval sealed before network policies existed runs under: a deliberate narrowing (provider hosts
- * and the repository's registries, nothing the project added since, local services of this Mac out of reach). Never
- * widened by a setting changed after it was approved.
- */
-export declare function legacyNetwork(provider: string, ecosystems: readonly Ecosystem[]): NetworkProfile;
-/** Strict re-hydration (scope.ts profileFromJson): exactly the keys this code writes, every host normalized, or null. */
-export declare function networkFromValue(value: unknown): NetworkProfile | null;
-/** A project setting as saved (store.ts project_network), or null when it isn't one this code wrote. */
-export declare function projectNetworkFromValue(value: unknown): ProjectNetwork | null;
-/** The network in plain words, for an approval card and a run's record. */
-export declare function networkWords(network: NetworkProfile | null): string;
-/** What the run's proxy saw: connections it made and refused, by host (at most HOST_LIMIT hosts, the rest summed). */
-export type EgressCounts = {
-    connections: number;
-    refused: number;
-    hosts: {
-        host: string;
-        connections: number;
-        refused: number;
-    }[];
-    otherHosts: number;
-};
-/** What a run's record keeps about its network: the mode it ran under, whether a caller's own proxy carried it, how many
- * hosts its list held, and what the run's proxy saw. */
-export type RunNetworkRecord = {
-    mode: "open" | "allowlist";
-    phase: "agent";
-    via?: true;
-    hosts?: number;
-    loopback?: LoopbackMode;
-    counts?: EgressCounts;
-};
-/** A stored record read back strictly: anything this code didn't write reads as none. */
-export declare function runNetworkFromValue(value: unknown): RunNetworkRecord | null;
-export type EgressProxy = {
-    /** The proxy's address with this run's credentials, for HTTPS_PROXY and the like. */
-    url: string;
-    /** This run's credential alone: a client presenting it (with any user name: the sandbox runtime names its own) is served. */
-    secret: string;
-    port: number;
-    counts: () => EgressCounts;
-    close: () => Promise<void>;
-};
-/** Every proxy setting a program might read, both cases, so none falls back to a direct connection the OS refuses. */
-export declare function proxyEnv(proxy: EgressProxy, loopback: LoopbackMode): Record<string, string>;
-/**
- * Start one run's proxy on loopback. Only a client presenting this run's credentials is served (another run's agent
- * on the same machine can't borrow it). CONNECT goes only to port 443 and plain HTTP only to port 80, only to a host
- * the run's list admits (matched by name before it is resolved), only to public addresses (the proxy resolves the
- * name itself and connects to exactly the addresses it checked). A plain HTTP request's Host must be the URL's host.
- */
-export declare function startEgressProxy(options: {
-    hosts: readonly string[];
-    lookup?: Lookup;
-    decided?: (host: string, allowed: boolean, why: string) => void;
-    /** Tests only: which resolved addresses may be reached (default: public internet addresses), and the port an
-     * approved request is relayed to (default: the one it asked for). */
-    addressAllowed?: (address: string) => boolean;
-    upstreamPort?: (port: number) => number;
-}): Promise<EgressProxy>;

package/dist/email-settings.d.ts

@@ -1,34 +0,0 @@
-/** The mail server (v87), and where Inbox triggers read it (v89: its IMAP address; same sign-in). */
-export type EmailSettings = {
-    host: string;
-    port: number;
-    secure: boolean;
-    user: string;
-    from: string;
-    imap: {
-        host: string;
-        port: number;
-        secure: boolean;
-    } | null;
-};
-export declare const ADDRESS: RegExp;
-export declare function readEmailSettings(dir: string | null): (EmailSettings & {
-    password: string;
-}) | null;
-/** Save the mail server from Settings; an empty password keeps the saved one. An IMAP address lets Inbox triggers read it. */
-export declare function saveEmailSettings(dir: string, input: {
-    host: unknown;
-    port: unknown;
-    secure: unknown;
-    user: unknown;
-    from: unknown;
-    password: unknown;
-    imapHost?: unknown;
-    imapPort?: unknown;
-}): {
-    ok: true;
-    said: string;
-} | {
-    ok: false;
-    message: string;
-};