toolroll 0.9.62 → 0.9.65

package/dist/store.d.ts

@@ -1,3 +1,5 @@
+import { type ProjectNetwork, type RunNetworkRecord } from "./egress.js";
+import { type AcpLaunch } from "./acp-attest.js";
 import { type ChatBinding } from "./chat-core.js";
 import { ChatMessages, TELEGRAM_HOLD_REASONS, TELEGRAM_SKIPPED_ELSEWHERE, TELEGRAM_SKIPPED_OTHER_CHAT, TELEGRAM_SKIPPED_QUIET } from "./chat-messages.js";
 import { isLifecycleNotification, isTelegramProgressNotification, LIFECYCLE_KEY_PREFIX, LIFECYCLE_KINDS, proposalTaskOf, type LifecycleKind } from "./notification-rows.js";
@@ -41,6 +43,10 @@ export declare function leadTurnKeepsProposals(turn: {
 /** What the lead promised to follow up on (lead-commitments.ts; no version bump: additive only, so a build that
  * predates it still opens the store). `condition_json` is a task, attempt, check or time; `check_at` is when to look
  * next; `channel` is where it reports (`chat`: the conversation it was promised in); a promise lapses at `expires_at`. */
+/** Lead fan-out (docs/plans/lead-fan-out.md): a sweep is N ordinary tasks under one shared brief, started with one yes,
+ * at most `max_parallel` of them claimed at once. Membership is by task family root, so a revision of a child is that
+ * child. Additive (no schema version bump), like lead_commitment. */
+export declare const LEAD_SWEEP_SCHEMA = "\nCREATE TABLE IF NOT EXISTS lead_sweep (\n  id           INTEGER PRIMARY KEY AUTOINCREMENT,\n  owner        TEXT NOT NULL,\n  thread       INTEGER,\n  repo         TEXT NOT NULL,\n  title        TEXT NOT NULL,\n  brief        TEXT NOT NULL,\n  max_parallel INTEGER NOT NULL CHECK (max_parallel BETWEEN 1 AND 16),\n  proposal     INTEGER UNIQUE,\n  created_at   TEXT NOT NULL\n);\nCREATE TABLE IF NOT EXISTS lead_sweep_task (\n  sweep     INTEGER NOT NULL REFERENCES lead_sweep(id),\n  root_task TEXT NOT NULL UNIQUE,\n  ordinal   INTEGER NOT NULL,\n  label     TEXT NOT NULL,\n  PRIMARY KEY (sweep, ordinal)\n);\n";
 export declare const LEAD_COMMITMENT_SCHEMA = "\nCREATE TABLE IF NOT EXISTS lead_commitment (\n  id             INTEGER PRIMARY KEY AUTOINCREMENT,\n  owner          TEXT NOT NULL,\n  repo           TEXT,\n  thread         INTEGER NOT NULL,\n  turn           INTEGER,\n  channel        TEXT NOT NULL DEFAULT 'chat',\n  what           TEXT NOT NULL,\n  condition_json TEXT NOT NULL,\n  check_at       TEXT NOT NULL,\n  expires_at     TEXT NOT NULL,\n  state          TEXT NOT NULL DEFAULT 'open' CHECK (state IN ('open', 'done', 'cancelled', 'expired')),\n  created_at     TEXT NOT NULL,\n  checked_at     TEXT,\n  closed_at      TEXT,\n  closed_by      TEXT,\n  outcome        TEXT\n);\nCREATE INDEX IF NOT EXISTS lead_commitment_due ON lead_commitment (state, check_at);\nCREATE INDEX IF NOT EXISTS lead_commitment_owner ON lead_commitment (owner, state, id);\n";
 /** What stops a finished run reading stopped (Store.stopQuiescenceFact). */
 export type StopFactKind = "open" | "alive" | "elsewhere" | "unprovable" | "unknown" | "settling";
@@ -92,6 +98,8 @@ export declare const BRANCH_BASE_MOVE_SCHEMA = "\nCREATE TABLE IF NOT EXISTS bra
  * continues a paused build with a short continue frame and no note: one row per request, bound to the exact paused run;
  * sent_at when the frame was written, ended_at when the run was no longer paused to take it. */
 export declare const LIVE_STEER_SCHEMA = "\nCREATE TABLE IF NOT EXISTS run_pause (\n  id            INTEGER PRIMARY KEY AUTOINCREMENT,\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  request_id    TEXT NOT NULL UNIQUE,\n  requested_by  TEXT NOT NULL,\n  requested_via TEXT NOT NULL CHECK (requested_via IN ('cli','web','chat')),\n  requested_at  TEXT NOT NULL,\n  note          INTEGER REFERENCES task_steer(id) ON DELETE SET NULL,\n  sent_at       TEXT,\n  paused_at     TEXT,\n  resumed_at    TEXT,\n  ended_at      TEXT\n);\nCREATE INDEX IF NOT EXISTS run_pause_by_run ON run_pause (run, id);\nCREATE TABLE IF NOT EXISTS run_resume (\n  id            INTEGER PRIMARY KEY AUTOINCREMENT,\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  request_id    TEXT NOT NULL UNIQUE,\n  requested_by  TEXT NOT NULL,\n  requested_via TEXT NOT NULL CHECK (requested_via IN ('cli','web','chat')),\n  requested_at  TEXT NOT NULL,\n  sent_at       TEXT,\n  ended_at      TEXT\n);\nCREATE INDEX IF NOT EXISTS run_resume_by_run ON run_resume (run, id);\n";
+/** A project's "Show commands in the live view" (live-detail.ts): absent means off. */
+export declare const LIVE_DETAIL_SCHEMA = "\nCREATE TABLE IF NOT EXISTS live_detail_setting (\n  repo       TEXT PRIMARY KEY,\n  commands   INTEGER NOT NULL CHECK (commands IN (0,1)),\n  updated_by TEXT NOT NULL,\n  updated_at TEXT NOT NULL\n);\n-- Every run a steering note reached, kept as it happens (live-notes.ts): a\n-- note's own attached/mailed fields move to the next attempt, this does not.\nCREATE TABLE IF NOT EXISTS steer_note_run (\n  note INTEGER NOT NULL REFERENCES task_steer(id) ON DELETE CASCADE,\n  run  INTEGER NOT NULL REFERENCES run(id) ON DELETE CASCADE,\n  how  TEXT NOT NULL CHECK (how IN ('attached','mailed','read')),\n  at   TEXT NOT NULL,\n  PRIMARY KEY (note, run, how)\n);\nCREATE INDEX IF NOT EXISTS steer_note_run_by_run ON steer_note_run (run, note);\n";
 export declare const CHAT_APPROVAL_SCHEMA = "\nCREATE TABLE IF NOT EXISTS chat_approval_setting (\n  approver             TEXT NOT NULL,\n  scope                TEXT NOT NULL,\n  enabled              INTEGER NOT NULL CHECK (enabled IN (0,1)),\n  full_access          INTEGER NOT NULL DEFAULT 0 CHECK (full_access IN (0,1)),\n  attempt_cap_microusd INTEGER CHECK (attempt_cap_microusd IS NULL OR attempt_cap_microusd >= 0),\n  generation           INTEGER NOT NULL,\n  digest               TEXT NOT NULL,\n  updated_by           TEXT NOT NULL,\n  updated_at           TEXT NOT NULL,\n  PRIMARY KEY (approver, scope)\n);\n";
 export declare const CHAT_DECIDE_SCHEMA = "\nCREATE TABLE IF NOT EXISTS chat_decide_action (\n  token       TEXT PRIMARY KEY,\n  channel     TEXT NOT NULL,\n  binding     INTEGER NOT NULL,\n  chat        TEXT NOT NULL,\n  message     TEXT,\n  act         TEXT NOT NULL CHECK (act IN ('accept','changes','retry','approve','not-now','merge')),\n  phase       TEXT NOT NULL CHECK (phase IN ('offer','yes','cancel')),\n  task_id     TEXT NOT NULL,\n  run         INTEGER,\n  digest      TEXT NOT NULL,\n  created_at  TEXT NOT NULL,\n  expires_at  TEXT NOT NULL,\n  consumed_at TEXT\n);\nCREATE INDEX IF NOT EXISTS chat_decide_action_message ON chat_decide_action (channel, chat, message);\nCREATE TABLE IF NOT EXISTS chat_decide_prompt (\n  id          INTEGER PRIMARY KEY AUTOINCREMENT,\n  channel     TEXT NOT NULL,\n  binding     INTEGER NOT NULL,\n  chat        TEXT NOT NULL,\n  task_id     TEXT NOT NULL,\n  run         INTEGER NOT NULL,\n  digest      TEXT NOT NULL,\n  message     TEXT,\n  created_at  TEXT NOT NULL,\n  expires_at  TEXT NOT NULL,\n  consumed_at TEXT\n);\nCREATE INDEX IF NOT EXISTS chat_decide_prompt_open ON chat_decide_prompt (channel, binding, consumed_at);\n";
 export type LeadAsk = {
@@ -110,6 +118,10 @@ export declare const LEAD_FOLLOW_MESSAGE = "Automatic crew update: inspect the s
  * nothing set up, such as no `gh` sign-in). `ok_at` and `error`/`error_at` keep the last success and the last
  * failure across checks, so a row can say both. `account` is a display name only, never a credential. */
 export declare const INTEGRATIONS_SCHEMA = "\nCREATE TABLE IF NOT EXISTS integration_check (\n  key         TEXT PRIMARY KEY,\n  outcome     TEXT NOT NULL CHECK (outcome IN ('ok', 'failed', 'absent')),\n  account     TEXT,\n  detail      TEXT,\n  problem     TEXT,\n  checked_at  TEXT NOT NULL,\n  ok_at       TEXT,\n  error       TEXT,\n  error_at    TEXT\n);\n";
+/** Tool secrets (no version bump): which sealing key Toolroll made for the secrets it keeps in the keychain, as a
+ * digest of the key, never the key. A key found beside them that isn't this one was put there by something else and is
+ * refused (tool-secret-store.ts). */
+export declare const TOOL_SECRET_KEY_SCHEMA = "\nCREATE TABLE IF NOT EXISTS tool_secret_key (\n  id      INTEGER PRIMARY KEY CHECK (id = 1),\n  digest  TEXT NOT NULL CHECK (length(digest) = 64),\n  made_at TEXT NOT NULL\n);\n-- Where secrets were kept before Toolroll's folder, decided once at this database's first start (null: none) and never\n-- probed again, so a folder a build makes later under an old name is never migrated in.\nCREATE TABLE IF NOT EXISTS tool_secret_legacy (\n  id         INTEGER PRIMARY KEY CHECK (id = 1),\n  dir        TEXT,\n  decided_at TEXT NOT NULL\n);\n";
 export type BackupSettings = {
     enabled: boolean;
     everyHours: number;
@@ -166,7 +178,7 @@ export type SealedLedgerEntry = LedgerEntry & {
         hash: string;
     } | null;
 };
-export declare const SCHEMA_VERSION = 122;
+export declare const SCHEMA_VERSION = 130;
 /** v118: the tables merged into `credential`, in the order they move (a person's API tokens keep their ids first). */
 export declare const V118_MERGED_TABLES: Readonly<Record<string, CredentialKind>>;
 /**
@@ -227,7 +239,11 @@ export declare const V115_DROPPED_TABLES: readonly string[];
  * three nullable task_steer columns (the running build's steering folder), checked the same way. v121 only adds
  * new tables and the columns in V121_ADDED_COLUMNS (null, or no sends), checked the same way. v122 only adds a new
  * table (branch_base_move) and the nullable column in V122_ADDED_COLUMNS (a project's recorded remote), checked the
- * same way.
+ * same way. v123 only adds new tables (unattended flows, tool secrets) and the columns in V123_ADDED_COLUMNS ('mode',
+ * 0 or null), checked the same way. v124 only adds new tables (the live conversation's setting and note history).
+ * v125 rebuilds five tables with wider CHECKs, every row and id carried over (the rehearsal's history rules find them
+ * unchanged), and adds the nullable column in V125_ADDED_COLUMNS, checked the same way. v126 only adds a new table
+ * (task_source) and the columns in V126_ADDED_COLUMNS (null or 0), checked the same way.
  */
 export declare const UPDATE_SAFE_MIGRATIONS: readonly number[];
 /** v119: the columns it adds, by table, with the value every row saved before it reads (toolroll-update's HISTORY_RULES). */
@@ -263,6 +279,52 @@ export declare const V122_ADDED_COLUMNS: Readonly<Record<string, Readonly<Record
     definition: string;
     saved: string;
 }>>>>;
+/** v123: the columns it adds, with the value every row saved before it reads: which authority armed a plan's
+ * unchanged-plan approval (saved rows read the operating mode), whether a trigger's firing was the clock's own (saved
+ * firings read not), and what code an on-time script firing a grant signed for ran (saved firings read none). */
+export declare const V123_ADDED_COLUMNS: Readonly<Record<string, Readonly<Record<string, {
+    definition: string;
+    saved: string;
+}>>>>;
+/** v125: the column it adds, with the value every row saved before it reads: what a run's ACP agent itself reported it
+ * used (acp-client.ts; never priced). Runs saved before it read none. */
+export declare const V125_ADDED_COLUMNS: Readonly<Record<string, Readonly<Record<string, {
+    definition: string;
+    saved: string;
+}>>>>;
+/** v126: the columns it adds, with the value every row saved before it reads (docs/plans/webhook-tasks.md). A saved
+ * receipt reads no state (accepted when it has a card, skipped otherwise), no acceptance time (its arrival counts) and
+ * no held item; a saved trigger is on its first credential generation with nothing turned away; a saved card was made
+ * by a person. */
+export declare const V126_ADDED_COLUMNS: Readonly<Record<string, Readonly<Record<string, {
+    definition: string;
+    saved: string;
+}>>>>;
+/** v128: whether a lead message waits for its turn. A message saved before v128 waits exactly when it is an operator
+ * message that a team queue row holds and no turn has taken (the team runtime's own unadmitted messages); every other
+ * saved message is history (`saved` is evaluated per row). */
+export declare const V128_ADDED_COLUMNS: Readonly<Record<string, Readonly<Record<string, {
+    definition: string;
+    saved: string;
+}>>>>;
+/** v129: how a run went (docs/plans/run-efficiency.md). Recorded from now on; a saved row reads unknown (NULL), never 0. */
+export declare const V129_ADDED_COLUMNS: Readonly<Record<string, Readonly<Record<string, {
+    definition: string;
+    saved: string;
+}>>>>;
+/** v130: a project's network (an approver's setting, egress.ts ProjectNetwork as JSON) and the installation's choice
+ * whether an agent may run where no OS confinement exists (one row; 0 until an instance operator turns it on). */
+export declare const CONFINEMENT_SCHEMA = "\nCREATE TABLE IF NOT EXISTS project_network (\n  repo          TEXT PRIMARY KEY,\n  network_json  TEXT NOT NULL CHECK (length(network_json) <= 16384),\n  updated_at    TEXT NOT NULL,\n  updated_by    TEXT NOT NULL\n);\nCREATE TABLE IF NOT EXISTS confinement_setting (\n  id               INTEGER PRIMARY KEY CHECK (id = 1),\n  unfenced_allowed INTEGER NOT NULL DEFAULT 0 CHECK (unfenced_allowed IN (0, 1)),\n  updated_at       TEXT,\n  updated_by       TEXT\n);\nINSERT OR IGNORE INTO confinement_setting (id, unfenced_allowed) VALUES (1, 0);\n";
+/** v129: a finished run's How it ran, derived from its own records on first view (display only: never a verdict). Its
+ * parser version says when to derive again; `steps` says how complete the step detail was, and why not. */
+export declare const RUN_EFFICIENCY_SCHEMA = "\nCREATE TABLE IF NOT EXISTS run_efficiency (\n  run             INTEGER PRIMARY KEY REFERENCES run(id) ON DELETE CASCADE,\n  parser_version  INTEGER NOT NULL,\n  steps           TEXT NOT NULL CHECK (steps IN ('complete','truncated','expired','absent')),\n  steps_reason    TEXT,\n  payload_json    TEXT NOT NULL CHECK (length(payload_json) <= 16384),\n  derived_at      TEXT NOT NULL\n);\n";
+/** v128: the personal lead queue (docs/plans/lead-message-queue.md). A message sent while one of its author's personal
+ * lead turns runs (or while earlier ones wait) waits here, one turn per message, in order. Its words are the
+ * lead_message row (pending until admitted); terminal rows keep only their request identity (a tombstone). */
+export declare const LEAD_QUEUE_SCHEMA = "\nCREATE TABLE IF NOT EXISTS lead_queue (\n  message             INTEGER PRIMARY KEY REFERENCES lead_message(id) ON DELETE CASCADE,\n  thread              INTEGER NOT NULL REFERENCES lead_thread(id) ON DELETE CASCADE,\n  approver            TEXT NOT NULL,\n  approver_generation INTEGER NOT NULL,\n  session             INTEGER NOT NULL,\n  ceiling_digest      TEXT NOT NULL,\n  request_id          TEXT NOT NULL,\n  payload_hash        TEXT NOT NULL,\n  context_json        TEXT,\n  status              TEXT NOT NULL CHECK (status IN ('queued','running','answered','failed','cancelled','uncertain')),\n  revision            INTEGER NOT NULL DEFAULT 1,\n  generation          INTEGER NOT NULL DEFAULT 0,\n  runner              TEXT,\n  claimed_at          TEXT,\n  turn_id             INTEGER REFERENCES mate_turn(id),\n  error               TEXT,\n  created_at          TEXT NOT NULL,\n  settled_at          TEXT,\n  UNIQUE (session, request_id)\n);\nCREATE INDEX IF NOT EXISTS lead_queue_backlog ON lead_queue (approver, status, message);\nCREATE UNIQUE INDEX IF NOT EXISTS lead_queue_one_running ON lead_queue (approver) WHERE status = 'running';\nCREATE INDEX IF NOT EXISTS lead_queue_admitted ON lead_queue (turn_id) WHERE turn_id IS NOT NULL;\n";
+/** v126: the outside source a task was filed from, kept with the task (a card's own task link moves on; this never
+ * does). Written in the filing's transaction, copied whole to a revision, never changed. */
+export declare const TASK_SOURCE_SCHEMA = "\nCREATE TABLE IF NOT EXISTS task_source (\n  task_id     TEXT PRIMARY KEY,\n  flow        INTEGER NOT NULL,\n  card        INTEGER NOT NULL,\n  card_entry  INTEGER NOT NULL,\n  source_json TEXT NOT NULL,\n  at          TEXT NOT NULL\n);\nCREATE TRIGGER IF NOT EXISTS task_source_immutable BEFORE UPDATE ON task_source\nBEGIN\n  SELECT RAISE(ABORT, 'a task source is immutable');\nEND;\nCREATE INDEX IF NOT EXISTS flow_trigger_event_accepted ON flow_trigger_event (trigger, accepted_at);\n";
 /** Whether a database settled at `version` reaches this build's schema through update-safe migrations alone. */
 export declare function updateSafeSchema(version: number | null): boolean;
 export type OAuthClientRow = {
@@ -587,6 +649,8 @@ export type LeadMessage = {
     text: string;
     activity: string | null;
     createdAt: string;
+    /** v128: still waiting for its turn (a queued message); absent when admitted or never queued. */
+    pending?: true;
 };
 export type LeadProposalKind = "task" | "next" | "reserve" | "hold" | "unhold" | "steer" | "scope" | "cancel" | "answer" | "repair" | "agents" | "review" | "control" | "task_action" | "action";
 /** A coordinator's proposal over the MCP gateway (mate arc v3): the same
@@ -821,6 +885,13 @@ export type FlowCardSource = {
         subject: string;
         from: string;
     };
+    /** v126: a webhook delivery's sender that proved it ("none": unsigned), the outside thing it names, and its receipt's key. */
+    verified?: string;
+    external?: {
+        id: string | null;
+        url: string | null;
+    };
+    receipt?: string;
     chat?: {
         app: string;
         installation: string;
@@ -859,6 +930,22 @@ export type FlowTriggerRow = {
     createdBy: string;
     createdAt: string;
     updatedAt: string;
+    /** v126: which saved secret proves this trigger's deliveries: "legacy" (the address every secret saved before v126
+     * has), "" (none yet: refused until one is saved), or the id of a secret written whole before the trigger pointed at it. */
+    hookCredential: string;
+    /** v126: deliveries turned away because the hold queue was full, and since when, until a person clears them. */
+    droppedCount: number;
+    droppedSince: string | null;
+};
+/** v126: what a trigger did with one delivery. Saved before v126: accepted when it made a card, skipped otherwise. */
+export type FlowReceiptState = "accepted" | "skipped" | "held" | "ignored";
+export type FlowReceipt = {
+    state: FlowReceiptState;
+    card: number | null;
+    note: string | null;
+    at: string;
+    acceptedAt: string | null;
+    itemJson: string | null;
 };
 export type FlowEventOutcome = "created" | "ok" | "fail" | "moved" | "approved" | "sent-back" | "cancelled";
 export type LeadTurn = {
@@ -1147,6 +1234,8 @@ export type Run = {
     tokensIn: number | null;
     tokensOut: number | null;
     costUsd: number | null;
+    /** v129: the agent's turns where its provider reports them (Claude's num_turns); null when unknown. */
+    agentTurns?: number | null;
     /** HEAD after the agent, as accepted — what a publication may push. */
     headRevision: string | null;
     /** The validated terminal handoff's conclusion. */
@@ -1161,7 +1250,7 @@ export type Run = {
      * How this attempt authenticated (v30) — 'subscription' or 'api-key' —
      * stamped by the gateway. Decides which exhaustion class a match yields.
      */
-    authMode?: "subscription" | "api-key" | null;
+    authMode?: "subscription" | "api-key" | "agent-login" | null;
     /**
      * The gateway's honest classification of how this attempt ENDED (v30),
      * computed where the structural terminal still exists (exhaustion.ts).
@@ -1750,6 +1839,77 @@ export declare const REVIEW_ROOT_ATTEMPTS = 3;
 /** The receipt v114 keeps a notification's old single-destination delivery under. No sender claims it: every real
  * destination is a kind and a 64-character hash, or a Telegram binding. */
 export declare const LEGACY_NOTIFICATION_DESTINATION = "legacy:single-destination";
+/**
+ * v125: an ACP agent's passed conformance checks (acp-attest.ts): per provider and runner, how to launch the exact
+ * binary that passed and every file that launch depends on, what the agent said it is, the models it offered and the
+ * checks it passed. At most one live row per agent and runner; revoking keeps the row as history.
+ */
+export declare const ACP_ATTESTATION_SCHEMA = "\nCREATE TABLE IF NOT EXISTS acp_attestation (\n  id                  INTEGER PRIMARY KEY AUTOINCREMENT,\n  provider            TEXT NOT NULL CHECK (provider IN ('opencode','cursor','cline','qwen','goose')),\n  runner              TEXT NOT NULL,\n  conformance_version INTEGER NOT NULL,\n  launch_json         TEXT NOT NULL,\n  agent_name          TEXT NOT NULL,\n  agent_version       TEXT NOT NULL,\n  cli_version         TEXT NOT NULL,\n  models_json         TEXT NOT NULL,\n  checks_json         TEXT NOT NULL,\n  recorded_at         TEXT NOT NULL,\n  recorded_by         TEXT NOT NULL,\n  revoked_at          TEXT,\n  revoked_by          TEXT\n);\nCREATE UNIQUE INDEX IF NOT EXISTS acp_attestation_live ON acp_attestation (provider, runner) WHERE revoked_at IS NULL;\n";
+/**
+ * v125: how an ACP agent's work on one model is billed, per runner (docs/plans/acp-adapter.md § Billing): metered
+ * (the default, and what no row means — cost unknown, charged as unknown cost is) or the agent's own plan ($0,
+ * counted as unmeasured). Each change is a new row; the newest is the declaration, its id the revision a run stamps.
+ */
+/**
+ * v125: a requested ACP agent check (docs/plans/acp-adapter.md § Layer E): asked for with a password, claimed and run
+ * by one watch of the named runner — one running check per runner, which the partial unique index holds — through two
+ * bounded steps, each bound to its run and graded on plane evidence; the attestation is recorded only in the same
+ * transaction that marks the request passed.
+ */
+export declare const ACP_CHECK_SCHEMA = "\nCREATE TABLE IF NOT EXISTS acp_check_request (\n  id                  INTEGER PRIMARY KEY AUTOINCREMENT,\n  provider            TEXT NOT NULL CHECK (provider IN ('opencode','cursor','cline','qwen','goose')),\n  runner              TEXT NOT NULL,\n  model               TEXT NOT NULL,\n  conformance_version INTEGER NOT NULL,\n  requested_by        TEXT NOT NULL,\n  requested_at        TEXT NOT NULL,\n  expires_at          TEXT NOT NULL,\n  state               TEXT NOT NULL DEFAULT 'pending' CHECK (state IN ('pending','running','passed','failed','expired')),\n  watch_repo          TEXT,\n  watch_owner         TEXT,\n  task_ref            INTEGER REFERENCES task_ref(id),\n  launch_json         TEXT,\n  lease_id            TEXT,\n  steps_used          INTEGER NOT NULL DEFAULT 0 CHECK (steps_used BETWEEN 0 AND 2),\n  step1_run           INTEGER REFERENCES run(id),\n  step2_run           INTEGER REFERENCES run(id),\n  step1_passed        INTEGER NOT NULL DEFAULT 0 CHECK (step1_passed IN (0,1)),\n  step2_passed        INTEGER NOT NULL DEFAULT 0 CHECK (step2_passed IN (0,1)),\n  result              TEXT,\n  finished_at         TEXT,\n  settled_at          TEXT,\n  settle_by           TEXT,\n  settle_until        TEXT\n);\nCREATE UNIQUE INDEX IF NOT EXISTS acp_check_running ON acp_check_request (runner) WHERE state = 'running';\n";
+/** A check request as the job and the screens read it. */
+export type AcpCheckRequest = {
+    id: number;
+    provider: string;
+    runner: string;
+    model: string;
+    conformanceVersion: number;
+    requestedBy: string;
+    requestedAt: string;
+    expiresAt: string;
+    state: "pending" | "running" | "passed" | "failed" | "expired";
+    watch: {
+        repo: string;
+        owner: string;
+    } | null;
+    taskRef: number | null;
+    launchJson: string | null;
+    /** The claim the check took on its task: the only one its cleanup may release. */
+    leaseId: string | null;
+    stepsUsed: number;
+    step1Run: number | null;
+    step2Run: number | null;
+    step1Passed: boolean;
+    step2Passed: boolean;
+    result: string | null;
+    finishedAt: string | null;
+    /** When everything the finished check held (claim, checkout, task) was let go. */
+    settledAt: string | null;
+};
+export declare const ACP_BILLING_SCHEMA = "\nCREATE TABLE IF NOT EXISTS acp_billing (\n  id        INTEGER PRIMARY KEY AUTOINCREMENT,\n  provider  TEXT NOT NULL CHECK (provider IN ('opencode','cursor','cline','qwen','goose')),\n  runner    TEXT NOT NULL,\n  model     TEXT NOT NULL,\n  kind      TEXT NOT NULL CHECK (kind IN ('metered','plan')),\n  set_at    TEXT NOT NULL,\n  set_by    TEXT NOT NULL\n);\nCREATE INDEX IF NOT EXISTS acp_billing_by ON acp_billing (provider, runner, model, id);\n";
+/** An ACP run's billing as stamped when the run was admitted: never re-read from the live declaration. */
+export type AcpBillingStamp = {
+    kind: "metered" | "plan";
+    revision: number;
+    model: string;
+};
+/** An ACP agent's live attestation, as the gateway reads it. */
+export type AcpAttestation = {
+    id: number;
+    provider: string;
+    runner: string;
+    conformanceVersion: number;
+    launch: AcpLaunch;
+    agent: {
+        name: string;
+        version: string;
+    };
+    cliVersion: string;
+    models: string[];
+    checks: string[];
+    recordedAt: string;
+    recordedBy: string;
+};
 /** Reporting never creates, migrates, or repairs a store. SQLite itself
  * enforces read-only access, including the race where the file disappears. */
 export declare function openStoreReadOnly(file: string): Store | null;
@@ -1770,6 +1930,18 @@ export declare class Store {
     /** The database's own file (null in memory): where the agent fence begins. */
     databaseFile(): string | null;
     close(): void;
+    /** The digest of the sealing key Toolroll made for its tool secrets; null before it made one (or in an older database). */
+    toolSecretKeyDigest(): string | null;
+    /**
+     * The folder secrets were kept in before Toolroll's own, as decided at this database's first start of a command that
+     * can start builds (`record`): `probe` runs until then, and its answer (null: none) is kept for every later start.
+     * Other commands never write, so a preview stays read-only and a busy database doesn't stop them.
+     */
+    toolSecretLegacyDir(probe: () => string | null, now: Date, options: {
+        record: boolean;
+    }): string | null;
+    /** Record a new sealing key's digest only if the one recorded is still `expected` (null: none yet). */
+    swapToolSecretKeyDigest(expected: string | null, next: string, now: Date): boolean;
     /**
      * Creating a task also creates its overlay reference, because a task with no
      * `TaskRef` cannot be claimed, held, or scheduled — it would be work the
@@ -2164,7 +2336,7 @@ export declare class Store {
      * exactly what the signed digest was bound to. Returns false when the
      * scope vanished mid-ceremony. */
     sealScopeApproval(taskId: string, by: string, now: Date, mutation?: Mutation, basis?: {
-        kind: "mode" | "chat";
+        kind: "mode" | "chat" | "grant";
         modeDigest: string;
     }, approverKind?: ApproverKind): boolean;
     /** Whether this task's scope carries a LIVE seal: approved, and the
@@ -2219,6 +2391,10 @@ export declare class Store {
      * ceremony. Reconciliation drops mode-basis intents to waiting-human;
      * `firing` rows are untouched — an issued call is one-shot (E1). */
     revokeMode(repo: string, by: string, reason: string, now: Date): boolean;
+    /** A flow's "runs on its own" grant ended (revoked, expired, renewed): the undispatched work it sealed falls back
+     * to a person, as a mode's does, and plans it armed lose their pre-authorization. Running and finished work keeps
+     * its history. */
+    withdrawGrantApprovals(digest: string, now: Date): void;
     /** F2/R-REVOKE: the ONE reconciliation road. newMode null = no live
      * automerge authority (revocation, expiry, or a notify posture):
      * mode-basis pending/claimed intents drop to waiting-human, leases
@@ -3142,6 +3318,19 @@ export declare class Store {
     } | null;
     /** Stamp a task as the revision it is: source task + immutable brief. */
     markRevision(taskRef: number, revisionOf: string, briefArtifact: number): void;
+    /** v126: where a task came from, written once in its filing's transaction (task-source.ts), never changed. */
+    recordTaskSource(taskId: string, from: {
+        flow: number;
+        card: number;
+        entry: number;
+    }, sourceJson: string, now: Date): void;
+    /** v126: where a task came from, as kept when it (or the task it revises) was filed; null for every other task. */
+    taskSourceOf(taskId: string): {
+        flow: number;
+        card: number;
+        entry: number;
+        sourceJson: string;
+    } | null;
     /**
      * Seal a revision in ONE transaction (Codex M5-M8 audit, C-3; contract
      * handoff task 2): the SOURCE BINDING is proven here, against live rows,
@@ -3441,13 +3630,19 @@ export declare class Store {
      * verified, attested or accepted, or its branch was published (revised
      * through its pull request). Null when `requeueTask` may run it again. */
     finalResultReason(runId: number): "accepted-result" | "published" | null;
-    requeueTask(taskId: string, by: string, now: Date): {
+    requeueTask(taskId: string, by: string, now: Date, 
+    /** Approve & build again: requeue only while this exact build is the finished task's latest result and the scope
+     * is still the one just approved, read inside this transaction ("moved" otherwise). */
+    expect?: {
+        run: number;
+        scopeDigest: string;
+    }): {
         ok: true;
         resolvedIncidents: number;
         rejectedRun: number | null;
     } | {
         ok: false;
-        reason: "unknown-task" | "not-stalled" | "claimed" | "accepted-result" | "published";
+        reason: "unknown-task" | "not-stalled" | "claimed" | "accepted-result" | "published" | "moved";
     };
     /**
      * Cancel, aware of who might be building right now. A live claim wins:
@@ -3954,6 +4149,9 @@ export declare class Store {
         unknownSpend?: boolean;
         replyBytes?: number;
         candidateCount?: number;
+        /** v129: the request's cache read and write tokens, where its provider reports them (unknown stays NULL). */
+        cacheReadTokens?: number | null;
+        cacheWriteTokens?: number | null;
     }, now: Date): boolean;
     /**
      * The crash sweep: turns past their deadline become failed('crashed'),
@@ -4411,7 +4609,96 @@ export declare class Store {
      * structural signal is gone. `auth-expired` pauses its provider; every
      * other class is observational.
      */
-    stampTerminalClass(id: number, authMode: "subscription" | "api-key", terminalClass: TerminalClass): void;
+    /**
+     * Record an ACP agent's passed conformance check on a runner (acp-attest.ts), replacing the live one — one
+     * transaction, so there is never a moment with two or with a gap that reads as the old one.
+     */
+    recordAcpAttestation(input: Omit<AcpAttestation, "id" | "recordedAt" | "conformanceVersion"> & {
+        conformanceVersion?: number;
+    }, now: Date): number;
+    /** An ACP agent's live attestation on a runner, under this build's conformance version; null when there is none. */
+    acpAttestationFor(provider: string, runner: string): AcpAttestation | null;
+    /** Declare how an ACP agent's work on one model is billed on a runner; the new revision. */
+    declareAcpBilling(input: {
+        provider: string;
+        runner: string;
+        model: string;
+        kind: "metered" | "plan";
+        by: string;
+    }, now: Date): number;
+    /** The billing declaration standing for an ACP agent's model on a runner: metered, revision 0, when none was made. */
+    acpBillingFor(provider: string, runner: string, model: string): AcpBillingStamp;
+    /** The billing an ACP run was admitted under, or null (not an ACP run, or unreadable — then it is metered). */
+    acpBillingOfRun(runId: number): AcpBillingStamp | null;
+    /** Ask for an ACP agent check on a runner (the caller proved the password); the request's id. Valid 30 minutes. */
+    requestAcpCheck(input: {
+        provider: string;
+        runner: string;
+        model: string;
+        by: string;
+    }, now: Date): number;
+    acpCheck(id: number): AcpCheckRequest | null;
+    /** The checks asked for an agent, newest first (for the providers screen). */
+    acpChecksFor(provider: string, limit?: number): AcpCheckRequest[];
+    /** The SQL that proves a watch still holds its lease (runner, repo, owner) at `?` — appended with its bindings. */
+    private static readonly WATCH_LIVE;
+    /**
+     * Claim the oldest pending, unexpired check for this runner, for the watch that will run it — one statement; the
+     * partial unique index refuses a second running check on the runner. Null when there is none (or another runs).
+     */
+    claimAcpCheck(runner: string, watch: {
+        repo: string;
+        owner: string;
+    }, now: Date): AcpCheckRequest | null;
+    /** Bind a running check, still owned and unexpired, to its task and the launch it inspected. */
+    bindAcpCheck(id: number, binding: {
+        taskRef: number;
+        launchJson: string;
+        leaseId: string;
+    }, now: Date): boolean;
+    /** Consume step 1 or 2 for its run: in order, once, owned, unexpired. */
+    consumeAcpCheckStep(id: number, step: 1 | 2, runId: number, now: Date): boolean;
+    /** Record a step as passed, once its grading did: owned, unexpired, and only for the run the step was bound to. */
+    passAcpCheckStep(id: number, step: 1 | 2, runId: number, now: Date): boolean;
+    /**
+     * Publish a passed check: in one transaction, the request moves to passed — only if it is still running, unexpired,
+     * owned by its live watch, with both steps used, bound and passed, and both their runs finished as agent-check
+     * refusals — and the attestation is recorded. Anything else publishes nothing.
+     */
+    publishAcpCheck(id: number, attestation: Omit<AcpAttestation, "id" | "recordedAt" | "conformanceVersion">, now: Date): boolean;
+    /** The check request, when it still admits this run as its current step: running, unexpired, its watch's lease
+     * live, and the step bound to exactly this run. Null otherwise. */
+    acpCheckAdmitting(id: number, step: 1 | 2, runId: number, now: Date): AcpCheckRequest | null;
+    /** Fail a check that hasn't finished, with its words. */
+    failAcpCheck(id: number, words: string, now: Date): boolean;
+    /** Running checks on this runner no live watch holds any more, or past their time: the ones recovery may close. */
+    abandonedAcpChecks(runner: string, now: Date): AcpCheckRequest[];
+    /** Finished checks on this runner whose claim, checkout and task are not yet let go: cleanup's to-do, retried each pass. */
+    unsettledAcpChecks(runner: string): AcpCheckRequest[];
+    /** The claim a finished check's cleanup now holds on its task (its first one expired): the only one it may release. */
+    setAcpCheckLease(id: number, leaseId: string): boolean;
+    /** A finished check holds something again (a checkout that landed after recovery settled it): cleanup reopens. */
+    unsettleAcpCheck(id: number): boolean;
+    /** Take — or renew — the one cleanup attempt a finished check may have at a time: free, lapsed, or already this one. */
+    holdAcpSettle(id: number, attempt: string, now: Date, ttlMs: number): boolean;
+    /** Whether this cleanup attempt still holds the check. */
+    holdsAcpSettle(id: number, attempt: string, now: Date): boolean;
+    /** Let go of a cleanup attempt (only this one). */
+    endAcpSettle(id: number, attempt: string): void;
+    /** Mark a finished check's holdings let go — by the attempt holding it, and only if no checkout of its branch is
+     * left (one that landed late keeps it open, whatever the attempt last saw). */
+    settleAcpCheck(id: number, attempt: string, branch: string, now: Date): boolean;
+    /** Pending checks past their time are expired, untouched. */
+    expireAcpChecks(now: Date): number;
+    /** Revoke an ACP agent's live attestation on a runner; whether there was one. */
+    revokeAcpAttestation(provider: string, runner: string, by: string, now: Date): boolean;
+    /** What a run's ACP agent itself reported it used (never priced; acp-client.ts). */
+    stampAgentReportedUsage(id: number, usage: string | null): void;
+    stampTerminalClass(id: number, authMode: "subscription" | "api-key" | "agent-login", terminalClass: TerminalClass): void;
+    /** A launch refused before any model turn (an installed CLI too old for a
+     * build's flags): the start stamp goes, its version and evidence stay. Only
+     * while the run is open, so a settled run's account never changes. */
+    withdrawProviderStart(id: number): void;
     /** The race-refusal stamp (Phase 3 C5): the version that was REFUSED,
      * recorded without provider_started_at — no provider process started. */
     stampProviderVersion(id: number, providerVersion: string): void;
@@ -4421,6 +4708,7 @@ export declare class Store {
         tokensOut?: number;
         costUsd?: number;
         usageJson?: string;
+        agentTurns?: number;
     }): void;
     /** v105: price a run as it stands (reported cost, or tokens at the catalogue price, or unpriced), frozen at the
      * price of the moment it's settled. Settled again whenever its usage changes. */
@@ -4515,6 +4803,9 @@ export declare class Store {
         subagent: number | null;
         agents?: readonly BudgetAgent[];
     }) => BudgetHold;
+    /** How one agent would bill new work now: an ACP agent by its declaration for that exact model on that runner
+     * (plan reads as a plan, anything else as metered), every other provider as agentsFor says. */
+    agentFor(provider: string, model: string | null, runner: string | null): BudgetAgent;
     /** How each provider would bill new work now (see spend.billingOf). */
     agentsFor(providers: readonly string[]): BudgetAgent[];
     /** v105: how a provider's CLI was seen billing (a Claude stream's key source, Codex's account mode). */
@@ -4768,6 +5059,27 @@ export declare class Store {
         reason: "unknown-task" | "task-finished" | "invalid-note";
         problem?: string;
     };
+    /**
+     * File a note for the exact run a person is watching (live-conversation.md
+     * §6): in ONE transaction, the run must still be the task's live attempt
+     * (or, `onward`, any attempt of this task: the note goes to the next one),
+     * and a repeated `key` from the same author hands back the same note — only
+     * for the same task, run and text, whichever of the two ways it was sent;
+     * any other reuse is refused. Nothing is filed on a refusal.
+     */
+    fileSteerNoteForRun(taskId: string, author: VerifiedAuthor, note: string, now: Date, expect: {
+        run: number;
+        key: string | null;
+        onward?: boolean;
+    }): {
+        ok: true;
+        id: number;
+        replayed: boolean;
+    } | {
+        ok: false;
+        reason: "unknown-task" | "task-finished" | "invalid-note" | "attempt-ended" | "key-reused";
+        problem?: string;
+    };
     /** One verified note, with the identity a running build's stdin copy is sent under: filing it is also what queues
      * its live delivery, in the same transaction (the builder's dispatcher sends whatever is filed and unsent). */
     private insertSteerNote;
@@ -4813,6 +5125,10 @@ export declare class Store {
     /** The pulse wrote this note into the run's steering folder. Mailing is not
      * reading: delivery settles only on the agent's own acknowledgement. */
     markSteerMailed(noteId: number, runId: number, now: Date): boolean;
+    /** One run a note reached, kept for its live conversation (live-notes.ts); display state, so a failure never blocks steering. */
+    private noteSteerReached;
+    /** The notes this run reached, filing order — attached to its brief, mailed into its folder, or read by it. */
+    steerNotesReaching(runId: number): SteerNote[];
     /**
      * The agent moved this note to handled/ (v120): it was read, by THIS run.
      * Acknowledgement is the only road from mailed to delivered — a hook firing
@@ -5401,12 +5717,16 @@ export declare class Store {
         by: string;
     }, now: Date): boolean;
     archiveFlow(id: number, by: string, now: Date): boolean;
+    /** A new card. `byKind` (v126) is decided where the card is made, never read from `by`: a delivery, a poll, a schedule
+     * a public form or a chat channel's message is automation whatever its label says; a signed-in person's own card is a
+     * person's. Every caller says which: filing passes it on exactly, and never reads it from `by`. */
     addFlowCard(card: {
         flow: number;
         title: string;
         description: string | null;
         stage: string;
         by: string;
+        byKind: "person" | "automation";
         source?: FlowCardSource;
     }, now: Date): number;
     getFlowCard(id: number): FlowCardRow | null;
@@ -5684,7 +6004,7 @@ export declare class Store {
     }, now: Date): number;
     /** A person approves a held script (one an imported flow brought): from now on it runs. False when it wasn't held. */
     approveFlowScript(repo: string, name: string): boolean;
-    removeFlowScript(repo: string, name: string): boolean;
+    removeFlowScript(repo: string, name: string, by?: string, now?: Date): boolean;
     /** Claim a card's visit to a step zone. False when another pass holds it or it already finished. */
     claimFlowStep(step: {
         card: number;
@@ -5764,7 +6084,7 @@ export declare class Store {
         lastOutcome?: string;
         failures?: number;
         hookHash?: string | null;
-    }, now: Date): void;
+    }, now: Date, by?: string): void;
     /** Whether a trigger already handled this outside thing (an issue, a run, a schedule slot). */
     flowTriggerSaw(trigger: number, key: string): boolean;
     /** The card one outside thing made (v89: a chat message, so replies in its thread find it). */
@@ -5775,7 +6095,48 @@ export declare class Store {
      * Record what a trigger did with one outside thing: the card it made, or why it made none, and (a standing order's
      * firing) the task it filed. False when it was already recorded.
      */
-    recordFlowTriggerEvent(trigger: number, key: string, card: number | null, note: string | null, now: Date, task?: string | null): boolean;
+    recordFlowTriggerEvent(trigger: number, key: string, card: number | null, note: string | null, now: Date, task?: string | null, onTime?: boolean, ranScript?: string | null): boolean;
+    /**
+     * v126: point a trigger at another saved secret ("" for none), and (when given) its new settings, in one write — only
+     * from the secret and settings the caller read, so of two changes at once exactly one lands. False when it changed
+     * meanwhile (or the trigger is gone): the caller then removes only the secret it wrote itself.
+     */
+    swapFlowHookCredential(id: number, from: {
+        credential: string;
+        configJson: string;
+        hookHash: string | null;
+    }, to: {
+        credential: string;
+        hookHash?: string;
+    }, configJson: string | null, now: Date): boolean;
+    /** v126: what a trigger did with one delivery, or null when it never received it. */
+    flowReceipt(trigger: number, key: string): FlowReceipt | null;
+    /** v126: a delivery received but made no card for: ignored (not for this flow), or held until there's room (its
+     * prepared item kept whole). False when the key was already received. */
+    recordFlowReceipt(trigger: number, key: string, state: "ignored" | "held", note: string | null, itemJson: string | null, now: Date): boolean;
+    /** v126: a held delivery became its card. Only ever from held, in the card's own transaction: false (the caller rolls
+     * the card back) when it is no longer held. */
+    acceptHeldReceipt(trigger: number, key: string, card: number, now: Date): boolean;
+    /** v126: the cards a trigger made since `since`, counted when each was made (a held delivery counts when it became
+     * its card, not when it arrived). A receipt saved before v126 counts at its arrival. */
+    flowCardsAcceptedSince(trigger: number, since: Date): number;
+    /** v126: a trigger's held deliveries, oldest first. */
+    heldFlowReceipts(trigger: number, limit: number): {
+        key: string;
+        itemJson: string;
+        at: string;
+    }[];
+    /** v126: a held delivery that can't become its card (its words no longer pass): left out, with why. */
+    skipHeldReceipt(trigger: number, key: string, note: string): boolean;
+    /** v126: how many deliveries a trigger holds. */
+    heldFlowReceiptCount(trigger: number): number;
+    /** v126: one delivery turned away because the hold queue was full: counted, and since when, until a person clears it. */
+    noteFlowDeliveryDropped(trigger: number, now: Date): void;
+    /** v126: a person has seen the turned-away deliveries. */
+    clearFlowDeliveriesDropped(trigger: number): void;
+    /** v126: whether this hour's "too many" note on a trigger is still to be written: true at most once an hour, claimed
+     * atomically so two deliveries at once write it once. */
+    claimFlowLimitNote(trigger: number, now: Date): boolean;
     /** The last card a trigger made, if any. */
     lastFlowTriggerCard(trigger: number): number | null;
     /**
@@ -5833,6 +6194,9 @@ export declare class Store {
         method: string;
         paths: number;
     }, now: Date): void;
+    /** What one attempt's network was and what its proxy saw (egress.ts), kept beside its fence. */
+    recordRunNetwork(run: number, network: RunNetworkRecord, now: Date): void;
+    runNetwork(run: number): RunNetworkRecord | null;
     runFence(run: number): {
         method: string;
         paths: number;
@@ -5855,13 +6219,20 @@ export declare class Store {
     /** `--end` and revocation: the thread's text and every proposal in it are
      * deleted; the thread row stays as closed metadata (when, whose). */
     closeLeadThreadsFor(approver: string, now: Date): number;
+    /** `pending`: a queued message (personal or team) that waits for its turn — out of the model's history until the
+     * admission that binds it clears the flag in the same statement (v128). */
     appendLeadMessage(message: {
         thread: number;
         turn: number | null;
         role: "operator" | "assistant";
         text: string;
         activity?: string | null;
+        pending?: boolean;
     }, now: Date): number;
+    /** The model's history: the last `limit` ADMITTED messages, oldest first — a message still waiting for its turn (or
+     * removed, expired or refused while waiting) is never read back to the lead. An index range scan whatever the backlog
+     * (lead_message_history). People see the whole thread through listLeadMessages. */
+    listLeadHistory(thread: number, limit: number): LeadMessage[];
     /** The last `limit` messages, oldest first. */
     listLeadMessages(thread: number, limit: number): LeadMessage[];
     /** A proposal is inert (`drafting`) until its turn finalizes. */
@@ -5930,12 +6301,18 @@ export declare class Store {
         weeklyCeilingMicrousd: number;
         deadlineMs: number;
         provider?: string;
+        /** The personal queue claim this turn runs (lead-queue.ts): the only admission the backlog lets through. */
+        queueClaim?: {
+            message: number;
+            runner: string;
+            generation: number;
+        };
     }, now: Date): {
         ok: true;
         id: number;
     } | {
         ok: false;
-        reason: "latched" | "concurrent" | "daily-cap" | "session-exhausted" | "session-ended" | "not-yours" | "thread-closed" | "over-budget" | "monthly-budget";
+        reason: "latched" | "concurrent" | "backlog" | "daily-cap" | "session-exhausted" | "session-ended" | "not-yours" | "thread-closed" | "over-budget" | "monthly-budget";
     };
     startLeadTurn(id: number, now: Date): {
         ok: true;
@@ -6115,7 +6492,7 @@ export declare class Store {
         handoff: string | null;
         costUsd: number | null;
         provider: string | null;
-        authMode: "subscription" | "api-key" | null;
+        authMode: "subscription" | "api-key" | "agent-login" | null;
         ranMinutes: number | null;
         prNumber: number | null;
         prUrl: string | null;
@@ -6149,7 +6526,7 @@ export declare class Store {
         startedAt: string;
         ranMinutes: number | null;
         costUsd: number | null;
-        authMode: "subscription" | "api-key" | null;
+        authMode: "subscription" | "api-key" | "agent-login" | null;
         prNumber: number | null;
         prUrl: string | null;
     }[];
@@ -6361,6 +6738,8 @@ export declare class Store {
      * note couldn't be read has stopped. */
     private workspaceConfirmedByApprover;
     reserveRunProcess(runId: number, now: Date, group?: boolean): number;
+    /** The run's process witnesses not yet proved exited — after first saving whatever exit evidence is available. */
+    openRunProcessCount(runId: number, now: Date): number;
     /** Save positive OS exit evidence while it is available, before a numeric
      * PID can be reused. Completion, missing ancestry and age prove nothing.
      * Existing rows stay intact; only a previously unknown exit is recorded.
@@ -6458,14 +6837,14 @@ export declare class Store {
         scope?: string;
         reason: string;
         resetAt?: Date;
-        authMode?: "subscription" | "api-key";
+        authMode?: "subscription" | "api-key" | "agent-login";
         credentialFp?: string;
     }, now: Date): void;
     /**
      * The quota gate's answer, with the lazy exhausted→half-open transition at
      * the known reset. Null means no recorded constraint.
      */
-    quotaState(runner: string, provider: string, scope: string, now: Date, authMode?: "subscription" | "api-key", credentialFp?: string): {
+    quotaState(runner: string, provider: string, scope: string, now: Date, authMode?: "subscription" | "api-key" | "agent-login", credentialFp?: string): {
         state: "exhausted" | "half-open";
         reason: string;
         resetAt: string | null;
@@ -6473,7 +6852,7 @@ export declare class Store {
     /** Read-only quota observation for status surfaces. A passed reset reads
      * half-open, matching quotaState's lazy transition, but this method never
      * consumes or changes the probe slot. */
-    readQuotaState(runner: string, provider: string, scope: string, now: Date, authMode?: "subscription" | "api-key", credentialFp?: string): {
+    readQuotaState(runner: string, provider: string, scope: string, now: Date, authMode?: "subscription" | "api-key" | "agent-login", credentialFp?: string): {
         state: "exhausted" | "half-open";
         reason: string;
         resetAt: string | null;
@@ -6485,9 +6864,9 @@ export declare class Store {
      * while the probe flies. The probe's success clears the row; the same
      * structured signal that stamped it re-stamps on failure.
      */
-    consumeHalfOpen(runner: string, provider: string, scope: string, now: Date, authMode?: "subscription" | "api-key", credentialFp?: string): boolean;
+    consumeHalfOpen(runner: string, provider: string, scope: string, now: Date, authMode?: "subscription" | "api-key" | "agent-login", credentialFp?: string): boolean;
     /** A structured all-clear (or an operator's), by name. */
-    clearQuota(runner: string, provider: string, scope: string, authMode?: "subscription" | "api-key", credentialFp?: string): boolean;
+    clearQuota(runner: string, provider: string, scope: string, authMode?: "subscription" | "api-key" | "agent-login", credentialFp?: string): boolean;
     /**
      * Live claims this runner holds right now — the occupied slots of §8's
      * capacity gate.
@@ -6498,6 +6877,16 @@ export declare class Store {
     /** Every builder's live attempts, by project: what `status` shows against each project's limit. */
     runningBuildsByRepo(now: Date): Map<string, number>;
     /** A project's build concurrency changed (project-concurrency.ts): the ledger keeps before → after. */
+    /** A project's network (egress.ts): its saved setting, or the default when none is saved or it doesn't read. */
+    projectNetwork(repo: string): ProjectNetwork;
+    /** An approver changed a project's network: saved, and in the ledger as before → after. */
+    setProjectNetwork(repo: string, network: ProjectNetwork, by: string, now: Date): {
+        before: ProjectNetwork;
+        after: ProjectNetwork;
+    };
+    /** Whether this installation lets an agent run where no OS confinement exists (off unless an operator said so). */
+    unfencedAgentsAllowed(): boolean;
+    setUnfencedAgentsAllowed(allowed: boolean, by: string, now: Date): void;
     recordProjectConcurrency(by: string, repo: string, before: number, after: number, now: Date): void;
     /** Review 827: a project's demo URL changed (`off` when it has none). */
     recordProjectDemo(by: string, repo: string, before: string | null, after: string | null, now: Date): void;
@@ -6518,6 +6907,7 @@ export declare class Store {
     advanceBridgeCursor(botId: string, owner: string, generation: number, cursor: number, now: Date): boolean;
     markTelegramUpdateApplied(...args: Parameters<ChatMessages["markUpdateApplied"]>): ReturnType<ChatMessages["markUpdateApplied"]>;
     enqueueTelegramConversation(...args: Parameters<ChatMessages["enqueueMessage"]>): ReturnType<ChatMessages["enqueueMessage"]>;
+    telegramMessagesWaiting(binding: number): number;
     telegramConversationWaitingOn(...args: Parameters<ChatMessages["messageWaitingOn"]>): ReturnType<ChatMessages["messageWaitingOn"]>;
     getTelegramConversation(...args: Parameters<ChatMessages["getMessage"]>): ReturnType<ChatMessages["getMessage"]>;
     listTelegramConversations(...args: Parameters<ChatMessages["listMessages"]>): ReturnType<ChatMessages["listMessages"]>;
@@ -6545,6 +6935,7 @@ export declare class Store {
     telegramRetryAt(botId: string): string;
     deferTelegram(botId: string, until: string): void;
     telegramDeliveryProblem(...args: Parameters<ChatMessages["deliveryProblem"]>): ReturnType<ChatMessages["deliveryProblem"]>;
+    telegramWatchFence(...args: Parameters<ChatMessages["watchFence"]>): ReturnType<ChatMessages["watchFence"]>;
     recordTelegramMessage(...args: Parameters<ChatMessages["recordMessage"]>): ReturnType<ChatMessages["recordMessage"]>;
     telegramMessageOf(...args: Parameters<ChatMessages["messageOf"]>): ReturnType<ChatMessages["messageOf"]>;
     finalizeTelegramDelivery(...args: Parameters<ChatMessages["finalizeDelivery"]>): ReturnType<ChatMessages["finalizeDelivery"]>;
@@ -6745,7 +7136,7 @@ export declare class Store {
      * the subscription live under its enrolled generation, the notification
      * unresolved and still stamped. Null = do not transmit.
      */
-    pushSendFence(id: number, owner: string, generation: number): (PushPair & {
+    pushSendFence(id: number, owner: string, generation: number, now?: Date): (PushPair & {
         subscriptionRow: PushSubscription;
         notificationRow: Notification;
     }) | null;
@@ -6790,6 +7181,62 @@ export declare class Store {
      */
     replay<T>(mutation: Mutation, operation: string, body: () => T, worthRecording?: (result: T) => boolean): T;
     private once;
+    /** A kept web session's changes: never inserts, so a session ended elsewhere is not brought back by a cached copy.
+     * False when it is gone. (Kept last in the class: the freshness tripwire pins method positions.) */
+    updateWebSession(session: Pick<WebSessionRow, "idHash" | "lastSeen" | "project" | "projectRevision" | "ssoAt">): boolean;
+    /** A new sweep record (inside the caller's filing transaction). */
+    createSweep(input: {
+        owner: string;
+        thread: number | null;
+        repo: string;
+        title: string;
+        brief: string;
+        maxParallel: number;
+        proposal: number | null;
+    }, now: Date): number;
+    /** Link one filed child (its family root) to its sweep, in order. */
+    addSweepTask(sweep: number, rootTask: string, ordinal: number, label: string): void;
+    getSweep(id: number): {
+        id: number;
+        owner: string;
+        thread: number | null;
+        repo: string;
+        title: string;
+        brief: string;
+        maxParallel: number;
+        proposal: number | null;
+        createdAt: string;
+    } | null;
+    /** The sweep a proposal filed, if it did (a replayed confirm finds it). */
+    sweepOfProposal(proposal: number): number | null;
+    /** A sweep's children, in order: each one's family root and its label. */
+    sweepTasks(sweep: number): {
+        rootTask: string;
+        ordinal: number;
+        label: string;
+    }[];
+    /** The sweep a task belongs to through its family root (a revision of a child belongs too), or null. */
+    sweepOfTask(taskId: string): {
+        id: number;
+        maxParallel: number;
+    } | null;
+    /**
+     * How many of a sweep's families hold a live claim now (the latest lease of any task in the family, unreleased and
+     * unexpired, across every runner) — claimed-but-not-started counts. `except` leaves one task_ref out (the one being
+     * claimed). Read inside acquire's own write transaction, so two runners can't both take the last slot.
+     */
+    sweepLiveClaims(sweep: number, stamp: string, except?: number | null): number;
+    /** Whether a request of this lead turn ended with its cost unknown and that cost is still unconfirmed — the turn is
+     * what keeps chat paused on its credential. Once confirmed, it no longer is. */
+    leadTurnCostUnconfirmed(leadTurn: number): boolean;
+    /** The lead turn a chat step belongs to (a lead reply's request), or null for a standalone chat turn. */
+    leadTurnOfStep(step: number): LeadTurn | null;
+    /** A waiting message that will never run keeps nothing of what it said (v128 lead queue): its words, the context it was
+     * sent with, and any copy the memory search made of it. Only while it is still pending — a message a turn took stays. */
+    /** Whether a send of this session reached the plane: the engine took it, or the lead queue holds it (waiting, run,
+     * removed or expired — any of those means the composer's draft was accepted and must not be sent again). */
+    leadRequestReceived(session: number, request: string): boolean;
+    forgetQueuedLeadMessage(message: number): void;
 }
 /** The receipt a bot's first pairing writes over pre-pairing history: an
  * explicit skip, with no delivered timestamp and no attempt, so suppressed