toolroll 0.9.99 → 0.9.100

package/dist/task-moves.d.ts

@@ -0,0 +1,90 @@
+/**
+ * The one door for writing a task's state (docs/plans/task-state-moves.md).
+ *
+ * A task is in one of five states: queued, running, done, failed, cancelled. TASK_MOVES lists every way code moves
+ * a task between them today: the state it writes and the states it may move from. moveTask writes one move as ONE
+ * statement, so the from-check and the write happen together inside whatever transaction the caller is in.
+ *
+ * Each from-list is copied from the statement it replaced, so this table records current behaviour exactly, except
+ * where docs/plans/closed-task-claims.md changed it (exhaust narrowed, claim added). The two moves marked
+ * `from: "any"` (complete, set) have no from-check and callers rely on that; making them narrower is a behaviour
+ * change with its own plan.
+ *
+ * Cancellation is not a move here: it has its own door, Store.applyCancellation, which also records why and who.
+ * Task creation (INSERT ... 'queued') is not a move either.
+ *
+ * This file imports nothing from store.ts at runtime (store.ts calls it), only types.
+ */
+import type { TaskState } from "./store.js";
+export declare const TASK_MOVES: {
+    /** Back to the queue from a running attempt that ended without finishing (stop, service stop, sign-in expired,
+     * vanished builder, move to a fallback agent). */
+    readonly requeue: {
+        readonly to: "queued";
+        readonly from: readonly ["running"];
+    };
+    /** An unfinished task that cannot go on (retries stopped, fallback agent signed out). */
+    readonly giveUp: {
+        readonly to: "failed";
+        readonly from: readonly ["queued", "running"];
+    };
+    /** A person's Retry. */
+    readonly retry: {
+        readonly to: "queued";
+        readonly from: readonly ["failed", "queued", "done"];
+    };
+    /** The tracker item was opened again. */
+    readonly reopen: {
+        readonly to: "queued";
+        readonly from: readonly ["cancelled", "failed", "queued"];
+    };
+    /** The fenced completion of an attempt. Wide today: a late result still writes over a closed task. */
+    readonly complete: {
+        readonly to: readonly ["done", "failed"];
+        readonly from: "any";
+    };
+    /** Strikes used up (build and scouting). Only an open task: one a person already closed keeps its state
+     * (docs/plans/closed-task-claims.md, decision B). */
+    readonly exhaust: {
+        readonly to: "failed";
+        readonly from: readonly ["queued", "running"];
+    };
+    /** The CLI `claim`: taking a task makes it running, in the grant's own transaction. `running` is listed because
+     * taking over an expired claim on a task a CLI runner left running keeps it running. */
+    readonly claim: {
+        readonly to: "running";
+        readonly from: readonly ["queued", "running"];
+    };
+    /** Store.setTaskState (the state verb, backend.setState, release and others). Wide by design: it is the
+     * general-purpose write; cancelled goes through applyCancellation instead. */
+    readonly set: {
+        readonly to: readonly ["queued", "running", "done", "failed"];
+        readonly from: "any";
+    };
+};
+export type TaskMoveName = keyof typeof TASK_MOVES;
+/** The smallest database handle moveTask needs (Store.handle fits). */
+export type MoveDatabase = {
+    prepare(sql: string): {
+        run(...params: unknown[]): {
+            changes: number | bigint;
+        };
+    };
+};
+/**
+ * Move one task. One statement: the from-check and the write together. True when the row changed (false when the
+ * task does not exist or is not in one of the move's from-states). `to` is required for complete and set, and
+ * refused for every other move.
+ */
+export declare function moveTask(db: MoveDatabase, id: string, move: TaskMoveName, now: Date, to?: TaskState): boolean;
+/**
+ * SQL condition, true while a runner holds a live claim on the task: the claim is not released, has not expired, and
+ * is the newest generation for its task. It needs the `claim` table in scope under that name, and binds one
+ * parameter: the current time as an ISO string. This is ownership, not proof that a process is alive.
+ */
+export declare const claimedNowSql = "claim.released_at IS NULL AND claim.expires_at > ? AND claim.lease_generation = (SELECT MAX(newest.lease_generation) FROM claim AS newest WHERE newest.task_ref = claim.task_ref)";
+/**
+ * SQL condition, true when the task's stored state is running (the `task` table in scope under that name). A task
+ * can be marked running with no live claim (see claimedNowSql), so the two can count differently.
+ */
+export declare const markedRunningSql = "task.state = 'running'";

