toolroll 0.9.103 → 0.9.105

package/dist/envelope.d.ts

@@ -1,47 +0,0 @@
-/**
- * The machine envelope — the one shape every `--json` answer takes.
- *
- * Agents branch on this output ten thousand times a night, so the contract
- * is versioned and deliberately dull: `envelopeVersion` first, then `ok`,
- * then `command`, then whatever the command has to say. Failures add a
- * stable `reason` token and a human `message`. Nothing else about the
- * shape is promised, and consumers are told to ignore keys they do not
- * recognize — that is what lets the envelope grow without breaking anyone.
- *
- * Every emission in the CLI routes through `envelopeJson` (a source-level
- * test enforces it), which is also what makes `-o <file>` possible: the
- * entry point asks this module for the last envelope written and copies it
- * to the file, so an agent never has to scrape a terminal.
- */
-export declare const ENVELOPE_VERSION = 1;
-/**
- * Feature detection for agent consumers, Claude-`system/init` style:
- * a bounded list of protocol behaviors this build honors. Consumers must
- * ignore values they do not recognize. Behaviors, not versions — an agent
- * should ask "can I rely on stable reasons", never "is this 0.1.2".
- */
-export declare const CAPABILITIES: readonly string[];
-/**
- * DOCUMENTED reasons — the curated vocabulary the command guide's
- * `notableReasons` may cite. Deliberately named for what it is: a list of
- * tokens that are DOCUMENTED, not a proof of runtime exhaustiveness (the
- * runtime `reason` field remains the truth; consumers branch on tokens
- * and ignore ones they do not recognize). A test ties every entry to a
- * literal in the source so a typo cannot ship.
- */
-export declare const DOCUMENTED_REASONS: readonly string[];
-export type EnvelopePayload = {
-    ok: boolean;
-    command: string;
-    [key: string]: unknown;
-};
-/** The entry point's early-flush hook (arc 2): for long-running commands,
- * `-o` lands the startup envelope the moment it exists. The hook must not
- * throw — the entry point's own hook catches internally. */
-export declare function onEnvelopeCaptured(hook: ((body: string) => void) | null): void;
-/** Serialize one envelope, remembering it for `-o` teeing at the entry point. */
-export declare function envelopeJson(payload: EnvelopePayload): string;
-/** The last envelope this process serialized, or null if none has been. */
-export declare function capturedEnvelope(): string | null;
-/** Forget the captured envelope — the entry point calls this before dispatch. */
-export declare function resetCapturedEnvelope(): void;

package/dist/eval-gate.d.ts

@@ -1,51 +0,0 @@
-export declare const EVAL_GATE_ENV = "TOOLROLL_EVAL_GATE";
-/** The gate's terms: how many provider dispatches the attempt may make. */
-export type EvalGateConfig = {
-    v: 2;
-    max: number;
-};
-/** One slot a dispatch took. */
-export type EvalGateSlot = {
-    n: number;
-    kind: string;
-    pid: number;
-    at: string;
-};
-export type EvalDispatch = {
-    active: false;
-} | {
-    active: true;
-    ok: true;
-    n: number;
-} | {
-    active: true;
-    ok: false;
-    why: string;
-};
-/** At most `limit` bodies at once; the others start in the order they asked, as each running one ends (provider-gate
- * limiter). */
-export declare function limiter(limit: number): <T>(body: () => Promise<T>) => Promise<T>;
-/** Read a small regular file without following a link; null when it isn't one, is too big or can't be read. */
-export declare function readNoFollow(path: string, maxBytes: number): Buffer | null;
-/** Make a world's gate in `dir` (a fresh folder the runner owns): its terms, and an empty slots folder. Refuses a folder
- * that already holds a gate. */
-export declare function openEvalGate(dir: string, config: EvalGateConfig): void;
-/** The world's gate, as this process's environment names it: null outside an eval world, its terms, or why it can't
- * be read (which refuses every dispatch). */
-export declare function evalWorldGate(env?: Readonly<Record<string, string | undefined>>): {
-    dir: string;
-    config: EvalGateConfig;
-} | {
-    dir: string;
-    problem: string;
-} | null;
-/** Take one dispatch slot of this eval world, before a provider is called. Outside an eval world: `{ active: false }`. */
-export declare function takeEvalDispatch(kind: string, env?: Readonly<Record<string, string | undefined>>, now?: Date): EvalDispatch;
-/** Whether this process is in an eval world (any gate named, readable or not): the helpers that keep no record refuse
- * there. */
-export declare function inEvalWorld(env?: Readonly<Record<string, string | undefined>>): boolean;
-/** Whether a dispatch in this world asked past its limit (and was refused). */
-export declare function evalGateOverLimit(dir: string): boolean;
-/** The slots a world's dispatches took, read back by the runner (never following a link). Null when the folder can't
- * be read whole: the runner then counts the world's spending as unknown. */
-export declare function evalGateSlots(dir: string): EvalGateSlot[] | null;

