toolroll 0.9.67 → 0.9.68

package/dist/contracts/memory-pass.js

@@ -7,6 +7,7 @@
 import { z } from "zod";
 import { TEXT_LIMITS } from "../text-limits.js";
 import { limited, readVersioned, toModelSchema, versioned } from "./contract.js";
+import { isRecord } from "../is-record.js";
 export const MEMORY_EFFECTS = ["harm", "non-compliance", "irrelevant"];
 export const MEMORY_DOMAINS = ["project", "orchestration"];
 export const MEMORY_PROPOSAL_KINDS = ["instruction-add", "instruction-remove", "decision-add"];
@@ -64,7 +65,6 @@ export const memoryVerdictReadSchema = memoryVerdictSchema.strip().extend({
 export const MEMORY_VERDICT_VERSION = 1;
 /** A verdict as a session keeps it. */
 export const savedVerdictSchema = versioned(MEMORY_VERDICT_VERSION, verdictShape(saved));
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /**
  * A verdict kept before it carried `version` (through 0.9.36), as version 1. Those left a gap's `matchesGap` out when
  * there was none; that reads as null. Values are never rewritten.

package/dist/contracts/plan.js

@@ -7,6 +7,7 @@
 import { z } from "zod";
 import { ACCEPTANCE_LIMITS, EVIDENCE_KINDS } from "../scope.js";
 import { limited, readVersioned, toModelSchema, versioned } from "./contract.js";
+import { isRecord } from "../is-record.js";
 /** How many paths a plan may say it touches. */
 export const PLAN_TOUCHES = 32;
 /** One acceptance criterion: the scope's own shape (scope.ts `AcceptanceCriterion`), `how` advisory and unsigned. */
@@ -37,7 +38,6 @@ function pick(body, fields) {
     }
     return out;
 }
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /**
  * A plan written before plans carried `version` (every plan through 0.9.33), as version 1. The old parser read only
  * the fields it knew and ignored any others, read a null goal, plan or acceptance as missing and null touches as

package/dist/contracts/project-knowledge.js

@@ -8,6 +8,7 @@
 import { z } from "zod";
 import { limited, readVersioned, versioned } from "./contract.js";
 import { decisionLineSchema } from "./project-memory.js";
+import { isRecord } from "../is-record.js";
 /** How many references a project keeps, and how many a run is given. Text limits live in TEXT_LIMITS. */
 export const KNOWLEDGE_COUNTS = { references: 12, selected: 3, decisions: 8 };
 const written = limited;
@@ -30,7 +31,6 @@ export const KNOWLEDGE_VERSION = 1;
 export const knowledgeSchema = versioned(KNOWLEDGE_VERSION, knowledgeShape(written));
 /** Knowledge as it is read back. */
 export const savedKnowledgeSchema = versioned(KNOWLEDGE_VERSION, knowledgeShape(saved));
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function pick(body, fields) {
     const out = {};
     for (const field of fields)

package/dist/contracts/project-skills.d.ts

@@ -83,7 +83,6 @@ export declare const skillSelectionSchema: z.ZodRecord<z.ZodString, z.ZodObject<
     sha: z.ZodString;
     enabled: z.ZodBoolean;
 }, z.core.$strict>>;
-export type SkillChoice = z.infer<typeof skillChoiceSchema>;
 export type SkillSelection = z.infer<typeof skillSelectionSchema>;
 export declare const SKILLS_SNAPSHOT_VERSION = 1;
 /** The versions a run is pinned to, as frozen: the packages by digest. */

package/dist/contracts/proof.js

@@ -8,6 +8,7 @@ import { z } from "zod";
 import { TEXT_LIMITS } from "../text-limits.js";
 import { EVIDENCE_KINDS } from "../scope.js";
 import { limited, readVersioned, versioned } from "./contract.js";
+import { isRecord } from "../is-record.js";
 /** How many entries each proof list may hold. Text limits live in TEXT_LIMITS. */
 export const PROOF_COUNTS = { criteria: 12, evidencePerCriterion: 4, checks: 12, changed: 64, caveats: 8, screenshots: 8 };
 /** Every proof limit by its long-standing name: the counts above and the byte limits from TEXT_LIMITS. */
@@ -62,7 +63,6 @@ export const proofSchema = versioned(PROOF_VERSION, {
     caveats: z.array(line("caveat")).max(PROOF_COUNTS.caveats),
     screenshots: z.array(proofScreenshotSchema).max(PROOF_COUNTS.screenshots),
 });
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /** The listed fields of `body`, a null or missing one left out (the old parser read null text as missing). */
 function pick(body, fields) {
     const out = {};

package/dist/contracts/recipes.js

@@ -13,6 +13,7 @@
 import { z } from "zod";
 import { parseContract, versioned } from "./contract.js";
 import { savedCriterionSchema } from "./scope.js";
+import { isRecord } from "../is-record.js";
 export const RECIPE_FORMAT = "standing-orders-recipe";
 /** Numbers the recipe rules use, in plain code after parsing (bytes of the whole document, characters of a field). */
 export const RECIPE_LIMITS = { documentBytes: 32_768, description: 400, inputs: 8, label: 80, answer: 500 };
@@ -38,7 +39,6 @@ const recipeFields = {
 export const recipeV1Schema = versioned(1, recipeFields);
 export const recipeV2Schema = versioned(2, { ...recipeFields, inputs: z.array(recipeInputSchema).min(1).max(RECIPE_LIMITS.inputs) });
 export const recipeDocumentSchema = z.discriminatedUnion("version", [recipeV1Schema, recipeV2Schema]);
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /** A success check as the scope reader reads it: an absent or empty `how` is null; every other key, known or not, as given. */
 function checkBody(entry) {
     if (!isRecord(entry) || (entry["how"] !== undefined && entry["how"] !== ""))

package/dist/contracts/scope.js

@@ -18,6 +18,7 @@ import { TEXT_LIMITS } from "../text-limits.js";
 import { ACCEPTANCE_LIMITS } from "./acceptance-terms.js";
 import { contractProblemOf, parseContract } from "./contract.js";
 import { acceptanceCriterionSchema as planCriterionSchema, planSchema } from "./plan.js";
+import { isRecord } from "../is-record.js";
 /** A criterion as saved and as every reader returns it: the plan's criterion with `how` always present (null for none). */
 export const savedCriterionSchema = z.lazy(() => planCriterionSchema.extend({ how: planCriterionSchema.shape.how.unwrap() }));
 /** A rubric as saved: at most twelve criteria (an empty one is a scope filed before rubrics, or by a road with none). */
@@ -33,7 +34,6 @@ export const scopeTermsSchema = z.lazy(() => z.strictObject({
     touches: z.array(planSchema.shape.touches.unwrap().element).max(TEXT_LIMITS.scopeTouches).optional(),
     acceptance: rubricSchema.optional(),
 }));
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /** A criterion as the reader takes it: only the fields it knows, a null or empty `how` as null. Anything else as is. */
 function criterionBody(entry) {
     if (!isRecord(entry))

package/dist/contracts/scout-report.js

@@ -8,6 +8,7 @@
 import { z } from "zod";
 import { limitRule, TEXT_LIMITS } from "../text-limits.js";
 import { limited, readVersioned, toModelSchema, versioned } from "./contract.js";
+import { isRecord } from "../is-record.js";
 /** How many follow-ups, items and screenshots a report may carry. */
 export const REPORT_COUNTS = { followUps: 5, items: 6, images: 8 };
 /** Caps are BYTES of UTF-8 (v4 review, finding 11): a 64 KiB report is 64 KiB whatever script it is written in. They
@@ -96,7 +97,6 @@ export const scoutHandbackSchema = z.strictObject({
     decision: scoutDecisionSchema.optional(),
 });
 export const SCOUT_OUTPUT_JSON_SCHEMA = toModelSchema(scoutHandbackSchema);
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function pick(body, fields) {
     const out = {};
     for (const field of fields) {

package/dist/contracts/teams-callback.d.ts

@@ -9,6 +9,5 @@ import { type ContractResult } from "./contract.js";
 export declare const teamsSubmitSchema: z.ZodObject<{
     so: z.ZodString;
 }, z.core.$strip>;
-export type TeamsSubmit = z.infer<typeof teamsSubmitSchema>;
 /** A submit's one-time token. */
 export declare function readTeamsSubmit(value: unknown): ContractResult<string>;

package/dist/converse.d.ts

@@ -66,10 +66,6 @@ export declare function priceForConfig(config: {
 }): ModelPrice | null;
 export declare function worstCaseForPrice(price: ModelPrice, promptBytes: number): number;
 export declare function settleForPrice(price: ModelPrice, tokensIn: number, tokensOut: number): number;
-/** The worst a turn can cost, in integer micro-dollars: every prompt byte
- * as a token-third (generous) plus the full output allowance. */
-export declare function worstCaseMicrousd(model: string, promptBytes: number): number | null;
-export declare function settleMicrousd(model: string, tokensIn: number, tokensOut: number): number | null;
 export declare const DIRECT_CHAT_PROVIDERS: readonly DirectChatProviderId[];
 export declare const SUBSCRIPTION_CHAT_PROVIDERS: readonly SubscriptionChatProviderId[];
 export declare function isDirectChatProvider(provider: ChatProviderId): provider is DirectChatProviderId;
@@ -167,8 +163,6 @@ export declare function leadWorstCaseForPrice(price: ModelPrice, baseBytes: numb
     callCap?: number;
     textCap?: number;
 }): number;
-/** The bytes a tool result costs on the wire: its JSON string form. */
-export declare function embeddedBytes(text: string): number;
 export type LeadToolSchema = {
     name: string;
     description: string;

package/dist/converse.js

@@ -131,21 +131,6 @@ export function worstCaseForPrice(price, promptBytes) {
 export function settleForPrice(price, tokensIn, tokensOut) {
     return tokensIn * price.inMicrousd + tokensOut * price.outMicrousd;
 }
-/** The worst a turn can cost, in integer micro-dollars: every prompt byte
- * as a token-third (generous) plus the full output allowance. */
-export function worstCaseMicrousd(model, promptBytes) {
-    const price = priceOf(model);
-    if (price === null)
-        return null;
-    const inputTokens = Math.ceil(promptBytes / 3);
-    return inputTokens * price.inMicrousd + MAX_OUTPUT_TOKENS * price.outMicrousd;
-}
-export function settleMicrousd(model, tokensIn, tokensOut) {
-    const price = priceOf(model);
-    if (price === null)
-        return null;
-    return tokensIn * price.inMicrousd + tokensOut * price.outMicrousd;
-}
 // ---------------------------------------------------------------- keys
 export const DIRECT_CHAT_PROVIDERS = ["anthropic-api", "openrouter-api"];
 export const SUBSCRIPTION_CHAT_PROVIDERS = ["claude-subscription", "codex-subscription"];
@@ -389,10 +374,6 @@ export function leadWorstCaseForPrice(price, baseBytes, caps = {}) {
     }
     return input * price.inMicrousd + S * MAX_OUTPUT_TOKENS * price.outMicrousd;
 }
-/** The bytes a tool result costs on the wire: its JSON string form. */
-export function embeddedBytes(text) {
-    return Buffer.byteLength(JSON.stringify(text), "utf8");
-}
 /** Anthropic prices a cache write at 1.25x and a cache read at 0.1x the input price (5-minute cache). */
 export const CACHE_WRITE_RATIO = 1.25;
 export const CACHE_READ_RATIO = 0.1;

package/dist/daemon.js

@@ -42,6 +42,7 @@ import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 import { isAlive } from "./runner.js";
 import { envTwins } from "./names.js";
+import { sleep as defaultSleep } from "./sleep.js";
 /** A stable fingerprint of a unit's text: the changed-definition test. */
 export function definitionDigest(unitContent) {
     return createHash("sha256").update(unitContent).digest("hex").slice(0, 16);
@@ -52,7 +53,7 @@ export function definitionDigest(unitContent) {
  * appears to succeed, then the pending bootout removes the new job too. Wait
  * for the observable supervisor boundary before loading the replacement.
  */
-async function waitForLaunchdBootout(run, service, attempts = 50, sleep = ms => new Promise(resolve => setTimeout(resolve, ms))) {
+async function waitForLaunchdBootout(run, service, attempts = 50, sleep = defaultSleep) {
     for (let attempt = 0; attempt < attempts; attempt += 1) {
         const status = await run("launchctl", ["print", service]);
         if (status.code !== 0)
@@ -624,7 +625,7 @@ export async function daemonStatus(plan, run) {
  * FRESH one, newer than what stood before the start, so a stale row from
  * the previous incarnation cannot pass for the new controller.
  */
-export async function awaitFreshHeartbeat(store, runnerName, heartbeatBefore, deadlineMs = 5_000, sleep = ms => new Promise(resolve => setTimeout(resolve, ms))) {
+export async function awaitFreshHeartbeat(store, runnerName, heartbeatBefore, deadlineMs = 5_000, sleep = defaultSleep) {
     const deadline = Date.now() + deadlineMs;
     for (;;) {
         const live = store.getRunner(runnerName)?.runner ?? null;

package/dist/decision.d.ts

@@ -14,9 +14,7 @@
  * caps also keep one screen one screen: an option list that needs scrolling
  * has already failed the milestone sentence.
  */
-import { type DecisionOption, type DecisionPayload } from "./contracts/decision.js";
-/** One option as a decision keeps it (src/contracts/decision.ts). */
-export type ParsedOption = DecisionOption;
+import { type DecisionPayload } from "./contracts/decision.js";
 /** A decision as read: the payload's fields, its text trimmed, and the optional ones present or null. */
 export type ParsedDecision = Omit<DecisionPayload, "assignee" | "deadline"> & {
     assignee: string | null;

package/dist/deprecations.d.ts

@@ -1,12 +1,20 @@
 /**
- * D5 (schema v117): one AI concept, the lead. The central team service (`connect`, the central `lead list|create|update|
+ * D5 (schema v117): one AI concept, the lead. The central team service's CLI (the central `lead list|create|update|
  * member|transfer`, `conversation …`, and `chat`/`brief` with --lead, --conversation or a saved profile) and native
- * coding sessions (`session …`) are deprecated. For this release they still work exactly as before, but they are
- * hidden from help, the command contract and the console, and each run says so once on stderr — never on stdout, so a
- * `--json` answer stays one envelope. Their code goes in the next minor release.
+ * coding sessions (`session …`) were deprecated in 0.9.56 and are removed now: each answers with one line naming what
+ * to use instead, changing nothing. `connect` stays — remote commands and `toolroll health` use the profile it saves.
  */
 export type Deprecated = "team" | "session";
 /** The one line a deprecated command prints on stderr: what it is, when it goes, and what to use instead. */
 export declare function deprecationWarning(command: string, kind: Deprecated): string;
 /** What a deprecated console page or API says about itself. */
 export declare const DEPRECATED_PAGE: Record<Deprecated, string>;
+/** The removed command an invocation names, as `{ named, kind }`; null when it is a live command. `chat`/`brief`
+ * without --local went to the central service whenever a profile was saved (`savedProfile`, asked only then): that
+ * invocation is removed too, never quietly run against this computer's lead instead. */
+export declare function removedCommand(argv: readonly string[], savedProfile?: () => boolean): {
+    named: string;
+    kind: Deprecated;
+} | null;
+/** The one line a removed command answers with. */
+export declare function removedMessage(named: string, kind: Deprecated): string;

package/dist/deprecations.js

@@ -1,9 +1,8 @@
 /**
- * D5 (schema v117): one AI concept, the lead. The central team service (`connect`, the central `lead list|create|update|
+ * D5 (schema v117): one AI concept, the lead. The central team service's CLI (the central `lead list|create|update|
  * member|transfer`, `conversation …`, and `chat`/`brief` with --lead, --conversation or a saved profile) and native
- * coding sessions (`session …`) are deprecated. For this release they still work exactly as before, but they are
- * hidden from help, the command contract and the console, and each run says so once on stderr — never on stdout, so a
- * `--json` answer stays one envelope. Their code goes in the next minor release.
+ * coding sessions (`session …`) were deprecated in 0.9.56 and are removed now: each answers with one line naming what
+ * to use instead, changing nothing. `connect` stays — remote commands and `toolroll health` use the profile it saves.
  */
 const NEXT_STEP = {
     team: "Talk to your lead with `toolroll chat`.",
@@ -18,3 +17,27 @@ export const DEPRECATED_PAGE = {
     team: "Team chat is deprecated and will be removed in the next minor release. Your lead in Chat does the same work.",
     session: "Coding sessions are deprecated and will be removed in the next minor release. Queue work as a task instead.",
 };
+const CENTRAL_LEAD_ACTIONS = ["list", "create", "update", "member", "transfer"];
+const CENTRAL_CHAT_FLAGS = ["--profile", "--lead", "--conversation", "--authorize", "--terms-digest", "--request-id"];
+/** The removed command an invocation names, as `{ named, kind }`; null when it is a live command. `chat`/`brief`
+ * without --local went to the central service whenever a profile was saved (`savedProfile`, asked only then): that
+ * invocation is removed too, never quietly run against this computer's lead instead. */
+export function removedCommand(argv, savedProfile = () => false) {
+    const [first, second] = argv;
+    const verb = () => argv.slice(1).find(arg => !arg.startsWith("-")) ?? "";
+    if (first === "session")
+        return { named: `session ${verb()}`.trim(), kind: "session" };
+    if (first === "conversation")
+        return { named: `conversation ${verb()}`.trim(), kind: "team" };
+    if (first === "lead" && second !== "token" && second !== "say" && argv.some(arg => arg === "--profile" || CENTRAL_LEAD_ACTIONS.includes(arg)))
+        return { named: `lead ${verb()}`.trim(), kind: "team" };
+    if ((first === "chat" || first === "brief") && argv.some(arg => CENTRAL_CHAT_FLAGS.includes(arg)))
+        return { named: `${first} --conversation`, kind: "team" };
+    if ((first === "chat" || first === "brief") && !argv.includes("--local") && savedProfile())
+        return { named: `${first} --conversation`, kind: "team" };
+    return null;
+}
+/** The one line a removed command answers with. */
+export function removedMessage(named, kind) {
+    return `\`toolroll ${named}\` was removed. ${NEXT_STEP[kind]}`;
+}

package/dist/desktop-update-recovery.js

@@ -8,9 +8,9 @@ import { bundleHash } from "./desktop-bundle.js";
 import { installLaunchdService, launchdPlist } from "./daemon.js";
 import { run } from "./exec.js";
 import { desktopUpdateStatus, durableJson, installationLock, pauseUpdateRecovery, readUpdateJournal, requestUpdateRestore, sqliteLock, updateTerminal } from "./desktop-update.js";
+import { sleep } from "./sleep.js";
 const recordFile = (j) => join(j.workDir, "recovery.json");
 const app = (j) => join(j.workDir, "Updater.app");
-const sleep = (ms) => new Promise(done => setTimeout(done, ms));
 function readRecovery(j) {
     const file = recordFile(j);
     if (!existsSync(file))

package/dist/desktop-update.js

@@ -1,5 +1,5 @@
 import { createHash, randomUUID } from "node:crypto";
-import { closeSync, chmodSync, copyFileSync, cpSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { closeSync, chmodSync, copyFileSync, cpSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { createRequire } from "node:module";
@@ -14,6 +14,7 @@ import { currentDesktopAccess } from "./desktop-access.js";
 import { assertCodingUpdateStopped, backupCodingCatalog, codingCatalogExists, releaseStaleCodingOwner } from "./coding-update.js";
 import { processMayBeAlive } from "./process-liveness.js";
 import { readDesktopRecoveryView, readDesktopUpdateJournal, supervisorPidsOf, updateRequestIs } from "./contracts/update-journal.js";
+import { sleep as defaultSleep } from "./sleep.js";
 /** Loaded on first use (as backup.ts and store.ts do), so modules that only import this one (the console,
  * and tests that load it in a browser-like environment) never need `node:sqlite` itself. */
 function sqlite() {
@@ -657,7 +658,7 @@ export async function runDesktopUpdate(stateDir, hooks = {}) {
         lock.close();
         throw Error("Another updater is working on this app. Its operation was not interrupted.");
     }
-    const sleep = hooks.sleep ?? (ms => new Promise(done => setTimeout(done, ms)));
+    const sleep = hooks.sleep ?? defaultSleep;
     const control = async (action, bundle, journal) => {
         if (action === "start" && updateStopRequested(journal))
             throw Error("You stopped the background service. Automatic restart is disabled for this update.");

package/dist/discord-chat.js

@@ -3,8 +3,7 @@ import { chatQuestionButtons } from "./subagent-question.js";
 import { chatAskButtons } from "./chat-ask.js";
 import { chatFlowButtons } from "./chat-flow.js";
 import { refuseResultShots, resultShotsPruned, shotWaitsUntil } from "./result-shots.js";
-import { channelInbox } from "./chat-inbox.js";
-import { roomCommand } from "./chat-rooms.js";
+import { admitChatEvent } from "./chat-admission.js";
 import { ChatState, ChatDeliveryError, chatHash, partContent, } from "./chat-delivery-state.js";
 import { readChatPart } from "./contracts/chat-content.js";
 import { readDiscordButtonToken, readDiscordComponentInteraction } from "./contracts/discord-callback.js";
@@ -100,20 +99,10 @@ export function receiveDiscord(state, identity, type, raw, now) {
         !discordId(thread) ||
         member === identity.bot)
         return false;
-    const words = "text" in payload ? payload.text ?? "" : "";
-    // v89: a channel that feeds a flow takes anyone's message (as a card, with no say over anything); "flow 12" connects one.
-    const inbox = isRoom && kind === "message" ? channelInbox(state.store, "discord", identity.installation, String(channel), words) : { watched: false, command: false };
-    const roomish = isRoom && (state.room(identity.installation, String(channel)) !== null || (kind === "message" && roomCommand(words) !== null) || inbox.watched || inbox.command);
-    if (isRoom && !roomish)
-        return false;
-    const binding = state.bindingFor(identity.installation, member);
-    const open = inbox.watched && !inbox.command;
-    if (kind === "pair"
-        ? !!binding || isRoom
-        : !open && (!binding ||
-            !state.live(binding) ||
-            (binding.channel !== channel && !roomish)))
+    const admitted = admitChatEvent(state, "discord", identity.installation, { kind, member, channel, isRoom, payload });
+    if (admitted === null)
         return false;
+    const { binding } = admitted;
     return state.enqueue({
         id: chatHash(`${identity.installation}:${kind === "action" ? "interaction" : "message"}:${id}`),
         installation: identity.installation,

package/dist/discord-settings.d.ts

@@ -1,8 +1,4 @@
 import type { Store } from "./store.js";
 import { type Html } from "./html.js";
-export declare function discordSettingsHtml(store: Store, dir: string, options?: {
-    code?: string;
-    problem?: string;
-    now?: Date;
-    who?: string;
-}): Html;
+import { type ChatSettingsOptions } from "./chat-settings-page.js";
+export declare function discordSettingsHtml(store: Store, dir: string, options?: ChatSettingsOptions): Html;

package/dist/discord-settings.js

@@ -1,41 +1,13 @@
-import { loadPrimary } from "./webhooks.js";
-import { html, postForm } from "./html.js";
+import { html } from "./html.js";
 import { loadDiscordCredentials } from "./discord-api.js";
-import { ChatState } from "./chat-delivery-state.js";
+import { chatSettingsHtml } from "./chat-settings-page.js";
 export function discordSettingsHtml(store, dir, options = {}) {
-    const credentials = loadDiscordCredentials(dir), state = new ChatState(store, "discord"), bindings = credentials ? state.bindings(credentials.installation).filter(one => state.live(one)) : [], binding = options.who === undefined ? null : bindings.find(one => one.approver === options.who) ?? null, others = bindings.length - (binding === null ? 0 : 1);
-    const runtime = credentials ? state.runtime(credentials.installation) : null;
-    const now = options.now ?? new Date(), live = runtime &&
-        runtime.leaseUntil !== null &&
-        runtime.leaseUntil > now.toISOString() &&
-        runtime.connected;
-    const password = html `<label>Your Toolroll password<input style="min-height:44px" type="password" name="password" autocomplete="current-password" required></label>`;
-    const post = (action, content) => postForm(`/settings/discord/${action}`, content, { attrs: { class: "card" } });
-    const parts = [];
-    if (!credentials) {
-        parts.push(html `<p>Manage projects and review results in a private Discord conversation.</p>`, html `<details open><summary>Create your Discord app</summary><ol><li><a href="https://discord.com/developers/applications" target="_blank" rel="noopener noreferrer">Create an application</a>, then copy its token from the Bot page.</li><li>Keep the Interactions Endpoint URL empty and privileged intents off.</li><li>Under Installation, enable Guild Install with the bot scope and no server permissions. Use its install link to add it to your server, then open a direct message to the bot.</li></ol></details>`, post("connect", html `<label>Bot token<input style="min-height:44px" type="password" name="bot-token" autocomplete="off" required></label>${password}<p class="meta">The token stays on this installation. Next, pair your own Discord account.</p><button type="submit">Connect Discord</button>`));
-    }
-    else {
-        parts.push(html `<p><strong>${credentials.workspace}</strong> · ${live ? "Connected" : "Waiting for connection"}</p>`);
-        if (runtime?.problem)
-            parts.push(html `<p role="status">${String(runtime.problem)}</p>`);
-        if (!live && !runtime?.problem)
-            parts.push(html `<p>Keep the Toolroll worker running to receive Discord messages.</p>`);
-        if (options.code) {
-            parts.push(html `<h2>Pair your account</h2><p>Send this in a direct message to your Toolroll Discord app. It expires in 10 minutes.</p>`, html `<label>Pairing message<input type="text" readonly value="pair ${options.code}" autocomplete="off" style="width:100%;max-width:100%;font-size:14px;min-height:44px"></label>`, html `<a class="button-link" style="min-height:44px;white-space:nowrap" href="/settings/discord">Check connection</a>`);
-        }
-        else if (binding && state.live(binding)) {
-            const { pending, dropped: failed } = state.partCounts(binding.id);
-            parts.push(html `<p>Your Discord account is paired.${others ? ` ${others} teammate${others === 1 ? " is" : "s are"} paired too.` : ""}${pending ? ` ${pending} replies waiting to send.` : ""}${failed ? ` ${failed} replies could not be delivered. Open the saved chat to recover them.` : ""}</p>`, html `<p>Try “What needs my attention?” or “Show the evidence for the latest result.”</p>`, html `<p><a href="/chat">Open saved chat</a></p>`, loadPrimary(process.env, dir) === "discord"
-                ? html `<p>Task updates are sent here.</p>`
-                : post("alerts", html `<button type="submit">Send task updates here</button>`));
-        }
-        else {
-            parts.push(post("pair", html `<h2>Pair your account</h2><p>Your paired Discord account can read your connected projects and confirm proposed changes. Password approvals still open in Toolroll.${others ? ` ${others} teammate${others === 1 ? " is" : "s are"} already paired.` : ""}</p>${password}<button type="submit">Create pairing code</button>`));
-        }
-        if (binding && state.live(binding) && !options.code)
-            parts.push(post("unpair", html `${password}<p class="meta">Unpairing ends every open button in your chat. Teammates are unaffected.</p><button type="submit">Unpair my account</button>`));
-        parts.push(html `<details><summary>Connection settings</summary>${post("disconnect", html `${password}<button type="submit">Disconnect Discord</button>`)}</details>`);
-    }
-    return html `<section style="max-width:42rem;overflow-wrap:anywhere"><p><a href="/settings">Settings</a></p><h1>Discord</h1>${options.problem ? html `<p class="problem" role="alert">${options.problem}</p>` : ""}${parts}<details><summary>Access and setup</summary><p>Private messages and replies use your Toolroll permissions. Shared channels are not supported. Secure review links use this installation’s configured HTTPS console address.</p><p>The worker connects out to Discord. It does not need a public webhook or a Tailscale account.</p></details></section>`;
+    return chatSettingsHtml(store, dir, options, {
+        provider: "discord",
+        label: "Discord",
+        credentials: loadDiscordCredentials(dir),
+        setup: html `<details open><summary>Create your Discord app</summary><ol><li><a href="https://discord.com/developers/applications" target="_blank" rel="noopener noreferrer">Create an application</a>, then copy its token from the Bot page.</li><li>Keep the Interactions Endpoint URL empty and privileged intents off.</li><li>Under Installation, enable Guild Install with the bot scope and no server permissions. Use its install link to add it to your server, then open a direct message to the bot.</li></ol></details>`,
+        connect: password => html `<label>Bot token<input style="min-height:44px" type="password" name="bot-token" autocomplete="off" required></label>${password}<p class="meta">The token stays on this installation. Next, pair your own Discord account.</p><button type="submit">Connect Discord</button>`,
+        access: html `<p>Private messages and replies use your Toolroll permissions. Shared channels are not supported. Secure review links use this installation’s configured HTTPS console address.</p><p>The worker connects out to Discord. It does not need a public webhook or a Tailscale account.</p>`,
+    });
 }

package/dist/discord.js

@@ -1,6 +1,6 @@
 /** A single leased Discord Gateway connection, hosted by the ordinary worker. */
 import { randomBytes } from "node:crypto";
-import { setTimeout as sleep } from "node:timers/promises";
+import { abortablePause, workChatQueue } from "./chat-follow.js";
 import { loadDiscordCredentials, discordApi, object, discordId, } from "./discord-api.js";
 import { ChatState, chatHash } from "./chat-delivery-state.js";
 import { receiveDiscord, processDiscordEvent, deliverDiscordPart, planDiscordNotifications, planDiscordRooms, } from "./discord-chat.js";
@@ -12,14 +12,7 @@ export function discordReadyMatches(raw, identity) {
 }
 export async function followDiscord(options) {
     const owner = randomBytes(16).toString("hex"), state = new ChatState(options.store, "discord");
-    const pause = async (ms) => {
-        try {
-            await sleep(ms, undefined, { signal: options.signal });
-        }
-        catch {
-            /* shutdown */
-        }
-    };
+    const pause = abortablePause(options.signal);
     while (!options.signal.aborted) {
         const credentials = loadDiscordCredentials(options.dir);
         if (!credentials ||
@@ -129,20 +122,16 @@ export async function followDiscord(options) {
         };
         try {
             await client.login(credentials.botToken);
-            while (same()) {
-                if (!connected || state.retryAt(credentials.installation) > new Date().toISOString()) {
-                    await pause(1000);
-                    continue;
-                }
-                await processDiscordEvent(chat);
-                if (same())
-                    await planDiscordRooms(chat);
-                if (same())
-                    await deliverDiscordPart(chat);
-                if (same() && options.notifications())
-                    await planDiscordNotifications(chat);
-                await pause(1000);
-            }
+            await workChatQueue({
+                same,
+                ready: () => connected && !(state.retryAt(credentials.installation) > new Date().toISOString()),
+                pause,
+                notifications: () => options.notifications(),
+                process: () => processDiscordEvent(chat),
+                rooms: () => planDiscordRooms(chat),
+                deliver: () => deliverDiscordPart(chat),
+                notify: () => planDiscordNotifications(chat),
+            });
         }
         catch {
             if (alive)

package/dist/evidence.d.ts

@@ -80,7 +80,6 @@ export declare function evidenceRoot(home: string): string;
  * name. The agent learns the name from its brief and nowhere else.
  */
 export declare function mailboxName(): string;
-export declare function looksLikeMailbox(name: string): boolean;
 /** Every protocol file the sweep must never let an old attempt leave behind.
  * The pre-rename NIGHTORDERS- prefix stays recognized here — a worktree cut
  * down before 2026-08-13 may still hold one, and cleanup has no vintage. */

package/dist/evidence.js

@@ -128,9 +128,6 @@ export function evidenceRoot(home) {
 export function mailboxName() {
     return `${MAILBOX_PREFIX}${randomBytes(8).toString("hex")}${MAILBOX_SUFFIX}`;
 }
-export function looksLikeMailbox(name) {
-    return name.startsWith(MAILBOX_PREFIX) && name.endsWith(MAILBOX_SUFFIX);
-}
 /** Every protocol file the sweep must never let an old attempt leave behind.
  * The pre-rename NIGHTORDERS- prefix stays recognized here — a worktree cut
  * down before 2026-08-13 may still hold one, and cleanup has no vintage. */

package/dist/exec.d.ts

@@ -246,15 +246,6 @@ export declare function run(file: string, args: readonly string[], options?: Run
  * worst useful case while remaining a hard, per-event memory boundary.
  */
 export declare const JSONL_EVENT_HARD_CAP: number;
-/**
- * The accounting an oversized Claude result still carries, read by a bounded scan of its kept prefix and tail: the
- * session's running `total_cost_usd`, its `usage` and `num_turns`, and whether it is a main result at all (an
- * `origin` naming anything but a person makes it a background task's). Anything unreadable or seen twice is absent.
- */
-export declare function scanOversizedClaudeResult(prefix: Buffer, tail: Buffer | undefined): {
-    primary: boolean;
-    account: Record<string, unknown>;
-};
 /** Marks a Claude result whose session cost could not be read: the gateway charges the run's dollar cap instead. */
 export declare const CLAUDE_COST_UNKNOWN = "standing_orders_cost_unknown";
 export declare function runStreamJsonl(file: string, args: readonly string[], options?: RunOptions): Promise<ExecResult>;