toolroll 0.5.0 → 0.7.0

package/dist/browser-workspace.d.ts

@@ -241,6 +241,31 @@ export type BrowserSettingsView = {
             redirect: string | null;
         };
     } | null;
+    /** Settings → Updates: this version, the latest known one and its notes, how to update, the daily-check switch, and each worker's version. */
+    updates?: BrowserUpdates | null;
+};
+export type BrowserUpdates = {
+    current: string;
+    /** The latest release the last check found; null before any check has worked. */
+    latest: {
+        version: string;
+        newer: boolean;
+        security: boolean;
+        notes: string;
+        url: string;
+    } | null;
+    updateCommand: string;
+    /** The daily check: off by TOOLROLL_NO_UPDATE_CHECK (byEnv) or by this switch; only an operator may flip it. */
+    check: {
+        on: boolean;
+        byEnv: boolean;
+        canManage: boolean;
+    };
+    workers: {
+        name: string;
+        version: string | null;
+        older: boolean;
+    }[];
 };
 /** A fold on the task page. Its HTML is the server's own section body, so
  * forms, ids and page scripts are unchanged. */
@@ -754,6 +779,27 @@ export type BrowserWorkspace = {
     view?: BrowserView | null;
     /** A live page (Inbox, System…) reads itself again this often; forms being edited are kept. */
     refreshSeconds?: number;
+    /** Providers whose sign-in stopped working: their work waits (one per provider). */
+    signIn?: BrowserSignIn[];
+    /** A newer Toolroll exists: a quiet notice for an operator, until they dismiss this version. */
+    update?: BrowserUpdateNotice;
+};
+/** The console's update notice: neutral, never the accent — an update does not need a person. */
+export type BrowserUpdateNotice = {
+    version: string;
+    security: boolean;
+    href: string;
+    dismissHref: string;
+};
+/** A provider's sign-in pause, as the console shows it: the plain reason,
+ * what to run, and the one action that resumes its work. */
+export type BrowserSignIn = {
+    provider: string;
+    title: string;
+    command: string;
+    detail: string;
+    resumeLabel: string;
+    resumeHref: string;
 };
 /** Safe inside a script[type=application/json] element. JSON escaping alone
  * does not stop the HTML parser from closing that element at </script>. */

package/dist/builder.d.ts

@@ -165,7 +165,9 @@ export type BuildResult = {
 };
 export type BuildRefusal = "skills-unavailable"
 /** Sprint 8: the organisation policy stops this provider, model or permission level. */
- | "policy" | "unapproved" | "scope-changed" | "stale-approval" | "mode-ended" | "stale-authorization" | "attended-only" | "session-cap" | "attended-held" | "attended-unsupported" | "run-held" | "spawn-failed" | "capability" | "no-claim" | "not-yours" | "not-leased" | "protected-branch" | "wrong-branch" | "moved-branch" | "fenced" | "agent" | "agent-reported" | "no-op" | "moved-head" | "timeout" | "git" | "commit-failure" | "malformed-decision" | "provider-init" | "setup" | "revision-brief" | "external" | "stopped" | "plan-revised" | "plan-revision-blocked" | "provider-unattested" | "provider-protocol" | "chain-credential" | "chain-custody" | "runner-custody" | "auth-mode" | "route-authority" | "containment";
+ | "policy" | "unapproved" | "scope-changed" | "stale-approval" | "mode-ended" | "stale-authorization" | "attended-only" | "session-cap" | "attended-held" | "attended-unsupported" | "run-held" | "spawn-failed" | "capability" | "no-claim" | "not-yours" | "not-leased" | "protected-branch" | "wrong-branch" | "moved-branch" | "fenced" | "agent" | "agent-reported" | "no-op"
+/** Run 2085: the agent stopped before its handoff; its work was kept for the retry. */
+ | "no-handoff" | "moved-head" | "timeout" | "git" | "commit-failure" | "malformed-decision" | "provider-init" | "setup" | "revision-brief" | "external" | "stopped" | "plan-revised" | "plan-revision-blocked" | "provider-unattested" | "provider-protocol" | "chain-credential" | "chain-custody" | "runner-custody" | "auth-mode" | "route-authority" | "containment";
 /** Long enough for real work; short enough that a stuck build ends the same night. */
 export declare const DEFAULT_BUILD_TIMEOUT_MS: number;
 export declare const DEFAULT_MAX_TURNS = 40;