package/dist/eval-hooks.d.ts

@@ -1,94 +0,0 @@
-import type ts from "typescript-parser";
-/** One required call: in this file, inside this top-level function, a call to this name, the name bound as `from`
- * says (a module specifier its un-renamed named import comes from; `self`: the file's own top-level function; `local`:
- * declared inside `inside`). `args`: the call's arguments, as text, must stay as the base has them. */
-export type EvalHook = {
-    file: string;
-    inside: string;
-    calls: string;
-    from: string;
-    args?: true;
-    why: string;
-};
-/** `fn` may also be `outer>inner` (docs/plans/learning-loops.md, Protection 3): a `const inner = (…) => …` (or function
- * expression) or `function inner`, bound once in the file and never reassigned, inside the top-level function `outer`
- * and in no other function between them. `strict`: a base that holds the file but can't resolve the pin is a problem,
- * never skipped (a base without the file at all is a project that isn't Toolroll, and holds none). */
-/** One function whose body (its text, as the candidate has it) must stay as the base has it: a top-level function, or
- * `Class#method`, a method of a top-level class. */
-export type EvalPinned = {
-    file: string;
-    fn: string;
-    why: string;
-    strict?: true;
-};
-export declare const EVAL_HOOKS: readonly EvalHook[];
-export declare const EVAL_PINNED: readonly EvalPinned[];
-/** The Store methods pinned by body, which no file may write over (storeRewriteProblem, store.ts sealStoreMoneyMethods). */
-export declare const PINNED_STORE_METHODS: readonly string[];
-/**
- * Why a candidate drops a required hook or changes a pinned body, or null. `candidate` gives a listed file's bytes at
- * the candidate (null: missing or unreadable, which needs a person too). With `base` (the plane's own record of where
- * the release started, which the candidate can't rewrite), only what the base holds is required: a project that isn't
- * Toolroll holds none, and a hook not yet landed can't be dropped.
- */
-export declare function evalHookProblem(candidate: (file: string) => Buffer | null, base?: (file: string) => Buffer | null, hooks?: readonly EvalHook[], pinned?: readonly EvalPinned[]): string | null;
-/** Every file the manifest reads, for one verified read of each tree. */
-export declare const EVAL_HOOK_FILES: readonly string[];
-/**
- * Why a changed file could write over a pinned Store method, or null (PR #263 security scan). Each changed JavaScript
- * or TypeScript file, store.ts included (its class's own method declarations exempt; their bodies are pinned), is held to
- * storeRewrites: a construct the base's copy of that file didn't already have (counted, by the sha256 of its whole
- * text) needs a person. A tree or file that can't be read, or a file that doesn't parse, needs one too; `paths` are the
- * files the verified diff says exist at the candidate, so no bytes is a failed read, never a deletion.
- */
-export declare function storeRewriteProblem(paths: readonly string[], candidate: ((file: string) => Buffer | null) | null, base: ((file: string) => Buffer | null) | null, pinned?: readonly string[]): string | null;
-/** The calls that record a check's facts: at disposition, and as the check's command starts. */
-export declare const LEARNING_HOOKS: readonly EvalHook[];
-/** The bodies a release can't change by itself, every one strict: what a run is told from project memory, how a memory
- * proposal and a decision are written, and where a check's conditions are captured. */
-export declare const LEARNING_PINNED: readonly EvalPinned[];
-/** Every file the learning manifest reads. */
-export declare const LEARNING_HOOK_FILES: readonly string[];
-/** Each protected table and its only writer modules (the v149 migration in store.ts aside). The decision tables'
- * existing writers stay theirs: project-memory.ts records and retires, project-delete.ts deletes a whole project. */
-export declare const LEARNING_WRITERS: Readonly<Record<string, readonly string[]>>;
-/** One SQL-shaped construct in a file: its static text (a placeholder `${}` where an expression sits), the protected
- * tables it writes, and the top-level declaration it's in ("" for none). `unreadable`: a write whose table name is
- * split around an expression; `bare`: a string that is only a protected table's name (SQL assembled elsewhere). */
-type LearningConstruct = {
-    text: string;
-    tables: string[];
-    inside: string;
-    unreadable: boolean;
-    bare: boolean;
-};
-/**
- * Every construct in the file that could write a protected table: each string literal, template (its static parts)
- * and `+` concatenation (its literal operands), whatever it's passed to — `prepare`, `exec`, a renamed `prepare`, a
- * helper. A write verb next to a protected table's name, a table name split around an expression next to a write
- * word, and a string that is only a protected table's name are each found.
- */
-export declare function learningConstructs(source: ts.SourceFile): LearningConstruct[];
-/**
- * Why a changed file writes a learning-loops table (or a decision merge or restore) from a place that may not, or null
- * (docs/plans/learning-loops.md, Protection 4). Every changed JavaScript or TypeScript file but tests is parsed; a
- * construct its writer module doesn't own is new unless the base's copy of that file already had exactly that text
- * (counted by its sha256, as storeRewriteProblem does). A file that can't be read or parsed needs a person. It reads
- * text the candidate wrote, never runs it: it raises the bar for review; a person reviewing these files is the backstop.
- */
-export declare function learningWriteProblem(paths: readonly string[], candidate: ((file: string) => Buffer | null) | null, base: ((file: string) => Buffer | null) | null): string | null;
-/**
- * Why a candidate needs a person for learning loops, or null: a required call dropped, a pinned body changed (strict
- * pins included), or a changed file writing a protected table from outside its writers. With `manifest.base`, only what
- * the base holds is required, as evalHookProblem does — except a strict pin whose file the base holds.
- */
-export declare function learningHookProblem(manifest: {
-    candidate: (file: string) => Buffer | null;
-    base?: (file: string) => Buffer | null;
-}, changed: {
-    paths: readonly string[];
-    candidate: ((file: string) => Buffer | null) | null;
-    base: ((file: string) => Buffer | null) | null;
-}): string | null;
-export {};

