toolroll 0.9.104 → 0.9.105

package/dist/acp-check.d.ts

@@ -1,37 +0,0 @@
-import type { ProviderRunner } from "./provider.js";
-import { type Store } from "./store.js";
-import type { WorktreePool } from "./worktree.js";
-export declare const CHECK_PROMPTS: {
-    readonly ok: "Create a file named done.txt in the current folder containing exactly the word ok. Then stop. Do nothing else.";
-    readonly stop: "Run the shell command `sleep 120` and wait for it to finish.";
-};
-/** How long the stop step waits for the agent to start its command, and for the cancel to be answered. Every product
- * path waits exactly this: runAcpChecks takes no other value (src/acp-check-timing.test.ts holds it). */
-export declare const STOP_WAIT_MS = 60000;
-export type AcpCheckJob = {
-    store: Store;
-    runner: string;
-    token: string;
-    /** The watch running it: its project and its lease's owner. */
-    watch: {
-        repo: string;
-        owner: string;
-    };
-    pool: WorktreePool;
-    clock?: () => Date;
-    keyHome?: string;
-    /** Tests only: a stand-in agent runner. */
-    agent?: ProviderRunner;
-    /** Tests only: a PATH to find the agent on. */
-    env?: Readonly<Record<string, string | undefined>>;
-    progress?: (line: string) => void;
-};
-/** Close what no live watch holds any more, let go of what finished checks still hold, then run this runner's next
- * check, if one is waiting. */
-export declare function runAcpChecks(job: AcpCheckJob): Promise<void>;
-/**
- * Tests only: runAcpChecks with a shorter stop-step window, so a test whose agent never starts its command doesn't
- * wait out the product's minute. No product code may import it (src/acp-check-timing.test.ts fails if any does); the
- * job carries no wait of its own, so no CLI, environment or config value can change the product's.
- */
-export declare function runAcpChecksForTests(job: AcpCheckJob, stopWaitMs: number): Promise<void>;

package/dist/acp-client.d.ts

