toolroll 0.5.0 → 0.7.0

package/dist/setup-guide.d.ts

@@ -15,10 +15,10 @@ export declare function detectPreparation(repo: string): {
 } | null;
 /** Browser installation may write only this known file inside its project. */
 export declare function previewProjectInstructions(repo: string): {
+    content?: never;
     ok: false;
     message: string;
     plan?: never;
-    content?: never;
     fingerprint?: never;
     installed?: never;
 } | {
@@ -30,10 +30,10 @@ export declare function previewProjectInstructions(repo: string): {
     installed: boolean;
 };
 export declare function addProjectInstructions(repo: string, fingerprint: string): {
+    content?: never;
     ok: false;
     message: string;
     plan?: never;
-    content?: never;
     fingerprint?: never;
     installed?: never;
 } | import("./skills.js").InstallResult;

package/dist/setup-guide.js

@@ -81,6 +81,8 @@ export function previewProjectInstructions(repo) {
     const content = skillContent();
     const current = existsSync(plan.skillPath) ? readFileSync(plan.skillPath, "utf8") : null;
     const fingerprint = createHash("sha256").update(JSON.stringify({ repo, current, content })).digest("hex");
+    // Installed means the CURRENT instructions are in place: a stale copy, or one only in the folder from before the
+    // rename, still offers Review so applyInstall can bring it up to date (the first-run checklist counts either).
     return { ok: true, plan, content, fingerprint, installed: current === content };
 }
 export function addProjectInstructions(repo, fingerprint) {

package/dist/skills.d.ts

@@ -33,6 +33,12 @@ export declare const CONTEXT_END = "<!-- standing-orders:end -->";
 export declare function skillContent(): string;
 /** The AGENTS.md block, marker-fenced so reinstalls replace only themselves. */
 export declare function contextBlock(): string;
+/**
+ * Whether a repository has the Toolroll skill: a SKILL.md in the current
+ * folder, or in the one installs before the rename used. The setup guide
+ * and the console's first-run checklist both ask this, so they agree.
+ */
+export declare function projectSkillInstalled(repo: string): boolean;
 export type InstallPlan = {
     skillPath: string;
     skillAction: "create" | "replace" | "refuse-foreign";

package/dist/skills.js

@@ -72,6 +72,14 @@ in the plane: read \`skills get knowledge\`, search it with
 merge anything yourself.
 ${CONTEXT_END}`;
 }
+/**
+ * Whether a repository has the Toolroll skill: a SKILL.md in the current
+ * folder, or in the one installs before the rename used. The setup guide
+ * and the console's first-run checklist both ask this, so they agree.
+ */
+export function projectSkillInstalled(repo) {
+    return [SKILL_DIR, LEGACY_SKILL_DIR].some(dir => existsSync(join(repo, dir, SKILL_FILE)));
+}
 /** What install would do, computed without writing anything. */
 export function planInstall(repo, writeContext) {
     const skillPath = join(repo, SKILL_DIR, SKILL_FILE);

package/dist/store.d.ts

@@ -74,7 +74,7 @@ export type SealedLedgerEntry = LedgerEntry & {
         hash: string;
     } | null;
 };
-export declare const SCHEMA_VERSION = 107;
+export declare const SCHEMA_VERSION = 109;
 export type ApiTokenRow = {
     id: string;
     account: string;
@@ -4820,7 +4820,7 @@ export declare class Store {
      * recovered-draft admission and the fallback admission's `recoveredFrom`:
      * the interrupted attempt whose draft a fresh run inherits is THIS
      * task's own builder or repair turn, left in this very worktree on this
-     * branch, either ended as `failed` for `interrupted` or still open under
+     * branch, either ended as `failed` for `interrupted` (or `no-handoff`) or still open under
      * a lease nobody holds any more. A planner, scout, or reviewer; a
      * parked, built, or otherwise failed run; a foreign workspace; or an
      * attempt still being built under a live claim is no grant — the words

package/dist/store.js

@@ -64,6 +64,7 @@ import { LEDGER_SCHEMA, LEDGER_TABLE, LEDGER_V54_COLUMNS, LEDGER_V54_TABLE, inst
 import { PLAN_AUTO_SCHEMA } from "./plan-auto.js";
 import { RECIPE_SCHEMA } from "./recipes.js";
 import { POLICY_SCHEMA, agentRefusal, approvalRefusal, attendedRefusal, policyParts, readPolicy, underCeiling, sessionCeilingRefusal } from "./policy.js";
+import { PROVIDER_AUTH_SCHEMA } from "./provider-auth.js";
 import { SPEND_SCHEMA, billingOf, budgetStates, canPrice, claudeMachineBilling, countsToward, filersOf, monthOf, priceWork, seenBilling as seenBillingOf, spendItems, teammateFilers, usd } from "./spend.js";
 import { FOREVER, RETENTION_SCHEMA, periodWords } from "./retention.js";
 import { IN_RANGE, LEDGER_CHAIN_SCHEMA, safeWhole, sealLedger, verifyLedgerChain } from "./ledger-chain.js";
@@ -249,7 +250,9 @@ const REGISTERED_AT_FILING = "again, as it was filed";
 // v105 prices every run (reported, or tokens at the catalogue price) and keeps monthly budgets per project, person, teammate and installation.
 // v106 keeps the organisation policy, retention periods, backup settings and runs, check progress, and runner capacity changes.
 // v107 keeps a check's progress and result in one record (run_check absorbs check_progress).
-export const SCHEMA_VERSION = 107;
+// v108 keeps sign-in pauses: one incident per provider whose sign-in stopped working (provider_auth_pause).
+// v109 remembers which sign-in pause parked a task (task_ref.auth_wait_pause), so reviews and other runs outside the tick wait for it too.
+export const SCHEMA_VERSION = 109;
 /** v102: a project's approval rules, and each person's approval of an exact scope (two are needed for protected work). */
 const APPROVAL_SCHEMA = `
 CREATE TABLE IF NOT EXISTS approval_policy (
@@ -3687,6 +3690,10 @@ function initializeStore(db, file) {
     db.exec(LEDGER_CHAIN_SCHEMA);
     db.exec(MONITORING_SCHEMA);
     db.exec(SPEND_SCHEMA);
+    // Sign-in pauses: one row per incident of a provider's sign-in no longer working.
+    db.exec(PROVIDER_AUTH_SCHEMA);
+    // The sign-in pause the dispatch gate last left this task waiting on (null: none), for the work index.
+    addColumn(db, "task_ref", "auth_wait_pause", "INTEGER REFERENCES provider_auth_pause(id)");
     db.exec(RETENTION_SCHEMA);
     db.exec(BACKUP_SCHEMA);
     // Sprint 8: the organisation policy (one row, or none: nothing restricted).
@@ -9785,7 +9792,7 @@ export class Store {
         const row = this.db
             .prepare(`SELECT id FROM run
           WHERE worktree = ?
-            AND (outcome IS NULL OR reason = 'interrupted' OR parent_run IS NOT NULL)
+            AND (outcome IS NULL OR reason IN ('interrupted', 'no-handoff') OR parent_run IS NOT NULL)
           ORDER BY id DESC LIMIT 1`)
             .get(path);
         return row === undefined ? null : Number(row.id);
@@ -15614,7 +15621,7 @@ export class Store {
      * recovered-draft admission and the fallback admission's `recoveredFrom`:
      * the interrupted attempt whose draft a fresh run inherits is THIS
      * task's own builder or repair turn, left in this very worktree on this
-     * branch, either ended as `failed` for `interrupted` or still open under
+     * branch, either ended as `failed` for `interrupted` (or `no-handoff`) or still open under
      * a lease nobody holds any more. A planner, scout, or reviewer; a
      * parked, built, or otherwise failed run; a foreign workspace; or an
      * attempt still being built under a live claim is no grant — the words
@@ -15627,7 +15634,9 @@ export class Store {
             return `run #${parent.id} is a ${parent.role} run — a recovered draft is a builder's or its repair turn's`;
         if (parent.worktree !== run.worktree || parent.branch !== run.branch)
             return `run #${parent.id} left its draft in ${parent.worktree ?? "no worktree"} on ${parent.branch ?? "no branch"}, not ${run.worktree} on ${run.branch}`;
-        const interrupted = parent.outcome === null || (parent.outcome === "failed" && parent.reason === "interrupted");
+        // An attempt that stopped before its handoff (run 2085) left its work in
+        // place for exactly this: the retry inherits it, like an interrupted one's.
+        const interrupted = parent.outcome === null || (parent.outcome === "failed" && (parent.reason === "interrupted" || parent.reason === "no-handoff"));
         if (!interrupted)
             return `run #${parent.id} ended as ${parent.outcome}${parent.reason === null ? "" : ` (${parent.reason})`} — only an interrupted attempt's draft is recovered`;
         if (parent.outcome === null && this.liveClaimByLease(parent.leaseId, now) !== null)

package/dist/subscription-chat.js

@@ -53,6 +53,9 @@ export function composeSubscriptionMatePrompt(request) {
         request.system,
         "SUBSCRIPTION HARNESS PROTOCOL:",
         "Do not use any harness tools or inspect the computer. The only current state is DATA and TOOL RESULTS below.",
+        // The model tried host tools as its own tool calls, which the harness refuses, and sometimes then told the operator the
+        // project search "wasn't available" (gate run, 2026-09-30). Host tools are requested only through calls.
+        "Host tools are not tools you can call yourself here: calling one directly always fails. Request one only by listing it in calls of the JSON object you return. Every AVAILABLE HOST TOOL below is available this way; never say one is unavailable. For what a project's files or code say, request get_project_context.",
         "Return the required JSON object. To request a host tool, append {id, name, argumentsJson} to calls; argumentsJson is the JSON serialization of that tool's argument object.",
         "The host validates and runs those calls, then gives you another step. When finished, return a non-empty text and an empty calls array.",
         `AVAILABLE HOST TOOLS:\n${JSON.stringify(request.tools)}`,

package/dist/update-notice.d.ts

@@ -0,0 +1,5 @@
+/** The update notice's words, shared by the server page and the console. Plain text; callers escape. */
+export declare function updateNoticeWords(notice: {
+    version: string;
+    security: boolean;
+}): string;

package/dist/update-notice.js

@@ -0,0 +1,4 @@
+/** The update notice's words, shared by the server page and the console. Plain text; callers escape. */
+export function updateNoticeWords(notice) {
+    return notice.security ? `Toolroll ${notice.version} is available, with security fixes` : `Toolroll ${notice.version} is available`;
+}

package/dist/work-index.js

@@ -2,6 +2,7 @@
  * not verify artifacts, inspect processes, or authorize task operations. */
 import { createHash } from 'node:crypto';
 import { readProjectAccess } from './project-access.js';
+import { pauseOnTaskProviders, providerName, signInReason } from './provider-auth.js';
 import { scopeTermsProblem } from './store.js';
 export const WORK_INDEX_PAGE_LIMIT = 40;
 export const WORK_INDEX_MAX_LIMIT = 100;
@@ -14,10 +15,12 @@ const s = (row, key) => row[key] == null ? null : String(row[key]);
  * admitted child needs its parent's exact revision brief, in the same repo.
  * All subsequent reads are scalar/indexed metadata, never artifact bytes.
  * MATERIALIZED prevents counts + page selection repeating correlated reads. */
+/** A gate note counts only while its pause is on one of the task's current providers. */
+const GATE_PAUSE_ON_TASK = pauseOnTaskProviders('p', 'c.ref_id');
 const PROJECTION = `WITH RECURSIVE admitted AS MATERIALIZED (
   SELECT t.id, t.title, t.state, t.created_at, t.updated_at, r.id ref_id, r.repo,
     r.revision_of, r.revision_brief_artifact, r.assigned_runner, r.plan,
-    r.deliverable, r.coordinator_cid, r.capability_requirements, r.park_rate
+    r.deliverable, r.coordinator_cid, r.capability_requirements, r.park_rate, r.auth_wait_pause
   FROM task_ref r JOIN task t ON t.id = r.external_id
   WHERE r.backend = 'built-in' AND ((r.repo IS NULL AND $unplaced = 1)
     OR (r.repo IS NOT NULL AND ($all = 1 OR r.repo IN (SELECT value FROM json_each($repos)))))
@@ -82,6 +85,14 @@ const PROJECTION = `WITH RECURSIVE admitted AS MATERIALIZED (
     (SELECT id FROM run WHERE task_ref=c.ref_id AND lease_id=c.live_lease AND outcome IS NULL ORDER BY id DESC LIMIT 1) live_run,
     h.owner_kind hold_kind,h.reason hold_reason,h.until hold_until,
     sc.task_id scope_id,sc.digest,sc.approved_at,sc.proposed_at,sc.profile_state,
+    -- The pause the dispatch gate itself left this task waiting on (the provider it resolved, pins,
+    -- configuration and planners included) first; the approved terms answer before any gate has looked.
+    EXISTS(SELECT 1 FROM provider_auth_pause p WHERE p.id=c.auth_wait_pause AND p.lifted_at IS NULL AND ${GATE_PAUSE_ON_TASK}) gate_signed_out,
+    COALESCE((SELECT p.provider||':'||p.auth_mode FROM provider_auth_pause p WHERE p.id=c.auth_wait_pause AND p.lifted_at IS NULL AND ${GATE_PAUSE_ON_TASK}),
+    (SELECT p.provider||':'||p.auth_mode FROM provider_auth_pause p WHERE p.lifted_at IS NULL AND p.provider IN (
+      SELECT json_extract(sc.approved_profile_json,'$.provider') WHERE json_valid(sc.approved_profile_json)
+      UNION ALL SELECT json_extract(leg.value,'$.provider') FROM json_each(CASE WHEN json_valid(sc.approved_route_json) THEN sc.approved_route_json ELSE '{}' END,'$.legs') leg
+        WHERE json_extract(leg.value,'$.phase')='build'))) signed_out,
     (sc.approved_at IS NOT NULL AND sc.approved_by IS NOT NULL AND sc.approved_digest=sc.digest) approved,
     (sc.approval_basis IS NOT 'mode' OR EXISTS(SELECT 1 FROM operating_mode om JOIN approver signer ON signer.name=om.signed_by
       WHERE om.repo=c.repo AND om.digest=sc.mode_digest AND om.revoked_at IS NULL AND om.absolute_expiry>$now
@@ -176,15 +187,16 @@ const PROJECTION = `WITH RECURSIVE admitted AS MATERIALIZED (
     WHEN worker_count=0 THEN 'no-worker-registered'
     WHEN online_count=0 THEN 'no-worker-online'
     WHEN available_count=0 THEN 'worker-at-capacity'
+    WHEN signed_out IS NOT NULL AND (gate_signed_out OR NOT (plan='requested' AND NOT COALESCE(approved AND dispatch_approval,0))) THEN 'signed-out'
     WHEN (plan='requested' OR park_rate>0) AND (SELECT COUNT(*) FROM decision WHERE state<>'answered' AND answered_at IS NULL)>=5 THEN 'decision-queue'
     WHEN plan='requested' AND NOT COALESCE(approved AND dispatch_approval,0) THEN 'planning-ready'
     WHEN deliverable='report' THEN 'scouting-ready'
     ELSE 'queued' END code
   FROM checked f
 ), ranked AS MATERIALIZED (
-  SELECT c.*,code NOT IN ('cancelled','complete','running','updating','retry-scheduled','waiting-dependency','worker-at-capacity','planning-ready','scouting-ready','queued') needs,
+  SELECT c.*,code NOT IN ('cancelled','complete','running','updating','retry-scheduled','waiting-dependency','worker-at-capacity','signed-out','planning-ready','scouting-ready','queued') needs,
     CASE WHEN code='complete' THEN 3 WHEN code='cancelled' THEN 4 WHEN code='running' THEN 1
-      WHEN code IN ('updating','retry-scheduled','waiting-dependency','worker-at-capacity','planning-ready','scouting-ready','queued') THEN 2 ELSE 0 END rank,
+      WHEN code IN ('updating','retry-scheduled','waiting-dependency','worker-at-capacity','signed-out','planning-ready','scouting-ready','queued') THEN 2 ELSE 0 END rank,
     CASE WHEN code='complete' THEN completed.at ELSE family_updated END sort_at,
     completed.actor checked_actor,completed.at checked_at,completed.outcome checked_digest
   FROM classified c LEFT JOIN action_ledger completed ON completed.id=c.checked_id WHERE ($state IS NULL OR c.state=$state) AND ($leadId IS NULL OR EXISTS(SELECT 1 FROM team_task_owner own WHERE own.task_ref=c.root_ref AND own.lead=$leadId))
@@ -283,7 +295,7 @@ export function workIndexPage(store, now, access, options = {}) {
     'earlier_id',earlier_id,'broken',broken,'live_run',live_run,'result_id',page_result_id,'result_outcome',(SELECT outcome FROM run WHERE id=page_result_id),
     'publication_url',(SELECT pr_url FROM publication WHERE run=page_result_id),'code',code,'needs',needs,'family_running',family_running,'rank',rank,'sort_at',sort_at,
     'checked_actor',checked_actor,'checked_at',checked_at,'checked_digest',checked_digest,'question_id',question_id,
-    'dependency_id',dependency_id,'dependency_state',dependency_state,'custody_unresolved',custody_unresolved,'hold_kind',hold_kind,'hold_reason',substr(hold_reason,1,300),'stop_run',stop_run,'unfinished',unfinished,
+    'dependency_id',dependency_id,'dependency_state',dependency_state,'custody_unresolved',custody_unresolved,'hold_kind',hold_kind,'hold_reason',substr(hold_reason,1,300),'stop_run',stop_run,'unfinished',unfinished,'signed_out',signed_out,
     'question_run',(SELECT run FROM decision WHERE id=page.question_id),
     'question_task',(SELECT r.external_id FROM decision d JOIN run ON run.id=d.run JOIN task_ref r ON r.id=run.task_ref WHERE d.id=page.question_id)) FROM page`)
         .all({ ...parameters(now, access, options), $cursorRoot: cursor?.root ?? 0, $cursorRank: cursor?.rank ?? 0, $cursorAt: cursor?.at ?? '', $limit: limit + 1, $recent: new Date(now.getTime() - 86_400_000).toISOString() });
@@ -336,6 +348,7 @@ function itemOf(row, principal) {
         'no-worker-registered': ['Needs your decision', 'No connected builder includes this project.', 'start-worker', 'Check connection'],
         'no-worker-online': ['Needs your decision', 'The builder has stopped checking in.', 'start-worker', 'Check connection'],
         'worker-at-capacity': ['Waiting for worker capacity', 'This task starts when an eligible worker has capacity.', null, ''],
+        'signed-out': ['Waiting for a sign-in', 'Its agent needs you to sign in again; it starts on its own once that works.', null, ''],
         'retry-scheduled': ['Retry scheduled', 'The attempt is backing off before retrying.', null, ''],
         updating: ['Waiting for app update', 'New work resumes after the update.', null, ''],
         'planning-ready': ['Planner ready', 'A connected worker can draft the plan.', null, ''],
@@ -343,6 +356,11 @@ function itemOf(row, principal) {
         queued: ['Ready to run', 'A connected worker can claim this task.', null, ''],
     };
     let [label, detail, actionCode, actionLabel] = words[code];
+    if (code === 'signed-out') {
+        const [provider = '', authMode = 'subscription'] = (s(row, 'signed_out') ?? '').split(':');
+        label = signInReason({ provider: provider, authMode: authMode === 'api-key' ? 'api-key' : 'subscription' });
+        detail = `It starts again on its own once ${providerName(provider)} works.`;
+    }
     if (code === 'running' && n(row, 'version_count') > 1)
         label = 'Revising';
     if (code === 'terminal-dependency' && s(row, 'dependency_id') !== null)

package/dist/worktree.d.ts

@@ -95,6 +95,19 @@ export declare function worktreeProcessOccupancy(path: string): {
 } | {
     held: false;
 };
+/**
+ * A checkout's uncommitted work as one patch — tracked changes against HEAD,
+ * then each untracked file against nothing (the lease note aside) — written
+ * to `file`. Nothing in the checkout is touched. Every road that is about to
+ * reset or clean a tree saves this first.
+ */
+export declare function saveWorkPatch(runner: Runner, path: string, file: string, header: string): Promise<{
+    ok: true;
+    file: string;
+} | {
+    ok: false;
+    message: string;
+}>;
 export declare class WorktreePool {
     private readonly store;
     private readonly options;

package/dist/worktree.js

@@ -25,7 +25,7 @@
 import { createHash, randomBytes } from "node:crypto";
 import { existsSync, readFileSync, writeFileSync, rmSync, realpathSync, mkdirSync, readdirSync } from "node:fs";
 import { hostname } from "node:os";
-import { basename, join } from "node:path";
+import { basename, dirname, join } from "node:path";
 import { run } from "./exec.js";
 import { currentBootId, provenDeadByBootChange } from "./boot-identity.js";
 import { HANDOFF_PREFIX, MAILBOX_SUFFIX, readMailbox } from "./evidence.js";
@@ -134,6 +134,40 @@ export function worktreeProcessOccupancy(path) {
         return code === "ESRCH" ? { held: false } : { held: true, by: pid };
     }
 }
+/**
+ * A checkout's uncommitted work as one patch — tracked changes against HEAD,
+ * then each untracked file against nothing (the lease note aside) — written
+ * to `file`. Nothing in the checkout is touched. Every road that is about to
+ * reset or clean a tree saves this first.
+ */
+export async function saveWorkPatch(runner, path, file, header) {
+    const status = await runner(GIT, [...READ_ONLY, "status", "--porcelain", "--untracked-files=all"], { cwd: path, timeoutMs: WORKTREE_TIMEOUT_MS });
+    if (status.code !== 0)
+        return { ok: false, message: `${path} could not be inspected before its work was saved` };
+    const untracked = status.stdout
+        .split("\n")
+        .filter(line => line.startsWith("?? ") && !line.trimEnd().endsWith(MARKER))
+        .map(line => line.slice(3).trim());
+    const tracked = await runner(GIT, [...READ_ONLY, "diff", "--binary", "HEAD"], { cwd: path, timeoutMs: WORKTREE_TIMEOUT_MS });
+    if (tracked.code !== 0)
+        return { ok: false, message: `${path}: git diff failed while saving its work (${firstLine(tracked.stderr)})` };
+    const parts = [tracked.stdout];
+    for (const one of untracked) {
+        // --no-index exits 1 when the sides differ; that is the expected answer.
+        const diff = await runner(GIT, [...READ_ONLY, "diff", "--binary", "--no-index", "--", "/dev/null", one], { cwd: path, timeoutMs: WORKTREE_TIMEOUT_MS });
+        if (diff.code > 1)
+            return { ok: false, message: `${path}: ${one} could not be captured (${firstLine(diff.stderr)})` };
+        parts.push(diff.stdout);
+    }
+    try {
+        mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
+        writeFileSync(file, header + parts.join(""), { mode: 0o600 });
+    }
+    catch (error) {
+        return { ok: false, message: `${path}: its work could not be written to ${file} (${error instanceof Error ? error.message : String(error)})` };
+    }
+    return { ok: true, file };
+}
 export class WorktreePool {
     store;
     options;
@@ -271,7 +305,7 @@ export class WorktreePool {
                 }
                 const previousRun = this.store.latestRunInWorktree(path);
                 const recoveryRun = this.store.latestRecoverableRunInWorktree(path);
-                const recovery = recoveryRun === null ? null : this.recoverableDraft(path, recoveryRun);
+                const recovery = recoveryRun === null ? null : this.recoverableDraft(path, recoveryRun, previousRun);
                 const kept = await this.keepLeftover(path, request.reclaim.evidenceRoot, request.now);
                 if (!kept.ok)
                     return { ok: false, reason: "git", message: kept.message };
@@ -354,7 +388,7 @@ export class WorktreePool {
      * the old result. It classifies the recovery context for the next freshly
      * fenced attempt, which must review and prove the inherited work itself.
      */
-    recoverableDraft(path, runId) {
+    recoverableDraft(path, runId, latestRun) {
         const prior = this.store.getRun(runId);
         if (prior === null)
             return null;
@@ -368,6 +402,23 @@ export class WorktreePool {
                 return { runId: source.id, kind: "partial" };
             }
         }
+        // An attempt that stopped before its handoff (run 2085) left work it
+        // never got to hand off: kept in place for the next attempt, never reset
+        // — until a later attempt fails some other way. That failure may have
+        // broken the tree, and the work is already saved (its own patch, and the
+        // leftover patch the caller writes first), so the tree can be reset. A
+        // crash or a sign-in that stopped working says nothing about the tree.
+        // A resumed or repair turn is judged as part of the attempt it belongs to.
+        const attemptOf = (one) => one !== null && one.role === "repair" && one.parentRun !== null ? this.store.getRun(one.parentRun) ?? one : one;
+        const brokeTree = (one) => one !== null && one.outcome === "failed" && one.reason !== "no-handoff" && one.reason !== "interrupted" && one.reason !== "auth-expired";
+        const attempt = attemptOf(prior);
+        const later = latestRun !== null && latestRun > runId ? attemptOf(this.store.getRun(latestRun)) : null;
+        const unhanded = attempt.outcome === "failed" && attempt.reason === "no-handoff"
+            ? attempt
+            : attempt.parentRun === null ? null : this.store.getRun(attempt.parentRun);
+        if (unhanded !== null && unhanded.outcome === "failed" && unhanded.reason === "no-handoff") {
+            return brokeTree(attempt) || brokeTree(later) ? null : { runId: unhanded.id, kind: "partial" };
+        }
         if (prior.outcome !== null && (prior.outcome !== "failed" || prior.reason !== "interrupted"))
             return null;
         let names;
@@ -395,35 +446,10 @@ export class WorktreePool {
      * run is on record). Nothing is deleted here.
      */
     async keepLeftover(path, evidenceRoot, now) {
-        const status = await this.runner(GIT, [...READ_ONLY, "status", "--porcelain", "--untracked-files=all"], { cwd: path, timeoutMs: WORKTREE_TIMEOUT_MS });
-        if (status.code !== 0)
-            return { ok: false, message: `${path} could not be inspected before reclaiming it` };
-        const untracked = status.stdout
-            .split("\n")
-            .filter(line => line.startsWith("?? ") && !line.trimEnd().endsWith(MARKER))
-            .map(line => line.slice(3).trim());
-        const tracked = await this.runner(GIT, [...READ_ONLY, "diff", "--binary", "HEAD"], { cwd: path, timeoutMs: WORKTREE_TIMEOUT_MS });
-        if (tracked.code !== 0)
-            return { ok: false, message: `${path}: git diff failed while reclaiming (${firstLine(tracked.stderr)})` };
-        const parts = [tracked.stdout];
-        for (const file of untracked) {
-            // --no-index exits 1 when the sides differ; that is the expected answer.
-            const one = await this.runner(GIT, [...READ_ONLY, "diff", "--binary", "--no-index", "--", "/dev/null", file], { cwd: path, timeoutMs: WORKTREE_TIMEOUT_MS });
-            if (one.code > 1)
-                return { ok: false, message: `${path}: ${file} could not be captured (${firstLine(one.stderr)})` };
-            parts.push(one.stdout);
-        }
         const lastRun = this.store.latestRunInWorktree(path);
         const dir = lastRun === null ? join(evidenceRoot, "leftover") : join(evidenceRoot, String(lastRun));
         const file = join(dir, lastRun === null ? `${now.toISOString().replace(/[:.]/g, "-")}.patch` : "leftover.patch");
-        try {
-            mkdirSync(dir, { recursive: true, mode: 0o700 });
-            writeFileSync(file, `# leftover from ${path}\n# kept ${now.toISOString()} before the tree was reset for the next attempt\n` + parts.join(""), { mode: 0o600 });
-        }
-        catch (error) {
-            return { ok: false, message: `${path}: the leftover could not be written to ${file} (${error instanceof Error ? error.message : String(error)})` };
-        }
-        return { ok: true, file };
+        return saveWorkPatch(this.runner, path, file, `# leftover from ${path}\n# kept ${now.toISOString()} before the tree was reset for the next attempt\n`);
     }
     /** Back to HEAD, untracked gone, our lease note kept; proven clean after. */
     async resetTree(path) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolroll",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "A control plane for unattended coding agents — queue tasks, walk away, come back to pull requests. Agents build in leased worktrees, never touch your default branch, and interrupt you only for decisions that need a human.",
   "directories": {
     "doc": "docs"