package/dist/eval-oracle-main.d.ts

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

package/dist/eval-oracle.d.ts

@@ -1,60 +0,0 @@
-export type OracleVerdict = {
-    outcome: "pass" | "fail" | "error";
-    why: string | null;
-};
-/** A case's hidden check (`oracle.mjs`): the files it grades, inputs chosen from a seeded random source, and the
- * answer it computes itself for each. */
-export type CaseOracle = {
-    files: readonly string[];
-    inputs: (random: () => number) => unknown[];
-    expected: (input: unknown) => unknown;
-};
-/** The most a graded program may print, and the most of each graded file the oracle copies. */
-export declare const ORACLE_OUTPUT_BYTES: number;
-/** A random source seeded by the nonce (mulberry32 over its digest): the inputs are fresh for every grading. */
-export declare function seededRandom(nonce: string): () => number;
-/** One value in a canonical form (object keys sorted), so two answers compare by content. */
-export declare function canonical(value: unknown): string;
-/** How the graded program is started: inside the native fence by default; a test may only ever narrow it. */
-export type GradeRunner = (input: {
-    cwd: string;
-    stdin: string;
-    timeoutMs: number;
-    deny: readonly string[];
-}) => Promise<{
-    code: number;
-    stdout: string;
-    timedOut: boolean;
-}>;
-/** The default: the installed node, `probe.mjs`, inside the release check's fence — writes only the grading folder, no
- * network (a proxy of its own that allows no host), the installed eval set and whatever else `deny` names unreadable. No
- * fence on this machine: nothing is graded (the attempt is an error, never a pass). */
-export declare const fencedGradeRunner: GradeRunner;
-/** Grade one attempt, in the oracle's own process. `caseDir` must be a case of the installed eval set (`evalsRoot`). */
-export declare function gradeCase(input: {
-    caseDir: string;
-    inputDir: string;
-    timeoutMs: number;
-    evalsRoot?: string;
-    runner?: GradeRunner;
-    deny?: readonly string[];
-}): Promise<OracleVerdict>;
-/** The oracle process's entry file, from the installed release (the sources under a test). */
-export declare function oracleEntry(): {
-    file: string;
-    args: string[];
-};
-/**
- * Grade in a separate process from the installed release (the plane's runner calls this once the attempt's process
- * tree is gone). Its verdict comes back over its own stdout; anything else — it crashed, timed out, said nothing
- * readable — is an error the plane recorded, never a pass.
- */
-export declare function runOracle(input: {
-    caseDir: string;
-    inputDir: string;
-    timeoutMs: number;
-    deny?: readonly string[];
-}, entry?: {
-    file: string;
-    args: string[];
-}): Promise<OracleVerdict>;