package/dist/task-moves.js

@@ -0,0 +1,68 @@
+const ALL_BUT_CANCELLED = ["queued", "running", "done", "failed"];
+export const TASK_MOVES = {
+    /** Back to the queue from a running attempt that ended without finishing (stop, service stop, sign-in expired,
+     * vanished builder, move to a fallback agent). */
+    requeue: { to: "queued", from: ["running"] },
+    /** An unfinished task that cannot go on (retries stopped, fallback agent signed out). */
+    giveUp: { to: "failed", from: ["queued", "running"] },
+    /** A person's Retry. */
+    retry: { to: "queued", from: ["failed", "queued", "done"] },
+    /** The tracker item was opened again. */
+    reopen: { to: "queued", from: ["cancelled", "failed", "queued"] },
+    /** The fenced completion of an attempt. Wide today: a late result still writes over a closed task. */
+    complete: { to: ["done", "failed"], from: "any" },
+    /** Strikes used up (build and scouting). Only an open task: one a person already closed keeps its state
+     * (docs/plans/closed-task-claims.md, decision B). */
+    exhaust: { to: "failed", from: ["queued", "running"] },
+    /** The CLI `claim`: taking a task makes it running, in the grant's own transaction. `running` is listed because
+     * taking over an expired claim on a task a CLI runner left running keeps it running. */
+    claim: { to: "running", from: ["queued", "running"] },
+    /** Store.setTaskState (the state verb, backend.setState, release and others). Wide by design: it is the
+     * general-purpose write; cancelled goes through applyCancellation instead. */
+    set: { to: ALL_BUT_CANCELLED, from: "any" },
+};
+/** The SQL for one move: the guard is built from the table's own constants, never from caller input. */
+function moveSql(rule) {
+    const base = "UPDATE task SET state = ?, updated_at = ? WHERE id = ?";
+    if (rule.from === "any")
+        return base;
+    return `${base} AND state IN (${rule.from.map(state => `'${state}'`).join(", ")})`;
+}
+/** The state a move writes; throws on a call that does not fit the table (a programming error, not a refusal). */
+function targetOf(name, rule, to) {
+    if (to === "cancelled")
+        throw new Error("moveTask never writes cancelled: use applyCancellation");
+    if (typeof rule.to === "string") {
+        if (to !== undefined)
+            throw new Error(`the ${name} move always writes ${rule.to}; do not pass a target`);
+        return rule.to;
+    }
+    if (to === undefined)
+        throw new Error(`the ${name} move needs a target (${rule.to.join(" or ")})`);
+    if (!rule.to.includes(to))
+        throw new Error(`the ${name} move cannot write ${to}`);
+    return to;
+}
+/**
+ * Move one task. One statement: the from-check and the write together. True when the row changed (false when the
+ * task does not exist or is not in one of the move's from-states). `to` is required for complete and set, and
+ * refused for every other move.
+ */
+export function moveTask(db, id, move, now, to) {
+    const rule = Object.hasOwn(TASK_MOVES, move) ? TASK_MOVES[move] : undefined;
+    if (rule === undefined)
+        throw new Error(`unknown task move: ${String(move)}`);
+    const state = targetOf(move, rule, to);
+    return Number(db.prepare(moveSql(rule)).run(state, now.toISOString(), id).changes) > 0;
+}
+/**
+ * SQL condition, true while a runner holds a live claim on the task: the claim is not released, has not expired, and
+ * is the newest generation for its task. It needs the `claim` table in scope under that name, and binds one
+ * parameter: the current time as an ISO string. This is ownership, not proof that a process is alive.
+ */
+export const claimedNowSql = "claim.released_at IS NULL AND claim.expires_at > ? AND claim.lease_generation = (SELECT MAX(newest.lease_generation) FROM claim AS newest WHERE newest.task_ref = claim.task_ref)";
+/**
+ * SQL condition, true when the task's stored state is running (the `task` table in scope under that name). A task
+ * can be marked running with no live claim (see claimedNowSql), so the two can count differently.
+ */
+export const markedRunningSql = "task.state = 'running'";

package/dist/teams-chat.js

@@ -3,7 +3,7 @@
 import { resultShotsPruned } from "./result-shots.js";
 import { chatQuestionButtons } from "./subagent-question.js";
 import { chatAskButtons } from "./chat-ask.js";
