toolroll 0.9.60 → 0.9.62

package/dist/agents-board.js

@@ -0,0 +1,225 @@
+/**
+ * The Agents board's projection (one place to check on running agents): each
+ * task's newest build attempt from the last day, in the viewer's admitted
+ * projects, grouped Needs you, Working, Stuck, Done (not viewed yet), Idle.
+ * A protocol repair never takes the row: while one runs, its parent's row says
+ * "Fixing the handoff" and keeps the parent's transcript, changes and link.
+ * Saved facts only (agent-board.ts, the run, its activity and its sealed diff
+ * stats); nothing here verifies evidence or grants an action.
+ */
+import { quietSince, stuckSince } from "./agent-board.js";
+import { activityLine } from "./activity-line.js";
+import { readVerifiedArtifact } from "./evidence.js";
+import { failedAttemptSentence } from "./needs-you.js";
+import { projectName } from "./project.js";
+import { providerName } from "./provider-auth.js";
+import { runActivityOf } from "./task-activity.js";
+export const AGENT_GROUPS = [
+    { key: "needs-you", label: "Needs you" },
+    { key: "working", label: "Working" },
+    { key: "stuck", label: "Stuck" },
+    { key: "done", label: "Done" },
+    { key: "idle", label: "Idle" },
+];
+/** Finished attempts stay on the board this long; unread Done and Needs you stay three days. */
+const RECENT_MS = 24 * 60 * 60_000;
+const KEPT_MS = 3 * RECENT_MS;
+const BOARD_LIMIT = 80;
+const str = (row, key) => row[key] == null ? null : String(row[key]);
+const FACTS = `SELECT r.id, r.task_ref, r.provider, r.runner, r.outcome, r.reason, r.started_at, r.finished_at, r.phase, r.attempt_key IS NULL AS legacy,
+    tr.external_id AS task_id, tr.repo, t.title, t.state AS task_state,
+    n.state AS turn, n.state_at, n.transcript_at, n.stuck_at, n.said, n.said_note, n.said_at, n.diff_files, n.tool_kind, n.tool_at, n.question_note,
+    EXISTS (SELECT 1 FROM run p WHERE p.parent_run = r.id AND p.role = 'repair' AND p.outcome IS NULL) AS repairing,
+    (SELECT json_object('id', q.id, 'key', q.key, 'text', q.question) FROM agent_question q
+      WHERE q.run = r.id AND q.closed_at IS NULL AND q.attempt_key = r.attempt_key ORDER BY q.id LIMIT 1) AS question,
+    EXISTS (SELECT 1 FROM agent_seen s WHERE s.account = $account AND s.run = r.id) AS seen
+  FROM run r
+  JOIN task_ref tr ON tr.id = r.task_ref AND tr.backend = 'built-in' AND tr.repo IS NOT NULL
+  JOIN task t ON t.id = tr.external_id
+  LEFT JOIN agent_now n ON n.task_ref = r.task_ref AND n.run = r.id AND n.attempt_key = r.attempt_key
+  WHERE r.role = 'builder'`;
+function readFacts(row) {
+    let question = null;
+    try {
+        const parsed = row["question"] == null ? null : JSON.parse(String(row["question"]));
+        question = parsed === null ? null : { id: Number(parsed.id), key: String(parsed.key), text: String(parsed.text) };
+    }
+    catch {
+        question = null;
+    }
+    return {
+        runId: Number(row["id"]), taskRef: Number(row["task_ref"]), taskId: String(row["task_id"]), title: String(row["title"]), repo: str(row, "repo"),
+        provider: String(row["provider"] ?? "claude"), runner: String(row["runner"]), outcome: str(row, "outcome"), reason: str(row, "reason"),
+        startedAt: String(row["started_at"]), finishedAt: str(row, "finished_at"), legacy: Number(row["legacy"]) === 1, taskState: String(row["task_state"]),
+        turn: str(row, "turn"), stateAt: str(row, "state_at"), transcriptAt: str(row, "transcript_at"), stuckAt: str(row, "stuck_at"),
+        said: str(row, "said"), saidNote: str(row, "said_note"), saidAt: str(row, "said_at"), diffFiles: row["diff_files"] == null ? null : Number(row["diff_files"]),
+        toolKind: str(row, "tool_kind"), toolAt: str(row, "tool_at"), phase: str(row, "phase"), questionNote: str(row, "question_note"), repairing: Number(row["repairing"]) === 1,
+        question, seen: Number(row["seen"]) === 1,
+    };
+}
+/**
+ * The board's candidate builds, through the partial indexes (agent_board_open, agent_board_recent): open ones and
+ * those finished since $kept, one per task (its newest), never a scan of every run. A candidate a newer build of the
+ * same task has replaced is dropped by an indexed probe, so the row is still the task's newest build.
+ */
+export const BOARD_CANDIDATES = `WITH candidate AS (
+    SELECT task_ref, id FROM run WHERE role = 'builder' AND outcome IS NULL
+    UNION ALL
+    SELECT task_ref, id FROM run WHERE role = 'builder' AND outcome IS NOT NULL AND finished_at >= $kept
+  ), newest AS (SELECT task_ref, MAX(id) AS id FROM candidate GROUP BY task_ref)`;
+/** The board's candidate attempts: each task's newest build, open or recently finished, in the admitted projects. */
+export function agentFacts(store, now, access, account) {
+    return store.handle.prepare(agentFactsSql())
+        .all({ $account: account, $kept: new Date(now.getTime() - KEPT_MS).toISOString(), $all: access.repos === null ? 1 : 0, $repos: JSON.stringify(access.repos ?? []) })
+        .map(readFacts);
+}
+/** The board's query, exported for its query-plan test. */
+export function agentFactsSql() {
+    return `${BOARD_CANDIDATES}
+    ${FACTS.replace("FROM run r", "FROM newest c JOIN run r ON r.id = c.id")}
+      AND NOT EXISTS (SELECT 1 FROM run x WHERE x.task_ref = r.task_ref AND x.role = 'builder' AND x.id > r.id)
+      AND NOT EXISTS (SELECT 1 FROM task_ref c WHERE c.backend = tr.backend AND c.revision_of = tr.external_id AND c.repo IS tr.repo)
+      AND ($all = 1 OR tr.repo IN (SELECT value FROM json_each($repos)))
+    ORDER BY r.id DESC LIMIT ${BOARD_LIMIT}`;
+}
+/** One exact build attempt, whatever its age (the opened row), in the admitted projects: a repair opens as its parent. */
+export function agentFactsFor(store, run, access, account) {
+    const row = store.handle.prepare(`${FACTS} AND r.id = (SELECT CASE WHEN role = 'repair' AND parent_run IS NOT NULL THEN parent_run ELSE id END FROM run WHERE id = $run) AND ($all = 1 OR tr.repo IN (SELECT value FROM json_each($repos)))`)
+        .get({ $account: account, $run: run, $all: access.repos === null ? 1 : 0, $repos: JSON.stringify(access.repos ?? []) });
+    return row === undefined ? null : readFacts(row);
+}
+const FINISHED_WELL = new Set(["built", "no-change"]);
+const SETTLED_TASK = new Set(["done", "cancelled"]);
+/** Where an attempt sits on the board, and its one state word. Stuck is worked out from the facts now, so fresh
+ * transcript or activity clears it at once (the pulse's saved mark only tells open boards it crossed). */
+export function agentGroupOf(facts, activityAt, now) {
+    if (facts.outcome === null) {
+        if (facts.question !== null)
+            return { group: "needs-you", label: "Question" };
+        if (facts.repairing)
+            return { group: "working", label: "Working" };
+        if (facts.turn === "crashed")
+            return { group: "needs-you", label: "Stopped unexpectedly" };
+        if (facts.said === "blocked" && facts.turn !== "idle")
+            return { group: "needs-you", label: "Blocked" };
+        if (facts.turn === "busy" && stuckSince({ state: "busy", stateAt: facts.stateAt ?? facts.startedAt, transcriptAt: facts.transcriptAt ?? facts.startedAt, toolAt: facts.toolAt }, activityAt, now) !== null) {
+            return { group: "stuck", label: "Stuck" };
+        }
+        // Its turn has its result, but the build is still capturing and checking it: still at work, not idle.
+        return { group: "working", label: "Working" };
+    }
+    if (FINISHED_WELL.has(facts.outcome)) {
+        const label = facts.outcome === "built" ? "Done" : "No changes";
+        // Unread only for attempts the board saw start: a run from before it never counts as news.
+        return { group: facts.seen || facts.legacy ? "idle" : "done", label };
+    }
+    if (SETTLED_TASK.has(facts.taskState))
+        return { group: "idle", label: facts.outcome === "interrupted" ? "Stopped" : "Failed" };
+    return { group: "needs-you", label: facts.outcome === "parked" ? "Needs a decision" : facts.outcome === "interrupted" ? "Stopped" : facts.outcome === "refused" ? "Not started" : "Failed" };
+}
+const sealed = new Map();
+/** A finished attempt's sealed diff stats (cached by artifact: sealed bytes never change). */
+export function sealedDiffOf(store, root, run) {
+    if (root === undefined)
+        return null;
+    const artifact = store.artifactsFor(run).find(one => one.kind === "diff-stat");
+    if (artifact === undefined || artifact.captureStatus !== "ok")
+        return null;
+    if (sealed.has(artifact.id))
+        return sealed.get(artifact.id) ?? null;
+    let summary = null;
+    try {
+        const read = readVerifiedArtifact(root, artifact);
+        if (read.ok) {
+            const stat = JSON.parse(read.content.toString("utf8"));
+            const files = Array.isArray(stat.files) ? stat.files.filter(one => typeof one?.["path"] === "string").map(one => ({
+                path: String(one["path"]), additions: typeof one["additions"] === "number" ? one["additions"] : null, deletions: typeof one["deletions"] === "number" ? one["deletions"] : null
+            })) : [];
+            summary = { fileCount: Number(stat.fileCount ?? files.length) || 0, additions: Number(stat.additions ?? 0) || 0, deletions: Number(stat.deletions ?? 0) || 0, files };
+        }
+    }
+    catch {
+        summary = null;
+    }
+    if (sealed.size > 500)
+        sealed.clear();
+    sealed.set(artifact.id, summary);
+    return summary;
+}
+const files = (count) => `${count} ${count === 1 ? "file" : "files"}`;
+/** A row's diff size: the sealed stats once finished, the pulse's count while it runs. */
+export function diffWords(facts, diff) {
+    if (facts.outcome !== null) {
+        if (diff === null)
+            return null;
+        if (diff.fileCount === 0)
+            return "No changes";
+        return `+${diff.additions} −${diff.deletions} · ${files(diff.fileCount)}`;
+    }
+    if (facts.diffFiles === null)
+        return null;
+    return facts.diffFiles === 0 ? "No changes yet" : `${files(facts.diffFiles)} changed`;
+}
+const SETTLING_PHASES = new Set(["validating-handoff", "capturing-evidence", "committing", "verifying-proof", "correcting-proof"]);
+/** Reasons whose words only restate the Failed chip: the row shows the agent's own last word instead, or nothing. */
+const RESTATES_FAILED = new Set(["agent"]);
+const minutes = (ms) => Math.max(1, Math.floor(ms / 60_000));
+/** A finished attempt's one line: never the state again (the chip says it), only why. */
+function endedLine(facts) {
+    const own = facts.said === "blocked" || facts.said === "done" ? facts.saidNote : null;
+    if (FINISHED_WELL.has(facts.outcome ?? ""))
+        return facts.said === "done" ? facts.saidNote : null;
+    if (facts.outcome === "parked")
+        return "Stopped to ask a question";
+    if (RESTATES_FAILED.has(facts.reason?.trim() ?? ""))
+        return own;
+    return failedAttemptSentence(facts.reason);
+}
+/** One board row. */
+export function agentRowOf(store, facts, now, root) {
+    const activity = facts.outcome === null ? runActivityOf(store, { id: facts.runId, runner: facts.runner, startedAt: facts.startedAt }, now) : null;
+    const { group, label } = agentGroupOf(facts, activity?.at ?? null, now);
+    let line, quiet = false;
+    if (facts.outcome !== null)
+        line = endedLine(facts);
+    else if (facts.question !== null)
+        line = facts.question.text;
+    else if (facts.repairing)
+        line = "Fixing the handoff";
+    else if (group === "stuck")
+        line = `No new output for ${Math.max(4, minutes(now.getTime() - quietSince({ stateAt: facts.stateAt ?? facts.startedAt, transcriptAt: facts.transcriptAt ?? facts.startedAt, toolAt: facts.toolAt }, activity.at)))} min`;
+    else if (facts.turn === "idle" || (facts.turn !== "crashed" && SETTLING_PHASES.has(facts.phase ?? "")))
+        line = "Checking the result";
+    else if (facts.turn === "busy" && facts.toolAt !== null && now.getTime() - Date.parse(facts.toolAt) >= 60_000) {
+        line = `${facts.toolKind === "command" ? "Running a command" : "Waiting on a tool"} · ${minutes(now.getTime() - Date.parse(facts.toolAt))} min`;
+    }
+    else {
+        const said = facts.saidNote !== null && facts.saidAt !== null && facts.saidAt >= activity.at ? facts.saidNote : null;
+        const read = activityLine(activity, now.getTime());
+        line = said ?? read.text;
+        quiet = said === null && read.quiet;
+    }
+    return {
+        runId: facts.runId, taskId: facts.taskId, title: facts.title, project: facts.repo === null ? null : projectName(facts.repo), href: `/agents?run=${facts.runId}`,
+        group, label, line, quiet, startedAt: facts.startedAt, endedAt: facts.finishedAt,
+        diff: diffWords(facts, facts.outcome === null ? null : sealedDiffOf(store, root, facts.runId)), agent: providerName(facts.provider),
+    };
+}
+/** The whole board: groups in order, rows newest first within each; empty groups dropped. */
+export function agentsBoardOf(store, now, access, account, root) {
+    const recent = new Date(now.getTime() - RECENT_MS).toISOString();
+    const rows = agentFacts(store, now, access, account).map(facts => ({ facts, row: agentRowOf(store, facts, now, root) }))
+        .filter(({ facts, row }) => facts.outcome === null || row.group === "done" || row.group === "needs-you" || (facts.finishedAt ?? "") >= recent)
+        .map(({ row }) => row);
+    return AGENT_GROUPS.map(group => ({ ...group, rows: rows.filter(row => row.group === group.key) })).filter(group => group.rows.length > 0);
+}
+/** A board fingerprint for one exact build: what its open view shows moved, its repairs included. */
+export function agentRunFingerprint(store, run) {
+    const row = store.handle.prepare(`SELECT r.outcome, r.finished_at, r.phase, n.state, n.state_at, n.transcript_bytes, n.stuck_at, n.said_at, n.diff_files, n.tool_at, n.question_note,
+      (SELECT count(*) || ':' || coalesce(max(id), 0) || ':' || coalesce(sum(closed_at IS NULL), 0) FROM agent_question WHERE run = r.id) AS asks,
+      (SELECT count(*) || ':' || coalesce(max(id), 0) || ':' || coalesce(sum(outcome IS NULL), 0) FROM run p WHERE p.parent_run = r.id AND p.role = 'repair') AS repairs,
+      (SELECT at FROM run_activity WHERE run = r.id) AS activity,
+      (SELECT count(*) || ':' || coalesce(max(id), 0) FROM task_steer WHERE task_ref = r.task_ref) AS steer
+    FROM run r LEFT JOIN agent_now n ON n.run = r.id AND n.attempt_key = r.attempt_key WHERE r.id = ?`).get(run);
+    return row === undefined ? null : Object.values(row).map(value => String(value)).join("|");
+}