@@ -1,163 +0,0 @@
-/**
- * The Agent Client Protocol, from the plane's side (docs/plans/acp-adapter.md).
- *
- * ACP is JSON-RPC 2.0, one message per line, over the agent's stdio. This
- * module is the whole conversation as a pure state machine: it is handed the
- * agent's lines one at a time and answers with the lines to send back. It
- * never spawns, reads a clock or touches a file — the runner (exec.ts) owns
- * the process, the timers and the shutdown.
- *
- * One conversation is one build: `initialize`, `session/new` in the
- * worktree, the sealed model selected and seen to be current, one
- * `session/prompt` carrying the brief, then `session/update`s until the
- * response to that prompt. Success is that response with
- * `stopReason: "end_turn"` and nothing else — no update, exit code or
- * message text can stand in for it.
- *
- * The plane offers no client capabilities (no file system, no terminal), so
- * every agent request except `session/request_permission` is answered
- * "method not found". A model is chosen only through a `model` config option,
- * whose answer shows the model current: `session/set_model` answers with
- * nothing to observe, so an agent that offers only that is refused until a
- * fixture proves how it confirms. Builds are full access inside the OS fence, so a
- * permission request is granted once (`allow_once`, never `allow_always`);
- * the fence, not this answer, is the boundary — OpenCode runs commands
- * without asking at all.
- *
- * What the runner keeps is not the agent's stream but a short synthetic
- * record (`retained()`), one JSON object per line, typed `acp.*` — a type
- * no agent can emit — which `acpParse` reads into the gateway's envelope.
- */
-/** How many offered models a conversation keeps (each id ≤ 200 characters). */
-export declare const ACP_OFFERED_CAP = 2000;
-/** The largest line (UTF-8 bytes) the plane reads from an agent; a longer one is a protocol failure. */
-export declare const ACP_LINE_CAP: number;
-export type AcpStopReason = "end_turn" | "max_tokens" | "max_turn_requests" | "refusal" | "cancelled";
-/** How the agent lets a client choose its model: a `model` config option, or `session/set_model`. */
-export type AcpModelMechanism = "config-option" | "set-model";
-export type AcpFailureKind = 
-/** The agent broke the protocol: malformed or oversized line, unknown or repeated response, a stranger's session. */
-"protocol"
-/** The agent is not the one attested (name or version). */
- | "identity"
-/** The sealed model is not offered, or the agent did not make it current. */
- | "model-unavailable"
-/** The agent wants a sign-in. */
- | "auth-required";
-export type AcpFailure = {
-    kind: AcpFailureKind;
-    text: string;
-};
-/** The response to our prompt: a stop reason, or a JSON-RPC error. */
-export type AcpTerminal = {
-    stopReason: AcpStopReason;
-} | {
-    error: {
-        code: number | null;
-        message: string;
-    };
-};
-export type AcpPhase = "initialize" | "session" | "model" | "prompt" | "ended" | "failed";
-export type AcpConversationOptions = {
-    /** The working directory the session is opened in (the worktree). */
-    cwd: string;
-    /** The brief, sent as one text block. */
-    prompt: string;
-    /** The sealed model: must be offered and become current. */
-    model: string;
-    /** The agent the attestation names; null only for the conformance probe's first look. */
-    expect: {
-        name: string;
-        version: string;
-    } | null;
-    /** MCP servers offered to the session (http entries only). */
-    mcpServers?: readonly {
-        type: "http";
-        name: string;
-        url: string;
-        headers: readonly {
-            name: string;
-            value: string;
-        }[];
-    }[];
-};
-/** What one received line asks of the runner. */
-export type AcpReaction = {
-    /** Lines to write to the agent's stdin, in order. */
-    send: string[];
-    /** Session updates for the live view (`{acp: update}` is how the recorder recognizes them). */
-    live: Record<string, unknown>[];
-};
-export type AcpConversation = {
-    /** The first line to send (`initialize`). */
-    start(): string[];
-    /** Hand over one line the agent wrote. */
-    receive(line: string): AcpReaction;
-    /** Ask the agent to stop the prompt in flight (a notification; the prompt still answers, with `cancelled`). */
-    cancel(): string[];
-    /** The transport saw something the conversation can't read (an oversized line): a protocol failure. */
-    refuse(text: string): void;
-    /** The `session/close` request to send after the terminal, when the agent offers it; else nothing. */
-    close(): string[];
-    /** Whether a line sent by close() has been answered (or failed). */
-    closeAnswered(): boolean;
-    phase(): AcpPhase;
-    failure(): AcpFailure | null;
-    terminal(): AcpTerminal | null;
-    sessionId(): string | null;
-    agent(): {
-        name: string;
-        version: string;
-    } | null;
-    mechanism(): AcpModelMechanism | null;
-    /** The models the agent offered, as it listed them. */
-    offered(): string[];
-    /** The synthetic record `acpParse` reads. */
-    retained(): string;
-};
-/**
- * The answer to a permission request: the `allow_once` option, else the `reject_once` one. The whole list must be
- * well formed — every option an object with a non-empty id and a known kind, no id twice — or nothing is chosen: an
- * id shared by "once" and "always" would make the answer mean either.
- */
-export declare function permissionAnswer(params: unknown): {
-    optionId: string;
-    granted: boolean;
-} | null;
-export declare function createAcpConversation(options: AcpConversationOptions): AcpConversation;
-/** What the gateway reads back from a conversation's retained record. */
-export type AcpEnvelope = {
-    sessionId: string | null;
-    protocolError: string | null;
-    finalMessage: string | null;
-    /** The agent's own usage report, unattested: never priced. */
-    reportedUsage: string | null;
-    initObserved: boolean;
-    /** True only when the prompt's answer was `end_turn`. */
-    promptConsumed: boolean;
-    diagnostic: string | null;
-    /** A failure terminal, when the prompt was answered with anything but end_turn or the conversation failed. */
-    terminal: {
-        failed: true;
-        text: string | null;
-        code: string;
-    } | null;
-    /** The models the agent offered at session/new (the conformance check records them). */
-    offered: string[];
-    /** Who the agent said it is at initialize. */
-    agent: {
-        name: string;
-        version: string;
-    } | null;
-    /** The prompt's stop reason, when it answered with one. */
-    stop: string | null;
-    /** How the agent's process ended, as the runner saw it: on its own after stdin closed, or by our SIGTERM or kill;
-     * and whether anything of its group was still alive at the reap. Null when the runner wrote none. */
-    exit: {
-        how: "eof" | "term" | "kill" | "self" | "error";
-        leftover: boolean;
-        timedOut: boolean;
-    } | null;
-};
-/** Read a conversation's retained record. Lines not typed `acp.*` are ignored. */
-export declare function acpParse(stdout: string): AcpEnvelope;

