toolroll 0.9.58 → 0.9.60

package/dist/flow-actions.js

@@ -21,7 +21,6 @@
 import { createHash } from "node:crypto";
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import nodemailer from "nodemailer";
 import { redactSecretAssignments } from "./builder.js";
 import { redactSecretLines, scanForSecrets } from "./evidence.js";
 import { fillFlowText } from "./flows.js";
@@ -132,6 +131,8 @@ export async function sendingAccount(dir, fetcher) {
 }
 /** The production sender: the operator's mail server through nodemailer. */
 export const sendThroughServer = async (settings, mail) => {
+    // nodemailer loads when mail is sent, not with every command that imports this module.
+    const { default: nodemailer } = await import("nodemailer");
     const transport = nodemailer.createTransport({
         // A password never travels unencrypted: with a sign-in, the connection must be (or become) TLS.
         host: settings.host, port: settings.port, secure: settings.secure, requireTLS: !settings.secure && settings.user !== "",

package/dist/guides.js

@@ -208,22 +208,25 @@ runner never pushes, merges, or opens pull requests itself.
 const steering = {
     name: "steering",
     title: "Steering a task",
-    oneLiner: "an operator ceremony: credentialed notes read before the next attempt — agents cannot file one",
+    oneLiner: "an operator ceremony: credentialed notes a running build reads when it next checks for notes, or the next attempt — agents cannot file one",
     content: `# Steering a task
 
 ${AUTHORITY_LINE}
 
 Steering is an OPERATOR ceremony. \`task steer <id> --note "..." --as
-<you> --token <t>\` files one note (≤4000 characters) for the
-task's NEXT attempt, and the credential is the point: the note appears
-in the agent's brief under an OPERATOR STEERING heading, so only a
-verified person may put words there. Anonymous or agent-authored notes
-are refused outright.
-
-- Delivery is recorded: the task page shows whether a note is waiting,
-  attached to an attempt, or was read. A running agent is never
-  interrupted — notes wait for the next natural boundary (a repair, a
-  resume after a parked decision, a fresh attempt, a revision).
+<you> --token <t>\` files one note (≤4000 characters) for the task's
+agent, and the credential is the point: the note reaches the agent as
+operator guidance, so only a verified person may put words there.
+Anonymous or agent-authored notes are refused outright.
+
+- While a build's agent is running, the note is put in its steering
+  folder; the agent reads it when it next checks for notes and moves it
+  to handled/, which is the only thing that marks it read. Otherwise —
+  or if the agent finishes before reading it — the next attempt's brief
+  quotes it under an OPERATOR STEERING heading.
+- Each note says where it stands, the same on the task page, in
+  \`task show\` and to the lead: waiting for the agent to read it, read
+  by the agent at a time, or will reach the next attempt.
 - A note is guidance INSIDE the approved scope. It cannot widen scope,
   approve anything, or replace the ceremony a change of scope needs.
 - Refusals: missing credential is usage; a wrong credential is

package/dist/lead-cli.js

@@ -1,4 +1,5 @@
 import { configureLeadFollow, leadFollowStatus } from './lead-follow.js';
+import { closedQuestionWords } from "./decision.js";
 /**
  * `toolroll chat` (mate arc §6): the same thread the console shows,
  * driven from a terminal. The password is typed once — it mints the lead
@@ -45,6 +46,8 @@ export function answerContextLines(store, payload) {
     const decision = id === null ? null : store.getDecision(id);
     if (decision === null)
         return ["     (the decision is gone)"];
+    if (decision.supersededReason !== null)
+        return [`     ${decision.question}`, `     ${closedQuestionWords(decision.supersededReason)}`];
     const pick = typeof payload["option"] === "string" ? payload["option"] : "";
     return [
         `     ${decision.question}${decision.state !== "open" ? ` [${decision.state}]` : ""}`,
@@ -68,7 +71,7 @@ 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 === "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")}`
                                 :

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 when it next checks for notes, else the next attempt; get_task steering says if it was read. 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

@@ -14,6 +14,8 @@ import { executeSharedAction, sharedActionPayload, sharedActionAllowsChallenge,
  * scope was rewritten, the decision answered) is a refusal, never a
  * 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 { isVerifiedApprover, reproveApprover } from "./principal.js";
@@ -57,7 +59,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
@@ -317,6 +319,8 @@ function executeProposal(store, actor, kind, payload, now, options) {
             return refuse("stale", "that option no longer exists on the decision");
         // The proposal contract is "open": a decision past its deadline — swept
         // or not — is not answered through a card (v3 review, finding 7).
+        if (decision.supersededReason !== null)
+            return refuse("stale", closedQuestionWords(decision.supersededReason));
         if (decision.state === "answered")
             return refuse("already-answered", "already answered — somebody got there first");
         if (decision.state !== "open" || (decision.deadline !== null && Date.parse(decision.deadline) <= now.getTime())) {
@@ -418,7 +422,9 @@ 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;
+        return { ok: true, kind, said: `Guidance saved for ${taskName}. ${steerDestinationWords(live)}`, 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,8 @@ 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 { 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$/;
@@ -284,12 +286,13 @@ export function decisionOver(store, repos, decisionId, now) {
         return null;
     // "Open" is derived, not stored (v3 review, finding 7): a decision past
     // its deadline is expired here whether or not the sweep has run.
-    const state = decision.state === "open" && decision.deadline !== null && Date.parse(decision.deadline) <= now.getTime() ? "expired" : decision.state;
+    const state = decision.supersededReason !== null ? "closed" : decision.state === "open" && decision.deadline !== null && Date.parse(decision.deadline) <= now.getTime() ? "expired" : decision.state;
     return {
         repoIndex,
         decision: decision.id,
         task: ref.externalId,
         state,
+        ...(decision.supersededReason === null ? {} : { closedBecause: decision.supersededReason }),
         question: decision.question,
         options: decision.options.map(one => ({ id: one.id, label: one.label, reversible: one.reversible, consequence: one.consequence })),
         ageHours: Math.max(0, Math.round((now.getTime() - Date.parse(decision.createdAt)) / 3_600_000)),
@@ -1491,7 +1494,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)
@@ -1537,6 +1540,11 @@ 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) }));
+                    })(),
                 },
             };
         },