-import { ChatDeliveryError, ChatState, chatHash, partContent } from "./chat-delivery-state.js";
+import { ChatDeliveryError, ChatState, chatHash, chatRetryAt, partContent } from "./chat-delivery-state.js";
 import { isLiveMessage, liveSpacingOf, underCooldown } from "./chat-live.js";
 import { channelAccess, chatObject as object, heldForWatch, planChatNotifications, planRoomMessages, processChatEvent, splitChatText } from "./chat-delivery.js";
 import { PLATFORM_LIMITS } from "./text-limits.js";
@@ -260,7 +260,7 @@ export async function deliverTeamsPart(options) {
             return true;
         }
         const problem = error instanceof TeamsError ? error : new TeamsError("Teams delivery failed", 15_000, true);
-        state.partFailed(row.id, { problem: problem.message, until: new Date(now.getTime() + problem.retryMs).toISOString(), uncertain: problem.uncertain }, 20);
+        state.partFailed(row.id, { problem: problem.message, until: chatRetryAt(now, problem.retryMs, row.attempts), uncertain: problem.uncertain });
         return true;
     }
 }

package/dist/telegram-flow.d.ts

@@ -1,7 +1,7 @@
 import { type FlowChoiceVisit, type FlowSendContent } from "./flow-send.js";
 import { type FlowStage } from "./flows.js";
 import { type InlineButton } from "./telegram-lead.js";