package/dist/acp-inspect.d.ts

@@ -1,23 +0,0 @@
-import { type AcpProviderId } from "./acp-agents.js";
-export type AcpInspection = {
-    found: false;
-    binary: string;
-} | {
-    found: true;
-    binary: string;
-    /** The PATH entry that matched, and where it really is. */
-    path: string;
-    realpath: string;
-    /** A native executable (Mach-O/ELF), or a script with a shebang line. */
-    kind: "native" | "script" | "unknown";
-    /** For a script: the nearest package.json's name and version, read, never run. */
-    package: {
-        name: string;
-        version: string;
-    } | null;
-    size: number;
-};
-/** Find an agent's binary on PATH, and describe it without running it. */
-export declare function inspectAcpAgent(provider: AcpProviderId, env?: Readonly<Record<string, string | undefined>>): AcpInspection;
-/** The words a screen says for an inspection: "installed at …, version …" or "not installed". */
-export declare function inspectionWords(inspection: AcpInspection): string;

package/dist/action-ledger.d.ts

@@ -1,27 +0,0 @@
-import type { Database } from "./store.js";
-/** v99: sign-ins (and refusals, lockouts, sign-outs) and policy changes are their own kinds of event.
- * v110: commands a person ran on this server with their API token, from the CLI ('api') or their agent ('mcp'). */
-export declare const LEDGER_SOURCES: readonly ["work", "request", "access", "sign-in", "policy", "api", "mcp"];
-export type LedgerSource = typeof LEDGER_SOURCES[number];
-export type LedgerEntry = {
-    id: number;
-    at: string;
-    actor: string;
-    repo: string | null;
-    taskId: string | null;
-    runId: number | null;
-    action: string;
-    outcome: string;
-    source: LedgerSource;
-    /** v99: what changed, in a short line (a policy's "before → after"); never a secret, prompt or body. */
-    detail: string | null;
-};
-/** The table as v99 made it (v107 has it): the one earlier shape the v110 rebuild accepts. */
-export declare const LEDGER_V99_TABLE: (name: string) => string;
-export declare const LEDGER_COLUMNS: readonly ["id", "at", "actor", "repo", "task_id", "run_id", "action", "outcome", "source", "detail"];
-export declare const LEDGER_TABLE: (name: string) => string;
-export declare const LEDGER_SCHEMA: string;
-/** Installed after all table migrations. Work events commit with the work,
- * including CLI and unattended workers; no prompts, tool arguments, tokens,
- * decision text, or transcript content are copied into the ledger. */
-export declare function installLedgerTriggers(db: Database): void;

package/dist/activity-line.d.ts

