toolroll 0.9.27 → 0.9.29

package/dist/flow-steps.js

@@ -27,12 +27,13 @@ import { join } from "node:path";
 import { approvedCommandShell, redactSecretAssignments, SETUP_ENV_ALLOWLIST, SETUP_ENV_DENYLIST } from "./builder.js";
 import { assignmentOf } from "./assignment.js";
 import { redactSecretLines, scanForSecrets } from "./evidence.js";
-import { flowDefinitionOf } from "./flow-engine.js";
+import { flowCardHref, flowDefinitionOf } from "./flow-engine.js";
 import { cardFollowers, notifyPeople } from "./flow-people.js";
 import { LINEAR_URL, readLinearKey } from "./flow-triggers.js";
 import { cardEmailOf, fillFlowText } from "./flows.js";
 import { JEV_MODEL, askJev, readJevAnswers, sortLog, sortRequest, sortState, sortWords } from "./flow-sort.js";
-import { claudeDraftRunner, DRAFT_TIMEOUT, draftPrompt, keptDraft } from "./flow-draft.js";
+import { claudeDraftRunner, DRAFT_CHARS, DRAFT_TIMEOUT, draftPrompt, wholeDraft } from "./flow-draft.js";
+import { overruns, passOn, TEXT_LIMITS, writeWithin } from "./text-limits.js";
 import { readFlowSecrets, sendingReady, runRequest, sendEmail, toolWaiting, useTool } from "./flow-actions.js";
 import { cleanFolder, runCode } from "./flow-code.js";
 import { agentFence } from "./agent-fence.js";
@@ -246,7 +247,13 @@ function settle(store, definition, stage, card, outcome, now, durationMs) {
         outcome = { state: "failed", said: `${outcome.said} It didn't work after three tries.` };
     }
     store.finishFlowStep(card.id, card.entry, { state: outcome.state === "passed" ? "passed" : "failed", result: outcome.said, ...kept }, now);
