toolroll 0.9.63 → 0.9.65

package/dist/store.js

@@ -1,3 +1,6 @@
+import { PROJECT_NETWORK_DEFAULT, projectNetworkFromValue, runNetworkFromValue } from "./egress.js";
+import { isAcpProfile, isAcpProvider } from "./acp-agents.js";
+import { ACP_CONFORMANCE_VERSION, launchFromJson } from "./acp-attest.js";
 import { reclaimDatabase } from "./database-reclaim.js";
 import { BASELINE_SCHEMA, BASELINE_SCHEMA_VERSION } from "./store-baseline.js";
 import { CHAT_PROVIDERS, CHAT_SCHEMA } from "./contracts/chat-tables.js";
@@ -77,6 +80,7 @@ import { parseCheckProgressSnapshot } from "./check-progress.js";
 import { accountReachesSql, normalizeProjectAccess, projectAccessAllows, readProjectAccess } from "./project-access.js";
 import { LEDGER_COLUMNS, LEDGER_SCHEMA, LEDGER_TABLE, LEDGER_V99_TABLE, installLedgerTriggers } from "./action-ledger.js";
 import { PLAN_AUTO_SCHEMA } from "./plan-auto.js";
+import { CONSOLE_INSTANCE_SCHEMA } from "./console-instance.js";
 import { endUnattendedGrants, FLOW_UNATTENDED_SCHEMA, grantStandsSql } from "./flow-unattended.js";
 import { RECIPE_SCHEMA } from "./recipes.js";
 import { POLICY_SCHEMA, agentRefusal, approvalRefusal, policyParts, readPolicy, underCeiling, sessionCeilingRefusal } from "./policy.js";
@@ -273,6 +277,29 @@ export 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 const LEAD_SWEEP_SCHEMA = `
+CREATE TABLE IF NOT EXISTS lead_sweep (
+  id           INTEGER PRIMARY KEY AUTOINCREMENT,
+  owner        TEXT NOT NULL,
+  thread       INTEGER,
+  repo         TEXT NOT NULL,
+  title        TEXT NOT NULL,
+  brief        TEXT NOT NULL,
+  max_parallel INTEGER NOT NULL CHECK (max_parallel BETWEEN 1 AND 16),
+  proposal     INTEGER UNIQUE,
+  created_at   TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS lead_sweep_task (
+  sweep     INTEGER NOT NULL REFERENCES lead_sweep(id),
+  root_task TEXT NOT NULL UNIQUE,
+  ordinal   INTEGER NOT NULL,
+  label     TEXT NOT NULL,
+  PRIMARY KEY (sweep, ordinal)
+);
+`;
 export const LEAD_COMMITMENT_SCHEMA = `
 CREATE TABLE IF NOT EXISTS lead_commitment (
   id             INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -409,6 +436,25 @@ CREATE TABLE IF NOT EXISTS run_resume (
 );
 CREATE INDEX IF NOT EXISTS run_resume_by_run ON run_resume (run, id);
 `;