package/dist/assignment-adapters.d.ts

@@ -83,6 +83,7 @@ export declare function assignmentForCoordinator(store: Store, token: string, op
                     at: string;
                     digest: string;
                     lead?: true;
+                    landed?: string;
                 } | null;
                 result: {
                     digest: string;

package/dist/assignment-status.d.ts

@@ -23,7 +23,7 @@ export declare function assignmentStatusBrief(assignment: AssignmentSnapshot): {
     } | null;
     runId: number | null;
     primaryAction: {
-        code: "confirm-stopped" | "inspect-decisions" | "inspect-run" | "inspect-stop" | "inspect-task" | "open-pr" | "reconcile-run" | "sign-in" | import("./dispatch.js").DispatchAction;
+        code: "answer-agent" | "confirm-stopped" | "inspect-decisions" | "inspect-run" | "inspect-stop" | "inspect-task" | "open-pr" | "reconcile-run" | "sign-in" | import("./dispatch.js").DispatchAction;
         label: string;
         target: import("./work-summary.js").WorkTarget;
     } | null;

package/dist/assignment.d.ts

@@ -86,11 +86,13 @@ export type AssignmentSnapshot = {
         }[];
     };
     /** `lead`: marked complete by the person's lead (`toolroll lead token`), shown as "by the lead". */