@@ -1690,7 +1698,7 @@ 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 build's agent reads it when it next checks for notes, otherwise the next attempt does. It never stops work.",
         handle: (ctx, args) => {
             const taskId = taskIdOf(args);
             const ref = taskId === null ? null : admittedRef(ctx, taskId);

package/dist/mailbox.js

@@ -15,8 +15,6 @@
  * answering machines. The card keeps the message's ID so a Send email step
  * replying to the sender stays in the same thread.
  */
-import { ImapFlow } from "imapflow";
-import { simpleParser } from "mailparser";
 import { googleAccessToken, googleConnected } from "./google-mail.js";
 import { readEmailSettings } from "./email-settings.js";
 const BODY_CHARS = 4000;
@@ -72,6 +70,8 @@ const header = (headers, name) => {
 };
 /** One raw message as plain words, and whether a machine sent it. */
 export async function readMail(uid, source) {
+    // The mail SDKs load when mail is read, not with every command that imports this module.
+    const { simpleParser } = await import("mailparser");
     const parsed = await simpleParser(source, { skipImageLinks: true, skipTextToHtml: true, skipTextLinks: true });
     const sender = parsed.from?.value[0];
     const from = (sender?.address ?? "").toLowerCase();
@@ -103,6 +103,7 @@ function problemOf(error) {
 }
 /** The production reader: one read-only IMAP visit. */
 export const readThroughImap = async (access, folder, after, limit) => {
+    const { ImapFlow } = await import("imapflow");
     const client = new ImapFlow({
         host: access.host, port: access.port, secure: access.secure, logger: false, disableAutoIdle: true,
         auth: access.accessToken !== undefined ? { user: access.user, accessToken: access.accessToken } : { user: access.user, pass: access.password ?? "" },

package/dist/mcp-core.js

@@ -56,7 +56,7 @@ const CONTRACT_GUIDE = [
     "recap, list_decisions, get_decision, and queue are the plane's own read queries (shared with the operator's mate). get_decision shows each option's consequence, never the builder's recommendation.",
     "propose_next, propose_reserve, propose_hold, propose_unhold, propose_scope, propose_cancel, and propose_answer write a PROPOSAL row and nothing else: an approver confirms it on the console or the CLI, and a stale one refuses there. Proposals share your hourly filing rate and hold at most 20 pending per credential; they expire after seven days.",
     "Approve, steer, answer, pick, mint, configure, merge: those verbs do not exist on this surface, by construction.",
-    "Claim one assignment, then follow list_assignment_updates with a saved cursor; inspect get_assignment when a current result or decision needs attention. claim_assignment records its lead; acknowledge_assignment records that lead's check of an exact ready receipt. Neither operation grants authority, accepts proof, answers decisions, approves work, publishes, or deploys.",
+    "Claim one assignment, then receive its changes with get_assignment_inbox and acknowledge each handled batch with acknowledge_assignment_delivery; inspect get_assignment when a current result or decision needs attention. list_assignment_updates is only the history of handoffs sent to people. claim_assignment records its lead; acknowledge_assignment records that lead's check of an exact ready receipt. Neither operation grants authority, accepts proof, answers decisions, approves work, publishes, or deploys.",
 ].join("\n");
 /** An assignment tool: the adapter reads its call with the same schema `toolroll assignment` does. */
 const assignmentHandler = (operation) => (ctx, args) => {

package/dist/needs-you.js

@@ -20,7 +20,9 @@ export const NEEDS = {
     hold: { sentence: () => "A hold is keeping this task from starting. Review it to release it.", action: { code: "inspect-hold", label: "Review hold" } },
     "choose-project": { sentence: () => "Choose a project so a builder can start.", action: { code: "place-task", label: "Choose a project" } },
     "define-task": { sentence: () => "Say what the task should do so it can be planned.", action: { code: "write-scope", label: "Define the task" } },
-    "fix-request": { sentence: () => "The request can't be planned as written. Edit it so the planner can start.", action: { code: "write-scope", label: "Edit the request" } },
+    "fix-request": { sentence: () => "The request can't be planned as written. Edit it so the planner can start.", action: { code: "write-scope", label: "Edit the request" },
+        // Its own size and limit say exactly what to shorten.
+        useReason: reason => /the planner can carry at most/.test(reason) },
     "choose-agent": { sentence: () => "Choose an agent to build this.", action: { code: "select-agent", label: "Choose an agent" } },
     "fix-dependency": { sentence: () => "A task this one waits on didn't finish. Fix or remove it so this one can start.", action: { code: "repair-dependency", label: "Fix the required task" },
         useReason: reason => /didn't finish|did not finish|before it finished/i.test(reason), withReason: reason => `${reason.replace(/[.\s]*$/, ".")} Fix or remove it so this one can start.` },