@@ -351,6 +353,21 @@ export declare function settleProviderOutcome(captured: CapturedBuild, result: A
  * old name of every rename git paired (provenance, never a path). Anything
  * missing, failed, tampered or unparseable reads as not captured. */
 export declare function sealedDiffStatFacts(store: Store, root: string, statArtifactId: number): DiffStatFacts | null;
+/**
+ * Read the mailbox, if the agent wrote one, and turn it into a package the
+ * caller can seal — or a problem list repair can work from.
+ *
+ * The payload is preserved as evidence *before* it is judged: a malformed
+ * park is still a person's best clue to what the agent meant, and the raw
+ * bytes leave the worktree either way — ingested once, then removed, so no
+ * later attempt can mistake them for its own agent's voice.
+ */
+/** What a person reads when an attempt stopped before its handoff (run 2085). */
+export declare const NO_HANDOFF_WORDS = "The agent stopped before handing off; its work was kept and it is being resumed.";
+/** The body of the work-in-progress commit an unresumable no-handoff attempt leaves on its branch. */
+export declare const WIP_COMMIT_WORDS = "Work in progress: the agent stopped before handing off. Kept so the next attempt continues from it.";
+/** The short turn a stopped agent's own session is resumed with. */
+export declare function handoffResumePrompt(done: string): string;
 /**
  * What a non-zero agent exit means, in words a person can act on: the
  * harness's own result line names the ending (a turn ceiling, an error

package/dist/builder.js

@@ -35,14 +35,14 @@ import { PREPARED_EVIDENCE_FILE, PREPARED_EVIDENCE_GIT, preparedScreenshotMatche
  * watchdog and a high runaway-turn breaker still stop a pathological loop;
  * repair remains narrowly time-bounded because its job is narrowly scoped.
  */
-import { unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { run, runOwnerTag } from "./exec.js";
 import { stopRequestedFor, stopWords, underStopWatch } from "./task-control.js";
 import { witnessedRunner } from "./process-custody.js";
 import { runWithIsolatedDatabase } from "./child-database.js";
-import { recordWorktreeProcess } from "./worktree.js";
+import { recordWorktreeProcess, saveWorkPatch } from "./worktree.js";
 import { approvalOf, digestOf, profileDigestOf, chainDigestOf, entryDigestOf, routeParityProblem, profileFromJson } from "./scope.js";
 import { legOf, routeDigestOf, routeFromJson } from "./phase-routing.js";
 import { execFileSync } from "node:child_process";
@@ -50,7 +50,7 @@ import { currentClaim, finalizeRevisionFenced, heartbeat, SYNC_MAX_AGE_MS } from
 import { missingCapability } from "./dispatch.js";
 import { heartbeat as runnerHeartbeat } from "./runner.js";
 import { MARKER as LEASE_MARKER } from "./worktree.js";
-import { parseDecision, parseHandoff, repairPrompt, HANDOFF_CONCLUSION_CAP, HANDOFF_ITEM_CAP, HANDOFF_LIST_CAP, HANDOFF_PAYLOAD_CAP } from "./decision.js";
+import { parseDecision, parseHandoff, repairPrompt, HEADLESS_RULE, HANDOFF_CONCLUSION_CAP, HANDOFF_ITEM_CAP, HANDOFF_LIST_CAP, HANDOFF_PAYLOAD_CAP } from "./decision.js";
 import { createHash, randomUUID } from "node:crypto";
 import { invokeAgent } from "./invoke.js";
 import { TELEGRAM_TOKEN_ENVS } from "./names.js";
@@ -1540,6 +1540,13 @@ export async function settleProviderOutcome(captured, result) {
     if (result.sessionId !== null) {
         store.stampRun(request.runId, { sessionId: result.sessionId });
     }
+    // The unfinished handoff (run 2085): the agent ended its turn with work in
+    // the tree and no handoff, park or proposal. Its own session is resumed in
+    // this same worktree for a short turn to finish and hand off, before the
+    // ordinary settlement below reads whatever that turn produced.
+    const resumed = await resumeUnhandedWork(captured, result.sessionId ?? undefined);
+    if (resumed !== null)
+        return resumed;
     // The adaptive-execution-plan settlement, checked at exactly the point
     // park is: both are "stop without committing" endings, and both must be
     // decided before the handoff is required of the agent at all.
@@ -1631,6 +1638,11 @@ export async function settleProviderOutcome(captured, result) {
         // Missing or unremovable — either way the sweep and the commit-path
         // exclusions keep it out of anybody's repository.
     }
+    if (!spoken.ok && spoken.missing) {
+        const kept = await keepUnhandedWork(captured, result.sessionId ?? undefined);
+        if (kept !== null)
+            return kept;
+    }
     if (!spoken.ok) {
         return {
             ok: false,
@@ -1757,7 +1769,8 @@ export async function settleProviderOutcome(captured, result) {
         return { ok: true, committed: false, noChange: true, branch, summary: handoff.conclusion };
     }
     // completed
-    if (dirty.length === 0) {
+    const finishesKeptWork = dirty.length === 0 && await startsFromKeptWork(captured, baseRevision, pinnedBase);
+    if (dirty.length === 0 && !finishesKeptWork) {
         return {
             ok: false,
             reason: "no-op",
@@ -1775,7 +1788,11 @@ export async function settleProviderOutcome(captured, result) {
         };
     }
     store.setRunPhase(request.runId, "committing");
-    const made = await commit(git, worktree, branch, taskId, scope, handoff.conclusion, request.attended === undefined ? scope?.candidate ?? null : null);
+    // Kept work that is already complete is already committed: the attempt's
+    // result is that commit, sealed below against the task's original base.
+    const made = finishesKeptWork
+        ? await keptWorkResult(captured, baseRevision, handoff.conclusion)
+        : await commit(git, worktree, branch, taskId, scope, handoff.conclusion, request.attended === undefined ? scope?.candidate ?? null : null);
     if (made.ok && made.parked === undefined && made.committed) {
         const newHead = await git(GIT, ["--no-optional-locks", "rev-parse", "HEAD"], { cwd: worktree });
         if (newHead.code === 0) {
@@ -2442,6 +2459,160 @@ function screenshotFileTag(path) {
  * bytes leave the worktree either way — ingested once, then removed, so no
  * later attempt can mistake them for its own agent's voice.
  */
+/** What a person reads when an attempt stopped before its handoff (run 2085). */
+export const NO_HANDOFF_WORDS = "The agent stopped before handing off; its work was kept and it is being resumed.";
+/** The body of the work-in-progress commit an unresumable no-handoff attempt leaves on its branch. */
+export const WIP_COMMIT_WORDS = "Work in progress: the agent stopped before handing off. Kept so the next attempt continues from it.";
+/**
+ * Whether this attempt starts from the work-in-progress commit an earlier
+ * no-handoff attempt of this task left (keepUnhandedWork), with changes
+ * against the task's original base. That commit's changes are the unfinished
+ * work this attempt was sent to finish, so they count as its own: an agent
+ * that finds them complete and hands off `completed` with a clean tree has
+ * done the work, not claimed work it never did.
+ */
+async function startsFromKeptWork(captured, baseRevision, pinnedBase) {
+    const { store, request, git, worktree, branch } = captured;
+    if (pinnedBase === baseRevision)
+        return false;
+    const kept = store.runsFor(request.taskRef).some(one => one.id < request.runId && one.role === "builder" && one.branch === branch && one.outcome === "failed" && one.reason === "no-handoff");
+    if (!kept)
+        return false;
+    const message = await git(GIT, ["--no-optional-locks", "log", "-1", "--format=%B", baseRevision], { cwd: worktree });
+    if (message.code !== 0 || !message.stdout.includes(WIP_COMMIT_WORDS))
+        return false;
+    // --quiet exits 1 exactly when the two sides differ.
+    const changed = await git(GIT, ["--no-optional-locks", "diff", "--quiet", pinnedBase, baseRevision, "--"], { cwd: worktree });
+    return changed.code === 1;
+}
+/** The accepted result of an attempt that finished kept work with nothing left to change. An exact prepared candidate must still match it. */
+async function keptWorkResult(captured, head, summary) {
+    const { git, worktree, branch, request, scope } = captured;
+    const candidate = request.attended === undefined ? scope?.candidate ?? null : null;
+    if (candidate !== null) {
+        const exact = await git(GIT, ["--no-optional-locks", "diff", "--quiet", candidate, head, "--"], { cwd: worktree });
+        if (exact.code !== 0)
+            return { ok: false, reason: "commit-failure", message: exact.code === 1
+                    ? "The kept work-in-progress commit does not match the approved prepared candidate. The checkout is preserved."
+                    : "The kept work-in-progress commit could not be checked against the approved prepared candidate. The checkout is preserved." };
+    }
+    return { ok: true, committed: true, branch, summary };
+}
+/** The short turn a stopped agent's own session is resumed with. */
+export function handoffResumePrompt(done) {
+    return [
+        `Your last turn ended before the handoff. Finish the task and write ${done}.`,
+        "Every rule from the original brief still applies.",
+        ...HEADLESS_RULE,
+    ].join("\n");
+}
+/** The agent's work in the tree: protocol files and the lease note aside. Null when git cannot say. */
+async function unhandedChanges(git, worktree) {
+    const status = await git(GIT, ["--no-optional-locks", "status", "--porcelain"], { cwd: worktree });
+    if (status.code !== 0)
+        return null;
+    return status.stdout
+        .split("\n")
+        .filter(line => line.trim() !== "" &&
+        !line.trimEnd().endsWith(LEASE_MARKER) &&
+        !(line.startsWith("?? ") && looksLikeProtocolFile(line.slice(3))));
+}
+/** Whether this attempt's own session can be resumed in place. */
+function canResumeSession(captured, sessionId) {
+    return sessionId !== undefined && sessionId.trim() !== "" && auditOf(captured.request.provider ?? "claude").resume === "native";
+}
+/**
+ * Resume the agent's own session when it ended its turn with changes but no
+ * handoff, park or plan proposal (run 2085: tests left running in the
+ * background, a wakeup scheduled, the headless process gone). Each turn is a
+ * repair-role child run under the same admission and budget as a park
+ * repair, in the same worktree, with the build's own limits: finishing the
+ * task can need a full check run. Nothing here reads or accepts a handoff —
+ * the ordinary settlement does that afterwards, unweakened.
+ */
+async function resumeUnhandedWork(captured, sessionId) {
+    const { store, request, agent, git, worktree, mailbox, done, effective, clock, taskId } = captured;
+    const waiting = () => !existsSync(join(worktree, done)) &&
+        !existsSync(join(worktree, mailbox)) &&
+        (captured.plan === undefined || !existsSync(join(worktree, captured.plan.proposal)));
+    // A watched (attended) session has an operator; nothing resumes it headless.
+    if (request.attended !== undefined || !waiting() || !canResumeSession(captured, sessionId))
+        return null;
+    const changes = await unhandedChanges(git, worktree);
+    if (changes === null || changes.length === 0)
+        return null;
+    const provider = request.provider ?? "claude";
+    const model = repairModelOf(effective.profile, request);
+    for (let turn = 0; turn < REPAIR_TURNS && waiting(); turn++) {
+        if (stopRequestedFor(store, request.runId, request.shouldStop))
+            return null;
+        if (request.leaseId !== undefined && !heartbeat(store, request.leaseId, clock()).ok) {
+            return { ok: false, reason: "fenced", message: `${taskId}'s lease did not survive the resumed turn — the work is still in ${worktree}` };
+        }
+        if (store.budgetGate(clock())({ ...store.budgetSubject(request.taskRef), agents: [{ provider, billing: store.runBilling(request.runId) ?? store.agentsFor([provider])[0].billing }] }).over !== null)
+            break;
+        if (store.agentPolicyRefusal(provider, model ?? null) !== null)
+            break;
+        const admitted = admitProtocolRepair(store, request, effective.profile, sessionId, clock);
+        if (!admitted.ok)
+            break;
+        const spoken = await invokeAgent(store, admitted.runId, { provider, model }, {
+            phase: "build",
+            brief: handoffResumePrompt(done),
+            maxTurns: effective.maxTurns ?? request.maxTurns ?? DEFAULT_MAX_TURNS,
+            permissionMode: effective.profile.provider === "claude" && effective.profile.permissionArgv !== "bypassPermissions"
+                ? effective.profile.permissionArgv
+                : (request.permissionMode ?? "auto"),
+            skipPermissions: effective.skipPermissions,
+            resumeSession: sessionId,
+            // The build's own spend cap holds for the turn that finishes it.
+            ...(request.maxBudgetUsd === undefined ? {} : { maxBudgetUsd: request.maxBudgetUsd }),
+        }, {
+            cwd: worktree,
+            ...(effective.profile.timeoutKind === "idle" ? { idleTimeoutMs: effective.timeoutMs } : { timeoutMs: effective.timeoutMs }),
+            omitEnv: AGENT_ENV_DENYLIST,
+            ...(agent === undefined ? {} : { runner: agent }),
+            ...(request.onProviderSpawn === undefined ? {} : { onSpawn: request.onProviderSpawn }),
+            clock,
+        });
+        const handedOff = !waiting();
+        const ran = spoken.kind === "ran" && !spoken.outcome.timedOut && spoken.outcome.code === 0 && !spoken.outcome.initFailed;
+        store.finishRun(admitted.runId, {
+            outcome: handedOff && ran ? "built" : "failed",
+            reason: spoken.kind === "refused" ? spoken.reason : handedOff ? "resumed-handoff" : ran ? "no-handoff" : spoken.outcome.timedOut ? "timeout" : "agent",
+            now: clock(),
+        });
+        if (request.leaseId !== undefined && !heartbeat(store, request.leaseId, clock()).ok) {
+            return { ok: false, reason: "fenced", message: `${taskId}'s lease did not survive the resumed turn — the work is still in ${worktree}` };
+        }
+    }
+    return null;
+}
+/**
+ * The attempt ended without a handoff, even after any resumed turn. When it
+ * left changes, they are never discarded: first saved as a patch in this
+ * run's evidence folder, then — when its session cannot be resumed — kept as
+ * a work-in-progress commit on the branch the next attempt continues from.
+ * Otherwise they stay in place, and the next lease keeps them for the retry.
+ * Null when there was nothing to keep: the ordinary no-op words apply.
+ */
+async function keepUnhandedWork(captured, sessionId) {
+    const { store, request, git, worktree, branch, taskId, scope, root, clock } = captured;
+    const changes = await unhandedChanges(git, worktree);
+    if (changes === null || changes.length === 0)
+        return null;
+    const saved = await saveWorkPatch(git, worktree, join(root, String(request.runId), "unhanded-work.patch"), `# work left without a handoff in ${worktree}\n# kept ${clock().toISOString()}\n`);
+    if (!saved.ok) {
+        return { ok: false, reason: "no-handoff", message: `${NO_HANDOFF_WORDS} Its changes stay uncommitted in ${worktree}; ${saved.message}.` };
+    }
+    if (request.attended === undefined && !canResumeSession(captured, sessionId) && scope !== null && !stopRequestedFor(store, request.runId, request.shouldStop)) {
+        const made = await commit(git, worktree, branch, taskId, scope, WIP_COMMIT_WORDS);
+        if (made.ok && "committed" in made && made.committed) {
+            return { ok: false, reason: "no-handoff", message: `${NO_HANDOFF_WORDS} It was saved as a work-in-progress commit on ${branch}.` };
+        }
+    }
+    return { ok: false, reason: "no-handoff", message: NO_HANDOFF_WORDS };
+}
 async function ingestPark(args) {
     const { store, request, agent, git, worktree, mailbox, baseRevision, root } = args;
     const path = join(worktree, mailbox);
@@ -2958,6 +3129,7 @@ planRevision = null) {
         `- You are on branch ${branch}. Do not switch branches, and never commit to main.`,
         "- Do not push, open a pull request, or run any network write.",
         "- Stay inside this worktree.",
+        ...HEADLESS_RULE,
         ...(revisionBrief === null ? [] : [
             "- If the sealed revision kind is evidence-observation, collect observations only.",
             "  Keep every repository file and HEAD unchanged; do not run the full suite.",

package/dist/chat-delivery.js

@@ -595,12 +595,14 @@ export async function planChatNotifications(options) {
                 if (notification.createdAt >= binding.created &&
                     notification.resolvedAt === null &&
                     // A flow decision for "anyone who approves" reaches every approver who can see the project.
-                    (personal ? notification.recipient === binding.approver : notification.taskId || notification.kind === "flow-decision") &&
-                    notification.project &&
-                    repos.includes(notification.project)) {
+                    // A notification addressed to this person reaches them whatever project
+                    // their channel follows (a sign-in pause is the installation's, v108).
+                    (personal
+                        ? notification.recipient === binding.approver && (notification.project === null || repos.includes(notification.project))
+                        : (notification.taskId || notification.kind === "flow-decision") && notification.project !== null && repos.includes(notification.project))) {
                     const run = store.telegramProgressRun(notification);
                     const id = chatHash(`${options.state.channel}:notice:${binding.id}:${notification.id}`), now = nowOf(options);
-                    if (run && notification.taskId && isTelegramProgressNotification(notification)) {
+                    if (run && notification.taskId && notification.project !== null && isTelegramProgressNotification(notification)) {
                         const card = telegramProgressCard(store, store.getRun(run.id), notification.taskId, notification.project, now, options.evidenceRoot);
                         const content = {
                             text: card.text,

package/dist/claim.d.ts

@@ -350,7 +350,9 @@ export declare function finalizeMalformedFenced(store: Store, args: {
     reason: "fenced" | "unknown" | "stopped";
 };
 /** How a failed attempt is classified, per gnhf. Decides retry, backoff, or stall. */
-export type FailureClass = "agent-reported" | "retryable-infra" | "no-op" | "commit-failure" | "unknown";
+export type FailureClass = "agent-reported" | "retryable-infra" | "no-op"
+/** Run 2085: stopped before its handoff; the work was kept and the retry resumes it. Strikes like no-op. */
+ | "no-handoff" | "commit-failure" | "unknown";
 export declare const MAX_STRIKES = 3;
 export type FailureDisposition = {
     ok: true;
@@ -366,6 +368,10 @@ export type FailureDisposition = {
     ok: true;
     disposition: "commit-incident";
     incidentId: number;
+} | {
+    ok: true;
+    disposition: "auth-expired";
+    provider: string;
 } | {
     ok: false;
     reason: "fenced" | "unknown" | "stopped";
@@ -580,6 +586,10 @@ export type PlanFailureDisposition = {
     disposition: "exhausted";
     incidentId: number;
     strikes: number;
+} | {
+    ok: true;
+    disposition: "auth-expired";
+    provider: string;
 } | {
     ok: false;
     reason: "fenced" | "unknown" | "stopped";
@@ -652,6 +662,10 @@ export type ScoutFailureDisposition = {
     disposition: "stalled";
     incidentId: number;
     strikes: number;
+} | {
+    ok: true;
+    disposition: "auth-expired";
+    provider: string;
 } | {
     ok: false;
     reason: "fenced" | "unknown" | "stopped";

package/dist/claim.js

@@ -30,6 +30,7 @@
 import { randomUUID } from "node:crypto";
 import { attendedLivenessState } from "./liveness.js";
 import { authenticate } from "./runner.js";
+import { pauseForAuth } from "./provider-auth.js";
 import { DEFAULT_MAX_OPEN_DECISIONS, missingCapability, scopeApprovedForDispatch, taskReadinessBlocker, } from "./dispatch.js";
 /** attendedLivenessState over the store's ISO columns. */
 function attendedWatchState(lastBeatAt, now, absoluteExpiry) {
@@ -1059,6 +1060,11 @@ export function finalizeFailureFenced(store, args) {
             store.finishRun(runId, { outcome: "refused", reason: "fenced", now });
             return refusal(db, leaseId);
         }
+        // A sign-in that no longer works is not the attempt's fault: no strike,
+        // no retry, the task back in the queue, and its provider paused.
+        if (failureClass !== "commit-failure" && run.terminalClass === "auth-expired") {
+            return { ok: true, ...sealAuthExpired(store, run, taskId, now) };
+        }
         store.finishRun(runId, { outcome: "failed", reason: failureClass, now });
         if (failureClass === "commit-failure") {
             // The work exists and is uncommitted; nothing times its way out of
@@ -1113,19 +1119,37 @@ export function finalizeFailureFenced(store, args) {
             taskRef: run.taskRef,
             ownerKind: "backoff",
             ownerId: String(run.taskRef),
-            reason: `retry ${strikes}/${MAX_STRIKES} after ${failureClass} — backing off ${Math.round(wait / 60_000)}m`,
+            // Run 2085: this failure is named in plain words wherever the hold shows.
+            reason: failureClass === "no-handoff"
+                ? `The agent stopped before handing off; its work was kept and it is being resumed (retry ${strikes}/${MAX_STRIKES} in ${Math.round(wait / 60_000)}m)`
+                : `retry ${strikes}/${MAX_STRIKES} after ${failureClass} — backing off ${Math.round(wait / 60_000)}m`,
             until,
         }, now);
         store.enqueueNotification({
             source: { run: runId },
             dedupeKey: `run:${runId}:failed`,
             kind: "build-failed",
-            subject: `${taskId}: attempt failed (${failureClass}), retry ${strikes}/${MAX_STRIKES}`,
+            subject: failureClass === "no-handoff"
+                ? `${taskId}: the agent stopped before handing off; its work was kept, retry ${strikes}/${MAX_STRIKES}`
+                : `${taskId}: attempt failed (${failureClass}), retry ${strikes}/${MAX_STRIKES}`,
             body: `${oneLine(message, 200)}\nNext attempt no earlier than ${until.toISOString()}.`,
         }, now);
         return { ok: true, disposition: "backoff", strikes, until: until.toISOString() };
     });
 }
+/**
+ * The auth-expired ending, inside the caller's fenced transaction (claim
+ * already released): the run fails as `auth-expired`, the task goes back to
+ * the queue with no strike and no backoff, and dispatch for the run's
+ * provider pauses — the first such run of an incident tells a person once.
+ */
+function sealAuthExpired(store, run, taskId, now) {
+    store.finishRun(run.id, { outcome: "failed", reason: "auth-expired", now });
+    store.handle.prepare("UPDATE task SET state = 'queued', updated_at = ? WHERE id = ? AND state = 'running'").run(now.toISOString(), taskId);
+    pauseForAuth(store, { provider: run.provider, authMode: run.authMode ?? null, runId: run.id, taskRef: run.taskRef, now });
+    store.bumpWake();
+    return { disposition: "auth-expired", provider: run.provider };
+}
 /** Untrusted text on its way into a subject line: one line, bounded. */
 function oneLine(text, cap) {
     const flat = text.replace(/\s+/g, " ").trim();
@@ -1479,6 +1503,8 @@ export function finalizePlanFailureFenced(store, args) {
             store.finishRun(runId, { outcome: "refused", reason: "fenced", now });
             return refusal(db, leaseId);
         }
+        if (kind === "failure" && run.terminalClass === "auth-expired")
+            return { ok: true, ...sealAuthExpired(store, run, taskId, now) };
         const malformedKind = args.malformed === "decision" ? "malformed-decision" : "malformed-plan";
         store.finishRun(runId, { outcome: "failed", reason: kind === "malformed" ? malformedKind : oneLine(message, 120), now });
         if (kind === "malformed") {
@@ -1620,6 +1646,8 @@ export function finalizeScoutFailureFenced(store, args) {
             store.finishRun(runId, { outcome: "refused", reason: "fenced", now });
             return refusal(db, leaseId);
         }
+        if (kind === "failure" && run.terminalClass === "auth-expired")
+            return { ok: true, ...sealAuthExpired(store, run, taskId, now) };
         const malformedKind = args.malformed === "decision" ? "malformed-decision" : "malformed-report";
         store.finishRun(runId, { outcome: "failed", reason: kind === "malformed" ? malformedKind : oneLine(message, 120), now });
         if (kind === "malformed") {

package/dist/control-ui.js

@@ -37,7 +37,7 @@ export function controlSetupHtml(data) {
         `<p class="meta">Preparation applies to subsequent runs, including already approved tasks. Saving setup does not execute it.</p></details>` +
         `<button type="submit">Review project setup</button></form>` +
         `<section class="card"><h2>Agent instructions</h2>` +
-        (data.instructions.message ? `<p>${escape(data.instructions.message)}</p>` : data.instructions.installed ? `<p>Current Toolroll instructions are installed.</p>` :
+        (data.instructions.message ? `<p>${escape(data.instructions.message)}</p>` : data.instructions.installed ? `<p>Toolroll instructions are installed.</p>` :
             `<p>Give the agent the project's Toolroll handoff instructions.</p><form method="post" action="/control/instructions-preview">${hiddenFields({ csrf: data.csrf, repo: data.repo })}<button>Review instructions</button></form>`) +
         `</section><p><a href="/fleet">Configure planning, repair, and review agents</a> · <a href="/tasks/new">Describe a task</a></p>`;
 }

package/dist/daemon.d.ts

@@ -158,6 +158,15 @@ export declare function stopLaunchdService(definition: ServiceDefinition, run: S
  * Installing the new one stops and removes it, so two watches never run.
  */
 export declare function installedLegacyDaemon(args: Parameters<typeof planDaemon>[0]): DaemonPlan | null;
+/**
+ * Install the watch, then retire its copy from before the rename. The new
+ * job goes in first: when its install fails the legacy watch is left
+ * running, so the repo is never left without one. Only once the new job is
+ * installed is the legacy one stopped and removed; the new one is then
+ * started again, since it may have stepped aside while the legacy watch
+ * still held the repo's lease.
+ */
+export declare function installReplacingLegacy(plan: DaemonPlan, token: string, legacy: DaemonPlan | null, run: SupervisorRunner): Promise<ServiceStart>;
 /** Write the token 0600 and the unit, then hand the unit to the supervisor. */
 export declare function installDaemon(plan: DaemonPlan, token: string, run: SupervisorRunner): Promise<ServiceStart>;
 export declare function uninstallDaemon(plan: DaemonPlan, run: SupervisorRunner): Promise<{

package/dist/daemon.js

@@ -404,6 +404,27 @@ export function installedLegacyDaemon(args) {
     const legacy = planDaemon({ ...args, label: legacyLabelFor(args.repo) });
     return "error" in legacy || !existsSync(legacy.unitPath) ? null : legacy;
 }
+/**
+ * Install the watch, then retire its copy from before the rename. The new
+ * job goes in first: when its install fails the legacy watch is left
+ * running, so the repo is never left without one. Only once the new job is
+ * installed is the legacy one stopped and removed; the new one is then
+ * started again, since it may have stepped aside while the legacy watch
+ * still held the repo's lease.
+ */
+export async function installReplacingLegacy(plan, token, legacy, run) {
+    const installed = await installDaemon(plan, token, run);
+    if (!installed.ok || legacy === null)
+        return installed;
+    try {
+        await uninstallDaemon(legacy, run);
+    }
+    catch (error) {
+        return { ok: false, message: `installed ${plan.label}, but could not stop ${legacy.label}, the same watch under its older name: ${error.message}` };
+    }
+    const restarted = await installDaemon(plan, token, run);
+    return restarted.ok ? installed : restarted;
+}
 /** Write the token 0600 and the unit, then hand the unit to the supervisor. */
 export async function installDaemon(plan, token, run) {
     writeFileSync(plan.tokenFile, `${token}\n`, { mode: 0o600 });

package/dist/decision.d.ts

@@ -117,4 +117,10 @@ export declare function parseHandoff(raw: string): {
  * then the one instruction. Written for an agent that already holds the
  * context — it needs the list of what failed, not the theory of why.
  */
+/**
+ * Every unattended agent runs headless (run 2085): its turn ending IS the
+ * process exiting, so a command left in the background, a wakeup or a loop
+ * never gets a second turn — the attempt just ends without its handoff.
+ */
+export declare const HEADLESS_RULE: readonly string[];
 export declare function repairPrompt(problems: readonly Problem[], mailbox: string): string;

package/dist/decision.js

@@ -374,6 +374,17 @@ export function parseHandoff(raw) {
  * then the one instruction. Written for an agent that already holds the
  * context — it needs the list of what failed, not the theory of why.
  */
+/**
+ * Every unattended agent runs headless (run 2085): its turn ending IS the
+ * process exiting, so a command left in the background, a wakeup or a loop
+ * never gets a second turn — the attempt just ends without its handoff.
+ */
+export const HEADLESS_RULE = [
+    "- You run headless: run every command in the foreground and wait for it,",
+    "  however long it takes. Never background a command to wait on it, and",
+    "  never schedule a wakeup, cron job, monitor or loop. Your turn ending",
+    "  ends the run, so write the handoff before you stop.",
+];
 export function repairPrompt(problems, mailbox) {
     return [
         `Your parked decision in ${mailbox} failed validation:`,
@@ -384,5 +395,6 @@ export function repairPrompt(problems, mailbox) {
         "JSON: { urgency: \"blocking\", recap, question, options: [{ id, label,",
         "consequence, reversible }], recommendation } — at least two options, every",
         "option's reversible stated explicitly, recommendation naming an option id.",
+        ...HEADLESS_RULE,
     ].join("\n");
 }

package/dist/desktop-update.d.ts

@@ -65,6 +65,7 @@ export declare function prepareDesktopUpdate(stateDir: string, installed: string
 export declare function sqliteLock(file: string, busyTimeoutMs?: number): DatabaseSync | null;
 export declare const installationLock: (j: UpdateJournal) => DatabaseSync | null;
 export declare function desktopUpdateStatus(stateDir: string): {
+    version?: never;
     active: boolean;
     phase: string;
     detail: string;
@@ -78,7 +79,6 @@ export declare function desktopUpdateStatus(stateDir: string): {
     wasRunning?: never;
     backupPath?: never;
     updateId?: never;
-    version?: never;
     buildId?: never;
     workDir?: never;
 } | {

package/dist/dispatch.d.ts

@@ -37,7 +37,9 @@ export type DispatchDiagnosisCode = "updating" | "complete" | "needs-verificatio
 /** v50: every root review attempt ended without a review; nothing retries. */
  | "review-exhausted" | "cancelled" | "failed" | "running" | "vanished-run" | "retry-scheduled" | "waiting-decision" | "waiting-incident" | "held"
 /** v52: an operator stopped one exact attempt; only resuming it lifts the pause. */
- | "stopped" | "waiting-dependency" | "terminal-dependency" | "needs-project" | "needs-scope" | "needs-agent-profile" | "needs-approval" | "missing-requirement" | "no-worker-registered" | "no-worker-online" | "worker-at-capacity" | "provider-quota" | "planning-ready" | "planner-source" | "scouting-ready" | "ready";
+ | "stopped" | "waiting-dependency" | "terminal-dependency" | "needs-project" | "needs-scope" | "needs-agent-profile" | "needs-approval" | "missing-requirement" | "no-worker-registered" | "no-worker-online" | "worker-at-capacity" | "provider-quota"
+/** The provider's sign-in stopped working; its dispatch is paused. */
+ | "signed-out" | "planning-ready" | "planner-source" | "scouting-ready" | "ready";
 export type DispatchDiagnosis = {
     /** The four-state Never Stuck contract. */
     condition: "running" | "retrying" | "waiting" | "terminal";

package/dist/dispatch.js

@@ -10,6 +10,7 @@ import { isAlive } from "./runner.js";
 import { updateAdmissionPaused, UPDATE_PAUSED } from "./desktop-update-gate.js";
 import { approvalOf } from "./scope.js";
 import { plannerSourceProblemOf } from "./planner-source.js";
+import { authPauseOf, authWaitOf, providerName, signInReason } from "./provider-auth.js";
 import { REVIEW_TOKENS, resultStatusOf, reviewFactsOf } from "./workspace-ui.js";
 import { BUILT_IN, parseCapabilityKey } from "./store.js";
 export const DEFAULT_MAX_OPEN_DECISIONS = 5;
@@ -222,6 +223,11 @@ export function diagnoseTaskDispatch(store, taskId, now) {
     const local = taskReadinessBlocker(store, ref.id, now);
     if (local?.code === "hold") {
         if (local.ownerKind === "backoff") {
+            // Run 2085: an attempt that stopped before its handoff says so plainly.
+            const last = store.runsFor(ref.id).find(one => one.role === "builder" && one.finishedAt !== null);
+            const when = local.until === null ? "" : ` The next attempt is eligible at ${local.until}.`;
+            if (last?.reason === "no-handoff")
+                return answer("retry-scheduled", "retrying", "Retry scheduled", `The agent stopped before handing off; its work was kept and it is being resumed.${when}`, { nextAt: local.until });
             return answer("retry-scheduled", "retrying", "Retry scheduled", local.until === null ? "The failed attempt is backing off before retrying." : `The next attempt is eligible at ${local.until}.`, { nextAt: local.until });
         }
         if (local.ownerKind === "decision")
@@ -281,6 +287,13 @@ export function diagnoseTaskDispatch(store, taskId, now) {
             return answer("provider-quota", "retrying", "Provider quota exhausted", nextAt === null ? "The provider has not supplied a reset time; this needs operator attention." : `The next recorded reset is ${nextAt}.`, { action: nextAt === null ? "select-agent" : null, nextAt, role });
         }
     }
+    // The sign-in pause: the task's provider stopped working; nothing it would
+    // run starts until someone signs in (or a run or check on it works again).
+    const provider = profile?.provider ?? (role === "planner" ? ref.planProvider : null) ?? null;
+    const signedOut = authWaitOf(store, ref.id) ?? (provider === null ? null : authPauseOf(store, provider));
+    if (signedOut !== null) {
+        return answer("signed-out", "waiting", signInReason(signedOut), `This task starts again on its own once ${providerName(signedOut.provider)} works.`, { role });
+    }
     const openDecisions = store.countUnanswered();
     if (openDecisions >= DEFAULT_MAX_OPEN_DECISIONS && (role === "planner" || ref.parkRate > 0)) {
         return answer("waiting-decision", "waiting", "Decision queue is full", `${openDecisions} decisions already wait; answer some before this task may add another.`, { action: "answer-decision", role });