toolroll 0.9.60 → 0.9.62

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## 0.9.62 — 2026-10-12
+
+- **Release checks in minutes.** The upgrade path runs on a sample, CI's
+  passing run on the exact commit is reused, and the first failure stops it.
+- **Storage sweep waits for quiet.** It runs when nothing is building, and
+  Settings → Storage says when it last ran and why it waits.
+- **Landing proof you can trust.** A task completes on its own only for a
+  merged pull request or the project's recorded remote main, never a local
+  branch a build could move. Projects added before this need it once: you
+  (the owner) or an instance operator's lead runs
+  `toolroll repos add <project> --remote <url>`. Until then, their tasks wait
+  for you.
+- **Cleanup follow-ups.** Only branches Toolroll created are removed, counted
+  from when it made them; scout branches stay, and duplicate teardowns merge.
+- **Fresh base.** A task with no commits starts from current main; the task
+  page shows its base.
+
+## 0.9.61 — 2026-10-12
+
+- **Agents board.** One place to check on running agents: Needs you,
+  Working, Stuck, Done and Idle, live on desktop and phone. Agents can ask a
+  question mid-run, and you reply from the board.
+- **Steer in seconds.** A note reaches a running Claude build within seconds.
+  Pause, Resume, and Pause and steer sit beside Stop.
+- **Builds run on their own setup.** Your personal Claude hooks, plugins, MCP
+  servers and memory no longer load into builds.
+- **The sweep can't stop builds.** Storage cleanup runs in its own process
+  with a time limit, and never removes what a build is using.
+- **Finished work cleans up.** Tasks whose work has landed complete on their
+  own, and their checkouts and branches are removed.
+- **Release checks test everything since the last release.**
+
 ## 0.9.60 — 2026-10-11
 
 - **Steer a running build.** A note now reaches the agent while it works, and

package/dist/agent-board.d.ts

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