toolroll 0.9.59 → 0.9.61

package/dist/lead-cli.js

@@ -71,25 +71,28 @@ export function proposalLines(proposals, repos, ordinal = (_p) => 0) {
                 ? `${t("operation") === "revise" ? "request a revision" : "save feedback"} for ${t("taskTitle") || t("task")}: ${t("note")}${Array.isArray(payload["notes"]) && payload["notes"].length > 0 ? ` (saved notes: ${payload["notes"].join(", ")})` : ""}`
                 : one.kind === "control"
                     ? (isChatControl(payload["control"]) ? `${CHAT_CONTROLS[payload["control"]].label}: ${chatControlHref(payload["control"], t("task"), payload["run"], payload["project"])} (open in the console)` : "control unavailable")
-                    : one.kind === "steer" ? `guide ${t("task")}'s next attempt: ${t("note")}`
-                        : one.kind === "agents" ? `change agents for ${t("task")}: ${t("role")} ${t("provider")} ${t("model")} ${t("risk")}`
-                            : one.kind === "repair" ? `${t("operation")} dependency ${t("blocker")} for ${t("task")}`
-                                :
-                                    one.kind === "task"
-                                        ? `file "${t("title")}" in ${repoLabel}${payload["report"] === true ? " (a scout task — it delivers a report, never a branch)" : ""}`
-                                        : one.kind === "next"
-                                            ? `move ${t("task")} to the front (was ${String(payload["position"] ?? "?")} of ${String(payload["of"] ?? "?")})`
-                                            : one.kind === "reserve"
-                                                ? `${payload["worker"] === null ? `release ${t("task")} to the shared queue` : `reserve ${t("task")} for ${t("worker")}`}`
-                                                : one.kind === "hold"
-                                                    ? `hold ${t("task")}: ${t("reason")}`
-                                                    : one.kind === "unhold"
-                                                        ? `release ${t("task")} from its hold`
-                                                        : one.kind === "answer"
-                                                            ? `answer decision #${String(payload["decision"])} on ${t("task")} with "${t("optionLabel")}"${payload["reversible"] === false ? " (irreversible — confirm N yes)" : ""}: ${t("rationale")}`
-                                                            : one.kind === "scope"
-                                                                ? `rewrite the scope of ${t("task")} (then approve it: toolroll task approve ${t("task")})`
-                                                                : `cancel ${t("task")}: ${t("reason")} (arm it yourself: toolroll task cancel ${t("task")})`;
+                    : one.kind === "steer" && one.payload["mode"] === "pause" ? `pause ${t("task")}'s build`
+                        : one.kind === "steer" && one.payload["mode"] === "resume" ? `resume ${t("task")}'s paused build`
+                            : one.kind === "steer" && one.payload["mode"] === "pause-and-steer" ? `pause ${t("task")}'s build, then send: ${t("note")}`
+                                : one.kind === "steer" ? `guidance for ${t("task")}'s agent: ${t("note")}`
+                                    : one.kind === "agents" ? `change agents for ${t("task")}: ${t("role")} ${t("provider")} ${t("model")} ${t("risk")}`
+                                        : one.kind === "repair" ? `${t("operation")} dependency ${t("blocker")} for ${t("task")}`
+                                            :
+                                                one.kind === "task"
+                                                    ? `file "${t("title")}" in ${repoLabel}${payload["report"] === true ? " (a scout task — it delivers a report, never a branch)" : ""}`
+                                                    : one.kind === "next"
+                                                        ? `move ${t("task")} to the front (was ${String(payload["position"] ?? "?")} of ${String(payload["of"] ?? "?")})`
+                                                        : one.kind === "reserve"
+                                                            ? `${payload["worker"] === null ? `release ${t("task")} to the shared queue` : `reserve ${t("task")} for ${t("worker")}`}`
+                                                            : one.kind === "hold"
+                                                                ? `hold ${t("task")}: ${t("reason")}`
+                                                                : one.kind === "unhold"
+                                                                    ? `release ${t("task")} from its hold`
+                                                                    : one.kind === "answer"
+                                                                        ? `answer decision #${String(payload["decision"])} on ${t("task")} with "${t("optionLabel")}"${payload["reversible"] === false ? " (irreversible — confirm N yes)" : ""}: ${t("rationale")}`
+                                                                        : one.kind === "scope"
+                                                                            ? `rewrite the scope of ${t("task")} (then approve it: toolroll task approve ${t("task")})`
+                                                                            : `cancel ${t("task")}: ${t("reason")} (arm it yourself: toolroll task cancel ${t("task")})`;
         const state = one.state === "pending" ? "" : ` [${one.state}${one.outcome !== null && typeof one.outcome.said === "string" ? `: ${one.outcome.said}` : ""}]`;
         return `  ${number}. ${what}${state}`;
     });

package/dist/lead-contract.js