+/** A project's "Show commands in the live view" (live-detail.ts): absent means off. */
+export const LIVE_DETAIL_SCHEMA = `
+CREATE TABLE IF NOT EXISTS live_detail_setting (
+  repo       TEXT PRIMARY KEY,
+  commands   INTEGER NOT NULL CHECK (commands IN (0,1)),
+  updated_by TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+-- Every run a steering note reached, kept as it happens (live-notes.ts): a
+-- note's own attached/mailed fields move to the next attempt, this does not.
+CREATE TABLE IF NOT EXISTS steer_note_run (
+  note INTEGER NOT NULL REFERENCES task_steer(id) ON DELETE CASCADE,
+  run  INTEGER NOT NULL REFERENCES run(id) ON DELETE CASCADE,
+  how  TEXT NOT NULL CHECK (how IN ('attached','mailed','read')),
+  at   TEXT NOT NULL,
+  PRIMARY KEY (note, run, how)
+);
+CREATE INDEX IF NOT EXISTS steer_note_run_by_run ON steer_note_run (run, note);
+`;
 export const CHAT_APPROVAL_SCHEMA = `
 CREATE TABLE IF NOT EXISTS chat_approval_setting (
   approver             TEXT NOT NULL,
@@ -645,7 +691,31 @@ const REGISTERED_AT_FILING = "again, as it was filed";
 // v123 adds, and changes no saved row: flows that run on their own (flow_script_provenance, flow_unattended_grant,
 // flow_unattended_run, plan_authorization.basis, flow_trigger_event.on_time and ran_script) and the tool-secret
 // sealing key's record (tool_secret_key, tool_secret_legacy).
-export const SCHEMA_VERSION = 123;
+// v124 adds, and changes no saved row: the live conversation's project setting (live_detail_setting: "Show commands in
+// the live view", absent means off) and the runs each steering note reached (steer_note_run; older notes have none).
+// v125 changes no saved row: ACP agents become providers (the provider CHECKs of phase_config, phase_tier_config,
+// phase_tier_alternate and provider_readiness widen, and provider_auth_pause's auth mode admits 'agent-login'; each
+// table is rebuilt with every row and id carried over) and a run keeps what its agent itself reported it used
+// (run.agent_reported_usage_json, never priced; saved runs read none).
+// v126 adds, and changes no saved row: signed webhooks into tasks (docs/plans/webhook-tasks.md): a receipt's typed state,
+// when its card was made and the item it holds while it waits for room (flow_trigger_event.state, accepted_at,
+// item_json); which saved secret a trigger's deliveries are proved with and its turned-away deliveries (flow_trigger.hook_credential,
+// dropped_count, dropped_since, limit_noted_at); who made a card (flow_card.created_kind); and the outside source a
+// task was filed from (task_source). Saved receipts read their state from their card, saved cards read a person.
+// v127 adds, and changes no saved row: the running console's instance record (console_instance, one row: its secret,
+// pid, port and build) that bare `toolroll` proves a console with before attaching (docs/plans/agents-cockpit.md B1).
+// v128 adds, and changes no saved row's existing columns: the personal lead queue (lead_queue; docs/plans/
+// lead-message-queue.md) and whether a lead message is still waiting for its turn (lead_message.pending, indexed with
+// its thread so the model's history reads only admitted messages). A saved message reads waiting exactly when it is an
+// operator message of a team queue row never bound to a turn (V128_ADDED_COLUMNS).
+// v129 adds, and changes no saved row: how a run went (docs/plans/run-efficiency.md) — the agent's turn count where its
+// provider reports it (run.agent_turns), a lead request's cache read and write tokens (chat_turn.cache_read_tokens,
+// cache_write_tokens), each NULL (unknown) on saved rows, and the derived, display-only run_efficiency row a result's
+// How it ran reads (a cache of the run's own records, written on first view, never a verdict).
+// v130 adds, and changes no saved row: what a project's builds may reach on the network (project_network; egress.ts,
+// docs/plans/agent-baseline-hardening.md arc 1) and whether this installation lets an agent run with no OS confinement
+// (confinement_setting, one row; off unless an instance operator turns it on).
+export 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 const V118_MERGED_TABLES = Object.freeze({ api_token: "person", coordinator_credential: "coordinator", lead_credential: "lead" });
 /** The foreign keys that named a merged table, exactly as their DDL wrote them; each names `credential(id)` instead. */
@@ -773,9 +843,12 @@ const V115_DROPPED_REFERENCES = /\s+REFERENCES (?:contestant|contest|tournament_
  * 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. v123 only adds new tables (unattended flows, tool secrets) and the columns in V123_ADDED_COLUMNS ('mode',
- * 0 or null), checked the same way.
+ * 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 const UPDATE_SAFE_MIGRATIONS = Object.freeze([108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123]);
+export const UPDATE_SAFE_MIGRATIONS = Object.freeze([108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130]);
 /** v119: the columns it adds, by table, with the value every row saved before it reads (toolroll-update's HISTORY_RULES). */
 export const V119_ADDED_COLUMNS = Object.freeze({
     task_ref: { planning_generation: { definition: "INTEGER NOT NULL DEFAULT 0", saved: "0" } },
@@ -836,6 +909,131 @@ export const V123_ADDED_COLUMNS = Object.freeze({
         ran_script: { definition: "TEXT", saved: "NULL" },
     },
 });
+/** 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 const V125_ADDED_COLUMNS = Object.freeze({
+    run: {
+        agent_reported_usage_json: { definition: "TEXT", saved: "NULL" },
+        // An ACP run's billing, stamped when it is admitted (AcpBillingStamp); every other run, and every saved one, none.
+        acp_billing_json: { definition: "TEXT", saved: "NULL" },
+    },
+});
+/** 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 const V126_ADDED_COLUMNS = Object.freeze({
+    flow_trigger_event: {
+        state: { definition: "TEXT CHECK (state IN ('accepted','skipped','held','ignored'))", saved: "NULL" },
+        accepted_at: { definition: "TEXT", saved: "NULL" },
+        item_json: { definition: "TEXT", saved: "NULL" },
+    },
+    flow_trigger: {
+        // Which saved secret proves its deliveries: 'legacy' (the address every secret saved before v126 has), '' (none:
+        // deliveries are refused until one is saved), or the id of one written whole before the trigger pointed at it.
+        hook_credential: { definition: "TEXT NOT NULL DEFAULT 'legacy'", saved: "'legacy'" },
+        dropped_count: { definition: "INTEGER NOT NULL DEFAULT 0", saved: "0" },
+        dropped_since: { definition: "TEXT", saved: "NULL" },
+        limit_noted_at: { definition: "TEXT", saved: "NULL" },
+    },
+    flow_card: {
+        created_kind: { definition: "TEXT CHECK (created_kind IN ('person','automation'))", saved: "NULL" },
+    },
+});
+/** 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 const V128_ADDED_COLUMNS = Object.freeze({
+    lead_message: {
+        pending: {
+            definition: "INTEGER NOT NULL DEFAULT 0 CHECK (pending IN (0, 1))",
+            saved: "(CASE WHEN role = 'operator' AND turn IS NULL AND EXISTS (SELECT 1 FROM team_message q WHERE q.message = lead_message.id) THEN 1 ELSE 0 END)",
+        },
+    },
+});
+/** v129: how a run went (docs/plans/run-efficiency.md). Recorded from now on; a saved row reads unknown (NULL), never 0. */
+export const V129_ADDED_COLUMNS = Object.freeze({
+    run: { agent_turns: { definition: "INTEGER CHECK (agent_turns IS NULL OR agent_turns >= 0)", saved: "NULL" } },
+    chat_turn: {
+        cache_read_tokens: { definition: "INTEGER CHECK (cache_read_tokens IS NULL OR cache_read_tokens >= 0)", saved: "NULL" },
+        cache_write_tokens: { definition: "INTEGER CHECK (cache_write_tokens IS NULL OR cache_write_tokens >= 0)", saved: "NULL" },
+    },
+});
+/** 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 const CONFINEMENT_SCHEMA = `
+CREATE TABLE IF NOT EXISTS project_network (
+  repo          TEXT PRIMARY KEY,
+  network_json  TEXT NOT NULL CHECK (length(network_json) <= 16384),
+  updated_at    TEXT NOT NULL,
+  updated_by    TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS confinement_setting (
+  id               INTEGER PRIMARY KEY CHECK (id = 1),
+  unfenced_allowed INTEGER NOT NULL DEFAULT 0 CHECK (unfenced_allowed IN (0, 1)),
+  updated_at       TEXT,
+  updated_by       TEXT
+);
+INSERT OR IGNORE INTO confinement_setting (id, unfenced_allowed) VALUES (1, 0);
+`;
+/** 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 const RUN_EFFICIENCY_SCHEMA = `
+CREATE TABLE IF NOT EXISTS run_efficiency (
+  run             INTEGER PRIMARY KEY REFERENCES run(id) ON DELETE CASCADE,
+  parser_version  INTEGER NOT NULL,
+  steps           TEXT NOT NULL CHECK (steps IN ('complete','truncated','expired','absent')),
+  steps_reason    TEXT,
+  payload_json    TEXT NOT NULL CHECK (length(payload_json) <= 16384),
+  derived_at      TEXT NOT NULL
+);
+`;
+/** 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 const LEAD_QUEUE_SCHEMA = `
+CREATE TABLE IF NOT EXISTS lead_queue (
+  message             INTEGER PRIMARY KEY REFERENCES lead_message(id) ON DELETE CASCADE,
+  thread              INTEGER NOT NULL REFERENCES lead_thread(id) ON DELETE CASCADE,
+  approver            TEXT NOT NULL,
+  approver_generation INTEGER NOT NULL,
+  session             INTEGER NOT NULL,
+  ceiling_digest      TEXT NOT NULL,
+  request_id          TEXT NOT NULL,
+  payload_hash        TEXT NOT NULL,
+  context_json        TEXT,
+  status              TEXT NOT NULL CHECK (status IN ('queued','running','answered','failed','cancelled','uncertain')),
+  revision            INTEGER NOT NULL DEFAULT 1,
+  generation          INTEGER NOT NULL DEFAULT 0,
+  runner              TEXT,
+  claimed_at          TEXT,
+  turn_id             INTEGER REFERENCES mate_turn(id),
+  error               TEXT,
+  created_at          TEXT NOT NULL,
+  settled_at          TEXT,
+  UNIQUE (session, request_id)
+);
+CREATE INDEX IF NOT EXISTS lead_queue_backlog ON lead_queue (approver, status, message);
+CREATE UNIQUE INDEX IF NOT EXISTS lead_queue_one_running ON lead_queue (approver) WHERE status = 'running';
+CREATE INDEX IF NOT EXISTS lead_queue_admitted ON lead_queue (turn_id) WHERE turn_id IS NOT NULL;
+`;
+/** 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 const TASK_SOURCE_SCHEMA = `
+CREATE TABLE IF NOT EXISTS task_source (
+  task_id     TEXT PRIMARY KEY,
+  flow        INTEGER NOT NULL,
+  card        INTEGER NOT NULL,
+  card_entry  INTEGER NOT NULL,
+  source_json TEXT NOT NULL,
+  at          TEXT NOT NULL
+);
+CREATE TRIGGER IF NOT EXISTS task_source_immutable BEFORE UPDATE ON task_source
+BEGIN
+  SELECT RAISE(ABORT, 'a task source is immutable');
+END;
+CREATE INDEX IF NOT EXISTS flow_trigger_event_accepted ON flow_trigger_event (trigger, accepted_at);
+`;
 /** Whether a database settled at `version` reaches this build's schema through update-safe migrations alone. */
 export function updateSafeSchema(version) {
     if (version === null || !Number.isSafeInteger(version) || version <= 0 || version > SCHEMA_VERSION)
@@ -970,6 +1168,19 @@ export const BUILT_IN = "built-in";
 /** States from which no further work is dispatched. */
 export const TERMINAL_STATES = ["done", "failed", "cancelled"];
 export const LEAD_THREAD = { kind: "lead" };
+/** A lead_message row as a LeadMessage. */
+function readLeadMessageRow(row) {
+    return {
+        id: Number(row["id"]),
+        thread: Number(row["thread"]),
+        turn: row["turn"] === null ? null : Number(row["turn"]),
+        role: String(row["role"]),
+        text: String(row["text"]),
+        activity: row["activity"] === null ? null : String(row["activity"]),
+        createdAt: String(row["created_at"]),
+        ...(Number(row["pending"] ?? 0) === 1 ? { pending: true } : {}),
+    };
+}
 function readSubagentMemory(row) {
     return { id: Number(row["id"]), subagent: Number(row["subagent"]), text: String(row["text"]), source: String(row["source"]), card: row["card"] === null ? null : Number(row["card"]),
         createdBy: String(row["created_by"]), createdAt: String(row["created_at"]), updatedBy: String(row["updated_by"]), updatedAt: String(row["updated_at"]), usedAt: row["used_at"] === null ? null : String(row["used_at"]) };
@@ -1032,7 +1243,9 @@ function readFlowCardRow(row) {
     const optional = (key) => row[key] === null || row[key] === undefined ? null : String(row[key]);
     return { id: Number(row["id"]), flow: Number(row["flow"]), title: String(row["title"]), description: optional("description"), stage: String(row["stage"]), entry: Number(row["entry"]),
         state: String(row["state"]), task: optional("task"), primaryTask: optional("primary_task"), note: optional("note"), waiting: optional("waiting"), outputs, attached,
-        createdBy: String(row["created_by"]), createdAt: String(row["created_at"]), updatedAt: String(row["updated_at"]), source: readFlowCardSource(row["source_json"]), owner: optional("owner") };
+        createdBy: String(row["created_by"]), createdAt: String(row["created_at"]), updatedAt: String(row["updated_at"]), source: readFlowCardSource(row["source_json"]), owner: optional("owner"),
+        // v126: a card saved before it was a person's (what filing always assumed).
+        createdKind: row["created_kind"] === "automation" ? "automation" : "person" };
 }
 function readFlowCardSource(value) {
     if (typeof value !== "string")
@@ -1044,12 +1257,17 @@ function readFlowCardSource(value) {
         const parsed = read.value;
         const mail = parsed["mail"] !== null && typeof parsed["mail"] === "object" ? parsed["mail"] : null;
         const chat = parsed["chat"] !== null && typeof parsed["chat"] === "object" ? parsed["chat"] : null;
+        const external = parsed["external"] !== null && typeof parsed["external"] === "object" ? parsed["external"] : null;
         return { kind: String(parsed["kind"] ?? ""), label: parsed["label"], url: typeof parsed["url"] === "string" ? parsed["url"] : null,
             ...(mail === null || typeof mail["from"] !== "string" ? {} : { mail: { id: typeof mail["id"] === "string" ? mail["id"] : null, references: Array.isArray(mail["references"]) ? mail["references"].filter((one) => typeof one === "string") : [],
                     subject: typeof mail["subject"] === "string" ? mail["subject"] : "", from: mail["from"] } }),
             ...(chat === null || typeof chat["app"] !== "string" || typeof chat["chat"] !== "string" || typeof chat["thread"] !== "string" || typeof chat["binding"] !== "number" ? {} : { chat: {
                     app: chat["app"], installation: String(chat["installation"] ?? ""), chat: chat["chat"], conversation: typeof chat["conversation"] === "string" ? chat["conversation"] : chat["chat"], thread: chat["thread"], binding: chat["binding"]
-                } }) };
+                } }),
+            // v126: kept as they were written at receipt; a card saved before them has none.
+            ...(typeof parsed["verified"] === "string" ? { verified: parsed["verified"] } : {}),
+            ...(external === null ? {} : { external: { id: typeof external["id"] === "string" ? external["id"] : null, url: typeof external["url"] === "string" ? external["url"] : null } }),
+            ...(typeof parsed["receipt"] === "string" ? { receipt: parsed["receipt"] } : {}) };
     }
     catch {
         return null;
@@ -1059,7 +1277,14 @@ function readFlowTriggerRow(row) {
     const optional = (key) => row[key] === null || row[key] === undefined ? null : String(row[key]);
     return { id: Number(row["id"]), flow: Number(row["flow"]), kind: String(row["kind"]), configJson: String(row["config_json"]), state: String(row["state"]),
         hookHash: optional("hook_hash"), cursor: optional("cursor"), nextAt: optional("next_at"), lastAt: optional("last_at"), lastOutcome: optional("last_outcome"),
-        failures: Number(row["failures"] ?? 0), createdBy: String(row["created_by"]), createdAt: String(row["created_at"]), updatedAt: String(row["updated_at"]) };
+        failures: Number(row["failures"] ?? 0), createdBy: String(row["created_by"]), createdAt: String(row["created_at"]), updatedAt: String(row["updated_at"]),
+        hookCredential: row["hook_credential"] === null || row["hook_credential"] === undefined ? "legacy" : String(row["hook_credential"]), droppedCount: Number(row["dropped_count"] ?? 0), droppedSince: optional("dropped_since") };
+}
+function readFlowReceipt(row) {
+    const card = row["card"] === null || row["card"] === undefined ? null : Number(row["card"]);
+    const state = row["state"] === null || row["state"] === undefined ? (card === null ? "skipped" : "accepted") : String(row["state"]);
+    const optional = (key) => row[key] === null || row[key] === undefined ? null : String(row[key]);
+    return { state, card, note: optional("note"), at: String(row["at"]), acceptedAt: optional("accepted_at"), itemJson: optional("item_json") };
 }
 /** `kind:name`, the unambiguous way a requirement names a capability. */
 export function capabilityKey(capability) {
@@ -1313,7 +1538,7 @@ CREATE TABLE IF NOT EXISTS mcp_idempotency (
 CREATE TABLE IF NOT EXISTS phase_config (
   scope      TEXT NOT NULL,
   phase      TEXT NOT NULL CHECK (phase IN ('plan','build','repair','review')),
-  provider   TEXT NOT NULL CHECK (provider IN ('claude','codex','openrouter','gemini')),
+  provider   TEXT NOT NULL CHECK (provider IN ('claude','codex','openrouter','gemini','opencode','cursor','cline','qwen','goose')),
   model      TEXT,
   updated_at TEXT NOT NULL,
   updated_by TEXT NOT NULL,
@@ -1329,7 +1554,7 @@ CREATE TABLE IF NOT EXISTS phase_tier_config (
   scope      TEXT NOT NULL,
   phase      TEXT NOT NULL CHECK (phase IN ('plan','build','repair','review')),
   tier       TEXT NOT NULL CHECK (tier IN ('light','strong')),
-  provider   TEXT NOT NULL CHECK (provider IN ('claude','codex','openrouter','gemini')),
+  provider   TEXT NOT NULL CHECK (provider IN ('claude','codex','openrouter','gemini','opencode','cursor','cline','qwen','goose')),
   model      TEXT,
   updated_at TEXT NOT NULL,
   updated_by TEXT NOT NULL,
@@ -1345,7 +1570,7 @@ CREATE TABLE IF NOT EXISTS phase_tier_config (
 -- substitutes for it.
 CREATE TABLE IF NOT EXISTS provider_readiness (
   runner      TEXT NOT NULL REFERENCES runner(name) ON DELETE CASCADE,
-  provider    TEXT NOT NULL CHECK (provider IN ('claude','codex','openrouter','gemini')),
+  provider    TEXT NOT NULL CHECK (provider IN ('claude','codex','openrouter','gemini','opencode','cursor','cline','qwen','goose')),
   state       TEXT NOT NULL CHECK (state IN ('ready','unavailable','unknown')),
   reason      TEXT NOT NULL,
   probe       TEXT NOT NULL,
@@ -2635,7 +2860,7 @@ CREATE TABLE IF NOT EXISTS quota (
   -- key. auth_mode + a stable NON-SECRET
   -- credential fingerprint join the key. Defaults keep every pre-v30 row
   -- identical (mode 'subscription', empty fp) since that is what they were.
-  auth_mode   TEXT NOT NULL DEFAULT 'subscription' CHECK (auth_mode IN ('subscription','api-key')),
+  auth_mode   TEXT NOT NULL DEFAULT 'subscription' CHECK (auth_mode IN ('subscription','api-key','agent-login')),
   credential_fp TEXT NOT NULL DEFAULT '',
   state       TEXT NOT NULL CHECK (state IN ('exhausted','half-open')),
   reason      TEXT NOT NULL,
@@ -3566,6 +3791,9 @@ function initializeStore(db, file) {
     db.exec(CHAT_DECIDE_SCHEMA);
     // An owner's lasting chat-approval setting (no version bump: additive only; absent means off).
     db.exec(CHAT_APPROVAL_SCHEMA);
+    // v124: the live conversation: a project's "Show commands in the live view" (absent means off) and every run a
+    // steering note reached (older notes simply have no rows). New tables only.
+    db.exec(LIVE_DETAIL_SCHEMA);
     // What a running agent did last (no version bump: additive only; absent means no word yet).
     db.exec(RUN_ACTIVITY_SCHEMA);
     // v122: a task branch moved to current main before an attempt (fresh base): a new table, nothing carried over.
@@ -3593,6 +3821,18 @@ function initializeStore(db, file) {
     addColumn(db, "task_ref", "route_tier", "TEXT");
     widenPhaseTierSchema(db);
     db.exec(PHASE_TIER_ALTERNATE_SCHEMA);
+    // v125: ACP agents as providers, their own sign-in as an auth mode (rows carry over, CHECKs widen; the auth schema
+    // runs again to put back the open-pause index the rebuild dropped), and what an agent itself reported it used
+    // (V125_ADDED_COLUMNS: never priced, saved runs read none).
+    widenForAcp(db);
+    db.exec(PROVIDER_AUTH_SCHEMA);
+    db.exec(ACP_ATTESTATION_SCHEMA);
+    db.exec(ACP_BILLING_SCHEMA);
+    db.exec(ACP_CHECK_SCHEMA);
+    for (const [table, columns] of Object.entries(V125_ADDED_COLUMNS)) {
+        for (const [column, { definition }] of Object.entries(columns))
+            addColumn(db, table, column, definition);
+    }
     db.exec(REVIEW_SCHEMA);
     db.exec(RETENTION_SCHEMA);
     // 1-day evidence: an older file's retention_setting only allowed 7 days or more (no version bump: its rows carry over).
@@ -3623,6 +3863,7 @@ function initializeStore(db, file) {
     // What a person's lead knows about them, beside its name and persona (an older lead_config gains it).
     addColumn(db, "lead_config", "about_json", "TEXT NOT NULL DEFAULT '[]'");
     db.exec(LEAD_COMMITMENT_SCHEMA);
+    db.exec(LEAD_SWEEP_SCHEMA);
     mergeCheckTables(db);
     // v110: the action ledger admits remote commands ('api', 'mcp').
     rebuildLedger(db);
@@ -3646,7 +3887,34 @@ function initializeStore(db, file) {
     addColumn(db, "workflow_preview", "flow_id", "INTEGER");
     // v115: the task each standing-order firing filed, kept on the firing itself (a card's task changes as it moves).
     addColumn(db, "flow_trigger_event", "task", "TEXT");
+    // v126: signed webhooks into tasks (V126_ADDED_COLUMNS: saved rows read null or 0) and each task's outside source.
+    for (const [table, columns] of Object.entries(V126_ADDED_COLUMNS)) {
+        for (const [column, { definition }] of Object.entries(columns))
+            addColumn(db, table, column, definition);
+    }
+    db.exec(TASK_SOURCE_SCHEMA);
     db.exec(PLAN_AUTO_SCHEMA);
+    // v127 (cockpit B1): the running console's instance record (one row; a new table, additive only).
+    db.exec(CONSOLE_INSTANCE_SCHEMA);
+    // v128: the personal lead queue (a new table) and lead_message.pending, set once from each saved row's provenance
+    // (exactly V128_ADDED_COLUMNS' `saved` expression), then the history index the model's reads use.
+    if (!hasColumn(db, "lead_message", "pending")) {
+        addColumn(db, "lead_message", "pending", V128_ADDED_COLUMNS.lead_message.pending.definition);
+        db.exec(`UPDATE lead_message SET pending = ${V128_ADDED_COLUMNS.lead_message.pending.saved}`);
+    }
+    db.exec("CREATE INDEX IF NOT EXISTS lead_message_history ON lead_message (thread, pending, id)");
+    db.exec(LEAD_QUEUE_SCHEMA);
+    // v128: the memory search indexes a waiting message when a turn takes it, found by the turn that took it.
+    db.exec("CREATE INDEX IF NOT EXISTS team_message_admitted ON team_message (turn_id) WHERE turn_id IS NOT NULL");
+    // v129: how a run went — its turn count and a lead request's cache tokens (V129_ADDED_COLUMNS: saved rows read NULL),
+    // and the derived How it ran row (a new table).
+    for (const [table, columns] of Object.entries(V129_ADDED_COLUMNS)) {
+        for (const [column, { definition }] of Object.entries(columns))
+            addColumn(db, table, column, definition);
+    }
+    db.exec(RUN_EFFICIENCY_SCHEMA);
+    // v130: a project's network and whether an agent may run unconfined (new tables only).
+    db.exec(CONFINEMENT_SCHEMA);
     // v123: a flow that runs on its own (flow-unattended.ts): its grants and daily runs (new tables), and which authority
     // armed a plan's unchanged-plan approval (plan_authorization.basis, V123_ADDED_COLUMNS: saved rows read the mode).
     db.exec(FLOW_UNATTENDED_SCHEMA);
@@ -4143,7 +4411,11 @@ function rebuildExact(db, table, oldDdl, targetDdl, columns) {
                 ? db.prepare("SELECT name, seq FROM sqlite_sequence ORDER BY rowid").all()
                 : [];
             db.exec(targetDdl(`${table}_next`));
-            const names = columns.join(", ");
+            // A table keyed by anything but an INTEGER PRIMARY KEY still has a hidden rowid, and a plain copy renumbers it;
+            // the update's history check reads it (count and highest rowid), so it is carried whole like any id.
+            const key = db.prepare(`PRAGMA table_info(${table})`).all().filter(one => Number(one["pk"]) > 0);
+            const aliased = key.length === 1 && String(key[0]["type"]).toUpperCase() === "INTEGER";
+            const names = (aliased || /WITHOUT\s+ROWID/i.test(stored) ? columns : ["rowid", ...columns]).join(", ");
             db.exec(`INSERT INTO ${table}_next (${names}) SELECT ${names} FROM ${table}`);
             db.exec(`DROP TABLE ${table}`);
             db.exec(`ALTER TABLE ${table}_next RENAME TO ${table}`);
@@ -4743,13 +5015,119 @@ CREATE TABLE IF NOT EXISTS phase_tier_alternate (
   scope      TEXT NOT NULL,
   phase      TEXT NOT NULL CHECK (phase IN ('plan','build')),
   tier       TEXT NOT NULL CHECK (tier IN ('light','routine','strong')),
-  provider   TEXT NOT NULL CHECK (provider IN ('claude','codex','openrouter','gemini')),
+  provider   TEXT NOT NULL CHECK (provider IN ('claude','codex','openrouter','gemini','opencode','cursor','cline','qwen','goose')),
   model      TEXT NOT NULL,
   updated_at TEXT NOT NULL,
   updated_by TEXT NOT NULL,
   PRIMARY KEY (scope, phase, tier, provider)
 );
 `;
+/**
+ * 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 const ACP_ATTESTATION_SCHEMA = `
+CREATE TABLE IF NOT EXISTS acp_attestation (
+  id                  INTEGER PRIMARY KEY AUTOINCREMENT,
+  provider            TEXT NOT NULL CHECK (provider IN ('opencode','cursor','cline','qwen','goose')),
+  runner              TEXT NOT NULL,
+  conformance_version INTEGER NOT NULL,
+  launch_json         TEXT NOT NULL,
+  agent_name          TEXT NOT NULL,
+  agent_version       TEXT NOT NULL,
+  cli_version         TEXT NOT NULL,
+  models_json         TEXT NOT NULL,
+  checks_json         TEXT NOT NULL,
+  recorded_at         TEXT NOT NULL,
+  recorded_by         TEXT NOT NULL,
+  revoked_at          TEXT,
+  revoked_by          TEXT
+);
+CREATE UNIQUE INDEX IF NOT EXISTS acp_attestation_live ON acp_attestation (provider, runner) WHERE revoked_at IS NULL;
+`;
+/**
+ * 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 const ACP_CHECK_SCHEMA = `
+CREATE TABLE IF NOT EXISTS acp_check_request (
+  id                  INTEGER PRIMARY KEY AUTOINCREMENT,
+  provider            TEXT NOT NULL CHECK (provider IN ('opencode','cursor','cline','qwen','goose')),
+  runner              TEXT NOT NULL,
+  model               TEXT NOT NULL,
+  conformance_version INTEGER NOT NULL,
+  requested_by        TEXT NOT NULL,
+  requested_at        TEXT NOT NULL,
+  expires_at          TEXT NOT NULL,
+  state               TEXT NOT NULL DEFAULT 'pending' CHECK (state IN ('pending','running','passed','failed','expired')),
+  watch_repo          TEXT,
+  watch_owner         TEXT,
+  task_ref            INTEGER REFERENCES task_ref(id),
+  launch_json         TEXT,
+  lease_id            TEXT,
+  steps_used          INTEGER NOT NULL DEFAULT 0 CHECK (steps_used BETWEEN 0 AND 2),
+  step1_run           INTEGER REFERENCES run(id),
+  step2_run           INTEGER REFERENCES run(id),
+  step1_passed        INTEGER NOT NULL DEFAULT 0 CHECK (step1_passed IN (0,1)),
+  step2_passed        INTEGER NOT NULL DEFAULT 0 CHECK (step2_passed IN (0,1)),
+  result              TEXT,
+  finished_at         TEXT,
+  settled_at          TEXT,
+  settle_by           TEXT,
+  settle_until        TEXT
+);
+CREATE UNIQUE INDEX IF NOT EXISTS acp_check_running ON acp_check_request (runner) WHERE state = 'running';
+`;
+export const ACP_BILLING_SCHEMA = `
+CREATE TABLE IF NOT EXISTS acp_billing (
+  id        INTEGER PRIMARY KEY AUTOINCREMENT,
+  provider  TEXT NOT NULL CHECK (provider IN ('opencode','cursor','cline','qwen','goose')),
+  runner    TEXT NOT NULL,
+  model     TEXT NOT NULL,
+  kind      TEXT NOT NULL CHECK (kind IN ('metered','plan')),
+  set_at    TEXT NOT NULL,
+  set_by    TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS acp_billing_by ON acp_billing (provider, runner, model, id);
+`;
+/** The provider CHECK before ACP agents joined (acp-agents.ts), and after: the same list, five ids longer. */
+const PROVIDERS_BEFORE_ACP = "CHECK (provider IN ('claude','codex','openrouter','gemini'))";
+const PROVIDERS_WITH_ACP = "CHECK (provider IN ('claude','codex','openrouter','gemini','opencode','cursor','cline','qwen','goose'))";
+/** The sign-in pause's auth mode before an ACP agent's own sign-in ('agent-login'), and after. */
+const AUTH_MODES_BEFORE_ACP = "CHECK (auth_mode IN ('subscription', 'api-key'))";
+const AUTH_MODES_WITH_ACP = "CHECK (auth_mode IN ('subscription', 'api-key', 'agent-login'))";
+/**
+ * v125: ACP agents as providers (docs/plans/acp-adapter.md): every row carries over whole, the CHECKs only widen. Each table whose stored DDL still has the old list is rebuilt with the wider one, through rebuildExact — the
+ * stored DDL must be exactly a known shape with the old clause appearing once, or the open refuses. Indexes the rebuild
+ * drops are put back by their own schema's IF NOT EXISTS, which the caller runs again after.
+ */
+function widenForAcp(db) {
+    const widen = (table, before, after) => {
+        const row = db.prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?").get(table);
+        if (row === undefined)
+            return;
+        const stored = String(row["sql"]);
+        if (stored.includes(after))
+            return;
+        if (stored.split(before).length !== 2)
+            throw new Error(`the ${table} table's DDL is not a shape this migration knows — refusing to widen it`);
+        const named = (sql) => (name) => sql.replace(new RegExp(`^CREATE TABLE (?:IF NOT EXISTS )?"?${table}"?`), `CREATE TABLE ${name}`);
+        const columns = db.prepare(`PRAGMA table_info(${table})`).all().map(one => String(one["name"]));
+        rebuildExact(db, table, named(stored), named(stored.replace(before, after)), columns);
+    };
+    for (const table of ["phase_config", "phase_tier_config", "phase_tier_alternate", "provider_readiness"])
+        widen(table, PROVIDERS_BEFORE_ACP, PROVIDERS_WITH_ACP);
+    widen("provider_auth_pause", AUTH_MODES_BEFORE_ACP, AUTH_MODES_WITH_ACP);
+    widen("quota", "CHECK (auth_mode IN ('subscription','api-key'))", "CHECK (auth_mode IN ('subscription','api-key','agent-login'))");
+}
 /** A file from before the light tier keeps `tier IN ('strong')` in phase_tier_config's CHECK: rebuild the table with
  * the wider one, keeping every row, in one transaction. A file already widened is untouched. */
 function widenPhaseTierSchema(db) {
@@ -4762,13 +5140,13 @@ function widenPhaseTierSchema(db) {
   scope      TEXT NOT NULL,
   phase      TEXT NOT NULL CHECK (phase IN ('plan','build','repair','review')),
   tier       TEXT NOT NULL CHECK (tier IN ('light','strong')),
-  provider   TEXT NOT NULL CHECK (provider IN ('claude','codex','openrouter','gemini')),
+  provider   TEXT NOT NULL CHECK (provider IN ('claude','codex','openrouter','gemini','opencode','cursor','cline','qwen','goose')),
   model      TEXT,
   updated_at TEXT NOT NULL,
   updated_by TEXT NOT NULL,
   PRIMARY KEY (scope, phase, tier)
 )`);
-        db.exec("INSERT INTO phase_tier_config_next SELECT scope, phase, tier, provider, model, updated_at, updated_by FROM phase_tier_config");
+        db.exec("INSERT INTO phase_tier_config_next (rowid, scope, phase, tier, provider, model, updated_at, updated_by) SELECT rowid, scope, phase, tier, provider, model, updated_at, updated_by FROM phase_tier_config");
         db.exec("DROP TABLE phase_tier_config");
         db.exec("ALTER TABLE phase_tier_config_next RENAME TO phase_tier_config");
         db.exec("COMMIT");
@@ -6228,7 +6606,8 @@ export class Store {
                         ? { ...profile, permissionArgv: "bypassPermissions" }
                         : profile.provider === "gemini"
                             ? { ...profile, approvalArgv: "yolo" }
-                            : { ...profile, sandboxMode: "danger-full-access" };
+                            : isAcpProfile(profile) ? profile
+                                : { ...profile, sandboxMode: "danger-full-access" };
             }
             // Anything still above the ceiling files at the highest level beneath it its provider has; a provider with none
             // keeps its terms, and approval refuses them in words.
@@ -9167,9 +9546,23 @@ export class Store {
     }
     /** Stamp a task as the revision it is: source task + immutable brief. */
     markRevision(taskRef, revisionOf, briefArtifact) {
-        this.db
-            .prepare("UPDATE task_ref SET revision_of = ?, revision_brief_artifact = ? WHERE id = ?")
-            .run(revisionOf, briefArtifact, taskRef);
+        this.transact(() => {
+            this.db
+                .prepare("UPDATE task_ref SET revision_of = ?, revision_brief_artifact = ? WHERE id = ?")
+                .run(revisionOf, briefArtifact, taskRef);
+            // v126: a revision keeps where the work came from, copied whole from the task it revises.
+            this.db.prepare(`INSERT OR IGNORE INTO task_source (task_id, flow, card, card_entry, source_json, at)
+        SELECT r.external_id, s.flow, s.card, s.card_entry, s.source_json, s.at FROM task_ref r JOIN task_source s ON s.task_id = ? WHERE r.id = ?`).run(revisionOf, taskRef);
+        });
+    }
+    /** v126: where a task came from, written once in its filing's transaction (task-source.ts), never changed. */
+    recordTaskSource(taskId, from, sourceJson, now) {
+        this.db.prepare("INSERT OR IGNORE INTO task_source (task_id, flow, card, card_entry, source_json, at) VALUES (?, ?, ?, ?, ?, ?)").run(taskId, from.flow, from.card, from.entry, sourceJson, now.toISOString());
+    }
+    /** v126: where a task came from, as kept when it (or the task it revises) was filed; null for every other task. */
+    taskSourceOf(taskId) {
+        const row = this.db.prepare("SELECT flow, card, card_entry, source_json FROM task_source WHERE task_id = ?").get(taskId);
+        return row === undefined ? null : { flow: Number(row["flow"]), card: Number(row["card"]), entry: Number(row["card_entry"]), sourceJson: String(row["source_json"]) };
     }
     // ---- the revision boundary: ONE field-by-field policy -------------------
     /**
@@ -9939,7 +10332,10 @@ export class Store {
             return "published";
         return null;
     }
-    requeueTask(taskId, by, now) {
+    requeueTask(taskId, by, now, 
+    /** 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) {
         return this.transact(() => {
             const ref = this.db
                 .prepare("SELECT id FROM task_ref WHERE backend = ? AND external_id = ?")
@@ -9985,6 +10381,12 @@ export class Store {
             else if (incidents.length === 0 && state !== "failed") {
                 return { ok: false, reason: "not-stalled" };
             }
+            if (expect !== undefined) {
+                const scope = this.db.prepare("SELECT digest, approved_digest FROM task_scope WHERE task_id = ?").get(taskId);
+                if (state !== "done" || rejectedRun !== expect.run || scope === undefined || String(scope["digest"]) !== expect.scopeDigest ||
+                    scope["approved_digest"] !== scope["digest"])
+                    return { ok: false, reason: "moved" };
+            }
             for (const incident of incidents)
                 this.resolveIncidentLocked(incident, by, now);
             this.resetStrikes(taskRef);
@@ -11265,9 +11667,9 @@ export class Store {
         this.spendCache = null; // its spend counts toward the next budget check
         const changed = this.db
             .prepare(`UPDATE chat_turn SET state = ?, failure_reason = ?, tokens_in = ?, tokens_out = ?,
-           settled_microusd = ?, unknown_spend = ?, reply_bytes = ?, candidate_count = ?, finished_at = ?
+           settled_microusd = ?, unknown_spend = ?, reply_bytes = ?, candidate_count = ?, cache_read_tokens = ?, cache_write_tokens = ?, finished_at = ?
          WHERE id = ? AND generation = ? AND state IN ('queued','running')`)
-            .run(outcome.state, outcome.failureReason ?? null, outcome.tokensIn ?? null, outcome.tokensOut ?? null, outcome.settledMicrousd, outcome.unknownSpend === true ? 1 : 0, outcome.replyBytes ?? null, outcome.candidateCount ?? null, now.toISOString(), id, generation);
+            .run(outcome.state, outcome.failureReason ?? null, outcome.tokensIn ?? null, outcome.tokensOut ?? null, outcome.settledMicrousd, outcome.unknownSpend === true ? 1 : 0, outcome.replyBytes ?? null, outcome.candidateCount ?? null, outcome.cacheReadTokens ?? null, outcome.cacheWriteTokens ?? null, now.toISOString(), id, generation);
         return Number(changed.changes) === 1;
     }
     /**
@@ -11990,6 +12392,11 @@ export class Store {
         // duplicate before any request is consumed.
         reviewAttempt);
         const id = Number(inserted.lastInsertRowid);
+        // An ACP run's billing is the declaration standing for its runner and model NOW, stamped with the row it bills:
+        // settlement reads this stamp, never the live declaration (docs/plans/acp-adapter.md § Billing).
+        if (provider !== undefined && provider !== null && isAcpProvider(provider) && model !== null) {
+            this.db.prepare("UPDATE run SET acp_billing_json = ? WHERE id = ?").run(JSON.stringify(this.acpBillingFor(provider, run.runner, model)), id);
+        }
         // The attempt key (Agents board): opaque, minted with the row, and the only key its stream state is recorded under.
         this.db.prepare("UPDATE run SET attempt_key = ? WHERE id = ?").run(mintAttemptKey(), id);
         // The provenance row lands in the same transaction as the run row —
@@ -12423,6 +12830,216 @@ export class Store {
      * structural signal is gone. `auth-expired` pauses its provider; every
      * other class is observational.
      */
+    /**
+     * 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, now) {
+        return this.transact(() => {
+            this.db.prepare("UPDATE acp_attestation SET revoked_at = ?, revoked_by = ? WHERE provider = ? AND runner = ? AND revoked_at IS NULL")
+                .run(now.toISOString(), `${input.recordedBy} (checked again)`, input.provider, input.runner);
+            const inserted = this.db.prepare(`INSERT INTO acp_attestation (provider, runner, conformance_version, launch_json, agent_name, agent_version, cli_version, models_json, checks_json, recorded_at, recorded_by)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(input.provider, input.runner, input.conformanceVersion ?? ACP_CONFORMANCE_VERSION, JSON.stringify(input.launch), input.agent.name, input.agent.version, input.cliVersion, JSON.stringify(input.models), JSON.stringify(input.checks), now.toISOString(), input.recordedBy);
+            return Number(inserted.lastInsertRowid);
+        });
+    }
+    /** An ACP agent's live attestation on a runner, under this build's conformance version; null when there is none. */
+    acpAttestationFor(provider, runner) {
+        const row = this.db.prepare("SELECT * FROM acp_attestation WHERE provider = ? AND runner = ? AND revoked_at IS NULL").get(provider, runner);
+        if (row === undefined || Number(row["conformance_version"]) !== ACP_CONFORMANCE_VERSION)
+            return null;
+        const launch = launchFromJson(String(row["launch_json"]));
+        const list = (json) => {
+            try {
+                const value = JSON.parse(String(json));
+                return Array.isArray(value) && value.every(one => typeof one === "string") ? value : null;
+            }
+            catch {
+                return null;
+            }
+        };
+        const models = list(row["models_json"]);
+        const checks = list(row["checks_json"]);
+        if (launch === null || models === null || checks === null)
+            return null;
+        return {
+            id: Number(row["id"]), provider: String(row["provider"]), runner: String(row["runner"]), conformanceVersion: Number(row["conformance_version"]),
+            launch, agent: { name: String(row["agent_name"]), version: String(row["agent_version"]) }, cliVersion: String(row["cli_version"]),
+            models, checks, recordedAt: String(row["recorded_at"]), recordedBy: String(row["recorded_by"]),
+        };
+    }
+    /** Declare how an ACP agent's work on one model is billed on a runner; the new revision. */
+    declareAcpBilling(input, now) {
+        return Number(this.db.prepare("INSERT INTO acp_billing (provider, runner, model, kind, set_at, set_by) VALUES (?, ?, ?, ?, ?, ?)")
+            .run(input.provider, input.runner, input.model, input.kind, now.toISOString(), input.by).lastInsertRowid);
+    }
+    /** The billing declaration standing for an ACP agent's model on a runner: metered, revision 0, when none was made. */
+    acpBillingFor(provider, runner, model) {
+        const row = this.db.prepare("SELECT id, kind FROM acp_billing WHERE provider = ? AND runner = ? AND model = ? ORDER BY id DESC LIMIT 1").get(provider, runner, model);
+        return row === undefined ? { kind: "metered", revision: 0, model } : { kind: row["kind"] === "plan" ? "plan" : "metered", revision: Number(row["id"]), model };
+    }
+    /** The billing an ACP run was admitted under, or null (not an ACP run, or unreadable — then it is metered). */
+    acpBillingOfRun(runId) {
+        const raw = this.db.prepare("SELECT acp_billing_json FROM run WHERE id = ?").get(runId)?.["acp_billing_json"];
+        if (typeof raw !== "string")
+            return null;
+        try {
+            const value = JSON.parse(raw);
+            if ((value["kind"] === "metered" || value["kind"] === "plan") && typeof value["revision"] === "number" && typeof value["model"] === "string") {
+                return { kind: value["kind"], revision: value["revision"], model: value["model"] };
+            }
+        }
+        catch { /* unreadable: metered */ }
+        return null;
+    }
+    /** Ask for an ACP agent check on a runner (the caller proved the password); the request's id. Valid 30 minutes. */
+    requestAcpCheck(input, now) {
+        return Number(this.db.prepare(`INSERT INTO acp_check_request (provider, runner, model, conformance_version, requested_by, requested_at, expires_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)`).run(input.provider, input.runner, input.model, ACP_CONFORMANCE_VERSION, input.by, now.toISOString(), new Date(now.getTime() + 30 * 60_000).toISOString()).lastInsertRowid);
+    }
+    acpCheck(id) {
+        const row = this.db.prepare("SELECT * FROM acp_check_request WHERE id = ?").get(id);
+        return row === undefined ? null : readAcpCheck(row);
+    }
+    /** The checks asked for an agent, newest first (for the providers screen). */
+    acpChecksFor(provider, limit = 10) {
+        return this.db.prepare("SELECT * FROM acp_check_request WHERE provider = ? ORDER BY id DESC LIMIT ?").all(provider, limit).map(readAcpCheck);
+    }
+    /** The SQL that proves a watch still holds its lease (runner, repo, owner) at `?` — appended with its bindings. */
+    static WATCH_LIVE = "EXISTS (SELECT 1 FROM watch_lease w WHERE w.runner = acp_check_request.runner AND w.repo = acp_check_request.watch_repo AND w.owner = acp_check_request.watch_owner AND w.expires_at > ?)";
+    /**
+     * 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, watch, now) {
+        const at = now.toISOString();
+        try {
+            const claimed = this.db.prepare(`UPDATE acp_check_request SET state = 'running', watch_repo = ?, watch_owner = ?
+        WHERE id = (SELECT id FROM acp_check_request WHERE runner = ? AND state = 'pending' AND expires_at > ? ORDER BY id LIMIT 1)
+          AND EXISTS (SELECT 1 FROM watch_lease w WHERE w.runner = ? AND w.repo = ? AND w.owner = ? AND w.expires_at > ?)
+        RETURNING id`).get(watch.repo, watch.owner, runner, at, runner, watch.repo, watch.owner, at);
+            return claimed === undefined ? null : this.acpCheck(Number(claimed["id"]));
+        }
+        catch (error) {
+            if (/UNIQUE constraint failed/.test(String(error)))
+                return null;
+            throw error;
+        }
+    }
+    /** Bind a running check, still owned and unexpired, to its task and the launch it inspected. */
+    bindAcpCheck(id, binding, now) {
+        const at = now.toISOString();
+        return Number(this.db.prepare(`UPDATE acp_check_request SET task_ref = ?, launch_json = ?, lease_id = ?
+      WHERE id = ? AND state = 'running' AND expires_at > ? AND task_ref IS NULL AND ${Store.WATCH_LIVE}`).run(binding.taskRef, binding.launchJson, binding.leaseId, id, at, at).changes) === 1;
+    }
+    /** Consume step 1 or 2 for its run: in order, once, owned, unexpired. */
+    consumeAcpCheckStep(id, step, runId, now) {
+        const at = now.toISOString();
+        const column = step === 1 ? "step1_run" : "step2_run";
+        return Number(this.db.prepare(`UPDATE acp_check_request SET steps_used = ?, ${column} = ?
+      WHERE id = ? AND state = 'running' AND steps_used = ? AND ${column} IS NULL AND expires_at > ? AND ${Store.WATCH_LIVE}
+        ${step === 2 ? "AND step1_passed = 1" : ""}`).run(step, runId, id, step - 1, at, at).changes) === 1;
+    }
+    /** Record a step as passed, once its grading did: owned, unexpired, and only for the run the step was bound to. */
+    passAcpCheckStep(id, step, runId, now) {
+        const at = now.toISOString();
+        const run = step === 1 ? "step1_run" : "step2_run";
+        const passed = step === 1 ? "step1_passed" : "step2_passed";
+        return Number(this.db.prepare(`UPDATE acp_check_request SET ${passed} = 1
+      WHERE id = ? AND state = 'running' AND ${run} = ? AND ${passed} = 0 AND expires_at > ? AND ${Store.WATCH_LIVE}`).run(id, runId, at, at).changes) === 1;
+    }
+    /**
+     * 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, attestation, now) {
+        const at = now.toISOString();
+        return this.transact(() => {
+            // The attestation must be for this request's agent and runner, and offer the model it was checked on.
+            const request = this.acpCheck(id);
+            if (request === null || request.provider !== attestation.provider || request.runner !== attestation.runner || !attestation.models.includes(request.model))
+                return false;
+            const moved = Number(this.db.prepare(`UPDATE acp_check_request SET state = 'passed', finished_at = ?, result = 'passed'
+        WHERE id = ? AND state = 'running' AND expires_at > ? AND ${Store.WATCH_LIVE}
+          AND steps_used = 2 AND step1_passed = 1 AND step2_passed = 1 AND conformance_version = ?
+          AND (SELECT COUNT(*) FROM run r WHERE r.id IN (step1_run, step2_run) AND r.task_ref = acp_check_request.task_ref
+               AND r.outcome = 'refused' AND r.reason = 'agent-check' AND r.finished_at IS NOT NULL) = 2`)
+                .run(at, id, at, at, ACP_CONFORMANCE_VERSION).changes);
+            if (moved !== 1)
+                return false;
+            this.recordAcpAttestation(attestation, now);
+            return true;
+        });
+    }
+    /** 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, step, runId, now) {
+        const at = now.toISOString();
+        const row = this.db.prepare(`SELECT * FROM acp_check_request WHERE id = ? AND state = 'running' AND expires_at > ? AND ${Store.WATCH_LIVE}
+      AND steps_used = ? AND ${step === 1 ? "step1_run" : "step2_run"} = ?`).get(id, at, at, step, runId);
+        return row === undefined ? null : readAcpCheck(row);
+    }
+    /** Fail a check that hasn't finished, with its words. */
+    failAcpCheck(id, words, now) {
+        return Number(this.db.prepare("UPDATE acp_check_request SET state = 'failed', result = ?, finished_at = ? WHERE id = ? AND state IN ('pending','running')")
+            .run(words.slice(0, 2000), now.toISOString(), id).changes) === 1;
+    }
+    /** Running checks on this runner no live watch holds any more, or past their time: the ones recovery may close. */
+    abandonedAcpChecks(runner, now) {
+        const at = now.toISOString();
+        return this.db.prepare(`SELECT * FROM acp_check_request WHERE runner = ? AND state = 'running' AND (expires_at <= ? OR NOT ${Store.WATCH_LIVE})`)
+            .all(runner, at, at).map(readAcpCheck);
+    }
+    /** Finished checks on this runner whose claim, checkout and task are not yet let go: cleanup's to-do, retried each pass. */
+    unsettledAcpChecks(runner) {
+        return this.db.prepare("SELECT * FROM acp_check_request WHERE runner = ? AND state IN ('passed','failed') AND settled_at IS NULL ORDER BY id").all(runner).map(readAcpCheck);
+    }
+    /** The claim a finished check's cleanup now holds on its task (its first one expired): the only one it may release. */
+    setAcpCheckLease(id, leaseId) {
+        return Number(this.db.prepare("UPDATE acp_check_request SET lease_id = ? WHERE id = ? AND state IN ('passed','failed') AND settled_at IS NULL").run(leaseId, id).changes) === 1;
+    }
+    /** A finished check holds something again (a checkout that landed after recovery settled it): cleanup reopens. */
+    unsettleAcpCheck(id) {
+        return Number(this.db.prepare("UPDATE acp_check_request SET settled_at = NULL WHERE id = ? AND state IN ('passed','failed') AND settled_at IS NOT NULL").run(id).changes) === 1;
+    }
+    /** Take — or renew — the one cleanup attempt a finished check may have at a time: free, lapsed, or already this one. */
+    holdAcpSettle(id, attempt, now, ttlMs) {
+        const at = now.toISOString();
+        return Number(this.db.prepare(`UPDATE acp_check_request SET settle_by = ?, settle_until = ?
+      WHERE id = ? AND state IN ('passed','failed') AND settled_at IS NULL AND (settle_by IS NULL OR settle_by = ? OR settle_until <= ?)`)
+            .run(attempt, new Date(now.getTime() + ttlMs).toISOString(), id, attempt, at).changes) === 1;
+    }
+    /** Whether this cleanup attempt still holds the check. */
+    holdsAcpSettle(id, attempt, now) {
+        return this.db.prepare("SELECT 1 FROM acp_check_request WHERE id = ? AND settle_by = ? AND settle_until > ?").get(id, attempt, now.toISOString()) !== undefined;
+    }
+    /** Let go of a cleanup attempt (only this one). */
+    endAcpSettle(id, attempt) {
+        this.db.prepare("UPDATE acp_check_request SET settle_by = NULL, settle_until = NULL WHERE id = ? AND settle_by = ?").run(id, attempt);
+    }
+    /** 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, attempt, branch, now) {
+        return Number(this.db.prepare(`UPDATE acp_check_request SET settled_at = ?, settle_by = NULL, settle_until = NULL
+      WHERE id = ? AND state IN ('passed','failed') AND settled_at IS NULL AND settle_by = ? AND settle_until > ?
+        AND NOT EXISTS (SELECT 1 FROM worktree w WHERE w.task_ref = acp_check_request.task_ref AND w.branch = ?)`)
+            .run(now.toISOString(), id, attempt, now.toISOString(), branch).changes) === 1;
+    }
+    /** Pending checks past their time are expired, untouched. */
+    expireAcpChecks(now) {
+        return Number(this.db.prepare("UPDATE acp_check_request SET state = 'expired', finished_at = ? WHERE state = 'pending' AND expires_at <= ?").run(now.toISOString(), now.toISOString()).changes);
+    }
+    /** Revoke an ACP agent's live attestation on a runner; whether there was one. */
+    revokeAcpAttestation(provider, runner, by, now) {
+        return Number(this.db.prepare("UPDATE acp_attestation SET revoked_at = ?, revoked_by = ? WHERE provider = ? AND runner = ? AND revoked_at IS NULL").run(now.toISOString(), by, provider, runner).changes) > 0;
+    }
+    /** What a run's ACP agent itself reported it used (never priced; acp-client.ts). */
+    stampAgentReportedUsage(id, usage) {
+        if (usage === null)
+            return;
+        this.db.prepare("UPDATE run SET agent_reported_usage_json = ? WHERE id = ?").run(usage.slice(0, 8192), id);
+    }
     stampTerminalClass(id, authMode, terminalClass) {
         // FIRST-WRITE only (Codex E2/E3 review, finding 8): the gateway stamps
         // the disposal class exactly once, before disposition; nothing may
@@ -12449,9 +13066,10 @@ export class Store {
             .prepare(`UPDATE run SET tokens_in = COALESCE(?, tokens_in),
                         tokens_out = COALESCE(?, tokens_out),
                         cost_usd = COALESCE(?, cost_usd),
-                        usage_json = COALESCE(?, usage_json)
+                        usage_json = COALESCE(?, usage_json),
+                        agent_turns = COALESCE(?, agent_turns)
           WHERE id = ?`)
-            .run(usage.tokensIn ?? null, usage.tokensOut ?? null, usage.costUsd ?? null, usage.usageJson ?? null, id);
+            .run(usage.tokensIn ?? null, usage.tokensOut ?? null, usage.costUsd ?? null, usage.usageJson ?? null, usage.agentTurns ?? null, id);
         this.settleRunSpend(id, new Date());
     }
     /** v105: price a run as it stands (reported cost, or tokens at the catalogue price, or unpriced), frozen at the
@@ -12461,8 +13079,11 @@ export class Store {
         if (row === undefined)
             return;
         // How the run is billed is fixed the first time it's settled (its chain entry's, or the provider's login or key).
+        // An ACP run is billed as its stamp says: its agent's own plan reads as a plan ($0), anything else as metered.
+        const acpStamp = isAcpProvider(String(row["provider"])) ? this.acpBillingOfRun(id) : null;
         const billing = row["billing"] === "subscription" || row["billing"] === "api-key" ? row["billing"]
-            : row["auth_mode"] === "subscription" || row["auth_mode"] === "api-key" ? row["auth_mode"] : billingOf(String(row["provider"]), this.db);
+            : isAcpProvider(String(row["provider"])) ? (acpStamp?.kind === "plan" ? "subscription" : "api-key")
+                : row["auth_mode"] === "subscription" || row["auth_mode"] === "api-key" ? row["auth_mode"] : billingOf(String(row["provider"]), this.db);
         const priced = priceWork(this.db, { provider: String(row["provider"]), model: row["model"] == null ? null : String(row["model"]), billing,
             costUsd: row["cost_usd"] == null ? null : Number(row["cost_usd"]), tokensIn: row["tokens_in"] == null ? null : Number(row["tokens_in"]), tokensOut: row["tokens_out"] == null ? null : Number(row["tokens_out"]) });
         this.db.prepare(`INSERT INTO run_spend (run, microusd, source, billing, price_model, input_usd, output_usd, priced_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
@@ -12732,6 +13353,15 @@ export class Store {
             return { ...none, remainingMicrousd: remaining };
         };
     }
+    /** 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, model, runner) {
+        if (isAcpProvider(provider)) {
+            const declared = model === null || runner === null ? null : this.acpBillingFor(provider, runner, model);
+            return { provider, billing: declared?.kind === "plan" ? "subscription" : "api-key" };
+        }
+        return this.agentsFor([provider])[0];
+    }
     /** How each provider would bill new work now (see spend.billingOf). */
     agentsFor(providers) {
         return [...new Set(providers)].map(provider => ({ provider, billing: billingOf(provider, this.db) }));
@@ -13291,6 +13921,60 @@ export class Store {
             return { ok: true, id };
         }), result => result.ok);
     }
