toolroll 0.9.76 → 0.9.78

package/dist/server/render-tasks.js

@@ -1,6 +1,7 @@
 /** Task pages: approval, agents, plans, controls, decisions and the task body. */
 import { networkWords } from "../egress.js";
 import { releaseAsksAgainWords, releaseTermsSentence } from "../scope.js";
+import { RELEASE_CI_RUNNING_WORDS } from "../release-ci-hold.js";
 import { writesWords } from "../writes-mode.js";
 import { checkAccessWords } from "../check-access.js";
 import { sandboxTermsWords } from "../project-sandbox.js";
@@ -1501,7 +1502,7 @@ export function taskBodyParts(data) {
             scope.touches.length === 0 ? "" : html `<p class="scope-paths"><strong>Touches</strong> ${scope.touches.join(", ")}</p>`,
             html `<p><strong>Quality</strong> ${qualityModeTitle(scope.qualityMode ?? "default")}</p>`,
             acceptanceCeremonyHtml(scope.acceptance),
-            scope.releaseTerms == null ? "" : html `<p><strong>Release</strong></p><p class="recap">${releaseTermsSentence(scope.releaseTerms)}</p>${scope.releaseTerms.policy.carry ? html `<details><summary>What asks again</summary><ul>${joinHtml(releaseAsksAgainWords(scope.releaseTerms).map(line => html `<li>${line}</li>`), "")}</ul></details>` : ""}`,
+            scope.releaseTerms == null ? "" : html `<p><strong>Release</strong></p><p class="recap">${releaseTermsSentence(scope.releaseTerms)}</p>${data.releaseCiRunning === true ? html `<p class="meta">${RELEASE_CI_RUNNING_WORDS}</p>` : ""}${scope.releaseTerms.policy.carry ? html `<details><summary>What asks again</summary><ul>${joinHtml(releaseAsksAgainWords(scope.releaseTerms).map(line => html `<li>${line}</li>`), "")}</ul></details>` : ""}`,
             approval.approved && data.autoRelease != null
                 ? html `<p class="meta scope-seal">${autoReleaseWords(data.autoRelease)} · <span class="seal">signs ${shortDigest(scope.digest)}</span></p>`
                 : approval.approved && data.release?.kind === "carried"

package/dist/server/request-context.d.ts

@@ -18,14 +18,22 @@ export type RequestFacts = {
     returnTo: string;
     actor?: string;
     createdTask?: string;
+    /** This request's latency timeline (latency-timeline.ts): kept when the answer was slow. */
+    timeline?: import("../latency-timeline.js").Timeline;
     browser?: boolean;
     workspaceRead?: boolean;
+    /** Receipt reconciliation, task and result reads (`request`, `task`, `result`): work is read afresh, never cached. */
+    freshWork?: boolean;
+    /** A workspace re-read's If-None-Match: the content validator it holds from its last read. */
+    workspaceIfNoneMatch?: string;
     workspaceRequest?: string | null;
     workCounts?: ReturnType<typeof workCountsByProject>;
     workCrew?: {
         project: string | null;
         page: WorkIndexPage;
     };
+    /** The chrome this request already read (console-chrome.ts keys): one snapshot per request, however often it asks. */
+    chromeReads?: Map<string, unknown>;
     lens?: string | null;
     workspaceValidator?: {
         key: string;

package/dist/server/runtime.d.ts

@@ -153,6 +153,8 @@ export interface ServerRuntime {
         saturated: boolean;
     };
     liveRefreshSeconds: () => number;
+    /** One work index page for an already-admitted reader, read at most once per workspace revision (console-chrome.ts). */
+    sharedIndexPage: (access: import("../work-summary.js").WorkSummaryAccess, options: import("../work-index.js").WorkIndexOptions) => import("../work-index.js").WorkIndexPage;
     chatKeyFor: (provider: DirectChatProviderId) => {
         key: string;
         source: "environment" | "stored";

package/dist/server/settings.js

@@ -117,7 +117,9 @@ import { sweepSchedule } from "../storage-sweep-schedule.js";
 import { storageHtml } from "../storage-ui.js";
 import { landedSummary } from "../landed-cleanup.js";
 import { bytesWords, parseCleanup } from "../storage.js";
-import { isDigestTime, RESULT_SCREENSHOTS } from "../store.js";
+import { isDigestTime, liveBackupState, RESULT_SCREENSHOTS, setLiveBackupSettings } from "../store.js";
+import { defaultLiveFolder, liveFolderOf, liveFolderProblem } from "../live-backup.js";
+import { LIVE_EVERY } from "../backup-ui.js";
 import { checkTeamsCredentials, clearTeamsCredentials, loadTeamsCredentials, saveTeamsCredentials, TeamsError } from "../teams-api.js";
 import { teamsSettingsHtml } from "../teams-settings.js";
 import { telegramSettingsHtml } from "../telegram-settings.js";
@@ -497,7 +499,9 @@ ${connectionHtml(asked, connection, task)}${command === null ? "" : html `<p>On
         if (databaseFile === null)
             return refuse(response, who, 403, "An instance operator looks after backups.", "/settings");
         const settings = store.backupSettings();
-        const view = { settings, folder: backupFolderOf(settings, databaseFile), defaultFolder: defaultBackupFolder(databaseFile), runs: store.backupRuns(20), csrf: who.session.csrf, now };
+        const live = liveBackupState(store);
+        const view = { settings, folder: backupFolderOf(settings, databaseFile), defaultFolder: defaultBackupFolder(databaseFile), runs: store.backupRuns(20), csrf: who.session.csrf, now,
+            live: { state: live, folder: liveFolderOf(live.settings, databaseFile), defaultFolder: defaultLiveFolder(databaseFile) } };
         return sendScreen(response, 200, screen("Backups", html `<p><a href="/settings">Settings</a></p><h1>Backups</h1>${(backupHtml(view, { said: url.searchParams.get("said"), problem: url.searchParams.get("problem") }))}`, { chrome: chromeFor(project, "settings") }));
     }
     // v105: Settings → Data, where an instance operator downloads everything. The download is a POST with the password.
@@ -1325,8 +1329,24 @@ ${repositoryContextHtml(chosen, query, result, who.role === 'approver' ? csrf :
             if (problem !== null)
                 return back("problem", problem);
         }
+        // The continuous copy (live-backup.ts): how often, and a folder that is a plain, private folder of this user's
+        // outside every project and checkout. A form without these fields leaves it as it is.
+        const liveBefore = liveBackupState(store).settings;
+        const liveEvery = body.get("live_every") ?? null;
+        const liveMinutes = Number(liveEvery);
+        if (liveEvery !== null && liveEvery !== "off" && !LIVE_EVERY.includes(liveMinutes))
+            return back("problem", "Choose how often to copy continuously.");
+        const liveTyped = body.get("live_folder") === null ? liveBefore.folder ?? "" : (body.get("live_folder") ?? "").trim();
+        const liveFolder = liveTyped === "" || liveTyped === defaultLiveFolder(databaseFile) ? null : liveTyped;
+        if (liveFolder !== null) {
+            const problem = liveFolderProblem(liveFolder, [...new Set([...managedRepos(), ...store.knownRepos(), ...(options.poolRoot === undefined ? [] : [options.poolRoot])])]);
+            if (problem !== null)
+                return back("problem", problem);
+        }
         const before = store.backupSettings();
         store.setBackupSettings({ enabled: every !== "off", everyHours: every === "off" ? before.everyHours : hours, keep, folder }, who.name, now);
+        setLiveBackupSettings(store, { enabled: liveEvery === null ? liveBefore.enabled : liveEvery !== "off", everyMinutes: liveEvery === null || liveEvery === "off" ? liveBefore.everyMinutes : liveMinutes,
+            keep: liveBefore.keep, folder: liveFolder }, who.name, now);
         return back("said", every === "off" ? "Saved. Scheduled backups are off." : "Saved.");
     }
     // v105: download everything as a .zip. An instance operator, with a step-up; the ledger records it.

package/dist/server/task-views.js

@@ -1,9 +1,10 @@
 import { releaseViewOf } from "../release-view.js";
+import { releaseCiRunningOf } from "../release-ci-hold.js";
 import { releaseObligationsOf } from "../release-recheck.js";
 import { approvalProofOf, freshlyApprovable, freshnessFor, withFreshness } from "../scope.js";
 import { liveAttemptOf, steerControlsFor } from "../steer-controls.js";
 import { originOf } from "../task-source.js";
-import { taskBaseOf } from "../task-base.js";
+import { recentGitReads, taskBaseOf } from "../task-base.js";
 import { assignmentPresentationOf, historicalAssessmentReason } from '../assignment-presentation.js';
 import { html, joinHtml } from "../html.js";
 import { assignmentStatusOf, assignmentWithEvidence } from '../assignment-ui.js';
@@ -53,6 +54,9 @@ import {} from "../store.js";
 import { taskControlOf } from "../task-control.js";
 import { lastErrorLineOf, missedRequirementOf, workStatusOf } from "../workspace-ui.js";
 export function createTaskViews(runtime) {
+    // The task page's base line reads Git through a frozen view of the project (~0.2-0.5 s on a large repository) and
+    // the page renders it twice per view and again on every live refresh: its answers are kept for a moment.
+    const baseGit = recentGitReads();
     /** The first task's way to Ready shows until the first Ready result, and stays on the installation's first task. */
     function guided(rootId, now) {
         if (runtime.store.isDemo())
@@ -491,12 +495,13 @@ export function createTaskViews(runtime) {
                 return { rows, decisions: decisionsFor(runtime.store, rows), now };
             })(),
             steering: ref === null ? [] : runtime.store.listSteerNotes(ref.id),
-            base: taskBaseOf(runtime.store, taskId),
+            base: taskBaseOf(runtime.store, taskId, baseGit),
             steeringLive: ref !== null && runtime.store.steeringLiveBuild(ref.id, now) !== null,
             steeringRun: ref === null ? null : runtime.store.steeringLiveBuild(ref.id, now),
             release: ref === null ? null : releaseViewOf(runtime.store, ref.externalId, now, authority => releaseObligationsOf(runtime.store, runtime.evidenceRoot, authority)),
             canStopRelease: who.role === "approver" && who.via === "cookie",
             autoRelease: ref === null ? null : autoReleaseOf(runtime.store.getScope(ref.externalId)),
+            releaseCiRunning: ref !== null && releaseCiRunningOf(runtime.store, ref.externalId) !== null,
             approvalProof: (() => {
                 // The proof of the approval shown: its approver, its exact sealed digest (approvedDigest === digest when approved).
                 const scope = ref === null ? null : runtime.store.getScope(ref.externalId);

package/dist/server/tasks.js

@@ -66,6 +66,7 @@ import { boardTickScript, oneLineOf, QUEUE_VIEW, refuse, regionScript, screen, t
 import { chatReturnWithSaid, matchTaskPath, redirect, respond, reviewHref, safeChatReturn, safeReturn, SAFETY, taskChatHref, taskHref } from "./http.js";
 import { boardBody, boardWorkers, donePage, inboxFingerprints, inboxPage, newTaskPage, nextPage, parseInboxTab, QUEUE_FRONT, queueBody, queueScript, TASK_STATES, workPage } from "./render-pages.js";
 import { runEfficiencyOf } from "../run-efficiency.js";
+import { timingFor } from "../latency-timeline.js";
 import { ACCEPT_ANYWAY_NEEDS_REASON, editorFileHref, proofBundleView, rankReviewQueue, RESULT_REFUSALS, REVIEW_QUEUE_CAP, reviewCockpitDetailParts, reviewCockpitPage, reviewPriorityOf, runFactsFragment, runOutcomeBadge, runPage, RUNS_PAGE, runsPage, withRefusal } from "./render-results.js";
 import { approvalFormDigest, approveRefusalWords, checkProgressHtml, consentDoorOf, decisionPage, nonceHashOf, PermissionsWouldChange, requirementsFromEditor, resumeDigestOf, taskOf } from "./render-tasks.js";
 import {} from "./session.js";
@@ -2837,7 +2838,7 @@ export function createTasksHandlers(runtime) {
             ...(store.isDemo() ? { demo: true } : {}),
         };
         if (run === null) {
-            return { ...base, run: null, detail: null, reviewRetry: null, review: null, notes: [] };
+            return { ...base, run: null, detail: null, reviewRetry: null, review: null, notes: [], timing: timingFor(store, null, row.taskId) };
         }
         const detail = resultDetailOf(run, who, now);
         return {
@@ -2866,6 +2867,8 @@ export function createTasksHandlers(runtime) {
             } })(),
             // What its network was and what its proxy saw (egress.ts), display only.
             network: store.runNetwork(run.id),
+            // Where the time went: its release check's parts and the task's deploys (latency-timeline.ts), display only.
+            timing: timingFor(store, run.id, row.taskId),
             // How far its checks reached (check-access.ts), display only.
             checkAccess: store.runCheckAccess(run.id),
             reviewRetry: store.reviewRetryStateOf(run.id),

package/dist/setup-guide.d.ts

@@ -15,10 +15,10 @@ export declare function detectPreparation(repo: string): {
 } | null;
 /** Browser installation may write only this known file inside its project. */
 export declare function previewProjectInstructions(repo: string): {
-    content?: never;
     ok: false;
     message: string;
     plan?: never;
+    content?: never;
     fingerprint?: never;
     installed?: never;
 } | {
@@ -30,10 +30,10 @@ export declare function previewProjectInstructions(repo: string): {
     installed: boolean;
 };
 export declare function addProjectInstructions(repo: string, fingerprint: string): {
-    content?: never;
     ok: false;
     message: string;
     plan?: never;
+    content?: never;
     fingerprint?: never;
     installed?: never;
 } | import("./skills.js").InstallResult;

package/dist/storage-sweep.js

@@ -8,7 +8,7 @@
  * Nothing live work uses goes (`liveWork`): while a run is open, a lease current or a checkout in use, each removal
  * and each signal first asks again whether that work uses the folder, and when its processes can't be read nothing
  * goes. Every scan and removal runs in a separate child: synchronous disk work must never delay the worker's lease
- * heartbeats (90 s). On Oct 12 the sweep starved those heartbeats and three builds ended interrupted half a second
+ * heartbeats (a lease lasts a minute). On Oct 12 the sweep starved those heartbeats and three builds ended interrupted half a second
  * after it finished. Once a run has ended, the next sweep removes what
  * it no longer uses.
  *

package/dist/storage.d.ts

@@ -36,3 +36,8 @@ export declare function storageReport(store: Store, databaseFile: string, checko
     lines: StorageLine[];
 };
 export declare function bytesWords(bytes: number): string;
+/** diskBytes without holding the event loop: the same one `du` per 200 paths and the same bounds, awaited. A console
+ * measuring its checkouts (tens of GB) used to stall every page for as long as `du` took. */
+export declare function diskBytesAsync(paths: readonly string[], run?: typeof duOnce): Promise<Map<string, number>>;
+/** `du -sk` over a batch, its output whatever it managed (a slow disk or a failure answers what it has, or nothing). */
+declare function duOnce(batch: readonly string[]): Promise<string>;

package/dist/storage.js

@@ -7,7 +7,7 @@
  * what slips through: stale test temp folders, leftover processes, extra
  * staged runtimes and dependency installs unused for a week.
  */
-import { spawnSync } from "node:child_process";
+import { execFile, spawnSync } from "node:child_process";
 import { lstatSync, readdirSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { DEPS_FOLDER, sharedCopies } from "./shared-deps.js";
@@ -190,3 +190,30 @@ export function bytesWords(bytes) {
         return `${Math.round(bytes / 1024 ** 2)} MB`;
     return `${Math.round(bytes / 1024)} KB`;
 }
+/** diskBytes without holding the event loop: the same one `du` per 200 paths and the same bounds, awaited. A console
+ * measuring its checkouts (tens of GB) used to stall every page for as long as `du` took. */
+export async function diskBytesAsync(paths, run = duOnce) {
+    const sizes = new Map();
+    if (paths.length === 0)
+        return sizes;
+    if (process.platform !== "win32") {
+        for (let at = 0; at < paths.length; at += 200) {
+            const batch = paths.slice(at, at + 200);
+            for (const line of (await run(batch)).split("\n")) {
+                const match = /^(\d+)\t(.+)$/.exec(line);
+                if (match !== null && batch.includes(match[2]))
+                    sizes.set(match[2], Number(match[1]) * 1024);
+            }
+        }
+    }
+    for (const path of paths)
+        if (!sizes.has(path))
+            sizes.set(path, treeBytes(path));
+    return sizes;
+}
+/** `du -sk` over a batch, its output whatever it managed (a slow disk or a failure answers what it has, or nothing). */
+function duOnce(batch) {
+    return new Promise(resolve => {
+        execFile("du", ["-sk", ...batch], { encoding: "utf8", maxBuffer: 16 * 1024 * 1024, timeout: 60_000 }, (_error, stdout) => resolve(typeof stdout === "string" ? stdout : ""));
+    });
+}

package/dist/store.d.ts

@@ -26,7 +26,7 @@ import type { Scope } from "./scope.js";
 import type { QualityMode } from "./quality.js";
 import type { ProgressSnapshot } from "./plan.js";
 import { type CheckProgressSnapshot } from "./check-progress.js";
-import { type ReleaseTerms } from "./contracts/release-terms.js";
+import { type ReleaseCheckPurpose, type ReleaseTerms } from "./contracts/release-terms.js";
 import { type ProjectAccess } from "./project-access.js";
 import { type LedgerEntry } from "./action-ledger.js";
 import type { LimitReading, LimitWindow } from "./provider-limits.js";
@@ -106,6 +106,10 @@ export declare const LIVE_STEER_SCHEMA = "\nCREATE TABLE IF NOT EXISTS run_pause
 /** v136: a run's own "Show commands in the live view" answer, captured once before its live file opens (live-detail.ts).
  * Absent, unreadable or anything but 1 means off. */
 export declare const RUN_LIVE_DETAIL_SCHEMA = "\nCREATE TABLE IF NOT EXISTS run_live_detail (\n  run         INTEGER PRIMARY KEY REFERENCES run(id) ON DELETE CASCADE,\n  commands    INTEGER NOT NULL CHECK (commands IN (0,1)),\n  captured_at TEXT NOT NULL\n);\n-- The Agents view's Live grid (docs/plans/agents-view.md \u00A72.5): every role's running runs and its recently ended ones.\n-- (id > 0 keeps them to the grid's own query, which names it: no other query's plan is offered them.)\nCREATE INDEX IF NOT EXISTS run_live_open ON run (id) WHERE outcome IS NULL AND id > 0;\nCREATE INDEX IF NOT EXISTS run_live_recent ON run (finished_at) WHERE outcome IS NOT NULL AND id > 0;\n";
+/** v137 (docs/plans/actors-lessons.md): explicit lifecycle, latency timelines and the continuous database copy. New
+ * tables only. A lifecycle row's `holder` binds it to one registration (a worker's registered_at) or one console
+ * process; a row whose holder no longer matches says nothing. Timelines are bounded and pruned as they are written. */
+export declare const V137_SCHEMA = "\nCREATE TABLE IF NOT EXISTS service_lifecycle (\n  component   TEXT PRIMARY KEY,\n  state       TEXT NOT NULL CHECK (state IN ('started','draining','stopped')),\n  holder      TEXT NOT NULL,\n  pid         INTEGER,\n  changed_at  TEXT NOT NULL,\n  beat_at     TEXT NOT NULL,\n  drain_until TEXT\n);\nCREATE TABLE IF NOT EXISTS latency_timeline (\n  id              INTEGER PRIMARY KEY AUTOINCREMENT,\n  kind            TEXT NOT NULL CHECK (kind IN ('console','release-check','deploy')),\n  subject         TEXT NOT NULL,\n  task_id         TEXT,\n  run_id          INTEGER,\n  started_at      TEXT NOT NULL,\n  total_ms        INTEGER NOT NULL,\n  milestones_json TEXT NOT NULL\n);\nCREATE INDEX IF NOT EXISTS latency_timeline_by_kind ON latency_timeline (kind, id);\nCREATE INDEX IF NOT EXISTS latency_timeline_by_run ON latency_timeline (run_id) WHERE run_id IS NOT NULL;\nCREATE INDEX IF NOT EXISTS latency_timeline_by_task ON latency_timeline (task_id) WHERE task_id IS NOT NULL;\nCREATE TABLE IF NOT EXISTS live_backup (\n  id            INTEGER PRIMARY KEY CHECK (id = 1),\n  enabled       INTEGER NOT NULL DEFAULT 1,\n  every_minutes INTEGER NOT NULL DEFAULT 5,\n  keep          INTEGER NOT NULL DEFAULT 24,\n  folder        TEXT,\n  holder        TEXT,\n  held_until    TEXT,\n  latest_file   TEXT,\n  latest_sha256 TEXT,\n  latest_at     TEXT,\n  latest_schema INTEGER,\n  latest_bytes  INTEGER,\n  tried_at      TEXT,\n  problem       TEXT\n);\n";
 /** A project's "Show commands in the live view" (live-detail.ts): absent means off. */
 export declare const LIVE_DETAIL_SCHEMA = "\nCREATE TABLE IF NOT EXISTS live_detail_setting (\n  repo       TEXT PRIMARY KEY,\n  commands   INTEGER NOT NULL CHECK (commands IN (0,1)),\n  updated_by TEXT NOT NULL,\n  updated_at TEXT NOT NULL\n);\n-- Every run a steering note reached, kept as it happens (live-notes.ts): a\n-- note's own attached/mailed fields move to the next attempt, this does not.\nCREATE TABLE IF NOT EXISTS steer_note_run (\n  note INTEGER NOT NULL REFERENCES task_steer(id) ON DELETE CASCADE,\n  run  INTEGER NOT NULL REFERENCES run(id) ON DELETE CASCADE,\n  how  TEXT NOT NULL CHECK (how IN ('attached','mailed','read')),\n  at   TEXT NOT NULL,\n  PRIMARY KEY (note, run, how)\n);\nCREATE INDEX IF NOT EXISTS steer_note_run_by_run ON steer_note_run (run, note);\n";
 export declare const CHAT_APPROVAL_SCHEMA = "\nCREATE TABLE IF NOT EXISTS chat_approval_setting (\n  approver             TEXT NOT NULL,\n  scope                TEXT NOT NULL,\n  enabled              INTEGER NOT NULL CHECK (enabled IN (0,1)),\n  full_access          INTEGER NOT NULL DEFAULT 0 CHECK (full_access IN (0,1)),\n  attempt_cap_microusd INTEGER CHECK (attempt_cap_microusd IS NULL OR attempt_cap_microusd >= 0),\n  generation           INTEGER NOT NULL,\n  digest               TEXT NOT NULL,\n  updated_by           TEXT NOT NULL,\n  updated_at           TEXT NOT NULL,\n  PRIMARY KEY (approver, scope)\n);\n";
@@ -186,7 +190,7 @@ export type SealedLedgerEntry = LedgerEntry & {
         hash: string;
     } | null;
 };
-export declare const SCHEMA_VERSION = 136;
+export declare const SCHEMA_VERSION = 138;
 /** v118: the tables merged into `credential`, in the order they move (a person's API tokens keep their ids first). */
 export declare const V118_MERGED_TABLES: Readonly<Record<string, CredentialKind>>;
 /**
@@ -331,6 +335,12 @@ export declare const V135_ADDED_COLUMNS: Readonly<Record<string, Readonly<Record
     definition: string;
     saved: string;
 }>>>>;
+/** v138 (docs/plans/pipeline-speed.md, P0): a scope's release check purpose, part of its digest when present. Saved
+ * rows read NULL. */
+export declare const V138_ADDED_COLUMNS: Readonly<Record<string, Readonly<Record<string, {
+    definition: string;
+    saved: string;
+}>>>>;
 /**
  * v135: one approval per release (docs/plans/release-once.md). `release_authority` is the single source of truth for a
  * release a person approved: one row per generation, changed only by compare-and-swap on `rev`, with a lease whose
@@ -2339,6 +2349,8 @@ export declare class Store {
         proposedVia?: ScopeAuthor | null;
         /** v135: release terms (release-once.md); undefined keeps the ones the scope carries, null removes them. */
         releaseTerms?: ReleaseTerms | null;
+        /** v138: a release check's purpose; undefined keeps the scope's, null removes it. Never beside terms. */
+        releaseCheck?: ReleaseCheckPurpose | null;
     }): void;
     /**
      * Re-file a scope under its OWN current words (v47): the route is
@@ -6600,6 +6612,9 @@ export declare class Store {
     };
     heartbeatWatchLease(runner: string, repo: string, owner: string, ttlMs: number, now: Date): boolean;
     releaseWatchLease(runner: string, repo: string, owner: string, now: Date): void;
+    /** Lapse every watch lease a runner holds now: its holder was proved gone (runner.ts registerRunnerIfIdle). The rows
+     * stay, so the next acquire takes them over and recovers the superseded incarnation as after any crash. */
+    expireWatchLeasesOf(runner: string, now: Date): number;
     /** The first still-unexpired watch lease this runner holds, if any (arc 2:
      * the takeover door refuses while one exists). */
     liveWatchLeaseOf(runner: string, now: Date): {
@@ -7780,3 +7795,121 @@ export type AgentsLiveRun = Run & {
  * Visibility is the caller's: it filters each by the console's ceiling and the viewer's access.
  */
 export declare function agentsLiveRuns(store: Store, endedSince: Date): AgentsLiveRun[];
+/**
+ * This runner's watches a predecessor left needing recovery (Codex review round 1, finding 2): a watch lease still
+ * live, or one whose holder left a claim open (or a run open under a claim a reaper already released). A replacement
+ * worker takes each over — recovering the holder's incarnation in the same transaction — before it admits new work,
+ * whichever projects its start names (a project being removed when the predecessor died is in none of them).
+ */
+export declare function predecessorWatches(store: Store, runner: string, now: Date): {
+    repo: string;
+    owner: string;
+}[];
+/** The longest a watch lease is taken or renewed for (durable-actors' MAX_HOST_LEASE_DURATION_MS). */
+export declare const MAX_WATCH_LEASE_MS = 60000;
+/** A service component's lifecycle (durable-actors' host lifecycle reports): started, then heartbeats, then draining
+ * (no new admission; its own drain ends by drain_until), then stopped (retired). */
+export type LifecycleState = "started" | "draining" | "stopped";
+export type LifecycleRow = {
+    component: string;
+    state: LifecycleState;
+    holder: string;
+    pid: number | null;
+    changedAt: string;
+    beatAt: string;
+    drainUntil: string | null;
+};
+/** One component's lifecycle row, or null (never reported: a component from before v137 says nothing). */
+export declare function lifecycleOf(store: Store, component: string): LifecycleRow | null;
+/** Every reported component, by name. */
+export declare function lifecycles(store: Store): LifecycleRow[];
+/**
+ * Report a component's state. `started` replaces whatever an earlier holder left; `draining` and `stopped` only move the
+ * current holder's row (a stale process can't mark its successor draining), and never back from stopped. Returns
+ * whether the row now says what was asked.
+ */
+export declare function reportLifecycle(store: Store, component: string, state: LifecycleState, holder: string, now: Date, extra?: {
+    pid?: number | null;
+    drainUntil?: Date | null;
+}): boolean;
+/** The short heartbeat: the current holder's row, while it is not stopped. False means another holder took it. */
+export declare function beatLifecycle(store: Store, component: string, holder: string, now: Date): boolean;
+/** A milestone in a latency timeline: what happened, how long after the operation began (ms), and an optional short
+ * reason. Never a secret: route ids, phase and part names, fixed reason words. */
+export type Milestone = {
+    name: string;
+    ms: number;
+    detail?: string;
+};
+export type LatencyKind = "console" | "release-check" | "deploy";
+export type LatencyTimeline = {
+    id: number;
+    kind: LatencyKind;
+    subject: string;
+    taskId: string | null;
+    runId: number | null;
+    startedAt: string;
+    totalMs: number;
+    milestones: Milestone[];
+};
+/** At most this many milestones per timeline (the rest are dropped, the last kept), and timelines kept per kind. */
+export declare const MAX_MILESTONES = 40;
+export declare const TIMELINES_KEPT = 200;
+/** Timelines older than this go whatever their count. */
+export declare const TIMELINE_DAYS = 14;
+/** Milestones made safe to keep: bounded in number and length, offsets whole non-negative milliseconds, in order. */
+export declare function boundedMilestones(milestones: readonly Milestone[]): Milestone[];
+/** Keep one timeline, then prune its kind to the newest TIMELINES_KEPT within TIMELINE_DAYS. */
+export declare function recordLatencyTimeline(store: Store, entry: {
+    kind: LatencyKind;
+    subject: string;
+    taskId?: string | null;
+    runId?: number | null;
+    startedAt: Date;
+    totalMs: number;
+    milestones: readonly Milestone[];
+}, now: Date): number;
+/** Timelines, newest first: of one kind, one run's, or one task's. A row that doesn't read is left out. */
+export declare function latencyTimelines(store: Store, filter: {
+    kind?: LatencyKind;
+    runId?: number;
+    taskId?: string;
+    limit?: number;
+}): LatencyTimeline[];
+/** The continuous copy (live-backup.ts): how often, how many, where (null: `backups/live` beside the database). */
+export type LiveBackupSettings = {
+    enabled: boolean;
+    everyMinutes: number;
+    keep: number;
+    folder: string | null;
+};
+export declare const DEFAULT_LIVE_BACKUP: LiveBackupSettings;
+/** The latest copy that passed its integrity check, as it was when it was made. */
+export type LiveBackupCopy = {
+    file: string;
+    sha256: string;
+    madeAt: string;
+    schemaVersion: number;
+    bytes: number;
+};
+export type LiveBackupState = {
+    settings: LiveBackupSettings;
+    latest: LiveBackupCopy | null;
+    triedAt: string | null;
+    problem: string | null;
+};
+export declare function liveBackupState(store: Store): LiveBackupState;
+/** Change the continuous copy's settings; the ledger keeps before → after. A new folder forgets the latest copy (it is
+ * in the old one). */
+export declare function setLiveBackupSettings(store: Store, next: LiveBackupSettings, by: string, now: Date): LiveBackupSettings;
+/** Take (or keep) the continuous copy's lease until `until`: one process copies at a time. */
+export declare function holdLiveBackup(store: Store, holder: string, now: Date, until: Date): boolean;
+export declare function releaseLiveBackup(store: Store, holder: string): void;
+/** A copy's outcome: a verified copy becomes the latest; a failure is kept as the problem (the latest stays). */
+export declare function recordLiveBackup(store: Store, outcome: {
+    ok: true;
+    copy: LiveBackupCopy;
+} | {
+    ok: false;
+    problem: string;
+}, now: Date): void;