@@ -20,7 +20,7 @@ export const LEAD_CONTRACT = [
     "Talk like a colleague in everyday words: task titles, 'the changes', 'the checks', 'try again'. Never say execution, run, scope, digest, dispatch or lane to the operator; say what happens next and what they can do.",
     "Read get_result for the exact execution/run; page nextFeedbackOffset. propose_review revise requests changes; note saves feedback. Use read notes only; clarify ambiguous intent. Ready is a saved result, not a reviewer stage. Historical missing assessments never require rerunning work. Failed checks and missing files remain visible; completion never deploys or changes checks.",
     "For screenshots, call get_result_images for that exact execution and run. On Telegram say they follow, never that they were delivered; elsewhere name result and image count. Limit 8/reply. If nextImageOffset exists, name remaining count; call it again with that offset or with the image ids it listed when asked. Select a newer revision explicitly; never describe unselected images or expose paths.",
-    "propose_steer guides the next attempt; propose_scope changes scope. propose_task_action uses control.run for stop/resume and supports retry, plan, dependencies. Requested stop is not stopped; ending chat differs. For protected actions read get_actions, use propose_action and full secure review. get_action_status proves saved outcomes; show_control only opens controls.",
+    "propose_steer reaches a running build (a Claude build in seconds), else the next attempt; get_task steering says if it was read. Its mode pause stops a running Claude build's turn and keeps the build; pause-and-steer then sends the note; resume continues a paused build; never use these for Stop. propose_scope changes scope. propose_task_action uses control.run for stop/resume and supports retry, plan, dependencies. Requested stop is not stopped; ending chat differs. For protected actions read get_actions, use propose_action and full secure review. get_action_status proves saved outcomes; show_control only opens controls.",
     "For a task's models/risk, read get_agents and answer in its words; for defaults, CLI versions and new models, read get_models; never an agent that is not listed. Changes require renewed approval. Before propose_answer read get_decision in an earlier step, including every option and consequence. Irreversible answers require explicit confirmation; cards retain consequences and recommendations.",
     "For intake, a plain-language outcome is enough to draft a task. Infer title, narrow goal, safe non-goals and testable criteria; leave touches empty for discovery. Do not ask the operator for a title, paths, implementation details, acceptance wording, model, budget or safely inferable fields. Ask at most three questions with defaults (one at a time with ask_owner) for material ambiguity, conflicting goals or unresolved irreversible/public/security/data-loss/migration choices. With 'use your judgment', use reversible defaults; real blockers may still arise.",
     "Set propose_task planning to 'required' for broad, risky or plan-first work, 'skip' for explicitly small direct builds, otherwise 'auto'. report:true investigates without a branch; follow-ups require confirmed proposals.",

package/dist/lead-doors.js

@@ -15,8 +15,10 @@ import { executeSharedAction, sharedActionPayload, sharedActionAllowsChallenge,
  * silent re-read.
  */
 import { closedQuestionWords } from "./decision.js";
+import { steerDestinationWords } from "./steer-status.js";
 import { isCheckLevel, setTaskCheckLevel } from "./check-levels.js";
 import { leadTurnKeepsProposals, verifiedAuthor } from "./store.js";
+import { agentQuestion, answerAgentQuestion } from "./agent-board.js";
 import { isVerifiedApprover, reproveApprover } from "./principal.js";
 import { TURN_WALL_CLOCK_MS } from './converse.js';
 import { teamChatAuthorization, subscriptionTeamChatProvider } from './team-chat-authorization.js';
@@ -58,7 +60,7 @@ const VIA_WORDS = {
 };
 const CARD_WORDS = {
     task: "New task", next: "Queue priority", reserve: "Worker assignment", hold: "Pause work", unhold: "Resume work",
-    steer: "Guidance for the next attempt", scope: "Scope revision", answer: "Decision answer", repair: "Waiting task",
+    steer: "Guidance for the agent", scope: "Scope revision", answer: "Decision answer", repair: "Waiting task",
     agents: "Agents change", task_action: "Task update", action: "Action",
 };
 /** A card about a task, confirmed anywhere but that task's own chat (the
@@ -407,10 +409,52 @@ function executeProposal(store, actor, kind, payload, now, options) {
         store.unhold(ref.id);
         return { ok: true, kind, said: `${taskId} released from its hold`, taskId };
     }
+    if (kind === "steer" && payload["mode"] === "resume") {
+        // Resume (live steering): the paused build the proposal saw, under the request id it was drafted with; no note.
+        const sawRun = payloadNumber(payload, "sawRun");
+        const request = payloadString(payload, "request");
+        if (sawRun === null || request === null)
+            return refuse("refused", "this proposal is missing what it saw");
+        const asked = store.requestResume({ taskId, runId: sawRun, by: verifiedAuthor(actor.name), via: "chat", requestId: request }, now);
+        if (!asked.ok) {
+            return refuse(asked.reason === "stale" || asked.reason === "not-paused" ? "stale" : "refused", asked.reason === "stale" ? "that build has stopped taking notes — look again" : asked.reason === "not-paused" ? "that build isn't paused any more — look again" : asked.detail);
+        }
+        const taskName = payloadString(payload, "taskTitle") ?? taskId;
+        return { ok: true, kind, said: `Resuming ${taskName} where it stopped.`, taskId };
+    }
+    if (kind === "steer" && (payload["mode"] === "pause" || payload["mode"] === "pause-and-steer")) {
+        // Pause, or Pause and steer (live steering): the build the proposal saw, under the request id it was drafted with.
+        const mode = payload["mode"];
+        const sawRun = payloadNumber(payload, "sawRun");
+        const request = payloadString(payload, "request");
+        const note = payloadString(payload, "note");
+        if (sawRun === null || request === null || (mode === "pause-and-steer" && note === null))
+            return refuse("refused", "this proposal is missing what it saw");
+        const asked = store.requestPause({ taskId, runId: sawRun, by: verifiedAuthor(actor.name), via: "chat", requestId: request, ...(mode === "pause-and-steer" ? { note: note } : {}) }, now);
+        if (!asked.ok)
+            return refuse(asked.reason === "stale" ? "stale" : "refused", asked.reason === "stale" ? "that build has stopped taking notes — look again" : asked.detail);
+        const taskName = payloadString(payload, "taskTitle") ?? taskId;
+        return { ok: true, kind, said: mode === "pause" ? `Pausing ${taskName}. Its next note continues it.` : `Pausing ${taskName}, then sending your note.`, taskId };
+    }
     if (kind === "steer") {
         const note = payloadString(payload, "note");
         if (note === null)
             return refuse("refused", "this proposal carries no guidance");
+        // A reply to the running agent's own question: the same door the Agents board's Reply uses, closing exactly that key.
+        const question = payloadNumber(payload, "question");
+        if (question !== null) {
+            const asked = agentQuestion(store, question);
+            if (asked === null || asked.taskRef !== ref.id)
+                return refuse("stale", "that question is not on this task");
+            const answered = answerAgentQuestion(store, { question, answer: note, author: actor.name, at: now,
+                file: (task, text) => store.fileSteerNote(task, verifiedAuthor(actor.name), text, now) });
+            if (!answered.ok) {
+                return answered.reason === "invalid-answer" || answered.reason === "not-saved"
+                    ? refuse("refused", answered.problem ?? "that reply could not be saved")
+                    : refuse("stale", "the agent's question already closed or its attempt ended — look again");
+            }
+            return { ok: true, kind, said: `Reply sent to the agent working on ${payloadString(payload, "taskTitle") ?? taskId}.`, taskId };
+        }
         const filed = store.fileSteerNote(taskId, verifiedAuthor(actor.name), note, now);
         if (!filed.ok) {
             const said = filed.reason === "task-finished"
@@ -421,7 +465,10 @@ function executeProposal(store, actor, kind, payload, now, options) {
             return refuse("refused", said);
         }
         const taskName = payloadString(payload, "taskTitle") ?? taskId;
-        return { ok: true, kind, said: `Guidance saved for ${taskName}'s next attempt`, taskId };
+        const steered = store.lookupRef(taskId);
+        const live = steered !== null && store.steeringLiveBuild(steered.id, now) !== null;
+        const liveInput = steered !== null && store.liveInputRun(steered.id, now) !== null;
+        return { ok: true, kind, said: `Guidance saved for ${taskName}. ${steerDestinationWords(live, liveInput)}`, taskId };
     }
     if (kind === "repair") {
         const blocker = payloadString(payload, "blocker");

package/dist/lead-follow.d.ts

@@ -6,6 +6,8 @@ export declare function leadFollowStatus(store: Store, actor: string): {
     enabled: boolean;
     detail: string;
 };
+/** A follow pass that failed outright says so where each enabled conversation reads its follow status. */
+export declare function recordLeadFollowFailure(store: Store, error: unknown, now: Date): void;
 export type LeadFollowInput = {
     store: Store;
     repos: () => readonly string[];

package/dist/lead-follow.js

@@ -1,13 +1,28 @@
 /** Durable crew updates for the built-in lead. Idle scans use no model.
- * Delivery replays reuse the saved lead request; they never dispatch a task. */
+ * The lead is an ordinary consumer of the assignment inbox: its scan records
+ * status events under its follow grant (assignment-status.ts), and it reads
+ * and acknowledges them through the same saved pages every coordinator uses
+ * (assignment-delivery.ts). Replays reuse the saved lead request; they never
+ * dispatch a task. */
 import { createHash } from 'node:crypto';
 import { LEAD_FOLLOW_MESSAGE } from './store.js';
 import { isVerifiedApprover, reproveApprover, verifyApproverStanding } from './principal.js';
 import { assignmentOf } from './assignment.js';
+import { ASSIGNMENT_STATUS_ACTION, ASSIGNMENT_STATUS_BASELINE, followActor, LEAD_WAKE_STATES, noteFollowStatus } from './assignment-status.js';
+import { acknowledgeLeadFollowDelivery, leadFollowInbox } from './assignment-delivery.js';
+import { publicChatText } from './chat-display.js';
 import { runLeadTurn } from './lead.js';
 import { updateAdmissionPaused } from './desktop-update-gate.js';
 import { checkLeadCommitments } from './lead-commitments.js';
+import { sweepIfMoved } from './sweep-gate.js';
 const CONFIG = 'lead follow configured';
+/** What follow status reads while nothing is waiting on the lead. */
+const FOLLOW_READY = 'The lead will respond when a result or decision is ready, or a task is cancelled.';
+const WAITING = 'Crew updates are waiting:';
+const FAILED = `${WAITING} the last update check failed`;
+/** The built-in lead's one inbox per grant. */
+const CONSUMER = 'lead';
+const PAGE = 20;
 const hash = (value) => createHash('sha256').update(JSON.stringify(value)).digest('hex');
 export function configureLeadFollow(store, who, session, thread, enabled, now) {
     if (!isVerifiedApprover(who) || !reproveApprover(store, who).ok || session.approver !== who.name || thread.approver !== who.name ||
@@ -46,7 +61,7 @@ export function leadFollowStatus(store, actor) {
     if (!grant?.enabled || !authorized(store, grant, grant.repos))
         return { enabled: false, detail: 'Automatic crew updates are off.' };
     const row = store.handle.prepare("SELECT outcome FROM action_ledger WHERE actor=? AND action=? AND source='work' ORDER BY id DESC LIMIT 1").get(actor, `lead delivery status:${grant.id}`);
-    return { enabled: true, detail: row ? String(row['outcome']) : 'The lead will respond when a result or decision is ready.' };
+    return { enabled: true, detail: row ? String(row['outcome']) : FOLLOW_READY };
 }
 function authorized(store, grant, admitted) {
     const latest = grantFor(store, grant.actor);
@@ -59,63 +74,81 @@ function authorized(store, grant, admitted) {
     const binding = liveBinding(store, proved.who, grant.session, grant.thread);
     return binding ? { who: proved.who, ...binding } : null;
 }
-/** Observe bounded pages; first sight of pre-existing work is only a baseline.
- * Subsequent meaningful transitions become immutable delivery events. */
+/** Observe bounded pages; first sight of work that has not moved since follow
+ * was enabled is only a baseline, recorded so the next change is compared to it. Every later transition — cancellation too —
+ * becomes an immutable status event in the grant's own inbox. */
 function observe(store, grant, now, root) {
     store.transact(() => {
         const cursor = `lead:${grant.id}:scan`, after = store.serviceCursor(cursor);
         const roots = store.handle.prepare(`SELECT id,external_id FROM task_ref WHERE backend='built-in' AND revision_of IS NULL
       AND repo IN (SELECT value FROM json_each(?)) AND id>? ORDER BY id LIMIT 50`).all(JSON.stringify(grant.repos), after);
+        const since = baselineOf(store, grant);
         for (const row of roots) {
             const a = assignmentOf(store, String(row['external_id']), now, { principal: 'operator', repos: grant.repos }, root);
             if (!a || !a.repo)
                 continue;
-            const observation = { task: a.rootId, repo: a.repo, state: a.state, detail: a.detail.slice(0, 400), result: a.receipt?.runId ?? null,
-                checks: a.receipt?.checks.status ?? null, decision: a.primaryAction?.target.decisionId ?? null, head: a.receipt?.head ?? null };
-            const digest = hash(observation), action = `lead observed:${grant.id}`;
-            const old = store.handle.prepare("SELECT outcome FROM action_ledger WHERE actor=? AND task_id=? AND action=? AND source='work' ORDER BY id DESC LIMIT 1").get(grant.actor, a.rootId, action);
-            if (old?.['outcome'] === digest)
-                continue;
-            store.recordAction({ at: now.toISOString(), actor: grant.actor, repo: a.repo, taskId: a.rootId, runId: a.receipt?.runId ?? null, action, outcome: digest, source: 'work' });
-            // Scope, question, result and completion writes do not necessarily
-            // update task.updated_at. A transition between enabling follow and
-            // the first scan must not be mistaken for a pre-existing baseline.
-            const scope = store.getScope(a.activeTaskId);
-            const question = observation.decision === null ? null : store.getDecision(observation.decision);
-            const changedAfterGrant = [store.getTask(a.activeTaskId)?.updatedAt, scope?.proposedAt, scope?.approvedAt,
-                question?.createdAt, a.completion?.at, ...a.attempts.map(attempt => attempt.runId === null ? null : store.getRun(attempt.runId)?.finishedAt)]
-                .some(at => typeof at === 'string' && at >= grant.at);
-            if ((old || changedAfterGrant) && ['ready-to-check', 'needs-decision', 'complete'].includes(a.state)) {
-                store.recordAction({ at: now.toISOString(), actor: grant.actor, repo: a.repo, taskId: a.rootId, runId: a.receipt?.runId ?? null,
-                    action: `lead update:${grant.id}`, outcome: JSON.stringify(observation), source: 'work' });
-            }
+            const seen = store.handle.prepare("SELECT 1 FROM action_ledger WHERE task_id=? AND action IN (?,?) AND source='work' AND actor=? LIMIT 1")
+                .get(a.rootId, ASSIGNMENT_STATUS_ACTION, ASSIGNMENT_STATUS_BASELINE, followActor(grant.id)) !== undefined;
+            const undelivered = !seen && store.handle.prepare("SELECT 1 FROM action_ledger WHERE actor=? AND action=? AND task_id=? AND source='work' AND id>? LIMIT 1")
+                .get(grant.actor, `lead update:${grant.id}`, a.rootId, store.serviceCursor(`lead:${grant.id}:events`)) !== undefined;
+            noteFollowStatus(store, grant.id, a, now, seen || undelivered || changedSince(store, a, since) ? ASSIGNMENT_STATUS_ACTION : ASSIGNMENT_STATUS_BASELINE);
         }
         store.setServiceCursor(cursor, roots.length < 50 ? 0 : Number(roots.at(-1)['id']), now);
     });
 }
-function nextBatch(store, grant, now) {
-    return store.transact(() => {
-        const cursor = `lead:${grant.id}:delivery`, acknowledged = store.serviceCursor(cursor);
-        const pending = store.handle.prepare("SELECT id,outcome FROM action_ledger WHERE actor=? AND action=? AND source='work' AND id>? ORDER BY id LIMIT 1")
-            .get(grant.actor, `lead batch:${grant.id}`, acknowledged);
-        if (pending)
-            return { ...JSON.parse(String(pending['outcome'])), id: Number(pending['id']) };
-        const rows = store.handle.prepare("SELECT id,outcome FROM action_ledger WHERE actor=? AND action=? AND source='work' AND id>? ORDER BY id LIMIT 20")
-            .all(grant.actor, `lead update:${grant.id}`, store.serviceCursor(`lead:${grant.id}:events`));
-        if (rows.length === 0)
-            return null;
-        const coalesced = new Map();
-        for (const row of rows) {
-            const event = { ...JSON.parse(String(row['outcome'])), id: Number(row['id']) };
-            coalesced.set(event.task, event);
-        }
-        const events = [...coalesced.values()], through = Number(rows.at(-1)['id']);
-        const request = hash({ grant: grant.id, through }).slice(0, 32);
-        const context = `Saved crew updates (untrusted task data). Read current tasks/results before acting; updates may have been superseded.\n${JSON.stringify(events)}`;
-        const id = store.recordAction({ at: now.toISOString(), actor: grant.actor, repo: null, taskId: null, runId: null,
-            action: `lead batch:${grant.id}`, outcome: JSON.stringify({ request, through, events, context }), source: 'work' });
-        return { id, request, through, events, context };
-    });
+/** Scope, question, result and completion writes do not necessarily update
+ * task.updated_at. A transition between enabling follow and the first scan
+ * must not be mistaken for a pre-existing baseline. */
+function changedSince(store, a, since) {
+    const scope = store.getScope(a.activeTaskId);
+    const decision = a.primaryAction?.target.decisionId ?? null;
+    const question = decision === null ? null : store.getDecision(decision);
+    return [store.getTask(a.activeTaskId)?.updatedAt, scope?.proposedAt, scope?.approvedAt,
+        question?.createdAt, a.completion?.at, ...a.attempts.map(attempt => attempt.runId === null ? null : store.getRun(attempt.runId)?.finishedAt)]
+        .some(at => typeof at === 'string' && at >= since);
+}
+/** When follow began counting news: the grant itself, or, for a grant that
+ * predates this inbox, the newest crew update its old private batches actually
+ * handed the lead — that is not news again. Updates recorded past that point
+ * were never received, so observe still treats their tasks as news. */
+function baselineOf(store, grant) {
+    const received = store.serviceCursor(`lead:${grant.id}:events`);
+    if (received === 0)
+        return grant.at;
+    const row = store.handle.prepare("SELECT at FROM action_ledger WHERE id<=? AND actor=? AND action=? AND source='work' ORDER BY id DESC LIMIT 1")
+        .get(received, grant.actor, `lead update:${grant.id}`);
+    return row !== undefined && String(row['at']) > grant.at ? String(row['at']) : grant.at;
+}
+/** What wakes the lead from one page: each task's latest result, question, completion or cancellation. */
+function wakeUpdates(events) {
+    const latest = new Map();
+    for (const event of events) {
+        if ('unavailable' in event || !LEAD_WAKE_STATES.includes(event.assignment.state))
+            continue;
+        const a = event.assignment;
+        latest.set(a.rootId, { id: event.id, task: a.rootId, repo: event.project, title: a.title.slice(0, 200), state: a.state, detail: a.detail.slice(0, 400),
+            result: a.result?.runId ?? null, checks: a.result?.checks.status ?? null, decision: a.primaryAction?.target.decisionId ?? null });
+    }
+    return [...latest.values()];
+}
+/** The lead's follow status line, written once per distinct status. */
+const lastDeliveryStatus = (store, grant) => store.handle.prepare("SELECT outcome FROM action_ledger WHERE actor=? AND action=? ORDER BY id DESC LIMIT 1").get(grant.actor, `lead delivery status:${grant.id}`)?.['outcome'];
+function noteDeliveryStatus(store, grant, status, now) {
+    if (lastDeliveryStatus(store, grant) !== status)
+        store.recordAction({ at: now.toISOString(), actor: grant.actor, repo: null, taskId: null, runId: null, action: `lead delivery status:${grant.id}`, outcome: status, source: 'work' });
+}
+const enabledGrants = (store) => store.handle.prepare("SELECT a.* FROM action_ledger a WHERE a.action=? AND a.source='work' AND a.id=(SELECT MAX(b.id) FROM action_ledger b WHERE b.actor=a.actor AND b.action=a.action AND b.source=a.source) ORDER BY a.id")
+    .all(CONFIG).map(readGrant).filter((one) => one !== null && one.enabled);
+const failureStatus = (error) => `${FAILED} (${publicChatText(error instanceof Error ? error.message : String(error), 200)}). It retries in a few seconds.`;
+/** With no page left unacknowledged, an earlier fault or refusal is no longer waiting. */
+function settle(store, grant, now) {
+    if (String(lastDeliveryStatus(store, grant) ?? '').startsWith(WAITING))
+        noteDeliveryStatus(store, grant, FOLLOW_READY, now);
+}
+/** A follow pass that failed outright says so where each enabled conversation reads its follow status. */
+export function recordLeadFollowFailure(store, error, now) {
+    for (const grant of enabledGrants(store))
+        noteDeliveryStatus(store, grant, failureStatus(error), now);
 }
 export async function runLeadFollowPass(input) {
     const { store } = input, clock = input.clock ?? (() => new Date());
@@ -124,48 +157,65 @@ export async function runLeadFollowPass(input) {
     store.sweepStaleLeadTurns(clock());
     // The lead's own promises are kept whether or not automatic crew updates are on: no model, one line when met.
     checkLeadCommitments(store, clock(), input.evidenceRoot);
-    const grants = store.handle.prepare("SELECT a.* FROM action_ledger a WHERE a.action=? AND a.source='work' AND a.id=(SELECT MAX(b.id) FROM action_ledger b WHERE b.actor=a.actor AND b.action=a.action AND b.source=a.source) ORDER BY a.id").all(CONFIG).map(readGrant).filter((one) => one !== null && one.enabled);
-    for (const grant of grants) {
-        const access = authorized(store, grant, input.repos());
-        if (!access || updateAdmissionPaused(store.raw()))
-            continue;
-        observe(store, grant, clock(), input.evidenceRoot);
-        const batch = nextBatch(store, grant, clock());
-        if (!batch)
-            continue;
-        // A replay after process exit reads the saved turn; even a failed turn is
-        // terminal for this delivery. Human chat remains available for follow-up.
-        const saved = store.leadRequestReceipt(grant.session, batch.request);
-        let turn = saved ? store.getLeadTurn(saved.turn) : null;
-        if (!turn) {
-            const provider = input.provider();
-            if (!provider)
-                continue;
-            const result = await (input.runTurn ?? runLeadTurn)({ store, ...access, ...provider, evidenceRoot: input.evidenceRoot, clock,
-                requestId: batch.request, message: LEAD_FOLLOW_MESSAGE,
-                context: batch.context, revalidate: async () => !updateAdmissionPaused(store.raw()) && authorized(store, grant, input.repos()) !== null ? { ok: true } : { ok: false, reason: 'access-changed' },
-                ...(input.fetcher ? { fetcher: input.fetcher } : {}), ...(input.subscriptionRunner ? { subscriptionRunner: input.subscriptionRunner } : {}) });
-            if (!result.ok && 'refused' in result) {
-                const status = `Crew updates are waiting: ${result.message}`;
-                const last = store.handle.prepare("SELECT outcome FROM action_ledger WHERE actor=? AND action=? ORDER BY id DESC LIMIT 1").get(grant.actor, `lead delivery status:${grant.id}`);
-                if (last?.['outcome'] !== status)
-                    store.recordAction({ at: clock().toISOString(), actor: grant.actor, repo: null, taskId: null, runId: null, action: `lead delivery status:${grant.id}`, outcome: status, source: 'work' });
-                continue;
-            }
-            turn = store.getLeadTurn(result.turn);
+    for (const grant of enabledGrants(store)) {
+        // One conversation's fault never holds up another's updates, and it is said where follow status is read.
+        try {
+            await followGrant(input, grant, clock);
+        }
+        catch (error) {
+            noteDeliveryStatus(store, grant, failureStatus(error), clock());
         }
-        if (!turn || turn.state === 'queued' || turn.state === 'running')
-            continue;
-        store.transact(() => {
-            // Concurrent passes may finish the same receipt, but ACK once.
-            if (store.serviceCursor(`lead:${grant.id}:delivery`) >= batch.id)
-                return;
-            store.setServiceCursor(`lead:${grant.id}:delivery`, batch.id, clock());
-            store.setServiceCursor(`lead:${grant.id}:events`, batch.through, clock());
-            const status = turn.state === 'answered' ? 'Crew updates handled.' : 'The lead response stopped. Open chat to continue; crew work was not rerun.';
-            store.recordAction({ at: clock().toISOString(), actor: grant.actor, repo: null, taskId: null, runId: null, action: `lead delivery status:${grant.id}`, outcome: status, source: 'work' });
-            if (turn.state !== 'answered' && authorized(store, grant, input.repos()))
-                store.appendLeadMessage({ thread: grant.thread, turn: null, role: 'assistant', text: status }, clock());
-        });
     }
 }
+async function followGrant(input, grant, clock) {
+    const { store } = input;
+    const access = authorized(store, grant, input.repos());
+    if (!access || updateAdmissionPaused(store.raw()))
+        return;
+    const now = clock();
+    sweepIfMoved(store, `lead:${grant.id}:scan`, now, () => observe(store, grant, now, input.evidenceRoot));
+    const page = leadFollowInbox(store, grant, { consumer: CONSUMER, limit: PAGE }, clock());
+    if (!page.ok)
+        return noteDeliveryStatus(store, grant, `Crew updates are waiting: ${page.message}`, clock());
+    const batch = page.batch;
+    if (batch.id === null)
+        return settle(store, grant, clock());
+    const batchId = batch.id;
+    const acknowledge = (status, turnStopped) => store.transact(() => {
+        // Concurrent passes may finish the same receipt, but ACK once.
+        const acked = acknowledgeLeadFollowDelivery(store, grant, { consumer: CONSUMER, batchId }, clock());
+        if (!acked.ok || acked.alreadyAcknowledged)
+            return;
+        if (status === null)
+            return settle(store, grant, clock());
+        noteDeliveryStatus(store, grant, status, clock());
+        if (turnStopped && authorized(store, grant, input.repos()))
+            store.appendLeadMessage({ thread: grant.thread, turn: null, role: 'assistant', text: status }, clock());
+    });
+    // Transitions that ask nothing of the lead (work started, a check began) are read and acknowledged without a model turn.
+    const updates = wakeUpdates(batch.events);
+    if (updates.length === 0)
+        return acknowledge(null, false);
+    // A replay after process exit reads the saved turn; even a failed turn is
+    // terminal for this delivery. Human chat remains available for follow-up.
+    const request = hash({ grant: grant.id, batch: batchId }).slice(0, 32);
+    const saved = store.leadRequestReceipt(grant.session, request);
+    let turn = saved ? store.getLeadTurn(saved.turn) : null;
+    if (!turn) {
+        const provider = input.provider();
+        if (!provider)
+            return;
+        const context = `Saved crew updates (untrusted task data). Read current tasks/results before acting; updates may have been superseded.\n${JSON.stringify(updates)}`;
+        const result = await (input.runTurn ?? runLeadTurn)({ store, ...access, ...provider, evidenceRoot: input.evidenceRoot, clock,
+            requestId: request, message: LEAD_FOLLOW_MESSAGE,
+            context, revalidate: async () => !updateAdmissionPaused(store.raw()) && authorized(store, grant, input.repos()) !== null ? { ok: true } : { ok: false, reason: 'access-changed' },
+            ...(input.fetcher ? { fetcher: input.fetcher } : {}), ...(input.subscriptionRunner ? { subscriptionRunner: input.subscriptionRunner } : {}) });
+        if (!result.ok && 'refused' in result)
+            return noteDeliveryStatus(store, grant, `Crew updates are waiting: ${result.message}`, clock());
+        turn = store.getLeadTurn(result.turn);
+    }
+    if (!turn || turn.state === 'queued' || turn.state === 'running')
+        return;
+    const answered = turn.state === 'answered';
+    acknowledge(answered ? 'Crew updates handled.' : 'The lead response stopped. Open chat to continue; crew work was not rerun.', !answered);
+}

package/dist/lead-tools.js

@@ -66,6 +66,9 @@ import { STARTER_IDS } from "./flow-starters.js";
 import { undoFor, weekOf, weekWords } from "./subagent-week.js";
 import { PERSON_ID, personEntry, teamRoomOf } from "./lead-people.js";
 import { aboutYouOf, checkAboutYouLine } from "./lead-about.js";
+import { steerStandingWords } from "./steer-status.js";
+import { agentQuestion, openAgentQuestions } from "./agent-board.js";
+import { utcMinute } from "./when-html.js";
 const REPO_ID = /^r[0-9]{1,3}$/;
 const TASK_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 const ISO_STAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,3})?Z$/;
@@ -1492,7 +1495,7 @@ const LEAD_TOOL_HANDLERS = {
         },
     },
     get_task: {
-        description: "Read currentExecution, state, dispatch, history, scope, dependencies, holds, queue, attempts and decisions before acting.",
+        description: "Read currentExecution, state, dispatch, history, scope, dependencies, holds, queue, attempts, decisions and whether the agent has read your notes before acting.",
         handle: (ctx, args) => {
             const taskId = taskIdOf(args);
             if (taskId === null)
@@ -1538,6 +1541,22 @@ const LEAD_TOOL_HANDLERS = {
                     attempts: runs.length,
                     lastAttempt: runs[0] === undefined ? null : { build: runs[0].id, outcome: runs[0].outcome ?? "unfinished", worker: runs[0].runner, tools: ctx.store.runTools(runs[0].id), secretsFenced: ctx.store.runFence(runs[0].id)?.method ?? null },
                     decisionsOpen,
+                    // Operator steering (v120), in the task page's words: read (and when), waiting, or for the next attempt.
+                    steering: (() => {
+                        const live = ctx.store.steeringLiveBuild(ref.id, ctx.now) !== null;
+                        return ctx.store.listSteerNotes(ref.id).slice(-5).map(one => ({ note: one.id, filedAt: one.createdAt, state: steerStandingWords(one, live, utcMinute) }));
+                    })(),
+                    // Live steering: the running Claude build a note reaches in seconds and a pause can reach, and its pause.
+                    liveBuild: (() => {
+                        const run = ctx.store.liveInputRun(ref.id, ctx.now);
+                        if (run === null)
+                            return null;
+                        const pause = ctx.store.livePauseOf(run);
+                        const until = pause?.state === "paused" && pause.pausedAt !== null && pause.limitMs !== null ? new Date(Date.parse(pause.pausedAt) + pause.limitMs).toISOString() : null;
+                        return { build: run, pause: pause?.state ?? null, ...(until === null ? {} : { pausedUntil: until }) };
+                    })(),
+                    // The running agent's open questions (Agents board): reply with propose_steer and its question id.
+                    agentQuestions: openAgentQuestions(ctx.store, ref.id).map(one => ({ question: one.id, key: one.key, asks: one.question, askedAt: one.askedAt })),
                 },
             };
         },
@@ -1691,23 +1710,44 @@ const LEAD_TOOL_HANDLERS = {
         },
     },
     propose_steer: {
-        description: "Guide the next attempt within existing scope; never interrupt work.",
+        description: "Send guidance within existing scope: a running Claude build gets it in seconds, another running build reads it when it next checks for notes, otherwise the next attempt does. mode pause stops a running Claude build's current turn and keeps the build (its next note continues it); pause-and-steer pauses, then sends the note; resume continues a paused build without a note. None stops work; get_task liveBuild says when a pause or resume is possible. With question (from get_task agentQuestions, mode note) the note is the reply to that open question.",
         handle: (ctx, args) => {
             const taskId = taskIdOf(args);
             const ref = taskId === null ? null : admittedRef(ctx, taskId);
             const task = taskId === null ? null : ctx.store.getTask(taskId);
             if (taskId === null || ref === null || task === null)
                 return notFound();
-            if (typeof args["note"] === "string" && args["note"].length > LIMITS.note)
-                return { ok: false, message: `guidance is ${args["note"].length} characters; the limit is ${LIMITS.note}. Shorten it and propose again.` };
-            if (!honest(args["note"], LIMITS.note))
-                return { ok: false, message: `guidance is plain text up to ${LIMITS.note} characters` };
+            const mode = args["mode"] === "pause" || args["mode"] === "pause-and-steer" || args["mode"] === "resume" ? args["mode"] : "note";
+            if (mode !== "pause" && mode !== "resume") {
+                if (typeof args["note"] === "string" && args["note"].length > LIMITS.note)
+                    return { ok: false, message: `guidance is ${args["note"].length} characters; the limit is ${LIMITS.note}. Shorten it and propose again.` };
+                if (!honest(args["note"], LIMITS.note))
+                    return { ok: false, message: `guidance is plain text up to ${LIMITS.note} characters` };
+            }
             if (task.state === "done" || task.state === "cancelled")
                 return { ok: false, message: "that task is finished, so guidance has no next attempt to reach" };
-            const id = ctx.draft("steer", { task: taskId, taskTitle: task.title, repoId: ref.repoId, note: args["note"] });
+            // A pause binds to the build running now: confirming it later reaches that build or none.
+            const sawRun = mode === "note" ? null : ctx.store.liveInputRun(ref.id, ctx.now);
+            if (mode !== "note" && sawRun === null)
+                return { ok: false, message: `that task has no running Claude build to ${mode === "resume" ? "resume" : "pause"}; send the guidance as a note instead` };
+            if (mode === "resume" && ctx.store.pauseStateOf(sawRun) !== "paused")
+                return { ok: false, message: "that task's build isn't paused, so there is nothing to resume" };
+            // A reply names exactly one open question of this task's running agent; the confirmation re-checks it. A reply is
+            // an ordinary note (the confirmation files it through the question's own door), so it never rides a pause or resume.
+            if (typeof args["question"] === "number" && mode !== "note")
+                return { ok: false, message: "a reply to the agent's question is sent as a note; propose it without mode" };
+            const asked = typeof args["question"] === "number" ? agentQuestion(ctx.store, args["question"]) : null;
+            if (typeof args["question"] === "number" && (asked === null || asked.taskRef !== ref.id || asked.closedAt !== null))
+                return { ok: false, message: "that question is no longer open; read get_task agentQuestions again" };
+            const id = ctx.draft("steer", {
+                task: taskId, taskTitle: task.title, repoId: ref.repoId,
+                ...(mode === "pause" || mode === "resume" ? {} : { note: args["note"] }),
+                ...(mode === "note" ? {} : { mode, sawRun, request: `lead-${randomUUID()}` }),
+                ...(asked === null ? {} : { question: asked.id, questionKey: asked.key }),
+            });
             if (id === null)
                 return tooMany();
-            return { ok: true, body: { proposal: id, kind: "steer", task: taskId, awaiting: "the operator's confirmation" } };
+            return { ok: true, body: { proposal: id, kind: "steer", task: taskId, mode, awaiting: "the operator's confirmation" } };
         },
     },
     propose_dependency_repair: {

package/dist/live-input.d.ts

@@ -0,0 +1,68 @@
+/** The child's stdin, as the transport hands it over. */
+export type LiveInputIo = {
+    write(line: string): void;
+    end(): void;
+};
+/** Why stdin closed: the handoff was written, the session had nothing more owed, the turn budget ran out, a paused
+ * session reached the idle limit, the process ended first, or a write failed. */
+export type LiveCloseReason = "finished" | "settled" | "turn-budget" | "paused-idle" | "ended" | "input-failed";
+/** What Resume sends a paused session: only a nudge to go on, never a note. */
+export declare const CONTINUE_TEXT = "continue";
+export type LiveInputOptions = {
+    /** Toolroll's total for the whole session: distinct assistant turns across every message. */
+    maxTurns: number;
+    /** The agent wrote its handoff (done, park or a plan revision): a turn that ends now closes stdin. */
+    finished?: () => boolean;
+    /** stdin is attached and the brief was written. */
+    onOpen?: () => void;
+    onClose?: (why: LiveCloseReason) => void;
+    /** The current turn stopped for a Pause (the harness confirmed the interrupt, or the turn's result arrived). */
+    onPaused?: () => void;
+};
+/** A stdin user frame, in the shape the harness reads. */
+export declare const userFrame: (text: string, uuid: string) => string;
+/** A stdin interrupt: stop the current turn, keep the session. */
+export declare const interruptFrame: (requestId: string, cancelQueued?: boolean) => string;
+export declare class LiveInput {
+    #private;
+    readonly maxTurns: number;
+    /** The brief's frame uuid, once begun. */
+    briefUuid: string | null;
+    constructor(options: LiveInputOptions);
+    /** Queue the brief as the first frame. Once, before the process is attached. */
+    begin(brief: string, uuid?: string): void;
+    /** The transport spawned the child with stdin piped: write what is queued, brief first. */
+    attach(io: LiveInputIo): void;
+    /** stdin is attached and still open: a note reaches the agent in seconds, and a Pause can stop its turn. */
+    get open(): boolean;
+    get paused(): boolean;
+    /** Distinct assistant turns so far, across every message. */
+    get turns(): number;
+    /** Why stdin closed, once it has. */
+    get closeReason(): LiveCloseReason | null;
+    /**
+     * Send a note (or anything the session should read next). A paused session continues. False once stdin is closed.
+     * Mid-turn, the harness folds it into the running turn; after an interrupt that turn is over, so the frame starts a
+     * turn of its own whose result is owed before stdin closes.
+     */
+    send(text: string, uuid: string): boolean;
+    /** Resume a paused session with a short continue frame and no note. "not-paused" when nothing waits to go on. */
+    resume(uuid: string): "sent" | "not-paused" | "closed";
+    /**
+     * The transport's idle limit was reached. A paused session closes stdin instead of being killed — the harness exits
+     * and the build settles from whatever handoff it saved — and true asks the watchdog to wait once more for that exit.
+     * Anything else is an ordinary idle timeout.
+     */
+    idleLimit(): boolean;
+    /**
+     * Pause: stop the current turn, keep the session. "sent" when an interrupt was written; "idle" when no turn was
+     * running (the session is already waiting, so it is paused as it stands); "closed" when stdin is gone.
+     */
+    interrupt(requestId: string): "sent" | "idle" | "closed";
+    /** Every parsed stdout event, in order. */
+    observe(event: Record<string, unknown>): void;
+    /** Close stdin: the harness finishes what it has and exits. Further sends refuse. */
+    close(why: LiveCloseReason): void;
+    /** The process ended (or its stdin failed): nothing more is written. */
+    detach(why?: "ended" | "input-failed"): void;
+}