+    /**
+     * 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, author, note, now, expect) {
+        return this.transact(() => {
+            const valid = validateNote(note);
+            if (!valid.ok)
+                return { ok: false, reason: "invalid-note", problem: valid.problem };
+            const task = this.db.prepare("SELECT state FROM task WHERE id = ?").get(taskId);
+            const ref = this.db.prepare("SELECT id FROM task_ref WHERE backend = ? AND external_id = ?").get(BUILT_IN, taskId);
+            if (task === undefined || ref === undefined)
+                return { ok: false, reason: "unknown-task" };
+            const taskRef = Number(ref["id"]);
+            const key = expect.key === null ? null : `steer-note:${author}:${expect.key}`;
+            const digest = createHash("sha256").update(JSON.stringify([taskId, expect.run, valid.note])).digest("hex");
+            if (key !== null) {
+                const seen = this.db.prepare("SELECT operation, result FROM mutation WHERE idempotency_key = ?").get(key);
+                if (seen !== undefined) {
+                    const saved = parseStoreColumn("mutation.result", seen["result"]);
+                    if (seen["operation"] === "fileSteerNoteForRun" && saved !== null && saved.digest === digest && typeof saved.id === "number") {
+                        return { ok: true, id: saved.id, replayed: true };
+                    }
+                    return { ok: false, reason: "key-reused" };
+                }
+            }
+            const state = String(task["state"]);
+            if (state === "done" || state === "cancelled")
+                return { ok: false, reason: "task-finished" };
+            const shown = this.db.prepare("SELECT task_ref, outcome, lease_id FROM run WHERE id = ?").get(expect.run);
+            if (shown === undefined || Number(shown["task_ref"]) !== taskRef)
+                return { ok: false, reason: "attempt-ended" };
+            // Sent on from an attempt that ended (`onward`), the note is for the task's next attempt. Otherwise the run on
+            // screen must still be the task's live attempt: unfinished, under the current lease. How the note reaches it —
+            // its brief, its steering folder, or stdin — is steering's own business, as for any note.
+            if (expect.onward !== true) {
+                const lease = this.currentLiveLease(taskRef, now);
+                if (shown["outcome"] !== null || lease === null || shown["lease_id"] !== lease)
+                    return { ok: false, reason: "attempt-ended" };
+            }
+            const id = this.insertSteerNote(taskRef, author, valid.note, now);
+            if (key !== null) {
+                this.db
+                    .prepare("INSERT INTO mutation (idempotency_key, operation, result, actor, created_at) VALUES (?, ?, ?, ?, ?)")
+                    .run(key, "fileSteerNoteForRun", JSON.stringify({ id, digest }), author, now.toISOString());
+            }
+            this.bumpWake();
+            return { ok: true, id, replayed: false };
+        });
+    }
     /** 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). */
     insertSteerNote(taskRef, author, note, now) {
@@ -13353,6 +14037,7 @@ export class Store {
                 this.db
                     .prepare("UPDATE task_steer SET attached_run = ?, attached_at = ?, live_sends = 0, live_sent_at = NULL, live_missed_at = NULL WHERE id = ?")
                     .run(runId, stamp, Number(row["id"]));
+                this.noteSteerReached(Number(row["id"]), runId, "attached", stamp);
             }
             return rows.map(row => readSteerNote({ ...row, attached_run: runId, attached_at: stamp, live_sends: 0, live_sent_at: null, live_missed_at: null }));
         });