-import type { FlowCardRow, FlowRow, Store, TelegramBinding, TelegramFlowAction, TelegramFlowChoice, TelegramFlowPrompt } from "./store.js";
+import { type FlowCardRow, type FlowRow, type Store, type TelegramBinding, type TelegramFlowAction, type TelegramFlowChoice, type TelegramFlowPrompt } from "./store.js";
 /** A flow decision's notice: one per visit, and again (`:ask:<ms>`) when the owner asks the lead to approve it. */
 export declare const FLOW_DECIDE_KEY: RegExp;
 type Waiting = {

package/dist/telegram-flow.js

@@ -26,6 +26,7 @@ import { decideFlowCard, draftFor, flowCardHref, flowDefinitionOf } from "./flow
 import { chooseFlowCard, flowChoiceAt, flowPersonOf, flowSendPaths, readFlowSend } from "./flow-send.js";
 import { deciderOf, FLOW_END, replyTarget } from "./flows.js";
 import { phoneLinkButton } from "./telegram-lead.js";
+import { CONFIRM_TTL_MS } from "./store.js";
 import { telegramButton } from "./contracts/telegram-callback.js";
 /** A flow decision's notice: one per visit, and again (`:ask:<ms>`) when the owner asks the lead to approve it. */
 export const FLOW_DECIDE_KEY = /^flow-decide:([1-9][0-9]{0,14}):([1-9][0-9]{0,9})(?::ask:[0-9]{1,15})?$/;
@@ -132,7 +133,6 @@ function freshButtons(store, binding, waiting, now) {
     const minted = flowButtons(store, binding, waiting, now);
     return { keyboard: minted.keyboard.map(row => row.flatMap(one => "callback_data" in one && typeof one.callback_data === "string" ? [{ label: one.text, token: one.callback_data }] : [])), place: minted.tokens };
 }
-const CONFIRM_TTL_MS = 10 * 60_000;
 const FLOW_QUESTION = /\n\nApprove “[^\n]*”\? [^\n]*$/;
 /** Where a card is now, for a message whose buttons no longer act: named and linked only when it is in one of the
  * viewer's projects, and linked only while it still waits on someone. Never a live button. */

package/dist/telegram-lead.d.ts

@@ -13,9 +13,8 @@ export declare const CONVERSATION_MAX_AGE_MS: number;
 /** Waiting for the lead itself (it is answering, or earlier messages wait in the person's lead queue) is bounded longer:
  * two hours from the message's arrival, never reset as it moves from waiting behind the queue to waiting on a turn. */
 export declare const CONVERSATION_WAIT_MAX_AGE_MS: number;
-/** A card's buttons and an armed irreversible challenge live this long. */
+/** A card's buttons live this long; its armed Yes and Cancel last CONFIRM_TTL_MS. */
 export declare const CARD_TTL_MS: number;
-export declare const CHALLENGE_TTL_MS: number;
 /** Telegram's own message ceiling, with room for our part headers (the same bound telegram.ts splits at). */
 export declare const PART_CAP = 3900;
 export type TelegramConversationOptions = {

package/dist/telegram-lead.js

@@ -29,7 +29,7 @@ import { createHash, randomBytes } from "node:crypto";
 import { leadFailureText, runLeadTurn } from "./lead.js";
 import { confirmLeadProposal, confirmTypedStart, dismissLeadProposal, TYPED_START_STARTED } from "./lead-doors.js";
 import { ceilingDigestOf, verifyApproverStanding } from "./principal.js";
-import { LEAD_ASK_OTHER } from "./store.js";
+import { CONFIRM_TTL_MS, LEAD_ASK_OTHER } from "./store.js";
 import { phoneText } from "./telegram-status.js";
 import { shapeReplyParts, telegramReply } from "./reply-shape.js";
 import { createTelegramLiveDraft, forgetWaitingDraft, telegramAck, telegramWaitingDraft } from "./telegram-live.js";
@@ -37,6 +37,7 @@ import { TeamLeads } from "./team-leads.js";
 import { chatResultHref } from "./chat-controls.js";
 import { resultImageFileName, safeResultImageCaption, verifyResultImage } from "./chat-evidence.js";
 import { telegramButton } from "./contracts/telegram-callback.js";
+import { chatOutcome, isAdmittedWait, isLeadWait } from "./chat-message-states.js";
 /** How long one claimed turn may go without a heartbeat before another poller may take it over. */
 export const CONVERSATION_CLAIM_MS = 2 * 60_000;
 /** A busy engine (one turn at a time) defers a queued message this long, up to the age bound below. */
@@ -45,11 +46,8 @@ export const CONVERSATION_MAX_AGE_MS = 10 * 60_000;
 /** Waiting for the lead itself (it is answering, or earlier messages wait in the person's lead queue) is bounded longer:
  * two hours from the message's arrival, never reset as it moves from waiting behind the queue to waiting on a turn. */
 export const CONVERSATION_WAIT_MAX_AGE_MS = 2 * 3_600_000;
-/** A message whose turn was admitted, waiting for the project records to deliver its answer (no age bound). */
-const ADMITTED_REGISTRY_WAIT = "registry-unavailable:admitted";
-/** A card's buttons and an armed irreversible challenge live this long. */
+/** A card's buttons live this long; its armed Yes and Cancel last CONFIRM_TTL_MS. */
 export const CARD_TTL_MS = 24 * 3_600_000;
-export const CHALLENGE_TTL_MS = 10 * 60_000;
 /** Telegram's own message ceiling, with room for our part headers (the same bound telegram.ts splits at). */
 export const PART_CAP = 3_900;
 // ---- the ceiling and the principal --------------------------------------------
@@ -261,8 +259,8 @@ export function applyProposalTap(store, binding, token, message, repos, options,
         const yes = randomBytes(16).toString("hex");
         const cancel = randomBytes(16).toString("hex");
         const placedOn = String(message.message_id);
-        store.createTelegramProposalAction({ token: yes, binding: binding.id, proposal: proposal.id, phase: "yes", chatId: tapChatId, messageId: placedOn, ttlMs: CHALLENGE_TTL_MS }, now);
-        store.createTelegramProposalAction({ token: cancel, binding: binding.id, proposal: proposal.id, phase: "cancel", chatId: tapChatId, messageId: placedOn, ttlMs: CHALLENGE_TTL_MS }, now);
+        store.createTelegramProposalAction({ token: yes, binding: binding.id, proposal: proposal.id, phase: "yes", chatId: tapChatId, messageId: placedOn, ttlMs: CONFIRM_TTL_MS }, now);
+        store.createTelegramProposalAction({ token: cancel, binding: binding.id, proposal: proposal.id, phase: "cancel", chatId: tapChatId, messageId: placedOn, ttlMs: CONFIRM_TTL_MS }, now);
         const body = preview.text.split("\n\nConfirm or Dismiss below")[0];
         if (challenged) {
             ack("confirm it");
@@ -358,8 +356,6 @@ export async function processTelegramConversations(args) {
 }
 class PlanRefused extends Error {
 }
-/** The outcome a planned reply waits under until the bridge's cycle sends it. */
-const ANSWERED_SENDING = "answered:sending";
 /**
  * One claimed message, in order of what is already known about it:
  *
@@ -401,11 +397,10 @@ async function runTelegramConversation(row, args) {
     const requeue = async (outcome) => {
         // A turn already admitted for it waits for that turn's own outcome (bounded by the turn's deadline); waiting for the
         // lead gets two hours from arrival; anything else, ten minutes.
-        const limit = outcome === "replayed:running" || outcome === ADMITTED_REGISTRY_WAIT ? Number.POSITIVE_INFINITY
-            : outcome === "busy" || outcome === "backlog" ? CONVERSATION_WAIT_MAX_AGE_MS : CONVERSATION_MAX_AGE_MS;
+        const limit = isAdmittedWait(outcome) ? Number.POSITIVE_INFINITY : isLeadWait(outcome) ? CONVERSATION_WAIT_MAX_AGE_MS : CONVERSATION_MAX_AGE_MS;
         if (ageMs > limit) {
             await notify(couldNotAnswerText(outcome === "registry-unavailable" ? "your projects couldn't be read" : "the assistant stayed busy with another message"));
-            finish({ state: "failed", outcome: `${outcome}:gave-up` });
+            finish({ state: "failed", outcome: chatOutcome.gaveUp(outcome) });
             report.refused++;
             return;
         }
@@ -413,7 +408,7 @@ async function runTelegramConversation(row, args) {
         if (outcome === "backlog" && row.outcome !== "backlog")
             await notify("Queued behind your earlier messages. It goes to the lead once they're answered.");
         // Waiting for the lead: a draft that says so, refreshed while it waits (never over this chat's running turn).
-        if (outcome === "busy" || outcome === "backlog") {
+        if (isLeadWait(outcome)) {
             await telegramWaitingDraft({ store, botId, transport, clock, chatId: row.chatId, binding: row.binding, draftId: row.id, allowed: () => stillPaired() && claimed(), ...(options.liveTiming === undefined ? {} : { timing: options.liveTiming }) });
         }
         finish({ state: "queued", outcome, nextAttemptAt: new Date(clock().getTime() + CONVERSATION_RETRY_MS).toISOString() });
@@ -483,7 +478,7 @@ async function runTelegramConversation(row, args) {
             if (now.getTime() - Date.parse(part.createdAt) > DELIVERY_MAX_AGE_MS) {
                 report.problems.push(`telegram chat reply for update ${row.updateId} was not sent within a day: ${part.lastError ?? "unsent"}`);
                 await notify(couldNotAnswerText("my reply couldn't be sent for a day"));
-                finish({ state: "failed", outcome: `unsent:gave-up:${part.lastError ?? "unsent"}` });
+                finish({ state: "failed", outcome: chatOutcome.unsentGaveUp(part.lastError) });
                 report.refused++;
                 return;
             }
@@ -510,7 +505,7 @@ async function runTelegramConversation(row, args) {
             if (problem !== null) {
                 report.problems.push(`telegram chat reply for update ${row.updateId} was not sent: ${problem}`);
                 await notify(`${problem.charAt(0).toUpperCase()}${problem.slice(1)}, so the assistant's reply was not sent. Nothing was changed. Send your message again if you still want it.`);
-                finish({ state: "failed", outcome: `unsent:${problem}` });
+                finish({ state: "failed", outcome: chatOutcome.unsent(problem) });
                 report.refused++;
                 return;
             }
@@ -708,7 +703,7 @@ async function runTelegramConversation(row, args) {
         }
         if (turn.state !== "answered") {
             await notify(leadFailureText(turn.failureReason, store.leadTurnCostUnconfirmed(turn.id), turn.failureDetail ?? null));
-            finish({ state: "failed", outcome: `replayed:${turn.failureReason ?? "failed"}` });
+            finish({ state: "failed", outcome: chatOutcome.replayedFailed(turn.failureReason) });
             report.refused++;
             return;
         }
@@ -724,11 +719,11 @@ async function runTelegramConversation(row, args) {
             await deliver(outcomeWord);
             return;
         }
-        finish({ state: "queued", outcome: outcomeWord === "answered" ? ANSWERED_SENDING : "delivering", nextAttemptAt: clock().toISOString() });
+        finish({ state: "queued", outcome: outcomeWord === "answered" ? "answered:sending" : "delivering", nextAttemptAt: clock().toISOString() });
     };
     // 2. Parts already planned: the turn answered; only the sending remains.
     if (store.listTelegramConversationParts(row.id).length > 0) {
-        await deliver(row.outcome === ANSWERED_SENDING ? "answered" : "replayed");
+        await deliver(row.outcome === "answered:sending" ? "answered" : "replayed");
         return;
     }
     // 3. A turn already admitted for it and still working: wait for that turn's own outcome. Nothing here needs the
@@ -755,7 +750,7 @@ async function runTelegramConversation(row, args) {
         // A turn already took it (its receipt is in the bound session): its answer exists or will, and is delivered once
         // the projects can be read again — never abandoned to the outage.
         const admitted = row.session !== null && store.leadRequestReceipt(row.session, row.request) !== null;
-        await requeue(admitted ? ADMITTED_REGISTRY_WAIT : "registry-unavailable");
+        await requeue(admitted ? "registry-unavailable:admitted" : "registry-unavailable");
         return;
     }
     const repos = telegramConversationRepos(store, binding.approver, registry);
@@ -826,7 +821,7 @@ async function runTelegramConversation(row, args) {
     }
     // It waited (for the lead, or behind earlier messages), was never admitted, and is past the wait from its arrival:
     // it is never sent this late, even when the lead is free now.
-    if ((row.outcome === "busy" || row.outcome === "backlog") && ageMs > CONVERSATION_WAIT_MAX_AGE_MS) {
+    if (isLeadWait(row.outcome) && ageMs > CONVERSATION_WAIT_MAX_AGE_MS) {
         await requeue(row.outcome);
         return;
     }
@@ -839,7 +834,7 @@ async function runTelegramConversation(row, args) {
     if (!resolved.ok) {
         if (resolved.said !== null)
             await notify(resolved.said);
-        finish({ state: "failed", outcome: `refused:${resolved.reason}` });
+        finish({ state: "failed", outcome: chatOutcome.refused(resolved.reason) });
         report.refused++;
         return;
     }
@@ -924,7 +919,7 @@ async function runTelegramConversation(row, args) {
             return;
         }
         await notify(phoneText(outcome.message, 1_000));
-        finish({ state: "failed", outcome: `refused:${outcome.refused}` });
+        finish({ state: "failed", outcome: chatOutcome.refused(outcome.refused) });
         report.refused++;
         return;
     }
@@ -932,7 +927,7 @@ async function runTelegramConversation(row, args) {
         // Truthful: what failed, that nothing was kept, and that a new message
         // is a new turn. A failed turn's drafts are already gone.
         await notify(phoneText(outcome.message, 1_000));
-        finish({ state: "failed", outcome: `failed:${outcome.failed}` });
+        finish({ state: "failed", outcome: chatOutcome.failed(outcome.failed) });
         report.refused++;
         return;
     }

package/dist/telegram-progress.js

@@ -5,6 +5,7 @@
  * once the lead or a person has marked that exact result. Slack, Discord and
  * Teams send this same card. */
 import { machineChecked } from "./machine-check.js";
+import { wasInterrupted } from "./run-ending.js";
 import { assignmentOf } from "./assignment.js";
 import { chatResultHref, chatControlHref } from "./chat-controls.js";
 import { phoneText, projectLabel } from "./telegram-status.js";
@@ -72,7 +73,7 @@ export function telegramProgressCard(store, run, taskId, project, now = new Date
     else if (run.outcome === "parked") {
         facts = { stage: "needs-you", need: "answer" };
     }
-    else if (run.outcome === "interrupted" || run.reason === "interrupted") {
+    else if (wasInterrupted(run)) {
         facts = { stage: "stopped", reason: "The attempt was interrupted. Inspect the saved work, then resume." };
     }
     else {

package/dist/telegram.d.ts

@@ -24,7 +24,6 @@ export type TelegramReadProjects = () => Promise<readonly string[]>;
 /** The environment name — and therefore the name the builder strips from agents (both names; see names.ts). */
 export { TELEGRAM_TOKEN_ENV as TOKEN_ENV, TELEGRAM_TOKEN_ENVS as TOKEN_ENVS } from "./names.js";
 export declare const PAIRING_TTL_MS: number;
-export declare const CONFIRM_TTL_MS: number;
 export declare const BRIDGE_LEASE_MS: number;
 export declare const DELIVERY_CLAIM_MS: number;
 /** Where Telegram pushes this bot's updates: under the public hooks address (Tailscale Funnel covers /hooks). */

package/dist/telegram.js

@@ -30,7 +30,7 @@ import { chmodSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { closedQuestionWords, validateNote } from "./decision.js";
 import { isShotsKind, resultShotsFor } from "./result-shots.js";
-import { isLifecycleNotification, isTelegramProgressNotification, TELEGRAM_HOLD_REASONS } from "./store.js";
+import { CONFIRM_TTL_MS, isLifecycleNotification, isTelegramProgressNotification, TELEGRAM_HOLD_REASONS } from "./store.js";
 import { telegramProgressCard } from "./telegram-progress.js";
 import { enqueueEveningDigests, finishedView, isTaskFact, joinsBatch, needsPerson, quietCardView } from "./chat-quiet.js";
 import { BATCH_MS, chatText, chatTitle, factLinkLabel, mentions, nameTelegramBot } from "./chat-voice.js";
@@ -59,7 +59,6 @@ export { TELEGRAM_TOKEN_ENV as TOKEN_ENV, TELEGRAM_TOKEN_ENVS as TOKEN_ENVS } fr
 /** BotFather's shape: numeric bot id, colon, secret. */
 const TOKEN_SHAPE = /^(\d+):[A-Za-z0-9_-]{20,}$/;
 export const PAIRING_TTL_MS = 10 * 60_000;
-export const CONFIRM_TTL_MS = 10 * 60_000;
 export const BRIDGE_LEASE_MS = 2 * 60_000;
 export const DELIVERY_CLAIM_MS = 2 * 60_000;
 /** Telegram's own message ceiling, with room for our part headers. */
@@ -2575,7 +2574,7 @@ function applyCallback(context, update, effects) {
             const draft = store.liveNoteDraft(binding.id, decision.id, clock());
             const digest = draft === null ? undefined : noteDigestOf(draft.note);
             if (draft !== null)
-                store.setNoteDraftState(draft.id, "armed");
+                store.setNoteDraftState(draft.id, ["pending", "armed"], "armed");
             store.createTelegramAction({ token: confirm, binding: binding.id, decision: decision.id, optionId: option.id, phase: "confirm", chatId: binding.chatId, messageId: placedOn, ttlMs: CONFIRM_TTL_MS, ...(digest === undefined ? {} : { noteDigest: digest }) }, clock());
             store.createTelegramAction({ token: cancel, binding: binding.id, decision: decision.id, optionId: option.id, phase: "cancel", chatId: binding.chatId, messageId: placedOn, ttlMs: CONFIRM_TTL_MS }, clock());
             ack("irreversible — confirm it");
@@ -2620,7 +2619,7 @@ function applyCallback(context, update, effects) {
     {
         const draft = store.liveNoteDraft(binding.id, decision.id, clock());
         if (draft !== null)
-            store.setNoteDraftState(draft.id, "discarded");
+            store.setNoteDraftState(draft.id, ["pending", "armed"], "discarded");
     }
     const fresh = decision.options.map(option => ({ option, token: randomBytes(16).toString("hex") }));
     for (const { option, token: choose } of fresh) {
@@ -2642,7 +2641,7 @@ function answerNow(context, decision, choice, binding, ack, editText) {
     const answered = store.answerDecisionLocked({ id: decision.id, choice, by: binding.approver, via: "telegram", ...(draft === null ? {} : { note: draft.note }) }, clock());
     if (answered.ok) {
         if (draft !== null)
-            store.setNoteDraftState(draft.id, "consumed");
+            store.setNoteDraftState(draft.id, ["pending", "armed"], "consumed");
         report.answered++;
         ack(`✓ ${choice}${draft === null ? "" : " — with your note"}`);
         editText(answeredText(store, answered.decision));
@@ -2650,7 +2649,7 @@ function answerNow(context, decision, choice, binding, ack, editText) {
     }
     if (answered.reason === "already-answered" || answered.reason === "closed") {
         if (draft !== null)
-            store.setNoteDraftState(draft.id, "discarded");
+            store.setNoteDraftState(draft.id, ["pending", "armed"], "discarded");
         const settled = store.getDecision(decision.id);
         ack(`${settled?.supersededReason != null ? closedQuestionWords(settled.supersededReason) : `already answered: ${settled?.choice ?? "?"}`}${draft === null ? "" : " — your note did NOT travel"}`);
         if (settled !== null)
@@ -2702,7 +2701,7 @@ function expiredDraftGuard(store, binding, decisionId, now) {
         .get(binding.id, decisionId, now.toISOString());
     if (expired === undefined)
         return false;
-    store.setNoteDraftState(Number(expired["id"]), "discarded");
+    store.setNoteDraftState(Number(expired["id"]), ["pending", "armed"], "discarded");
     return true;
 }
 /** Bridges in this process waiting out their push idle, by bot: a kept push ends the wait early. */

package/dist/vanished-retry.js

@@ -19,6 +19,7 @@
 import { authorityStandsSql } from "./approval-authority.js";
 import { stopFactOf } from "./store.js";
 import { refArchived } from "./task-archive.js";
+import { moveTask } from "./task-moves.js";
 /** The automatic-retry limits, in one place. */
 export const RETRY_LIMIT = 3;
 export const RETRY_SPEND_TIMES = 2;
@@ -48,7 +49,7 @@ function approvalStands(store, taskRef, now) {
     WHERE task_scope.approved_digest = task_scope.digest AND task_scope.approved_at IS NOT NULL AND ${authorityStandsSql("task_scope", "task_ref.repo", "?")}`).get(taskRef, stamp, stamp, stamp, stamp) !== undefined;
 }
 function requeue(store, taskId, now) {
-    return Number(store.handle.prepare("UPDATE task SET state = 'queued', updated_at = ? WHERE id = ? AND state = 'running'").run(now.toISOString(), taskId).changes) > 0;
+    return moveTask(store.handle, taskId, "requeue", now);
 }
 function episodeOf(store, taskRef) {
     const row = store.handle.prepare("SELECT retries, reserved_microusd FROM retry_episode WHERE task_ref = ?").get(taskRef);
@@ -59,7 +60,7 @@ function stopFor(store, input) {
     store.handle.prepare(`INSERT INTO retry_episode (task_ref, retries, reserved_microusd, stopped, stopped_run, started_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)
     ON CONFLICT (task_ref) DO UPDATE SET stopped = excluded.stopped, stopped_run = excluded.stopped_run, reserved_microusd = excluded.reserved_microusd, updated_at = excluded.updated_at`)
         .run(input.taskRef, input.retries, input.reservedMicrousd, input.why, input.run, stamp, stamp);
-    store.handle.prepare("UPDATE task SET state = 'failed', updated_at = ? WHERE id = ? AND state IN ('running', 'queued')").run(stamp, input.taskId);
+    moveTask(store.handle, input.taskId, "giveUp", input.now);
     store.enqueueNotification({
         source: { run: input.run },
         dedupeKey: `vanished:${input.run}`,

package/dist/workspace-ui.js

@@ -23,6 +23,7 @@ import { manualReviewOnly, plainReasonWords } from "./proof.js";
 import { CHECK_COMMAND_CHANGED, CHECK_UNREADABLE, OPEN_RESULT, approvedCheckOf, approvedCheckStateOf, plainReasonOf, stageOfCode, taskStatusOf, workToneOf } from "./task-status.js";
 import { whenUtc } from "./when-html.js";
 import { NEEDS } from "./needs-you.js";
+import { wasInterrupted } from "./run-ending.js";
 import { html, postForm } from "./html.js";
 export const WORK_VIEWS = [
     { key: "all", label: "All", hint: "Every task in view, most urgent first.", empty: "Nothing is in progress. Describe work in chat or add a task, and it appears here." },
@@ -50,7 +51,7 @@ export function reviewFactsOf(retry, reviewerAlive, automaticPending = false) {
         attempts: retry.attempts.length,
         retriesRemaining: retry.retriesRemaining,
         latestReason: retry.latest?.reason ?? null,
-        interrupted: retry.latest !== null && (retry.latest.outcome === "interrupted" || retry.latest.reason === "interrupted"),
+        interrupted: retry.latest !== null && wasInterrupted(retry.latest),
         queuedBy: retry.openRequest?.requestedBy ?? null,
         queuedOrigin: retry.openRequest?.origin ?? null,
         reviewerAlive: retry.live !== null && reviewerAlive(retry.live.runner),

package/dist/worktree.js

@@ -34,6 +34,7 @@ import { HANDOFF_PREFIX, MAILBOX_SUFFIX, looksLikeProtocolFile, readMailbox } fr
 import { parseHandoff } from "./decision.js";
 import { diskBytes } from "./storage.js";
 import { markNeverIndex } from "./never-index.js";
+import { endedInterrupted } from "./run-ending.js";
 import { checkoutGit, gitIncidentRecord, teardownGit } from "./teardown-git.js";
 /**
  * The note a lease leaves in the checkout, naming the process holding it.
@@ -598,7 +599,7 @@ export class WorktreePool {
         // failed/interrupted source required here.
         if (prior.parentRun !== null) {
             const source = this.store.getRun(prior.parentRun);
-            if (source?.outcome === "failed" && source.reason === "interrupted") {
+            if (source !== null && endedInterrupted(source)) {
                 return { runId: source.id, kind: "partial" };
             }
         }
@@ -619,7 +620,7 @@ export class WorktreePool {
         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"))
+        if (prior.outcome !== null && !endedInterrupted(prior))
             return null;
         let names;
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolroll",
-  "version": "0.9.99",
+  "version": "0.9.100",
   "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"