-    store.updateFlowCard(card.id, { outputs: { ...card.outputs, [stage.id]: outcome.output ?? outcome.said }, waiting: null }, now);
+    // What the steps after it read: whole up to TEXT_LIMITS.stageOutput; longer is attached whole to the card's discussion,
+    // and they read a link to it. Never cut.
+    const whole = outcome.output ?? outcome.said;
+    const passed = passOn(whole, TEXT_LIMITS.stageOutput, { label: "the card's discussion", href: flowCardHref(card.flow, card.id) });
+    if (passed.kept)
+        store.addFlowComment({ card: card.id, author: "flow", body: `What ${stage.title} produced, in full (${whole.length.toLocaleString("en-US")} characters):\n\n${whole}`, mentions: [] }, now);
+    store.updateFlowCard(card.id, { outputs: { ...card.outputs, [stage.id]: passed.text }, waiting: null }, now);
     const titleOf = (id) => definition.stages.find(one => one.id === id)?.title ?? "another zone";
     if (outcome.state === "passed") {
         // A sort names where the card goes; one it isn't sure about is a person's to place.
@@ -289,16 +296,32 @@ function draftModel(store) {
 /** A draft: Claude writes what the zone asks, from the card, with the lead chat's Claude model; the text stays on the card. */
 async function draftCard(store, definition, stage, card, io, repo, now) {
     const model = draftModel(store);
-    const answer = await (io.draft ?? claudeDraftRunner())({ model, prompt: draftPrompt(stage, card, definition), timeoutMs: DRAFT_TIMEOUT });
+    const runner = io.draft ?? claudeDraftRunner();
+    // Claude is told the limit before it writes; a draft over it is asked once to shorten, and one still over is kept whole
+    // in the step's log and attached to the card's discussion, linked from what the next steps read (settle): never cut.
+    let first = null;
+    const written = await writeWithin(async (shorten) => {
+        const answer = await runner({ model, prompt: draftPrompt(stage, card, definition, shorten === null || first === null ? null : { draft: first, ask: shorten }), timeoutMs: DRAFT_TIMEOUT });
+        // v105: what it cost, billed as this computer's Claude does (a plan's is $0).
+        if (answer.ok) {
+            store.recordDraftSpend({ repo, model: model === "default" ? null : model, costUsd: answer.costUsd ?? null }, now);
+            first ??= wholeDraft(answer.text);
+        }
+        return answer;
+    }, answer => answer.ok ? overruns({ draft: wholeDraft(answer.text) }, { draft: DRAFT_CHARS }) : []);
+    const answer = written.answer;
     if (!answer.ok)
-        return { state: "retry", said: answer.said };
-    // v105: what it cost, billed as this computer's Claude does (a plan's is $0).
-    store.recordDraftSpend({ repo, model: model === "default" ? null : model, costUsd: answer.costUsd ?? null }, now);
-    const text = keptDraft(answer.text);
+        return written.repaired && first !== null ? draftOutcome(first, model, null, true) : { state: "retry", said: answer.said };
+    const text = wholeDraft(answer.text);
     if (text === "")
-        return { state: "retry", said: "Claude's draft came back empty." };
+        return written.repaired && first !== null ? draftOutcome(first, model, answer.ms, true) : { state: "retry", said: "Claude's draft came back empty." };
+    return draftOutcome(text, model, answer.ms, written.repaired);
+}
+/** A draft step's result: the draft whole, on the card and in its log. */
+function draftOutcome(text, model, ms, shortened) {
     const words = text.split(/\s+/).filter(Boolean).length;
-    return { state: "passed", said: `Drafted ${words} word${words === 1 ? "" : "s"}.`, output: text, log: `Claude (${model}) · ${(answer.ms / 1000).toFixed(1)} s\n\n${text}` };
+    const over = text.length > DRAFT_CHARS ? ` It is still over the ${DRAFT_CHARS.toLocaleString("en-US")}-character limit after one ask to shorten, so it is kept whole.` : shortened ? " Shortened once to fit." : "";
+    return { state: "passed", said: `Drafted ${words} word${words === 1 ? "" : "s"}.${over}`, output: text, log: `Claude (${model})${ms === null ? "" : ` · ${(ms / 1000).toFixed(1)} s`}\n\n${text}` };
 }
 /** A sort: Jev picks one of the zone's answers for the card; the answer (or the not-sure path) says where it goes. */
 async function sortCard(definition, stage, card, key, io) {

package/dist/flows.d.ts

@@ -167,6 +167,14 @@ export declare function deciderOf(stage: Pick<FlowStage, "approver" | "toOwner">
 export declare function validateFlowDefinition(input: unknown, options?: {
     stored?: boolean;
 }): FlowDefinition;
+/** The instructions 0.9.26 and earlier read from a saved zone: they re-check this length on every read, and a flow with a
+ * longer one won't load. A saved zone keeps its first part under it, and the rest in `instructionsMore`, which they ignore. */
+export declare const FLOW_INSTRUCTIONS_STORED = 4000;
+/** A flow's definition as the store saves it: any zone's instructions over FLOW_INSTRUCTIONS_STORED are split, so a
+ * person who goes back a version still opens the flow (with its instructions' first part). Unchanged otherwise. */
+export declare function flowDefinitionForStore(json: string): string;
+/** A saved flow's definition with every zone's instructions whole again (flowDefinitionForStore). */
+export declare function flowDefinitionFromStore(json: string): string;
 /** The zones a card can reach from `start` without passing through a zone `stop` picks (those zones aren't included). */
 export declare function reachableWithout(stages: readonly FlowStage[], start: string, stop: (stage: FlowStage) => boolean): Set<string>;
 /** The zones a choose zone's options lead to (an option that ends the card leads to none). */
@@ -183,20 +191,27 @@ type FlowFillCard = {
 };
 /** Fill a zone's text from the card: title, description, the latest note and earlier zones' reports. */
 export declare function fillFlowText(template: string, card: FlowFillCard, encode?: (value: string) => string): string;
-/** The task door's goal limit (task-text.ts). A work zone's goal is kept under it. */
-export declare const FLOW_GOAL_LIMIT = 2000;
-/** What stands in for the middle of a filled-in value the goal had no room for. */
-export declare const FLOW_CUT = "\u2026 (cut; the full text is on the card)";
+/** The task door's goal limit (task-text.ts). A work zone's goal is kept within it. */
+export declare const FLOW_GOAL_LIMIT: 8000;
+/** What stands in a goal for a filled-in value too long to hold whole: the agent is given it whole, attached (flowGoalCuts). */
+export declare const flowAttachedMark: (label: string) => string;
 /** A work zone's words, plus the card and any send-back note when the words leave them out. "Fix the bug on the card"
  * says nothing on its own (found in the real e2e: the builder saw only the branch name). */
 export declare function flowWorkTemplate(instructions: string, card: {
     description: string | null;
     note: string | null;
 }): string;
-/** A work zone's goal, filled from the card and kept under FLOW_GOAL_LIMIT: the zone's own words stay whole, and only the
- * filled-in values are shortened (the longest first), each keeping its start and end. Null when the words alone leave no
- * room, which a saved flow can't have (validateFlowDefinition). */
-export declare function fitFlowText(template: string, card: FlowFillCard, limit?: number): string | null;
+/** How a filled-in value is named where it is attached: the same words flowGoalCuts labels it with. */
+export declare function flowValueLabel(key: string, stageTitle?: (id: string) => string): string;
+/** A work zone's goal, filled from the card and kept within `limit`: the zone's own words stay whole, and every filled-in
+ * value goes in whole. When they don't all fit, the longest values are attached instead (each named in the goal by
+ * flowAttachedMark, and given to the agent whole by flowGoalCuts) until the rest fits: nothing is cut. Words that fill
+ * the limit to the last character leave attached values a shorter mark, then none (they are still attached). Null only
+ * when the template's own words are over the limit: the caller then files the zone's words alone (flowGoal). */
+export declare function fitFlowText(template: string, card: FlowFillCard, limit?: 8000, stageTitle?: (id: string) => string): string | null;
+/** A work zone's goal for a card: its words, the card and any note, fitted (fitFlowText); when the zone's words leave no
+ * room for the card's own lines, its words alone, with the card attached. Null only for words over the limit. */
+export declare function flowGoal(instructions: string, card: FlowFillCard, stageTitle?: (id: string) => string): string | null;
 /** The first email address a card mentions, or "" — what {{card.email}} holds. */
 export declare function cardEmailOf(card: {
     title: string;

package/dist/flows.js

@@ -47,6 +47,7 @@
  * The engine is deterministic and model-free: it runs in the worker's pass
  * beside routines, and no card ever skips an approval the task itself needs.
  */
+import { TEXT_LIMITS } from "./text-limits.js";
 import { createHash } from "node:crypto";
 export const FLOW_STAGE_KINDS = ["inbox", "task", "report", "approval", "check", "pull-request", "update", "notify", "sort", "draft", "request", "email", "tool", "wait", "teammate", "send", "choose", "done"];
 export const FLOW_COLORS = ["slate", "blue", "violet", "amber", "green", "rose"];
@@ -310,7 +311,8 @@ export function validateFlowDefinition(input, options = {}) {
         return {
             id, title, kind: kind,
             zone: { x: coordinate(zone["x"], -20000, 20000, index * 320), y: coordinate(zone["y"], -20000, 20000, 0), w: coordinate(zone["w"], 220, 1200, 280), h: coordinate(zone["h"], 160, 1600, 360), color },
-            instructions: text(stage["instructions"], 4000),
+            // Reading a saved flow never re-checks length: a limit is for writing.
+            instructions: text(stage["instructions"], options.stored ? Number.POSITIVE_INFINITY : TEXT_LIMITS.flowInstructions),
             planning: kind === "task" ? planning ?? "auto" : null,
             approver: kind === "approval" && stage["toOwner"] !== true ? text(stage["approver"], 64) : null,
             ...(kind === "approval" && stage["toOwner"] === true ? { toOwner: true } : {}),
@@ -356,11 +358,6 @@ export function validateFlowDefinition(input, options = {}) {
             throw new Error(`Zone ${stage.title}: an answer can't send cards back into the same zone.`);
         if ((stage.kind === "task" || stage.kind === "report") && stage.instructions === null)
             throw new Error(`Zone ${stage.title}: say what the agent should do.`);
-        // A work zone's goal must fit a task: its own words whole, with room left for the card's details. Refused here, when the flow
-        // is saved, never when a card arrives. A flow saved before this rule is still read, and its card says why it can't file.
-        const over = !options.stored && (stage.kind === "task" || stage.kind === "report") && stage.instructions !== null ? flowGoalOverflow(stage.instructions) : 0;
-        if (over > 0)
-            throw new Error(`Zone ${stage.title}: its instructions leave no room for the card's details. Shorten them by ${over} characters.`);
         if (stage.kind === "draft" && stage.instructions === null)
             throw new Error(`Zone ${stage.title}: say what Claude should write.`);
         if (stage.kind === "notify" && stage.message === null)
@@ -381,6 +378,59 @@ export function validateFlowDefinition(input, options = {}) {
     }
     return { version: 1, start, stages };
 }
+/** The instructions 0.9.26 and earlier read from a saved zone: they re-check this length on every read, and a flow with a
+ * longer one won't load. A saved zone keeps its first part under it, and the rest in `instructionsMore`, which they ignore. */
+export const FLOW_INSTRUCTIONS_STORED = 4000;
+/** A flow's definition as the store saves it: any zone's instructions over FLOW_INSTRUCTIONS_STORED are split, so a
+ * person who goes back a version still opens the flow (with its instructions' first part). Unchanged otherwise. */
+export function flowDefinitionForStore(json) {
+    let raw;
+    try {
+        raw = JSON.parse(json);
+    }
+    catch {
+        return json;
+    }
+    const stages = raw?.stages;
+    if (!Array.isArray(stages))
+        return json;
+    let split = false;
+    const kept = stages.map(one => {
+        const stage = one;
+        const words = stage?.["instructions"];
+        if (stage === null || typeof stage !== "object" || typeof words !== "string" || words.length <= FLOW_INSTRUCTIONS_STORED)
+            return one;
+        let at = FLOW_INSTRUCTIONS_STORED;
+        if (/[\uD800-\uDBFF]/.test(words[at - 1]))
+            at--;
+        split = true;
+        return { ...stage, instructions: words.slice(0, at), instructionsMore: words.slice(at) };
+    });
+    return split ? JSON.stringify({ ...raw, stages: kept }) : json;
+}
+/** A saved flow's definition with every zone's instructions whole again (flowDefinitionForStore). */
+export function flowDefinitionFromStore(json) {
+    if (!json.includes("\"instructionsMore\""))
+        return json;
+    let raw;
+    try {
+        raw = JSON.parse(json);
+    }
+    catch {
+        return json;
+    }
+    const stages = raw?.stages;
+    if (!Array.isArray(stages))
+        return json;
+    const whole = stages.map(one => {
+        const stage = one;
+        if (stage === null || typeof stage !== "object" || typeof stage["instructionsMore"] !== "string")
+            return one;
+        const { instructionsMore, ...rest } = stage;
+        return { ...rest, instructions: `${typeof stage["instructions"] === "string" ? stage["instructions"] : ""}${instructionsMore}` };
+    });
+    return JSON.stringify({ ...raw, stages: whole });
+}
 /** A Pull request zone's merge: true is squash, the default. */
 function validateMerge(value, title) {
     if (value === true)
@@ -498,12 +548,10 @@ const FILLED = /\{\{\s*(card\.title|card\.description|card\.email|note|stage\.([
 export function fillFlowText(template, card, encode = value => value) {
     return template.replace(FILLED, (_match, key, stage) => encode(fillOne(key, stage, card))).trim();
 }
-/** The task door's goal limit (task-text.ts). A work zone's goal is kept under it. */
-export const FLOW_GOAL_LIMIT = 2000;
-/** What stands in for the middle of a filled-in value the goal had no room for. */
-export const FLOW_CUT = "… (cut; the full text is on the card)";
-/** The least room each filled-in value keeps: the cut mark and 20 characters from each end. */
-const VALUE_ROOM = FLOW_CUT.length + 40;
+/** The task door's goal limit (task-text.ts). A work zone's goal is kept within it. */
+export const FLOW_GOAL_LIMIT = TEXT_LIMITS.goal;
+/** What stands in a goal for a filled-in value too long to hold whole: the agent is given it whole, attached (flowGoalCuts). */
+export const flowAttachedMark = (label) => `[${label}: attached in full below]`;
 /** A work zone's words, plus the card and any send-back note when the words leave them out. "Fix the bug on the card"
  * says nothing on its own (found in the real e2e: the builder saw only the branch name). */
 export function flowWorkTemplate(instructions, card) {
@@ -515,50 +563,56 @@ export function flowWorkTemplate(instructions, card) {
     ];
     return [instructions, ...extra].join("\n\n");
 }
-/** Characters a work zone's instructions leave no room for, with every filled-in value kept to its least room. 0 when they fit. */
-function flowGoalOverflow(instructions) {
-    const widest = flowWorkTemplate(instructions, { description: "x", note: "x" });
-    const values = [...widest.matchAll(FILLED)].length;
-    return Math.max(0, widest.replace(FILLED, "").length + values * VALUE_ROOM - (FLOW_GOAL_LIMIT - 1));
-}
 /** Script output can carry carriage returns, colour codes and hidden marks a task goal refuses; the goal drops them. */
 const goalSafe = (value) => value.replace(/\r\n?/g, "\n").replace(/[\u0000-\u0008\u000B-\u001F\u007F-\u009F\u2028\u2029\u061C\u200E\u200F\u202A-\u202E\u2066-\u2069]/g, "");
-/** A value kept to `room` characters: its start and end, with the cut mark between. */
-function cutToRoom(value, room) {
-    if (value.length <= room)
-        return value;
-    const keep = room - FLOW_CUT.length;
-    let head = Math.ceil(keep / 2), from = value.length - (keep - head);
-    if (/[\uD800-\uDBFF]/.test(value[head - 1] ?? ""))
-        head--;
-    if (/[\uDC00-\uDFFF]/.test(value[from] ?? ""))
-        from++;
-    return value.slice(0, head) + FLOW_CUT + value.slice(from);
+/** How a filled-in value is named where it is attached: the same words flowGoalCuts labels it with. */
+export function flowValueLabel(key, stageTitle = id => id) {
+    if (key === "card.title")
+        return "The card's title";
+    if (key === "card.description")
+        return "The card's description";
+    if (key === "card.email")
+        return "The card's email address";
+    if (key === "note")
+        return "The note it was sent back with";
+    const match = /^stage\.([a-z0-9-]+)(?:\.(items|report))?$/.exec(key);
+    if (match === null)
+        return key;
+    return `What ${stageTitle(match[1])} ${match[2] === "items" ? "listed" : match[2] === "report" ? "reported in full" : "found"}`;
 }
-/** A work zone's goal, filled from the card and kept under FLOW_GOAL_LIMIT: the zone's own words stay whole, and only the
- * filled-in values are shortened (the longest first), each keeping its start and end. Null when the words alone leave no
- * room, which a saved flow can't have (validateFlowDefinition). */
-export function fitFlowText(template, card, limit = FLOW_GOAL_LIMIT) {
-    const values = [...template.matchAll(FILLED)].map(match => goalSafe(fillOne(match[1], match[2], card)));
-    const room = limit - 1 - template.replace(FILLED, "").length;
-    let each = Math.max(0, ...values.map(one => one.length));
-    const used = (cap) => values.reduce((sum, one) => sum + Math.min(one.length, cap), 0);
-    if (used(each) > room) {
-        // The widest cap every value can share: the shortest values stay whole, the longest are cut to it.
-        let low = 0, high = each;
-        while (low < high) {
-            const mid = Math.ceil((low + high) / 2);
-            if (used(mid) <= room)
-                low = mid;
-            else
-                high = mid - 1;
-        }
-        each = low;
-        if (each < FLOW_CUT.length + 2)
-            return null;
+/** A work zone's goal, filled from the card and kept within `limit`: the zone's own words stay whole, and every filled-in
+ * value goes in whole. When they don't all fit, the longest values are attached instead (each named in the goal by
+ * flowAttachedMark, and given to the agent whole by flowGoalCuts) until the rest fits: nothing is cut. Words that fill
+ * the limit to the last character leave attached values a shorter mark, then none (they are still attached). Null only
+ * when the template's own words are over the limit: the caller then files the zone's words alone (flowGoal). */
+export function fitFlowText(template, card, limit = FLOW_GOAL_LIMIT, stageTitle) {
+    const matches = [...template.matchAll(FILLED)];
+    const values = matches.map(match => goalSafe(fillOne(match[1], match[2], card)));
+    const marks = matches.map(match => flowAttachedMark(flowValueLabel(match[1], stageTitle)));
+    const attached = new Set();
+    const build = () => { let at = 0; return template.replace(FILLED, () => { const i = at++; return attached.has(i) ? marks[i] : values[i]; }).trim(); };
+    let goal = build();
+    // The longest first, so the fewest values leave the goal.
+    const order = values.map((value, i) => i).filter(i => values[i].length > marks[i].length).sort((a, b) => values[b].length - values[a].length);
+    for (const i of order) {
+        if (goal.length <= limit)
+            break;
+        attached.add(i);
+        goal = build();
     }
-    let at = 0;
-    return template.replace(FILLED, () => cutToRoom(values[at++], each)).trim();
+    for (const shorter of ["[attached]", ""]) {
+        if (goal.length <= limit)
+            break;
+        for (const i of attached)
+            marks[i] = shorter;
+        goal = build();
+    }
+    return goal.length <= limit ? goal : null;
+}
+/** A work zone's goal for a card: its words, the card and any note, fitted (fitFlowText); when the zone's words leave no
+ * room for the card's own lines, its words alone, with the card attached. Null only for words over the limit. */
+export function flowGoal(instructions, card, stageTitle) {
+    return fitFlowText(flowWorkTemplate(instructions, card), card, FLOW_GOAL_LIMIT, stageTitle) ?? fitFlowText(instructions, card, FLOW_GOAL_LIMIT, stageTitle);
 }
 /** The first email address a card mentions, or "" — what {{card.email}} holds. */
 export function cardEmailOf(card) {

package/dist/guides.js

@@ -207,7 +207,7 @@ const steering = {
 ${AUTHORITY_LINE}
 
 Steering is an OPERATOR ceremony. \`task steer <id> --note "..." --as
-<you> --token <t>\` files one short note (≤500 characters) for the
+<you> --token <t>\` files one note (≤4000 characters) for the
 task's NEXT attempt, and the credential is the point: the note appears
 in the agent's brief under an OPERATOR STEERING heading, so only a
 verified person may put words there. Anonymous or agent-authored notes

package/dist/lead-context.d.ts

@@ -1,17 +1,11 @@
-/** Bounded DB memory shared by browser and terminal lead turns. No provider,
- * repository scan, mutation, or hidden approval happens while catching up.
- *
- * The bundle is ordered by importance and built fresh each turn: who the lead
- * is (name, persona), who it is talking to (first name, time zone, today), what
- * it knows about them (their confirmed lines), the people, AI teammates and team
- * chats it works with (one line each), the channel, what needs them now,
- * projects by name with their active decisions, then the rest. Over 8 KB, the
- * least important goes first: the rest, then people, then decisions. */
 import type { Store } from './store.js';
 import { type AssignmentCatchUp } from './assignment-brief.js';
 export declare const LEAD_CONTEXT_MAX_BYTES = 8000;
 /** Where this turn's conversation happens. */
 export type LeadChannel = 'console' | 'terminal' | 'telegram' | 'slack' | 'discord' | 'teams';
+/** One message on the channel, in characters: the lead writes a reply within it (it is told before it writes and asked
+ * once to shorten one over it); a longer reply is split across messages, never cut. Null: no platform limit. */
+export declare const LEAD_REPLY_LIMITS: Record<LeadChannel, number | null>;
 export type LeadContextOptions = {
     evidenceRoot?: string;
     /** The person this turn talks to (their account name). */

package/dist/lead-context.js

@@ -1,3 +1,13 @@
+/** Bounded DB memory shared by browser and terminal lead turns. No provider,
+ * repository scan, mutation, or hidden approval happens while catching up.
+ *
+ * The bundle is ordered by importance and built fresh each turn: who the lead
+ * is (name, persona), who it is talking to (first name, time zone, today), what
+ * it knows about them (their confirmed lines), the people, AI teammates and team
+ * chats it works with (one line each), the channel, what needs them now,
+ * projects by name with their active decisions, then the rest. Over 8 KB, the
+ * least important goes first: the rest, then people, then decisions. */
+import { PLATFORM_LIMITS } from './text-limits.js';
 import { activeDecisionsOf, assignmentCatchUp } from './assignment-brief.js';
 import { publicChatText } from './chat-display.js';
 import { leadIdentityOf } from './lead-identity.js';
@@ -37,13 +47,19 @@ function followThrough(store, owner, thread) {
         ...(corrections.length === 0 ? {} : { followThrough: 'The operator confirmed these corrections since your last reply. Re-check the open proposals and promises listed here; release or replace any they affect and say in one line what you changed.' }) };
 }
 export const LEAD_CONTEXT_MAX_BYTES = 8_000;
+/** One message on the channel, in characters: the lead writes a reply within it (it is told before it writes and asked
+ * once to shorten one over it); a longer reply is split across messages, never cut. Null: no platform limit. */
+export const LEAD_REPLY_LIMITS = {
+    console: null, terminal: null, telegram: PLATFORM_LIMITS.telegram, slack: PLATFORM_LIMITS.slack, discord: PLATFORM_LIMITS.discord, teams: PLATFORM_LIMITS.teams,
+};
+const within = (channel) => { const limit = LEAD_REPLY_LIMITS[channel]; return limit === null ? '' : ` Keep each reply within ${limit.toLocaleString('en-US')} characters, one message; a longer one is split across messages.`; };
 const CHANNEL_WORDS = {
     console: 'The Toolroll console in a browser: cards and links show beside your reply.',
     terminal: 'The Toolroll CLI in a terminal: plain text only.',
-    telegram: 'Telegram on their phone: a few short lines, the most important first.',
-    slack: 'A Slack thread: a few short lines; teammates may read it.',
-    discord: 'A Discord thread: a few short lines; teammates may read it.',
-    teams: 'A Microsoft Teams thread: a few short lines; teammates may read it.',
+    telegram: `Telegram on their phone: a few short lines, the most important first.${within('telegram')}`,
+    slack: `A Slack thread: a few short lines; teammates may read it.${within('slack')}`,
+    discord: `A Discord thread: a few short lines; teammates may read it.${within('discord')}`,
+    teams: `A Microsoft Teams thread: a few short lines; teammates may read it.${within('teams')}`,
 };
 /** "alex.pelletier@example.com" → "Alex". */
 export function firstNameOf(account) {
@@ -114,7 +130,7 @@ export function leadContext(store, repos, now, options = {}) {
         you: { firstName, ...localNow(now, options.timeZone ?? Intl.DateTimeFormat().resolvedOptions().timeZone) },
         aboutYou,
         people: { people: [], teammates: [], teams: [] },
-        channel: options.channel === undefined ? null : { id: options.channel, fit: CHANNEL_WORDS[options.channel] },
+        channel: options.channel === undefined ? null : { id: options.channel, fit: CHANNEL_WORDS[options.channel], replyLimit: LEAD_REPLY_LIMITS[options.channel] },
         needsYou: brief.assignments.filter(needs).map(task),
         ...(options.owner === undefined || options.thread === undefined ? {} : followThrough(store, options.owner, options.thread)),
         projects,

package/dist/lead-status.js

@@ -114,19 +114,21 @@ export function taskWaitSnapshot(store, taskId, now, watchedRun) {
         const next = holdKind === "operator" ? "Remove hold" : holdKind === "revision" ? "Review plan" : holdKind === "stop" ? "Resume or close attempt" : holdKind === "contest" ? "Choose a result" : "Review task";
         return answer("Needs a person", next, true, 1, "needs-person");
     }
-    if (task["plan"] === "drafted")
-        return answer("Needs a person", "Approve plan", true, 1, "needs-person");
-    if (Number(task["strikes"] ?? 0) >= 3)
-        return answer("Needs a person", "Review repeated failures", true, 1, "needs-person");
     // An admitted attempt is already the work being watched. Its immutable
     // approval snapshot lives on the run, so a damaged or later-edited current
     // scope must not make `wait` abandon that attempt before it settles.
     if (attempt !== undefined)
         return answer("Running", phase === null ? "Wait for attempt" : `Wait — ${phase}`, false, null, null);
-    const scope = store.handle.prepare("SELECT digest, approved_digest, profile_state FROM task_scope WHERE task_id = ?").get(taskId);
+    const scope = store.handle.prepare(`SELECT digest, approved_digest, profile_state,
+    (approved_at IS NOT NULL AND approved_by IS NOT NULL AND approved_digest = digest) AS approved
+    FROM task_scope WHERE task_id = ?`).get(taskId);
+    if (task["plan"] === "drafted" && Number(scope?.["approved"]) !== 1)
+        return answer("Needs a person", "Approve plan", true, 1, "needs-person");
+    if (Number(task["strikes"] ?? 0) >= 3)
+        return answer("Needs a person", "Review repeated failures", true, 1, "needs-person");
     if (scope === undefined)
         return answer("Needs a person", "Add scope", true, 1, "needs-person");
-    if (scope["approved_digest"] !== scope["digest"] || scope["profile_state"] !== "resolved")
+    if (Number(scope["approved"]) !== 1 || scope["profile_state"] !== "resolved")
         return answer("Needs a person", "Approve task", true, 1, "needs-person");
     if (state === "running" && attempt === undefined) {
         const liveClaim = store.handle.prepare(`SELECT 1 AS hit FROM claim INDEXED BY claim_by_task
@@ -157,7 +159,7 @@ function queueReason(row) {
         return "needs a result choice";
     if (hold === "backoff")
         return "retrying later";
-    if (row["plan"] === "drafted")
+    if (row["plan"] === "drafted" && Number(row["approved"]) !== 1)
         return "needs plan review";
     if (Number(row["strikes"] ?? 0) >= 3)
         return "stalled after failures";
@@ -165,7 +167,7 @@ function queueReason(row) {
         return "waiting for another task";
     if (row["scope_digest"] == null)
         return "needs a scope";
-    if (row["approved_digest"] !== row["scope_digest"] || row["profile_state"] !== "resolved")
+    if (Number(row["approved"]) !== 1 || row["profile_state"] !== "resolved")
         return "needs approval";
     return "ready for a worker";
 }
@@ -181,7 +183,7 @@ export function repairStaleStatuses(store, now) {
 }
 /** `viewer`: the person asking (the lead asks as its person); null when nobody is known, which shows no lead. */
 export function installationStatus(store, now, viewer = currentActor()?.account ?? null) {
-    const runningRows = store.handle.prepare(`SELECT run.id, run.role, run.phase, ref.external_id AS task
+    const runningRows = store.handle.prepare(`SELECT run.id, run.role, run.phase, ref.id AS task_ref, ref.external_id AS task
     FROM run INDEXED BY work_unfinished
     JOIN task_ref AS ref ON ref.id = run.task_ref
     JOIN claim ON claim.lease_id = run.lease_id
@@ -194,8 +196,10 @@ export function installationStatus(store, now, viewer = currentActor()?.account
         phases.set(phase, (phases.get(phase) ?? 0) + 1);
         return { task: String(row["task"]), run: Number(row["id"]), phase };
     });
-    const queuedRows = store.handle.prepare(`SELECT task.id, ref.plan, ref.strikes, scope.digest AS scope_digest,
-      scope.approved_digest, scope.profile_state,
+    const runningRefs = new Set(runningRows.map(row => Number(row["task_ref"])));
+    const queuedRows = store.handle.prepare(`SELECT task.id, ref.id AS task_ref, ref.plan, ref.strikes, scope.digest AS scope_digest,
+      scope.profile_state,
+      (scope.approved_at IS NOT NULL AND scope.approved_by IS NOT NULL AND scope.approved_digest = scope.digest) AS approved,
       EXISTS (SELECT 1 FROM task_edge WHERE task_edge.blocked = task.id
         AND EXISTS (SELECT 1 FROM task AS blocker WHERE blocker.id = task_edge.blocker AND blocker.state <> 'done')) AS blocked,
       (SELECT owner_kind FROM hold INDEXED BY hold_by_task WHERE hold.task_ref = ref.id AND (hold.until IS NULL OR hold.until > ?)
@@ -203,7 +207,8 @@ export function installationStatus(store, now, viewer = currentActor()?.account
     FROM task INDEXED BY task_by_state
     JOIN task_ref AS ref INDEXED BY sqlite_autoindex_task_ref_1 ON ref.backend = ? AND ref.external_id = task.id
     LEFT JOIN task_scope AS scope ON scope.task_id = task.id
-    WHERE task.state = 'queued'`).all(now.toISOString(), BUILT_IN);
+    WHERE task.state = 'queued'`).all(now.toISOString(), BUILT_IN)
+        .filter(row => !runningRefs.has(Number(row["task_ref"])));
     const reasons = new Map();
     const queuedTasks = [];
     const pauses = openAuthPauses(store);

package/dist/mate-doors.js

@@ -20,7 +20,7 @@ import { isVerifiedApprover, reproveApprover } from "./principal.js";
 import { TeamLeads } from './team-leads.js';
 import { fileTaskProposal } from "./proposal.js";
 import { proposeGuarded } from "./scope.js";
-import { isRiskLevel, PHASES, riskTitle, specWords } from "./phase-routing.js";
+import { isRiskLevel, isTaskSize, PHASES, riskTitle, specWords } from "./phase-routing.js";
 import { isProviderId } from "./provider.js";
 import { applyChatReview } from "./chat-review.js";
 import { applyChatTaskAction } from "./chat-task-actions.js";
@@ -454,11 +454,15 @@ function executeProposal(store, actor, kind, payload, now, options) {
         const clear = payload["clear"] === true;
         const provider = payloadString(payload, "provider");
         const model = payloadString(payload, "model");
+        const size = payload["size"];
+        const risky = payload["risky"];
         if (risk !== undefined && !isRiskLevel(risk))
             return refuse("refused", "this proposal carries an unknown risk level");
+        if (size !== undefined && (!isTaskSize(size) || typeof risky !== "boolean"))
+            return refuse("refused", "this proposal carries an unknown size");
         if (phase !== undefined && (typeof phase !== "string" || !PHASES.includes(phase)))
             return refuse("refused", "this proposal names an unknown role");
-        if (risk === undefined && phase === undefined)
+        if (risk === undefined && phase === undefined && size === undefined)
             return refuse("refused", "this proposal changes nothing about the agents");
         let override;
         if (typeof phase === "string") {
@@ -478,6 +482,7 @@ function executeProposal(store, actor, kind, payload, now, options) {
                 return standing.ok ? { ok: true } : { ok: false, reason: `your approver standing changed (${standing.reason}) — sign in again` };
             },
             ...(isRiskLevel(risk) ? { risk } : {}),
+            ...(isTaskSize(size) && typeof risky === "boolean" ? { size: { size, risky } } : {}),
             ...(override === undefined ? {} : { override }),
             expectDigest: payloadString(payload, "sawDigest"),
             // The pair is re-proved against the role's configured choices
@@ -508,6 +513,7 @@ function executeProposal(store, actor, kind, payload, now, options) {
         const roleWord = typeof phase === "string" ? { plan: "planner", build: "builder", repair: "repair", review: "reviewer" }[phase] ?? phase : null;
         const changed = [
             ...(isRiskLevel(risk) ? [`risk is now ${riskTitle(risk).toLowerCase()}`] : []),
+            ...(isTaskSize(size) ? [`it is now a ${size}${risky === true ? ", risky" : ""} change`] : []),
             ...(roleWord === null ? [] : clear ? [`the ${roleWord} choice was cleared — the recommendation stands again`] : [`the ${roleWord} is now ${specWords({ provider: provider, model: model })}`]),
         ];
         return {