+    /** `landed`: Toolroll marked it complete because its work is already in main, and why ("its pull request merged"). */
     completion: {
         actor: string;
         at: string;
         digest: string;
         lead?: true;
+        landed?: string;
     } | null;
     handoff: {
         kind: "result" | "decision" | "attention";
@@ -154,6 +156,7 @@ export declare function assignmentBrief(assignment: AssignmentSnapshot | null):
         at: string;
         digest: string;
         lead?: true;
+        landed?: string;
     } | null;
     result: {
         digest: string;
@@ -272,6 +275,7 @@ export declare function assignmentUpdates(store: Store, now: Date, access: Assig
                 at: string;
                 digest: string;
                 lead?: true;
+                landed?: string;
             } | null;
             result: {
                 digest: string;

package/dist/assignment.js

@@ -4,7 +4,7 @@
 import { createHash } from "node:crypto";
 import { currentActor, withActor } from "./actor.js";
 import { replacedWords } from "./task-status.js";
-import { COMPLETION_ACTION, familyChangedFiles } from "./result-completion.js";
+import { COMPLETER_ACTOR, COMPLETION_ACTION, familyChangedFiles, landedReasonOf } from "./result-completion.js";
 import { homedir } from "node:os";
 import { readSchemaVersion, stopFactOf } from "./store.js";
 import { approvalOf } from "./scope.js";
@@ -263,20 +263,22 @@ export function assignmentOf(store, taskId, now, access, root, memo) {
             : completionKind === "accepted-exception" ? "An operator accepted this result with its recorded limitations. The lead can inspect that decision; the recorded checks are unchanged."
                 : receipt.checks.detail;
         primaryAction = { code: "open-result", label: completionKind === "research-report" ? "Read report" : "Open result", target: { taskId: current.id, runId: result.id, decisionId: null }, access: "read", retry: "read-again" };
-        const checked = store.handle.prepare("SELECT actor,at FROM action_ledger WHERE task_id = ? AND run_id = ? AND action = ? AND outcome = ? AND source = 'work' ORDER BY id DESC")
-            .all(family.root.id, result.id, CHECK_ACTION, receipt.digest).find(row => /^(operator|coordinator|lead):.+/.test(String(row["actor"])));
+        const checked = store.handle.prepare("SELECT actor,at,detail FROM action_ledger WHERE task_id = ? AND run_id = ? AND action = ? AND outcome = ? AND source = 'work' ORDER BY id DESC")
+            .all(family.root.id, result.id, CHECK_ACTION, receipt.digest).find(row => COMPLETER_ACTOR.test(String(row["actor"])));
         // This ledger fact was authorized when written. Credential rotation,
         // membership changes and ownership transfer cannot revoke past completion.
         // The exact result digest still fences changes to work, scope and history.
         if (checked !== undefined) {
             const rootRef = store.lookupRef(family.root.id);
             const byLead = rootRef !== null && olderStoreSafe(() => store.taskActs(rootRef.id), []).filter(one => one.act === "completed").at(-1)?.lead === true;
-            completion = { actor: String(checked["actor"]), at: String(checked["at"]), digest: receipt.digest, ...(byLead ? { lead: true } : {}) };
+            const landed = landedReasonOf(String(checked["actor"]), checked["detail"] == null ? null : String(checked["detail"]));
+            completion = { actor: String(checked["actor"]), at: String(checked["at"]), digest: receipt.digest, ...(byLead && landed === null ? { lead: true } : {}), ...(landed === null ? {} : { landed }) };
             state = "complete";
             primaryAction = { ...primaryAction, label: completionKind === "research-report" ? "Read report" : "Open result" };
             const label = byLead ? "the lead" : completion.actor.startsWith("operator:") ? completion.actor.slice(9) : owner && completion.actor === actorOf(owner) ? owner.label : "the previous lead";
-            detail = completionKind === "research-report" ? `Research report checked by ${label}. No deployment is implied.`
-                : `Handled by ${label}. ${receipt.checks.detail} Publication and deployment are separate.`;
+            detail = landed !== null ? `Marked complete automatically: ${landed}. ${receipt.checks.detail}`
+                : completionKind === "research-report" ? `Research report checked by ${label}. No deployment is implied.`
+                    : `Handled by ${label}. ${receipt.checks.detail} Publication and deployment are separate.`;
         }
     }
     else if (work.status.rank === 0 || (!live && (current.state === "done" || current.state === "failed" || work.status.views.includes("needs-you")))) {