@@ -13364,9 +14049,13 @@ export class Store {
      * first receipt wins, and a replay changes nothing.
      */
     settleSteerDelivered(runId, now) {
+        const stamp = now.toISOString();
+        const settled = this.db.prepare("SELECT id FROM task_steer WHERE attached_run = ? AND delivered_at IS NULL").all(runId);
         const { changes } = this.db
             .prepare("UPDATE task_steer SET delivered_at = ? WHERE attached_run = ? AND delivered_at IS NULL")
-            .run(now.toISOString(), runId);
+            .run(stamp, runId);
+        for (const row of settled)
+            this.noteSteerReached(Number(row["id"]), runId, "read", stamp);
         return Number(changes);
     }
     /**
@@ -13420,8 +14109,24 @@ export class Store {
             live_missed_at = CASE WHEN mailed_run IS ? THEN live_missed_at ELSE NULL END
           WHERE id = ? AND delivered_at IS NULL AND superseded_at IS NULL`)
             .run(runId, now.toISOString(), runId, runId, runId, noteId);
+        if (Number(changes) > 0)
+            this.noteSteerReached(noteId, runId, "mailed", now.toISOString());
         return Number(changes) > 0;
     }
+    /** One run a note reached, kept for its live conversation (live-notes.ts); display state, so a failure never blocks steering. */
+    noteSteerReached(noteId, runId, how, at) {
+        try {
+            this.db.prepare("INSERT OR IGNORE INTO steer_note_run (note, run, how, at) VALUES (?, ?, ?, ?)").run(noteId, runId, how, at);
+        }
+        catch { /* display state */ }
+    }
+    /** The notes this run reached, filing order — attached to its brief, mailed into its folder, or read by it. */
+    steerNotesReaching(runId) {
+        return this.db
+            .prepare("SELECT * FROM task_steer WHERE id IN (SELECT note FROM steer_note_run WHERE run = ?) ORDER BY id")
+            .all(runId)
+            .map(readSteerNote);
+    }
     /**
      * 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
@@ -13434,6 +14139,8 @@ export class Store {
             .prepare(`UPDATE task_steer SET acked_at = ?, delivered_at = ?, attached_run = ?, attached_at = COALESCE(mailed_at, ?)
           WHERE id = ? AND mailed_run = ? AND acked_at IS NULL AND delivered_at IS NULL AND superseded_at IS NULL`)
             .run(stamp, stamp, runId, stamp, noteId, runId);
+        if (Number(changes) > 0)
+            this.noteSteerReached(noteId, runId, "read", stamp);
         if (Number(changes) > 0)
             this.bumpWake();
         return Number(changes) > 0;
@@ -14531,17 +15238,31 @@ export class Store {
         return row === undefined ? null : readLeadSession(row);
     }
     endLeadSession(id, by, now) {
-        const changed = this.db
-            .prepare("UPDATE lead_session SET ended_at = ?, ended_by = ? WHERE id = ? AND ended_at IS NULL")
-            .run(now.toISOString(), by, id);
-        return Number(changed.changes) === 1;
+        return this.transact(() => {
+            const changed = this.db
+                .prepare("UPDATE lead_session SET ended_at = ?, ended_by = ? WHERE id = ? AND ended_at IS NULL")
+                .run(now.toISOString(), by, id);
+            // Its waiting messages can never run under it (each is bound to the session it was sent in): they end now, Not
+            // sent, and keep no words (v128 lead queue).
+            if (Number(changed.changes) === 1) {
+                const waiting = this.db.prepare("SELECT message FROM lead_queue WHERE session = ? AND status = 'queued'").all(id).map(row => Number(row["message"]));
+                for (const message of waiting) {
+                    this.db.prepare("UPDATE lead_queue SET status = 'cancelled', error = 'Not sent: this conversation ended before it ran.', revision = revision + 1, settled_at = ? WHERE message = ?").run(now.toISOString(), message);
+                    this.forgetQueuedLeadMessage(message);
+                }
+            }
+            return Number(changed.changes) === 1;
+        });
     }
     /** Revocation's companion (ruling 10): an approver's standing ends every session it minted. */
     endLeadSessionsFor(approver, by, now) {
-        const changed = this.db
-            .prepare("UPDATE lead_session SET ended_at = ?, ended_by = ? WHERE approver = ? AND ended_at IS NULL")
-            .run(now.toISOString(), by, approver);
-        return Number(changed.changes);
+        return this.transact(() => {
+            const ending = this.db.prepare("SELECT id FROM lead_session WHERE approver = ? AND ended_at IS NULL").all(approver).map(row => Number(row["id"]));
+            // Each ends as endLeadSession ends one: its waiting messages too (v128 lead queue).
+            for (const id of ending)
+                this.endLeadSession(id, by, now);
+            return ending.length;
+        });
     }
     /** The live thread for this approver and scope under THIS ceiling; a
      * thread under another ceiling is closed first (ruling 9) — the surface
@@ -14627,11 +15348,14 @@ export class Store {
         const { changes } = this.db.prepare("UPDATE flow SET state = 'archived', updated_by = ?, updated_at = ? WHERE id = ? AND state = 'active'").run(by, now.toISOString(), id);
         return Number(changes) === 1;
     }
+    /** 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, now) {
         return this.transact(() => {
             const stamp = now.toISOString();
-            const id = Number(this.db.prepare("INSERT INTO flow_card (flow, title, description, stage, state, created_by, created_at, updated_at, source_json) VALUES (?, ?, ?, ?, 'active', ?, ?, ?, ?)")
-                .run(card.flow, card.title, card.description, card.stage, card.by, stamp, stamp, card.source === undefined ? null : JSON.stringify(card.source)).lastInsertRowid);
+            const id = Number(this.db.prepare("INSERT INTO flow_card (flow, title, description, stage, state, created_by, created_at, updated_at, source_json, created_kind) VALUES (?, ?, ?, ?, 'active', ?, ?, ?, ?, ?)")
+                .run(card.flow, card.title, card.description, card.stage, card.by, stamp, stamp, card.source === undefined ? null : JSON.stringify(card.source), card.byKind).lastInsertRowid);
             this.db.prepare("INSERT INTO flow_event (card, from_stage, to_stage, outcome, actor, note, at) VALUES (?, NULL, ?, 'created', ?, NULL, ?)").run(id, card.stage, card.by, stamp);
             return id;
         });
@@ -15208,7 +15932,80 @@ export class Store {
      * firing) the task it filed. False when it was already recorded.
      */
     recordFlowTriggerEvent(trigger, key, card, note, now, task = null, onTime = false, ranScript = null) {
-        const { changes } = this.db.prepare("INSERT OR IGNORE INTO flow_trigger_event (trigger, key, card, note, at, task, on_time, ran_script) VALUES (?, ?, ?, ?, ?, ?, ?, ?)").run(trigger, key, card, note, now.toISOString(), task, onTime ? 1 : 0, ranScript);
+        const at = now.toISOString();
+        const { changes } = this.db.prepare("INSERT OR IGNORE INTO flow_trigger_event (trigger, key, card, note, at, task, on_time, ran_script, state, accepted_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")
+            .run(trigger, key, card, note, at, task, onTime ? 1 : 0, ranScript, card === null ? "skipped" : "accepted", card === null ? null : at);
+        return Number(changes) === 1;
+    }
+    /**
+     * 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, from, to, configJson, now) {
+        // The address moves with it when given: one write, from the very secret, settings and address the caller read.
+        const { changes } = this.db.prepare(`UPDATE flow_trigger SET hook_credential = ?, hook_hash = COALESCE(?, hook_hash), config_json = COALESCE(?, config_json), updated_at = ?
+      WHERE id = ? AND hook_credential = ? AND config_json = ? AND hook_hash IS ? AND state != 'removed'`)
+            .run(to.credential, to.hookHash ?? null, configJson, now.toISOString(), id, from.credential, from.configJson, from.hookHash);
+        return Number(changes) === 1;
+    }
+    /** v126: what a trigger did with one delivery, or null when it never received it. */
+    flowReceipt(trigger, key) {
+        const row = this.db.prepare("SELECT card, note, at, state, accepted_at, item_json FROM flow_trigger_event WHERE trigger = ? AND key = ?").get(trigger, key);
+        return row === undefined ? null : readFlowReceipt(row);
+    }
+    /** 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, key, state, note, itemJson, now) {
+        if ((state === "held") !== (itemJson !== null))
+            throw new Error("a held receipt keeps its item, and only a held one");
+        const { changes } = this.db.prepare("INSERT OR IGNORE INTO flow_trigger_event (trigger, key, card, note, at, state, item_json) VALUES (?, ?, NULL, ?, ?, ?, ?)")
+            .run(trigger, key, note, now.toISOString(), state, itemJson);
+        return Number(changes) === 1;
+    }
+    /** 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, key, card, now) {
+        const { changes } = this.db.prepare("UPDATE flow_trigger_event SET state = 'accepted', card = ?, accepted_at = ?, item_json = NULL WHERE trigger = ? AND key = ? AND state = 'held'")
+            .run(card, now.toISOString(), trigger, key);
+        return Number(changes) === 1;
+    }
+    /** 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, since) {
+        const at = since.toISOString();
+        const row = this.db.prepare(`SELECT
+        (SELECT COUNT(*) FROM flow_trigger_event WHERE trigger = :trigger AND accepted_at > :at)
+      + (SELECT COUNT(*) FROM flow_trigger_event WHERE trigger = :trigger AND accepted_at IS NULL AND state IS NULL AND card IS NOT NULL AND at > :at) AS n`).get({ trigger, at });
+        return Number(row?.["n"] ?? 0);
+    }
+    /** v126: a trigger's held deliveries, oldest first. */
+    heldFlowReceipts(trigger, limit) {
+        return this.db.prepare("SELECT key, item_json, at FROM flow_trigger_event WHERE trigger = ? AND state = 'held' ORDER BY at, rowid LIMIT ?").all(trigger, limit)
+            .map(row => ({ key: String(row["key"]), itemJson: String(row["item_json"]), at: String(row["at"]) }));
+    }
+    /** v126: a held delivery that can't become its card (its words no longer pass): left out, with why. */
+    skipHeldReceipt(trigger, key, note) {
+        const { changes } = this.db.prepare("UPDATE flow_trigger_event SET state = 'skipped', note = ?, item_json = NULL WHERE trigger = ? AND key = ? AND state = 'held'").run(note, trigger, key);
+        return Number(changes) === 1;
+    }
+    /** v126: how many deliveries a trigger holds. */
+    heldFlowReceiptCount(trigger) {
+        return Number(this.db.prepare("SELECT COUNT(*) AS n FROM flow_trigger_event WHERE trigger = ? AND state = 'held'").get(trigger)?.["n"] ?? 0);
+    }
+    /** v126: one delivery turned away because the hold queue was full: counted, and since when, until a person clears it. */
+    noteFlowDeliveryDropped(trigger, now) {
+        this.db.prepare("UPDATE flow_trigger SET dropped_count = dropped_count + 1, dropped_since = COALESCE(dropped_since, ?) WHERE id = ?").run(now.toISOString(), trigger);
+    }
+    /** v126: a person has seen the turned-away deliveries. */
+    clearFlowDeliveriesDropped(trigger) {
+        this.db.prepare("UPDATE flow_trigger SET dropped_count = 0, dropped_since = NULL WHERE id = ?").run(trigger);
+    }
+    /** 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, now) {
+        const { changes } = this.db.prepare("UPDATE flow_trigger SET limit_noted_at = ? WHERE id = ? AND (limit_noted_at IS NULL OR limit_noted_at <= ?)")
+            .run(now.toISOString(), trigger, new Date(now.getTime() - 3_600_000).toISOString());
         return Number(changes) === 1;
     }
     /** The last card a trigger made, if any. */
@@ -15307,6 +16104,25 @@ export class Store {
         this.db.prepare(`INSERT INTO run_tool (run, tools_json, created_at) VALUES (?, json_object('fence', json(?)), ?)
       ON CONFLICT (run) DO UPDATE SET tools_json = json_set(tools_json, '$.fence', json(?))`).run(run, JSON.stringify(fence), now.toISOString(), JSON.stringify(fence));
     }
+    /** What one attempt's network was and what its proxy saw (egress.ts), kept beside its fence. */
+    recordRunNetwork(run, network, now) {
+        const json = JSON.stringify(network);
+        this.db.prepare(`INSERT INTO run_tool (run, tools_json, created_at) VALUES (?, json_object('network', json(?)), ?)
+      ON CONFLICT (run) DO UPDATE SET tools_json = json_set(tools_json, '$.network', json(?))`).run(run, json, now.toISOString(), json);
+    }
+    runNetwork(run) {
+        const row = this.db.prepare("SELECT json_extract(tools_json, '$.network') AS network FROM run_tool WHERE run = ?").get(run);
+        if (row === undefined || row["network"] === null)
+            return null;
+        let parsed;
+        try {
+            parsed = JSON.parse(String(row["network"]));
+        }
+        catch {
+            return null;
+        }
+        return runNetworkFromValue(parsed);
+    }
     runFence(run) {
         const row = this.db.prepare("SELECT json_extract(tools_json, '$.fence') AS fence FROM run_tool WHERE run = ?").get(run);
         if (row === undefined || row["fence"] === null)
@@ -15357,27 +16173,30 @@ export class Store {
             return rows.length;
         });
     }