@@ -1,29 +0,0 @@
-/**
- * What a running agent did last, in one line (live tasks): "Ran a command ·
- * 40 s ago". Pure and shared: the server sends the facts, and each page words
- * them against its own clock, so the age keeps counting between reads.
- *
- * After five minutes with no word the line says when it last heard, in the
- * same quiet secondary text (a quiet agent isn't something a person must do;
- * the needs-you mark is for what needs you). A worker whose heartbeat stopped says that
- * instead, and that one is marked: the builder going away needs a person.
- */
-/** The facts behind the line: our own words for the last thing done (never a tool's arguments), when, and whether
- * the worker running it still answers. */
-export type RunActivity = {
-    what: string;
-    at: string;
-    worker: "online" | "offline";
-};
-export declare const QUIET_AFTER_MS: number;
-/** The words for each fixed activity kind (live.ts's vocabulary) and for a progress checkpoint. */
-export declare const ACTIVITY_WORDS: Readonly<Record<string, string>>;
-/** "just now", "40 s ago", "3 min ago", "2 h ago". */
-export declare function agoWords(ms: number): string;
-/** The line itself. `quiet` (marked): the worker is offline, which needs a person. `stale`: silent five minutes or
- * more, said in the same neutral words as any other update. */
-export declare function activityLine(activity: RunActivity, now: number): {
-    text: string;
-    quiet: boolean;
-    stale: boolean;
-};

package/dist/actor.d.ts

@@ -1,11 +0,0 @@
-export type Actor = {
-    account: string;
-    lead: boolean;
-};
-/** Run `fn` with this actor (or an empty slot a verified sign-in may fill). */
-export declare function withActor<T>(actor: Actor | null, fn: () => T): T;
-export declare function currentActor(): Actor | null;
-/** A person verified their password inside this command: their acts are now theirs. A lead keeps its own label. */
-export declare function claimActor(account: string): void;
-/** How the ledger names an actor. */
-export declare function actorLabel(actor: Actor): string;

package/dist/agent-board.d.ts

