toolroll 0.9.65 → 0.9.68

package/dist/contracts/cli.d.ts

@@ -54,37 +54,6 @@ export declare const commandRowSchema: z.ZodReadonly<z.ZodObject<{
         meaning: z.ZodString;
     }, z.core.$loose>>>>>;
     notableReasons: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-    inputSchema: z.ZodOptional<z.ZodCustom<{
-        type: 'object';
-        additionalProperties: false;
-        required: readonly string[];
-        properties: Record<string, {
-            type: 'string' | 'integer' | readonly ['string', 'null'];
-            minLength?: number;
-            maxLength?: number;
-            pattern?: string;
-            minimum?: number;
-            maximum?: number;
-            maxBytes?: number;
-            nonblank?: boolean;
-            const?: number;
-        }>;
-    }, {
-        type: 'object';
-        additionalProperties: false;
-        required: readonly string[];
-        properties: Record<string, {
-            type: 'string' | 'integer' | readonly ['string', 'null'];
-            minLength?: number;
-            maxLength?: number;
-            pattern?: string;
-            minimum?: number;
-            maximum?: number;
-            maxBytes?: number;
-            nonblank?: boolean;
-            const?: number;
-        }>;
-    }>>;
     remote: z.ZodEnum<{
         no: "no";
         "step-up": "step-up";
@@ -134,37 +103,6 @@ export declare const COMMAND_OUTPUTS: {
                 meaning: z.ZodString;
             }, z.core.$loose>>>>>;
             notableReasons: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
-            inputSchema: z.ZodOptional<z.ZodCustom<{
-                type: 'object';
-                additionalProperties: false;
-                required: readonly string[];
-                properties: Record<string, {
-                    type: 'string' | 'integer' | readonly ['string', 'null'];
-                    minLength?: number;
-                    maxLength?: number;
-                    pattern?: string;
-                    minimum?: number;
-                    maximum?: number;
-                    maxBytes?: number;
-                    nonblank?: boolean;
-                    const?: number;
-                }>;
-            }, {
-                type: 'object';
-                additionalProperties: false;
-                required: readonly string[];
-                properties: Record<string, {
-                    type: 'string' | 'integer' | readonly ['string', 'null'];
-                    minLength?: number;
-                    maxLength?: number;
-                    pattern?: string;
-                    minimum?: number;
-                    maximum?: number;
-                    maxBytes?: number;
-                    nonblank?: boolean;
-                    const?: number;
-                }>;
-            }>>;
             remote: z.ZodEnum<{
                 no: "no";
                 "step-up": "step-up";

package/dist/contracts/cli.js

@@ -38,8 +38,6 @@ function answers(command, shape) {
 export const commandFlagSchema = z.looseObject({ name: str, takesValue: z.boolean(), meaning: str }).readonly();
 /** The remote policy every command row states; see `remote` below. */
 export const REMOTE_POLICIES = ["yes", "no", "step-up"];
-/** A session operation's executable input schema, as session-contract.ts states it. */
-const sessionInputSchema = z.custom(value => typeof value === "object" && value !== null && !Array.isArray(value));
 export const commandRowSchema = z.looseObject({
     /** What you type after `toolroll` (subcommands included). */
     invocation: str,
@@ -62,8 +60,6 @@ export const commandRowSchema = z.looseObject({
     positionals: z.array(z.looseObject({ name: str, required: z.boolean(), meaning: str }).readonly()).readonly().optional(),
     flags: z.array(commandFlagSchema).readonly().optional(),
     notableReasons: z.array(str).readonly().optional(),
-    /** Session schemas are executable input contracts, not a grant of authority. */
-    inputSchema: sessionInputSchema.optional(),
     /** Whether a person signed in to a central server with their own API token may run it there (`runOperateAs`):
      *  yes — runs as that person, within their token's scope and project access.
      *  no — this machine's own infrastructure, credentials or files; never run for a remote caller.

package/dist/contracts/coding-workspace.js

@@ -6,6 +6,7 @@
 import { z } from "zod";
 import { readVersioned, versioned } from "./contract.js";
 import { CODING_CONTEXT_VERSION, codingContextSchema } from "./coding-context.js";
+import { isRecord } from "../is-record.js";
 export const CODING_STATUSES = ["starting", "ready", "working", "needs-input", "stopping", "interrupted", "failed", "uncertain", "closed"];
 export const codingSessionSchema = z.strictObject({
     id: z.string(),
@@ -33,7 +34,6 @@ export const codingSessionSchema = z.strictObject({
 });
 export const CODING_SESSION_VERSION = 1;
 export const codingSessionRecordSchema = versioned(CODING_SESSION_VERSION, codingSessionSchema.shape);
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /**
  * Unversioned records were read as a cast, including partial fields, nulls and unknown nested keys. Preserve that
  * boundary exactly; only records explicitly written as version 1 are subject to its strict schema.

package/dist/contracts/console-api.d.ts

@@ -83,6 +83,7 @@ export declare const CONSOLE_FORMS: {
     readonly projectConcurrency: FormContract<"concurrency" | "repo">;
     readonly projectLiveView: FormContract<"act" | "nonce" | "password" | "repo">;
     readonly projectNetwork: FormContract<"hosts" | "local" | "mode" | "password" | "repo">;
+    readonly projectWrites: FormContract<"password" | "repo" | "writes">;
     readonly projectDelete: FormContract<"name" | "password" | "repo" | "step">;
     readonly policy: FormContract<"ceiling" | "models" | "password" | "provider" | "tools">;
     readonly approval: FormContract<"not_requester" | "password" | "paths" | "protect" | "repo">;

package/dist/contracts/console-api.js

@@ -92,6 +92,7 @@ export const CONSOLE_FORMS = {
     projectConcurrency: formContract("POST /settings/project/concurrency", ["repo", "concurrency"]),
     projectLiveView: formContract("POST /settings/project/live-view", ["repo", "act", "password", "nonce"]),
     projectNetwork: formContract("POST /settings/project/network", ["repo", "mode", "local", "hosts", "password"]),
+    projectWrites: formContract("POST /settings/project/writes", ["repo", "writes", "password"]),
     projectDelete: formContract("POST /settings/project/delete", ["repo", "name", "step", "password"]),
     policy: formContract("POST /settings/policy", ["password", "provider", "models", "tools", "ceiling"]),
     approval: formContract("POST /settings/approval", ["repo", "password", "protect", "paths", "not_requester"]),

package/dist/contracts/contract.js

@@ -8,6 +8,7 @@
  */
 import { z } from "zod";
 import { limitRule, TEXT_LIMITS } from "../text-limits.js";
+import { isRecord } from "../is-record.js";
 /**
  * A string bounded by its TEXT_LIMITS entry, never a literal. The limit rule rides along as the field's description,
  * so a model reads the bound before it writes. Zod counts UTF-16 code units; for a limit named in bytes this is the
@@ -42,7 +43,6 @@ function got(input) {
         return "an array";
     return typeof input === "object" ? "an object" : `a ${typeof input}`;
 }
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /** The schema at `path`, including whether that value may be omitted, following arrays, wrappers and unions. */
 function nodeAt(schema, input, path) {
     let node = schema, value = input;

package/dist/contracts/flow-card.d.ts

@@ -9,7 +9,6 @@
  */
 import { z } from "zod";
 export declare const FLOW_CARD_STATES: readonly ["active", "done", "cancelled"];
-export type FlowCardState = (typeof FLOW_CARD_STATES)[number];
 export declare const flowCardSchema: z.ZodObject<{
     id: z.ZodInt;
     flow: z.ZodInt;

package/dist/contracts/flow-propose.d.ts

@@ -320,6 +320,5 @@ export declare const proposeFlowInputSchema: z.ZodObject<{
         timeZone: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>], "kind">>;
 }, z.core.$strict>;
-export type ProposeFlowInput = z.infer<typeof proposeFlowInputSchema>;
 /** What the lead is told propose_flow takes: exactly the schema its call is read with. */
 export declare const PROPOSE_FLOW_MODEL_SCHEMA: Readonly<Record<string, unknown>>;

package/dist/contracts/flow-send.js

@@ -12,6 +12,7 @@
  */
 import { z } from "zod";
 import { parseContract, readVersioned, versioned } from "./contract.js";
+import { isRecord } from "../is-record.js";
 /** A link the message carries: a page of Toolroll's (a button) or the one outside page, a pull request. */
 export const flowSendLinkSchema = z.union([
     z.strictObject({ label: z.string(), path: z.string().regex(/^\//, { error: "must be a path in Toolroll, starting with /" }) }),
@@ -51,7 +52,6 @@ export const flowChoosePayloadSchema = versioned(FLOW_SEND_VERSION, {
     /** Whether a reply is taken instead (the zone has somewhere replies go). */
     reply: z.boolean(),
 });
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /** A kept item as 0.9.36 read it: its five words (a web link), and a screenshot id only when it is a whole number. */
 const savedItemSchema = z.object({ ...flowSendItemSchema.shape, shot: z.unknown() });
 export function readFlowItems(raw) {

package/dist/contracts/gateway-tools.d.ts

@@ -371,7 +371,6 @@ export declare const GATEWAY_TOOL_OUTPUTS: {
         admission: z.ZodString;
     }, z.core.$loose>;
 };
-export type GatewayToolOutput<N extends GatewayToolName> = z.infer<(typeof GATEWAY_TOOL_OUTPUTS)[N]>;
 export declare const PERSON_TOOL_INPUTS: {
     readonly status: z.ZodObject<{}, z.core.$strict>;
     readonly list_tasks: z.ZodObject<{

package/dist/contracts/integration-metadata.js

@@ -14,9 +14,9 @@
  */
 import { z } from "zod";
 import { parseContract } from "./contract.js";
+import { isRecord } from "../is-record.js";
 /** RFC 6749 scope tokens. */
 export const SCOPE_TOKEN = /^[\x21\x23-\x5b\x5d-\x7e]{1,128}$/;
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /** A field's schema without its optional wrapper. */
 const inner = (field) => (field instanceof z.ZodOptional ? field.unwrap() : field);
 /**

package/dist/contracts/lead-tools.d.ts

@@ -2003,7 +2003,6 @@ export declare const LEAD_TOOL_OUTPUTS: {
         awaiting: z.ZodString;
     }, z.core.$loose>;
 };
-export type LeadToolOutput<N extends LeadToolName> = z.infer<(typeof LEAD_TOOL_OUTPUTS)[N]>;
 /**
  * Report a result that disagrees with its output schema without hiding the actual result, including under Vitest.
  * Contract tests assert output shapes directly; executing a tool always writes the diagnostic and returns its result.

package/dist/contracts/memory-pass.d.ts

@@ -131,7 +131,6 @@ export declare const memoryEvidenceSchema: z.ZodArray<z.ZodObject<{
     session: z.ZodString;
     quote: z.ZodString;
 }, z.core.$strict>>;
-export type MemoryEvidence = z.infer<typeof memoryEvidenceSchema>;
 /** A proposal as its row reads; its evidence is a JSON list (an older runtime reads it as one, so it has no envelope). */
 export declare const memoryProposalSchema: z.ZodObject<{
     id: z.ZodInt;

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;