+    /** `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, now) {
         const inserted = this.db
-            .prepare("INSERT INTO lead_message (thread, turn, role, text, activity, created_at) VALUES (?, ?, ?, ?, ?, ?)")
-            .run(message.thread, message.turn, message.role, message.text, message.activity ?? null, now.toISOString());
+            .prepare("INSERT INTO lead_message (thread, turn, role, text, activity, created_at, pending) VALUES (?, ?, ?, ?, ?, ?, ?)")
+            .run(message.thread, message.turn, message.role, message.text, message.activity ?? null, now.toISOString(), message.pending === true ? 1 : 0);
         this.db.prepare("UPDATE lead_thread SET last_turn_at = ? WHERE id = ?").run(now.toISOString(), message.thread);
         return Number(inserted.lastInsertRowid);
     }
+    /** 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, limit) {
+        return this.db
+            .prepare("SELECT * FROM (SELECT * FROM lead_message WHERE thread = ? AND pending = 0 ORDER BY id DESC LIMIT ?) ORDER BY id ASC")
+            .all(thread, limit)
+            .map(readLeadMessageRow);
+    }
     /** The last `limit` messages, oldest first. */
     listLeadMessages(thread, limit) {
         return this.db
             .prepare("SELECT * FROM (SELECT * FROM lead_message WHERE thread = ? ORDER BY id DESC LIMIT ?) ORDER BY id ASC")
             .all(thread, limit)
-            .map(row => ({
-            id: Number(row["id"]),
-            thread: Number(row["thread"]),
-            turn: row["turn"] === null ? null : Number(row["turn"]),
-            role: String(row["role"]),
-            text: String(row["text"]),
-            activity: row["activity"] === null ? null : String(row["activity"]),
-            createdAt: String(row["created_at"]),
-        }));
+            .map(readLeadMessageRow);
     }
     /** A proposal is inert (`drafting`) until its turn finalizes. */
     draftLeadProposal(proposal, now) {
@@ -15558,6 +16377,18 @@ export class Store {
             const liveChat = this.db.prepare("SELECT 1 FROM chat_turn WHERE approver=? AND state IN ('queued','running') AND mate_turn IS NULL LIMIT 1").get(args.approver);
             if (live !== undefined || liveChat !== undefined)
                 return { ok: false, reason: "concurrent" };
+            // v128: while something of this person's waits in the personal queue (or is claimed but not yet bound), the only
+            // personal turn admitted is the one carrying the exact claim of the backlog's oldest message — a follow pass, a
+            // channel turn or another send waits behind it. Team turns are counted per thread and are not held.
+            if (!teamBinding) {
+                const oldest = this.db.prepare("SELECT message, runner, generation, status FROM lead_queue WHERE approver = ? AND (status = 'queued' OR (status = 'running' AND turn_id IS NULL)) ORDER BY message LIMIT 1").get(args.approver);
+                if (oldest !== undefined) {
+                    const claim = args.queueClaim;
+                    const own = claim !== undefined && Number(oldest["message"]) === claim.message && oldest["status"] === "running" && oldest["runner"] === claim.runner && Number(oldest["generation"]) === claim.generation;
+                    if (!own)
+                        return { ok: false, reason: "backlog" };
+                }
+            }
             if (this.chatTurnsToday(args.approver, now) >= args.dailyTurns)
                 return { ok: false, reason: "daily-cap" };
             if (session.endedAt !== null) {
@@ -16053,7 +16884,7 @@ export class Store {
             handoff: row["handoff"] === null ? null : String(row["handoff"]),
             costUsd: row["cost_usd"] === null ? null : Number(row["cost_usd"]),
             provider: row["provider"] === null || row["provider"] === undefined ? null : String(row["provider"]),
-            authMode: row["auth_mode"] === "subscription" || row["auth_mode"] === "api-key"
+            authMode: row["auth_mode"] === "subscription" || row["auth_mode"] === "api-key" || row["auth_mode"] === "agent-login"
                 ? row["auth_mode"]
                 : null,
             ranMinutes: row["started_at"] === null || row["finished_at"] === null || row["started_at"] === undefined
@@ -16110,7 +16941,7 @@ export class Store {
                 ? null
                 : Math.max(1, Math.round((new Date(String(row["finished_at"])).getTime() - new Date(String(row["started_at"])).getTime()) / 60_000)),
             costUsd: row["cost_usd"] === null ? null : Number(row["cost_usd"]),
-            authMode: row["auth_mode"] === "subscription" || row["auth_mode"] === "api-key"
+            authMode: row["auth_mode"] === "subscription" || row["auth_mode"] === "api-key" || row["auth_mode"] === "agent-login"
                 ? row["auth_mode"]
                 : null,
             prNumber: row["pr_number"] === null || row["pr_number"] === undefined ? null : Number(row["pr_number"]),
@@ -16932,6 +17763,11 @@ export class Store {
         return Number(this.db.prepare("INSERT INTO run_process (run,host,process_group,observed_at,boot_id) VALUES (?,?,?,?,?)")
             .run(runId, hostname(), group ? 1 : 0, now.toISOString(), currentBootId()).lastInsertRowid);
     }
+    /** The run's process witnesses not yet proved exited — after first saving whatever exit evidence is available. */
+    openRunProcessCount(runId, now) {
+        this.recordRunProcessExits(runId, now);
+        return Number(this.db.prepare("SELECT COUNT(*) AS n FROM run_process WHERE run = ? AND exited_at IS NULL").get(runId).n);
+    }
     /** 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.
@@ -17382,6 +18218,45 @@ export class Store {
         return counts;
     }
     /** 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) {
+        const row = this.db.prepare("SELECT network_json FROM project_network WHERE repo = ?").get(repo);
+        if (row === undefined)
+            return PROJECT_NETWORK_DEFAULT;
+        let parsed = null;
+        try {
+            parsed = JSON.parse(String(row["network_json"]));
+        }
+        catch {
+            parsed = null;
+        }
+        // A damaged row reads as the narrowest setting, never a wider one.
+        return projectNetworkFromValue(parsed) ?? { mode: "allowlist", hosts: [], loopback: "proxy-only" };
+    }
+    /** An approver changed a project's network: saved, and in the ledger as before → after. */
+    setProjectNetwork(repo, network, by, now) {
+        return this.transact(() => {
+            const before = this.projectNetwork(repo);
+            const json = JSON.stringify({ mode: network.mode, hosts: [...new Set(network.hosts)].sort(), loopback: network.loopback });
+            this.db.prepare(`INSERT INTO project_network (repo, network_json, updated_at, updated_by) VALUES (?, ?, ?, ?)
+        ON CONFLICT (repo) DO UPDATE SET network_json = excluded.network_json, updated_at = excluded.updated_at, updated_by = excluded.updated_by`).run(repo, json, now.toISOString(), by);
+            const after = this.projectNetwork(repo);
+            const words = (one) => `${one.mode}${one.hosts.length === 0 ? "" : ` +${one.hosts.join(",")}`}${one.loopback === "proxy-only" ? " no-local" : ""}`;
+            this.recordPolicy(by, repo, "network", words(before), words(after), now);
+            return { before, after };
+        });
+    }
+    /** Whether this installation lets an agent run where no OS confinement exists (off unless an operator said so). */
+    unfencedAgentsAllowed() {
+        return Number(this.db.prepare("SELECT unfenced_allowed FROM confinement_setting WHERE id = 1").get()?.["unfenced_allowed"] ?? 0) === 1;
+    }
+    setUnfencedAgentsAllowed(allowed, by, now) {
+        this.transact(() => {
+            const before = this.unfencedAgentsAllowed();
+            this.db.prepare("UPDATE confinement_setting SET unfenced_allowed = ?, updated_at = ?, updated_by = ? WHERE id = 1").run(allowed ? 1 : 0, now.toISOString(), by);
+            this.recordPolicy(by, null, "unconfined agents", before ? "allowed" : "refused", allowed ? "allowed" : "refused", now);
+        });
+    }
     recordProjectConcurrency(by, repo, before, after, now) {
         this.recordPolicy(by, repo, "builds at once", String(before), String(after), now);
     }
@@ -17406,6 +18281,7 @@ export class Store {
     markTelegramUpdateApplied(...args) { return this.telegramChat().markUpdateApplied(...args); }
     // ---- the conversation queue (v62) ------------------------------------------
     enqueueTelegramConversation(...args) { return this.telegramChat().enqueueMessage(...args); }
+    telegramMessagesWaiting(binding) { return this.telegramChat().messagesWaiting(binding); }
     telegramConversationWaitingOn(...args) { return this.telegramChat().messageWaitingOn(...args); }
     getTelegramConversation(...args) { return this.telegramChat().getMessage(...args); }
     listTelegramConversations(...args) { return this.telegramChat().listMessages(...args); }
@@ -17440,6 +18316,7 @@ export class Store {
         this.telegramChat().deferUntil(botId, until);
     }
     telegramDeliveryProblem(...args) { return this.telegramChat().deliveryProblem(...args); }
+    telegramWatchFence(...args) { return this.telegramChat().watchFence(...args); }
     recordTelegramMessage(...args) { return this.telegramChat().recordMessage(...args); }
     telegramMessageOf(...args) { return this.telegramChat().messageOf(...args); }
     finalizeTelegramDelivery(...args) { return this.telegramChat().finalizeDelivery(...args); }
@@ -18032,7 +18909,7 @@ export class Store {
      * the subscription live under its enrolled generation, the notification
      * unresolved and still stamped. Null = do not transmit.
      */
-    pushSendFence(id, owner, generation) {
+    pushSendFence(id, owner, generation, now = new Date()) {
         const pair = this.db
             .prepare(`SELECT * FROM push_delivery
           WHERE id = ? AND state = 'claimed' AND claim_owner = ? AND claim_generation = ?`)
@@ -18052,7 +18929,20 @@ export class Store {
             .get(Number(pair["notification"]));
         if (notification === undefined)
             return null;
-        return { ...readPushPair(pair), subscriptionRow: readPushSubscription(subscription), notificationRow: readNotification(notification) };
+        // The watch, again at the last moment (cockpit §3): a person who opened the agent since the claim holds the ping
+        // (back to pending, no attempt spent) or, for news they have now seen, retires it.
+        const row = readNotification(notification), approverName = String(subscription["approver"]);
+        const watched = watchedPing(this, row, approverName, now);
+        if (watched === "skip") {
+            this.db.prepare("UPDATE push_delivery SET state = 'retired', last_error = 'seen', claim_owner = NULL WHERE id = ? AND state = 'claimed' AND claim_owner = ? AND claim_generation = ?").run(id, owner, generation);
+            return null;
+        }
+        if (watched !== "send") {
+            this.db.prepare(`UPDATE push_delivery SET state = 'pending', claim_owner = NULL, claim_expires_at = NULL, next_attempt_at = ?
+        WHERE id = ? AND state = 'claimed' AND claim_owner = ? AND claim_generation = ?`).run(watched.hold, id, owner, generation);
+            return null;
+        }
+        return { ...readPushPair(pair), subscriptionRow: readPushSubscription(subscription), notificationRow: row };
     }
     /** Settle a pair, conditionally on owner + generation (finding 25). */
     settlePushPair(id, owner, generation, outcome, now) {
@@ -18145,6 +19035,87 @@ export class Store {
             .run(idempotencyKey, operation, JSON.stringify(result ?? null), actor, at.toISOString());
         return result;
     }
+    /** 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) {
+        return Number(this.db.prepare("UPDATE web_session SET last_seen = ?, project = ?, project_revision = ?, sso_at = ? WHERE id_hash = ?")
+            .run(session.lastSeen, session.project, session.projectRevision, session.ssoAt, session.idHash).changes) > 0;
+    }
+    // ---- lead sweeps (docs/plans/lead-fan-out.md). Kept last in the class: the freshness tripwire pins method positions.
+    /** A new sweep record (inside the caller's filing transaction). */
+    createSweep(input, now) {
+        const row = this.db.prepare("INSERT INTO lead_sweep (owner, thread, repo, title, brief, max_parallel, proposal, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)")
+            .run(input.owner, input.thread, input.repo, input.title, input.brief, input.maxParallel, input.proposal, now.toISOString());
+        return Number(row.lastInsertRowid);
+    }
+    /** Link one filed child (its family root) to its sweep, in order. */
+    addSweepTask(sweep, rootTask, ordinal, label) {
+        this.db.prepare("INSERT INTO lead_sweep_task (sweep, root_task, ordinal, label) VALUES (?, ?, ?, ?)").run(sweep, rootTask, ordinal, label);
+    }
+    getSweep(id) {
+        const row = this.db.prepare("SELECT * FROM lead_sweep WHERE id = ?").get(id);
+        if (row === undefined)
+            return null;
+        return { id: Number(row["id"]), owner: String(row["owner"]), thread: row["thread"] === null ? null : Number(row["thread"]), repo: String(row["repo"]), title: String(row["title"]),
+            brief: String(row["brief"]), maxParallel: Number(row["max_parallel"]), proposal: row["proposal"] === null ? null : Number(row["proposal"]), createdAt: String(row["created_at"]) };
+    }
+    /** The sweep a proposal filed, if it did (a replayed confirm finds it). */
+    sweepOfProposal(proposal) {
+        const row = this.db.prepare("SELECT id FROM lead_sweep WHERE proposal = ?").get(proposal);
+        return row === undefined ? null : Number(row["id"]);
+    }
+    /** A sweep's children, in order: each one's family root and its label. */
+    sweepTasks(sweep) {
+        return this.db.prepare("SELECT root_task, ordinal, label FROM lead_sweep_task WHERE sweep = ? ORDER BY ordinal").all(sweep)
+            .map(row => ({ rootTask: String(row["root_task"]), ordinal: Number(row["ordinal"]), label: String(row["label"]) }));
+    }
+    /** The sweep a task belongs to through its family root (a revision of a child belongs too), or null. */
+    sweepOfTask(taskId) {
+        const { chain } = this.revisionAncestryStatus(taskId);
+        const root = chain.at(-1) ?? taskId;
+        const row = this.db.prepare("SELECT s.id, s.max_parallel FROM lead_sweep_task t JOIN lead_sweep s ON s.id = t.sweep WHERE t.root_task = ?").get(root);
+        return row === undefined ? null : { id: Number(row["id"]), maxParallel: Number(row["max_parallel"]) };
+    }
+    /**
+     * 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, stamp, except = null) {
+        const row = this.db.prepare(`WITH RECURSIVE fam(root, id, depth) AS (
+        SELECT t.root_task, t.root_task, 0 FROM lead_sweep_task t WHERE t.sweep = ?
+        UNION SELECT fam.root, r.external_id, fam.depth + 1 FROM task_ref r JOIN fam ON r.revision_of = fam.id WHERE r.backend = ? AND fam.depth < 64),
+      refs AS (SELECT DISTINCT fam.root, r.id AS ref FROM fam JOIN task_ref r ON r.backend = ? AND r.external_id = fam.id),
+      latest AS (SELECT refs.root, c.released_at, c.expires_at FROM refs JOIN claim c ON c.task_ref = refs.ref
+        WHERE refs.ref IS NOT ? AND c.lease_generation = (SELECT MAX(lease_generation) FROM claim WHERE task_ref = refs.ref))
+      SELECT COUNT(DISTINCT root) AS n FROM latest WHERE released_at IS NULL AND expires_at > ?`).get(sweep, BUILT_IN, BUILT_IN, except, stamp);
+        return Number(row?.["n"] ?? 0);
+    }
+    /** 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) {
+        return this.db.prepare("SELECT 1 AS hit FROM chat_turn WHERE mate_turn = ? AND unknown_spend = 1 AND acknowledged_at IS NULL LIMIT 1").get(leadTurn) !== undefined;
+    }
+    /** The lead turn a chat step belongs to (a lead reply's request), or null for a standalone chat turn. */
+    leadTurnOfStep(step) {
+        const row = this.db.prepare("SELECT mate_turn FROM chat_turn WHERE id = ?").get(step);
+        return row === undefined || row["mate_turn"] === null ? null : this.getLeadTurn(Number(row["mate_turn"]));
+    }
+    /** 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, request) {
+        return this.leadRequestReceipt(session, request) !== null
+            || this.db.prepare("SELECT 1 FROM lead_queue WHERE session = ? AND request_id = ?").get(session, request) !== undefined;
+    }
+    forgetQueuedLeadMessage(message) {
+        const blanked = this.db.prepare("UPDATE lead_message SET text = '' WHERE id = ? AND pending = 1").run(message);
+        if (Number(blanked.changes) !== 1)
+            return;
+        this.db.prepare("UPDATE lead_queue SET context_json = NULL WHERE message = ?").run(message);
+        this.db.prepare("DELETE FROM memory_search WHERE kind = 'conversation' AND ref = ?").run(`message:${message}`);
+    }
 }
 /** A stored count or id that must be a whole, non-negative number — a
  * NULL, an empty string, a fraction, or text reads as null (v48 authority repair). */
@@ -18192,6 +19163,7 @@ function readRun(row) {
             : String(row["provider_started_at"]),
         tokensIn: row["tokens_in"] === null || row["tokens_in"] === undefined ? null : Number(row["tokens_in"]),
         tokensOut: row["tokens_out"] === null || row["tokens_out"] === undefined ? null : Number(row["tokens_out"]),
+        agentTurns: row["agent_turns"] === null || row["agent_turns"] === undefined ? null : Number(row["agent_turns"]),
         costUsd: row["cost_usd"] === null || row["cost_usd"] === undefined ? null : Number(row["cost_usd"]),
         headRevision: row["head_revision"] === null || row["head_revision"] === undefined
             ? null
@@ -18203,7 +19175,7 @@ function readRun(row) {
                 ? String(row["phase"])
                 : null,
         // An auth mode is exactly one of the two words — anything else reads as unknown.
-        authMode: row["auth_mode"] === "api-key" ? "api-key" : row["auth_mode"] === "subscription" ? "subscription" : null,
+        authMode: row["auth_mode"] === "api-key" ? "api-key" : row["auth_mode"] === "subscription" ? "subscription" : row["auth_mode"] === "agent-login" ? "agent-login" : null,
         terminalClass: row["terminal_class"] === null || row["terminal_class"] === undefined
             ? null
             : String(row["terminal_class"]),
@@ -18777,6 +19749,8 @@ export function permissionModeOfProfile(profile) {
         return profile.permissionArgv === "bypassPermissions" ? "bypassPermissions" : "auto";
     if (profile.provider === "gemini")
         return profile.approvalArgv === "yolo" ? "bypassPermissions" : "auto";
+    if (isAcpProfile(profile))
+        return "bypassPermissions";
     return profile.sandboxMode === "danger-full-access" ? "bypassPermissions" : "auto";
 }
 export function revisionTermsOf(sourceRef, sourceScope, coverage, permissionDefault, qualityDefault) {
@@ -19042,3 +20016,18 @@ function readGrant(row) {
 export function verifiedAuthor(name) {
     return name;
 }
+function readAcpCheck(row) {
+    const text = (key) => row[key] == null ? null : String(row[key]);
+    const num = (key) => row[key] == null ? null : Number(row[key]);
+    const state = String(row["state"]);
+    return {
+        id: Number(row["id"]), provider: String(row["provider"]), runner: String(row["runner"]), model: String(row["model"]),
+        conformanceVersion: Number(row["conformance_version"]), requestedBy: String(row["requested_by"]), requestedAt: String(row["requested_at"]),
+        expiresAt: String(row["expires_at"]),
+        state: state === "running" || state === "passed" || state === "failed" || state === "expired" ? state : "pending",
+        watch: row["watch_repo"] == null || row["watch_owner"] == null ? null : { repo: String(row["watch_repo"]), owner: String(row["watch_owner"]) },
+        taskRef: num("task_ref"), launchJson: text("launch_json"), leaseId: text("lease_id"), stepsUsed: Number(row["steps_used"]), step1Run: num("step1_run"), step2Run: num("step2_run"),
+        step1Passed: Number(row["step1_passed"]) === 1, step2Passed: Number(row["step2_passed"]) === 1, result: text("result"), finishedAt: text("finished_at"),
+        settledAt: text("settled_at"),
+    };
+}