@@ -1,229 +0,0 @@
-import type { Store } from "./store.js";
-export type AgentTurn = "busy" | "idle" | "crashed";
-export type AgentSaid = "working" | "blocked" | "done";
-/** A busy run whose transcript and activity are both this old is Stuck. */
-export declare const STUCK_AFTER_MS: number;
-/** With a tool call still open (a long test run is silent), it is Stuck only after this long. */
-export declare const TOOL_STUCK_AFTER_MS: number;
-/** A page's watch on one run lapses this long after its last keep-alive (the stream's keep-alive is every 15 s). */
-export declare const VIEW_LEASE_MS = 20000;
-export declare const QUESTION_KEY: RegExp;
-export declare const QUESTION_MAX = 300;
-export declare const NOTE_MAX = 200;
-export declare const ANSWER_MAX = 1500;
-/** An agent is untrusted: at most this many of its questions are open at once per run… */
-export declare const QUESTIONS_OPEN_MAX = 3;
-/** …and at most this many are ever opened per attempt. A needs-decision past either opens nothing and pages no one. */
-export declare const QUESTIONS_PER_ATTEMPT = 10;
-/** At most one question page per run in this long; questions asked meanwhile wait for the next page. */
-export declare const QUESTION_PAGE_EVERY_MS: number;
-/** The board's one note on a run whose agent asked past the caps (set once). */
-export declare const QUESTIONS_OVERFLOW_NOTE = "The agent asked more questions than the board takes; see its transcript.";
-export declare const AGENT_BOARD_SCHEMA = "\nCREATE TABLE IF NOT EXISTS agent_turn (\n  id          INTEGER PRIMARY KEY,\n  run         INTEGER NOT NULL REFERENCES run(id) ON DELETE CASCADE,\n  attempt_key TEXT NOT NULL,\n  state       TEXT NOT NULL CHECK (state IN ('busy','idle','crashed')),\n  at          TEXT NOT NULL\n);\nCREATE INDEX IF NOT EXISTS agent_turn_run ON agent_turn (run, id);\nCREATE TABLE IF NOT EXISTS agent_now (\n  task_ref         INTEGER PRIMARY KEY REFERENCES task_ref(id) ON DELETE CASCADE,\n  run              INTEGER NOT NULL REFERENCES run(id) ON DELETE CASCADE,\n  attempt_key      TEXT NOT NULL,\n  state            TEXT NOT NULL CHECK (state IN ('busy','idle','crashed')),\n  state_at         TEXT NOT NULL,\n  transcript_bytes INTEGER NOT NULL DEFAULT 0,\n  transcript_at    TEXT NOT NULL,\n  stuck_at         TEXT,\n  said             TEXT CHECK (said IN ('working','blocked','done')),\n  said_note        TEXT,\n  said_at          TEXT,\n  status_offset    INTEGER NOT NULL DEFAULT 0,\n  diff_files       INTEGER,\n  diff_at          TEXT\n);\nCREATE TABLE IF NOT EXISTS agent_question (\n  id          INTEGER PRIMARY KEY,\n  run         INTEGER NOT NULL REFERENCES run(id) ON DELETE CASCADE,\n  task_ref    INTEGER NOT NULL REFERENCES task_ref(id) ON DELETE CASCADE,\n  attempt_key TEXT NOT NULL,\n  key         TEXT NOT NULL,\n  question    TEXT NOT NULL,\n  asked_at    TEXT NOT NULL,\n  closed_at   TEXT,\n  closed_how  TEXT CHECK (closed_how IN ('answered','ended')),\n  answer_note INTEGER REFERENCES task_steer(id),\n  answered_by TEXT,\n  UNIQUE (run, key)\n);\nCREATE INDEX IF NOT EXISTS agent_question_open ON agent_question (task_ref) WHERE closed_at IS NULL;\nCREATE TABLE IF NOT EXISTS agent_seen (\n  account TEXT NOT NULL,\n  run     INTEGER NOT NULL REFERENCES run(id) ON DELETE CASCADE,\n  seen_at TEXT NOT NULL,\n  PRIMARY KEY (account, run)\n);\nCREATE TABLE IF NOT EXISTS agent_view (\n  view       TEXT PRIMARY KEY,\n  account    TEXT NOT NULL,\n  run        INTEGER NOT NULL,\n  expires_at TEXT NOT NULL\n);\nCREATE INDEX IF NOT EXISTS agent_view_run ON agent_view (run, account);\nCREATE INDEX IF NOT EXISTS agent_board_open ON run (task_ref, id) WHERE role = 'builder' AND outcome IS NULL;\nCREATE INDEX IF NOT EXISTS agent_board_recent ON run (finished_at, task_ref, id) WHERE role = 'builder' AND outcome IS NOT NULL;\nCREATE INDEX IF NOT EXISTS agent_board_repair ON run (parent_run, id) WHERE role = 'repair';\n";
-/** Added to agent_now after the table first shipped (store.ts addColumn): the oldest open tool call's kind and start. */
-export declare const AGENT_NOW_COLUMNS: readonly [string, string][];
-/** Unpredictable per attempt: the run row is the only place it is written down. */
-export declare function mintAttemptKey(): string;
-/** A run's attempt key; null for a run admitted before the board existed (or no such run). */
-export declare function attemptKeyOf(store: Store, run: number): string | null;
-/** The task's newest build attempt: a repair mends its parent and never stands in for it. */
-export declare const NEWEST_BUILDER: (task: string) => string;
-/** The build attempt a run belongs to on the board: a repair's parent, otherwise itself. */
-export declare function boardRunOf(store: Store, run: number): number;
-export type TurnFact = {
-    run: number;
-    attemptKey: string;
-    state: AgentTurn;
-    at: Date;
-};
-/**
- * Record one turn change. Always appended to the run's own history (under its
- * key); the task's current snapshot moves only when this run is the task's
- * newest and is not already newer-owned. Returns whether the snapshot moved.
- */
-export declare function recordAgentTurn(store: Store, fact: TurnFact): boolean;
-/** One run's turn history, oldest first. */
-export declare function agentTurnHistory(store: Store, run: number): {
-    attemptKey: string;
-    state: AgentTurn;
-    at: string;
-}[];
-export type AgentNow = {
-    taskRef: number;
-    run: number;
-    attemptKey: string;
-    state: AgentTurn;
-    stateAt: string;
-    transcriptBytes: number;
-    transcriptAt: string;
-    stuckAt: string | null;
-    said: AgentSaid | null;
-    saidNote: string | null;
-    saidAt: string | null;
-    statusOffset: number;
-    diffFiles: number | null;
-    diffAt: string | null;
-    /** The oldest tool call still open (a command, or any other tool), and when it started; null when none is. */
-    toolKind: ToolKind | null;
-    toolAt: string | null;
-    /** QUESTIONS_OVERFLOW_NOTE once the agent asked past the caps; null otherwise. */
-    questionNote: string | null;
-    /** The last question page: when it went, and the newest question it covered. */
-    pagedAt: string | null;
-    pagedUpto: number;
-};
-export type ToolKind = "command" | "tool";
-/** The task's current snapshot, whichever run owns it. */
-export declare function agentNowForTask(store: Store, taskRef: number): AgentNow | null;
-/** The snapshot this attempt owns, or null when another (newer) attempt does or none was recorded. */
-export declare function agentNowForRun(store: Store, run: number, attemptKey: string): AgentNow | null;
-/** The pulse saw the live transcript's size: new bytes are news, and news is not Stuck. */
-export declare function noteTranscript(store: Store, run: number, attemptKey: string, bytes: number, at: Date): boolean;
-/** The changed-file count the pulse observed (null: it could not look). */
-export declare function noteDiff(store: Store, run: number, attemptKey: string, files: number | null, at: Date): boolean;
-/** The stream opened or closed a tool call: the oldest still open, or null. The stream moved, so it clears Stuck. */
-export declare function noteOpenTool(store: Store, run: number, attemptKey: string, open: {
-    kind: ToolKind;
-    at: Date;
-} | null, at: Date): boolean;
-/** When the agent last showed a sign of life: its turn, transcript, recorded activity or the tool it opened. */
-export declare function quietSince(now: Pick<AgentNow, "stateAt" | "transcriptAt"> & {
-    toolAt?: string | null;
-}, activityAt: string | null): number;
-/**
- * Stuck, from saved facts and the clock alone (no model, no tokens): busy, and
- * neither the transcript, the recorded activity nor the turn itself has moved
- * for STUCK_AFTER_MS — or for TOOL_STUCK_AFTER_MS while a tool call is open.
- */
-export declare function stuckSince(now: Pick<AgentNow, "state" | "stateAt" | "transcriptAt"> & {
-    toolAt?: string | null;
-}, activityAt: string | null, clock: Date): string | null;
-/** The pulse persists the Stuck crossing (and its clearing), so open boards hear it through /live. */
-export declare function markStuck(store: Store, run: number, attemptKey: string, clock: Date): boolean;
-export type StatusLine = {
-    status: "working" | "blocked" | "done";
-    note: string | null;
-} | {
-    status: "needs-decision";
-    key: string;
-    question: string;
-};
-export type StatusIngest = {
-    lines: StatusLine[];
-    nextOffset: number;
-};
-/**
- * The agent's status lines since the saved offset, for the attempt that owns
- * the snapshot. The offset only moves forward; a needs-decision opens its key
- * once (a key already asked this run is never reopened), within the caps:
- * QUESTIONS_OPEN_MAX open at once and QUESTIONS_PER_ATTEMPT in all. One past
- * either opens nothing and pages no one; the run gets QUESTIONS_OVERFLOW_NOTE,
- * once. New questions page the people the task reaches (pageQuestions).
- */
-export declare function ingestStatus(store: Store, run: number, attemptKey: string, read: StatusIngest, at: Date): {
-    asked: string[];
-    moved: boolean;
-};
-/**
- * Page the run's open questions no page has covered yet, at most once per
- * QUESTION_PAGE_EVERY_MS. A question asked outside that window, alone, pages
- * at once with its own words; questions asked inside it wait, and the next
- * page after the window says how many are waiting. The pulse calls this every
- * beat, so the waiting ones go out when the window ends.
- */
-export declare function pageQuestions(store: Store, run: number, attemptKey: string, at: Date): boolean;
-export declare const questionsWaiting: (count: number) => string;
-export type AgentQuestion = {
-    id: number;
-    run: number;
-    taskRef: number;
-    key: string;
-    question: string;
-    askedAt: string;
-};
-/** A task's open questions, oldest first: only its newest run's, and only while that run is open. */
-export declare function openAgentQuestions(store: Store, taskRef: number): AgentQuestion[];
-export declare function agentQuestion(store: Store, id: number): (AgentQuestion & {
-    closedAt: string | null;
-    closedHow: string | null;
-    answerNote: number | null;
-}) | null;
-/** A run ended: every question it still had open is closed unanswered (its answer would reach no one). */
-export declare function closeRunQuestions(store: Store, run: number, at: Date): number;
-export type ReplyRefusal = "no-question" | "closed" | "stale" | "invalid-answer" | "not-saved";
-export type ReplyResult = {
-    ok: true;
-    note: number;
-    key: string;
-} | {
-    ok: false;
-    reason: ReplyRefusal;
-    problem?: string;
-};
-/** The steering note a reply becomes: the agent reads it in its steering folder, under its own key. */
-export declare function replyNoteText(key: string, answer: string): string;
-/**
- * Reply to one open question, atomically: the question is still open, its run
- * is still the task's open newest attempt under the same key, the answer saves
- * as an ordinary verified steering note (the mailbox pulse delivers it), and
- * exactly that key closes. Anything stale changes nothing.
- */
-export declare function answerAgentQuestion(store: Store, reply: {
-    question: number;
-    answer: string;
-    author: string;
-    at: Date;
-    file: (taskId: string, note: string) => {
-        ok: true;
-        id: number;
-    } | {
-        ok: false;
-        reason: string;
-        problem?: string;
-    };
-}): ReplyResult;
-/** This person opened a finished run (on the board or its result page): it leaves their unread Done. */
-export declare function markAgentSeen(store: Store, account: string, run: number, at: Date): boolean;
-/** A page is watching a run: hold (or renew) its short lease. */
-export declare function holdAgentView(store: Store, view: string, account: string, run: number, at: Date): void;
-export declare function releaseAgentView(store: Store, view: string, at: Date): void;
-/** Until when this person has this exact run open (its repairs count as the run); null when they do not. */
-export declare function watchingAgentUntil(store: Store, account: string, run: number, at: Date): string | null;
-/** Someone has this exact run open right now. */
-export declare function watchingAgent(store: Store, account: string, run: number, at: Date): boolean;
-export declare const neverHeld: (kind: string) => boolean;
-/**
- * A notification's subject (cockpit §3, R11): the run it is about — its own, or for a ping about a task the task's
- * live build — so any ping, not only the agent's own kinds, can be held while its person watches that agent. Null:
- * about nothing a person watches. Its version is the notification's own identity (its dedupe key), so a newer fact
- * about the same subject is a new ping.
- */
-export declare function attentionSubjectOf(store: Store, row: {
-    kind: string;
-    run: number | null;
-    taskRef?: number | null;
-}): {
-    run: number;
-} | null;
-/**
- * A watched ping (cockpit §3, R11), decided when its delivery is claimed AND again at every channel's final send
- * fence, after the permanent rules in store.pingAllowed: held until the watch lapses while this person has its
- * subject's agent open; then skipped when it was news about a finished run they have since seen; otherwise sent.
- * A ping about nothing anyone watches is sent. (A delivery already handed to the network can't be recalled.)
- */
-export declare function watchedPing(store: Store, row: {
-    kind: string;
-    run: number | null;
-    taskRef?: number | null;
-}, account: string, now: Date): {
-    hold: string;
-} | "skip" | "send";
-/** A page's own watch id: 24 hex characters the shell makes (never a database row id). */
-export declare const AGENT_VIEW_ID: RegExp;
-/**
- * POST /agents/watch, hold: this person's page watches a run (renewed on each keep-alive). A view id another person
- * already holds is never taken over or renewed: only the holder's own row moves. False when nothing was held.
- */
-export declare function holdOwnAgentView(store: Store, view: string, account: string, run: number, at: Date): boolean;
-/** POST /agents/watch, release: this person's page went away. Only their own view is released (and lapsed ones swept). */
-export declare function releaseOwnAgentView(store: Store, view: string, account: string, at: Date): void;