package/dist/eval-world.d.ts

@@ -1,17 +0,0 @@
-import { type EvalCase } from "./evals.js";
-/** The installed CLI, as the world's commands run it (the sources under a test). */
-export declare function evalCliEntry(): {
-    file: string;
-    args: string[];
-};
-export type WorldReport = {
-    evalStage: "world-start" | "done";
-    why: string | null;
-};
-/** Make the world and run its build to the end. Never throws: a failure is the report. */
-export declare function runEvalWorld(one: EvalCase, input: {
-    worldDir: string;
-    databaseFile: string;
-    deny: readonly string[];
-    timeoutMs: number;
-}): Promise<WorldReport>;

package/dist/evals.d.ts

@@ -1,299 +0,0 @@
-import { type OracleVerdict } from "./eval-oracle.js";
-import { type ReportedAmount } from "./reported-usage.js";
-import { Store } from "./store.js";
-export declare const EVALS_ROOT: string;
-export declare const EVAL_K = 3;
-/** An errored attempt gets one replacement when the plane confirms the error; at most this many a campaign. */
-export declare const EVAL_MAX_REPLACEMENTS = 3;
-/** Attempts at once within one campaign. */
-export declare const EVAL_CONCURRENCY = 2;
-export type EvalCaseKind = "build" | "ask";
-export type EvalCase = {
-    id: string;
-    version: string;
-    dir: string;
-    kind: EvalCaseKind;
-    title: string;
-    /** What the task asks, as the agent's brief gets it. */
-    goal: string;
-    touches: string[];
-    pin: {
-        provider: "claude";
-        model: string;
-    };
-    maxDispatches: number;
-    timeoutMinutes: number;
-    /** build: the files the oracle copies from the built commit. ask: the options the question must offer (patterns). */
-    grade: {
-        files: string[];
-    } | {
-        options: string[];
-    };
-    /** The person who validated the expected outcome, or null: a draft, counted in no canonical campaign. */
-    validatedBy: string | null;
-    fixture: Record<string, string>;
-};
-export type EvalSet = {
-    ok: true;
-    root: string;
-    manifestDigest: string;
-    cases: EvalCase[];
-} | {
-    ok: false;
-    problem: string;
-};
-/** Why a pin isn't an exact model id, or null. An alias, an empty or odd value, or a non-Claude provider is no pin. */
-export declare function exactModelProblem(pin: {
-    provider?: unknown;
-    model?: unknown;
-} | null | undefined): string | null;
-/** The installed eval set: the manifest's cases, each read whole and versioned. Any case that can't be read, and any
- * folder the manifest doesn't list, refuses the whole set. */
-export declare function loadEvalSet(root?: string): EvalSet;
-export type CampaignAsk = {
-    cases?: string[];
-    k?: number;
-    diagnostic?: boolean;
-};
-export type CampaignPlan = {
-    canonical: boolean;
-    k: number;
-    cases: EvalCase[];
-};
-/** What a campaign runs. Canonical (nothing asked): every case, k = 3, refused while any case is a draft. Diagnostic
- * (anything asked): a report only. Either way every case runs under an exact model pin. */
-export declare function planCampaign(set: Extract<EvalSet, {
-    ok: true;
-}>, ask: CampaignAsk): {
-    ok: true;
-    plan: CampaignPlan;
-} | {
-    ok: false;
-    problem: string;
-};
-export type Admission = {
-    ok: true;
-    id: string;
-} | {
-    ok: false;
-    reason: "person-only" | "release-busy" | "already-running";
-    message: string;
-};
-/**
- * Admit a campaign (eval or reviewer): a person proved now, nothing releasing or deploying, and no other canonical
- * campaign running (canonical campaigns settle in the order they were admitted). One transaction: the proof, the checks
- * and the row, with the runner that owns it (this process, on this computer) for recovery.
- */
-export declare function admitEvalCampaign(store: Store, input: {
-    kind: "eval" | "reviewer";
-    canonical: boolean;
-    manifestDigest: string;
-    buildDigest: string;
-    version: string;
-    k: number;
-    sealed: unknown;
-    as: string;
-    token: string;
-    now: Date;
-    id?: string;
-    runner?: {
-        host: string;
-        pid: number;
-        started?: string | null;
-    };
-}): Admission;
-/** Record one attempt's start (its identity is unique). Refused when the campaign isn't running. */
-export declare function startEvalAttempt(store: Store, input: {
-    campaign: string;
-    caseId: string;
-    caseVersion: string;
-    n: number;
-    replaces: number;
-    modelPinned: string;
-    now: Date;
-}): {
-    ok: true;
-    attempt: number;
-} | {
-    ok: false;
-    why: string;
-};
-export type EvalOutcome = "pass" | "fail" | "error" | "unevaluated";
-/** One provider dispatch an attempt's world made: its record (`run:<id>`, `chat_turn:<id>`) or the gate slot no record
- * accounts for (`slot:<n>`), what it was billed as, and the model it reported. */
-export type EvalDispatchRecord = {
-    kind: string;
-    worldRef: string;
-    recorded: boolean;
-    amount: ReportedAmount;
-    modelReported: string | null;
-};
-export type AttemptResult = {
-    outcome: EvalOutcome;
-    why: string | null;
-    modelReported: string | null;
-    dispatches: number | null;
-    apiMicrousd: number | null;
-    subscriptionMicrousd: number | null;
-    usageUnknown: boolean;
-    turns: number | null;
-    tokensIn: number | null;
-    cacheRead: number | null;
-    cacheWrite: number | null;
-    tokensOut: number | null;
-    toolCalls: number | null;
-    wallMs: number;
-    invocations: EvalDispatchRecord[];
-};
-/** Record a finished attempt, once: its outcome, each dispatch as it was billed, and its totals. */
-export declare function recordEvalAttempt(store: Store, attempt: number, result: AttemptResult, now: Date): void;
-/** End a campaign, once: complete or incomplete. */
-export declare function finishEvalCampaign(store: Store, id: string, state: "complete" | "incomplete", why: string | null, now: Date): void;
-/** What a campaign spent, from its attempts as recorded: API dollars (null when any dispatch's money is unknown),
- * subscription usage (null when any is unknown or unreported), and how many attempts had unknown spending. Never one
- * total of the three. */
-export declare function campaignSpending(store: Store, id: string): {
-    apiMicrousd: number | null;
-    subscriptionMicrousd: number | null;
-    unknownAttempts: number;
-    attempts: number;
-};
-export type WorldDispatches = {
-    invocations: EvalDispatchRecord[];
-    modelReported: string | null;
-    dispatches: number | null;
-    /** Asked past the case's limit (the gate refused it), or more dispatches than the limit recorded. */
-    overLimit: boolean;
-    /** A dispatch the gate and the records don't agree on: a record with no slot (it went around the gate), a slot with no
-     * record, or slots that can't be read. Its spending is unknown and the attempt is an error. */
-    unaccounted: boolean;
-    apiMicrousd: number | null;
-    subscriptionMicrousd: number | null;
-    usageUnknown: boolean;
-    turns: number | null;
-    tokensIn: number | null;
-    cacheRead: number | null;
-    cacheWrite: number | null;
-    tokensOut: number | null;
-    toolCalls: number | null;
-};
-/** Every provider dispatch a world made, from its own records (its database, opened read only; null when there is none
- * or it can't be read) and its gate's slots: each with what it was billed as and the model it reported. A slot no
- * record accounts for, and a record no slot does, is a dispatch with unknown money and an unknown model. */
-export declare function collectWorld(world: Store | null, gateDir: string, maxDispatches: number, evidenceRoot: string, now: Date): WorldDispatches;
-/** The installed build's identity: its version, a digest of every file of the code that is running (dist when
- * installed, the sources in a checkout), and the service definitions that say which runtime the plane runs (a deploy
- * rewrites them to another runtime's folder). A change between attempts, or before the end, stops the campaign as
- * incomplete. */
-export declare function installedBuildDigest(version: string, home?: string): string;
-/** How an attempt's world is started: the child command (the installed binary's `evals attempt`, or a test's world). */
-export type AttemptCommand = (input: {
-    campaign: string;
-    caseId: string;
-    n: number;
-    worldDir: string;
-    databaseFile: string;
-    gateDir: string;
-}) => {
-    file: string;
-    args: string[];
-    env: Record<string, string>;
-};
-export type AttemptDeps = {
-    command: AttemptCommand;
-    /** The oracle (eval-oracle.ts runOracle by default: a separate process from the installed release). */
-    oracle?: (input: {
-        caseDir: string;
-        inputDir: string;
-        timeoutMs: number;
-        deny?: readonly string[];
-    }) => Promise<OracleVerdict>;
-    /** Where worlds are made (a folder the plane owns). */
-    workRoot: string;
-    /** How long the world's processes get to end after its child does, before the attempt is an error. */
-    settleMs?: number;
-    /** Called the moment the whole process tree is proven gone, before anything is read or graded (tests). */
-    onTreeGone?: () => void;
-    keepWorlds?: boolean;
-    now?: () => Date;
-};
-/**
- * One attempt: record its start, make the world, run its child to the end of its whole process tree, read what it
- * did, grade it, record it. What the world dispatched is collected and recorded on every road out, the runner's own
- * failure included, before the world is removed. Outcomes (plan, "Grading"): an error only where the plane itself
- * recorded one (the world failed before the agent started, the provider refused or was down, the oracle failed, the
- * world's processes wouldn't end, a dispatch the gate and the records don't agree on); the agent timing out, crashing
- * or going past its dispatch limit is a fail; a reported model other than the pin is unevaluated.
- */
-export declare function runEvalAttempt(store: Store, input: {
-    campaign: string;
-    one: EvalCase;
-    n: number;
-    replaces: number;
-}, deps: AttemptDeps): Promise<{
-    attempt: number;
-    result: AttemptResult;
-    stopCampaign: string | null;
-} | {
-    attempt: null;
-    why: string;
-}>;
-export type CampaignDeps = AttemptDeps & {
-    /** The installed build's identity now (installedBuildDigest): a change stops the campaign as incomplete. */
-    buildDigest: () => string;
-    /** The installed eval set now (loadEvalSet): a change stops the campaign as incomplete too. */
-    evalSet?: () => EvalSet;
-    concurrency?: number;
-};
-/** Run an admitted campaign to its end: every sealed attempt (EVAL_CONCURRENCY at once), one replacement for an
- * attempt the plane recorded an error for (at most EVAL_MAX_REPLACEMENTS a campaign), then complete — or incomplete
- * when the installed build or eval set changed (checked before every attempt and again at the end), a deploy is
- * draining, or the runner itself failed. */
-export declare function runEvalCampaign(store: Store, campaign: string, cases: readonly EvalCase[], deps: CampaignDeps): Promise<{
-    state: "complete" | "incomplete";
-    why: string | null;
-}>;
-/**
- * Recover campaigns whose runner stopped (Codex round 1 #12): a running campaign whose runner was this computer's and
- * whose process is gone. Each unfinished attempt is recorded as an error with whatever its world recorded (its spending
- * unknown where the records can't say), once its world's process group is proven gone; then the campaign ends
- * incomplete. A campaign whose runner is alive, ran on another computer, or still has a world running stays as it is.
- */
-export declare function recoverEvalCampaigns(store: Store, now: Date, options?: {
-    host?: string;
-    alive?: (pid: number, started: string | null) => boolean;
-}): {
-    id: string;
-    recovered: boolean;
-    why: string;
-}[];
-/** A process's start time as the system reports it (`ps -o lstart`, whole seconds, in UTC and the C locale), or null
- * when it can't be read: the identity a saved pid is compared by, so a later process that reuses the number is never
- * taken for the one recorded. */
-export declare function processStartOf(pid: number): string | null;
-/** Whether a campaign's runner may still be running (PR #263 review): its pid is held, and by the same process — its
- * start time, where one was recorded, matches. A pid now held by a process that started at another time is someone
- * else's. A start that can't be read now counts as alive (a person ends such a campaign: `evals recover --abandon`). */
-export declare function runnerMayBeAlive(pid: number, started: string | null): boolean;
-/**
- * End a stuck campaign by a person's word (PR #263 review): a campaign recovery can't settle (its runner can't be
- * proven gone, or a world's processes can't). A person proved now with their password (a lead token or remembered
- * login is no proof); in one transaction every unfinished attempt is recorded as an error with unknown spending, the
- * campaign's spending is marked unknown, and it ends incomplete. No process is signalled and no world is read or
- * removed: whatever is still running is left to the person.
- */
-export declare function abandonEvalCampaign(store: Store, input: {
-    id: string;
-    as: string;
-    token: string;
-    now: Date;
-}): {
-    ok: true;
-    attempts: number;
-} | {
-    ok: false;
-    reason: "person-only" | "not-running";
-    message: string;
-};
-/** A random hex id, for the world's throwaway approver password. */
-export declare const worldSecret: () => string;