toolroll 0.9.27 → 0.9.28

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/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 {

package/dist/mate-tools.js

@@ -1,3 +1,4 @@
+import { TEXT_LIMITS } from "./text-limits.js";
 import { connectionsOf, oneClickOf } from "./mcp-connect.js";
 import { checkLevelFromWords, isCheckLevel } from "./check-levels.js";
 import { policyParts } from "./policy.js";
@@ -42,7 +43,7 @@ import { parseAcceptanceCriteria, ACCEPTANCE_LIMITS, EVIDENCE_KINDS } from "./sc
 import { diagnoseTaskDispatch, withDispatchDiagnoses } from "./dispatch.js";
 import { agentChoicesFor, routeOfTask, INSTALLATION_SCOPE } from "./agentconfig.js";
 import { isNewModel, modelWords, priceWords, runtimeStates, seenModels } from "./model-catalog.js";
-import { agentsSummary, chosenWords, isRiskLevel, PHASES, postureWords, RISK_CHOICES, riskConsequence, riskTitle, routeProblems, sameSpec, specWords } from "./phase-routing.js";
+import { agentsSummary, chosenWords, isRiskLevel, isTaskSize, PHASES, postureWords, RISK_CHOICES, riskConsequence, riskTitle, routeProblems, sameSpec, sizeSourceWords, sizeWords, specWords } from "./phase-routing.js";
 import { TOOL_CATALOG, discoverTools, projectToolsOf, secretsSetFor, toolCommandLine, toolStanding } from "./project-tools.js";
 import { deciderOf, durationWords, FLOW_KIND_WORDS, FLOW_STAGE_KINDS, FLOW_TEMPLATES, flowFromSteps, stepsFor } from "./flows.js";
 import { flowDefinitionOf } from "./flow-engine.js";
@@ -359,6 +360,7 @@ export function agentsOver(store, taskId, now) {
     const base = {
         task: taskId,
         risk: { level: risk, title: riskTitle(risk), consequence: riskConsequence(risk) },
+        size: ref.sizing == null ? null : { size: ref.sizing.size, risky: ref.sizing.risky, reason: ref.sizing.reason, source: sizeSourceWords(ref.sizing.source) },
         riskChoices: RISK_CHOICES.map(one => ({ risk: one.risk, title: one.title, consequence: one.consequence })),
         editable,
         editableWhy,
@@ -378,6 +380,7 @@ export function agentsOver(store, taskId, now) {
         standing: routed.source === "approved" ? "approved" : routed.source === "proposed" ? "awaiting approval" : "recommended",
         summary: agentsSummary(route),
         posture: postureWords(route),
+        sizeWords: sizeWords(route),
         demands: route.demands.filter(reason => !/review/i.test(reason)),
         agents: route.legs.filter(leg => leg.phase !== "review").map(leg => ({ role: ROLE_WORD[leg.phase], provider: leg.provider, model: leg.model, chosen: chosenWords(leg), reasons: leg.reasons.map(reason => reason.replace("builder and reviewer", "builder")), problem: leg.problem })),
         problems: routeProblems(route),
@@ -433,7 +436,7 @@ export const MATE_TOOLS = [
     {
         name: "propose_action",
         description: "Read get_actions and relevant skills/evidence first. Save an exact-state proposal only; protected or long terms require full secure review.",
-        inputSchema: schema({ operation: { type: 'string', enum: Object.keys(CHAT_ACTIONS).filter(one => !one.startsWith('flow_') && !one.startsWith('teammate_')) }, repo: { type: 'string' }, task: TASK_ARG, version: { type: 'string' }, restore: { type: 'integer', minimum: 1 }, sample: { type: 'string', maxLength: 800 }, content: { type: 'string', maxLength: 12000 }, instructions: { type: 'string', maxLength: 4000 }, title: { type: 'string', maxLength: 120 }, id: { type: 'string' }, run: { type: 'integer', minimum: 1 }, note: { type: 'string', maxLength: 2000 }, catalog: { type: 'string', maxLength: 40 }, name: { type: 'string', maxLength: 40 }, command: { type: 'string', maxLength: 400 }, args: { type: 'array', items: { type: 'string', maxLength: 400 }, maxItems: 40 }, url: { type: 'string', maxLength: 500 }, secrets: { type: 'array', items: { type: 'string', maxLength: 64 }, maxItems: 12 }, about: { type: 'string', maxLength: 240 } }, ['operation']),
+        inputSchema: schema({ operation: { type: 'string', enum: Object.keys(CHAT_ACTIONS).filter(one => !one.startsWith('flow_') && !one.startsWith('teammate_')) }, repo: { type: 'string' }, task: TASK_ARG, version: { type: 'string' }, restore: { type: 'integer', minimum: 1 }, sample: { type: 'string', maxLength: 800 }, content: { type: 'string', maxLength: 12000 }, instructions: { type: 'string', maxLength: TEXT_LIMITS.flowInstructions }, title: { type: 'string', maxLength: 120 }, id: { type: 'string' }, run: { type: 'integer', minimum: 1 }, note: { type: 'string', maxLength: LIMITS.note, description: `At most ${LIMITS.note} characters; longer is refused with its length, not cut.` }, catalog: { type: 'string', maxLength: 40 }, name: { type: 'string', maxLength: 40 }, command: { type: 'string', maxLength: 400 }, args: { type: 'array', items: { type: 'string', maxLength: 400 }, maxItems: 40 }, url: { type: 'string', maxLength: 500 }, secrets: { type: 'array', items: { type: 'string', maxLength: 64 }, maxItems: 12 }, about: { type: 'string', maxLength: 240 } }, ['operation']),
         handle: (ctx, args) => {
             const operation = args['operation'];
             if (!isChatAction(operation))
@@ -894,7 +897,7 @@ export const MATE_TOOLS = [
             name: { type: "string", maxLength: 80 }, template: { type: "string", enum: FLOW_TEMPLATES.map(one => one.id) },
             steps: { type: "array", minItems: 1, maxItems: 24, items: { type: "object", additionalProperties: false, properties: {
                         id: { type: "string", maxLength: 32 }, title: { type: "string", maxLength: 60 }, kind: { type: "string", enum: [...FLOW_STAGE_KINDS] },
-                        instructions: { type: "string", maxLength: 4000 }, planning: { type: "string", enum: ["auto", "required", "skip"] },
+                        instructions: { type: "string", maxLength: TEXT_LIMITS.flowInstructions }, planning: { type: "string", enum: ["auto", "required", "skip"] },
                         decider: { type: "string", maxLength: 64 }, message: { type: "string", maxLength: 1000 },
                         script: { type: "string", maxLength: 40 }, close: { type: "boolean" },
                         question: { type: "string", maxLength: 300 }, sureAt: { type: "integer", minimum: 50, maximum: 99 },
@@ -913,7 +916,7 @@ export const MATE_TOOLS = [
                         ifReplied: { type: "string", maxLength: 60 }, repo: REPO_ARG,
                         next: { type: "string", maxLength: 60 }, ifFails: { type: "string", maxLength: 60 }, ifNotSure: { type: "string", maxLength: 60 },
                     } } },
-            title: { type: "string", maxLength: 200 }, description: { type: "string", maxLength: 4000 }, zone: { type: "string", maxLength: 60 }, note: { type: "string", maxLength: 2000 },
+            title: { type: "string", maxLength: 200 }, description: { type: "string", maxLength: 4000 }, zone: { type: "string", maxLength: 60 }, note: { type: "string", maxLength: LIMITS.note, description: `At most ${LIMITS.note} characters; longer is refused with its length, not cut.` },
             choice: { type: "integer", minimum: 1, maximum: 4 },
             trigger: { type: "integer", minimum: 1 }, owner: { type: "string", maxLength: 64 },
             script: { type: "object", additionalProperties: false, properties: { name: { type: "string", maxLength: 40 }, about: { type: "string", maxLength: 160 }, body: { type: "string", maxLength: 1600 }, timeoutMinutes: { type: "integer", minimum: 1, maximum: 60 },
@@ -1829,15 +1832,17 @@ export const MATE_TOOLS = [
     {
         name: "propose_steer",
         description: "Guide the next attempt within existing scope; never interrupt work.",
-        inputSchema: schema({ task: TASK_ARG, note: { type: "string", maxLength: 2_000 } }, ["task", "note"]),
+        inputSchema: schema({ task: TASK_ARG, note: { type: "string", maxLength: LIMITS.note, description: `At most ${LIMITS.note} characters; longer is refused with its length, not cut.` } }, ["task", "note"]),
         handle: (ctx, args) => {
             const taskId = taskIdOf(args);
             const ref = taskId === null ? null : admittedRef(ctx, taskId);
             const task = taskId === null ? null : ctx.store.getTask(taskId);
             if (taskId === null || ref === null || task === null)
                 return notFound();
-            if (!honest(args["note"], 2_000))
-                return { ok: false, message: "guidance is plain text up to 2,000 characters" };
+            if (typeof args["note"] === "string" && args["note"].length > LIMITS.note)
+                return { ok: false, message: `guidance is ${args["note"].length} characters; the limit is ${LIMITS.note}. Shorten it and propose again.` };
+            if (!honest(args["note"], LIMITS.note))
+                return { ok: false, message: `guidance is plain text up to ${LIMITS.note} characters` };
             if (task.state === "done" || task.state === "cancelled")
                 return { ok: false, message: "that task is finished, so guidance has no next attempt to reach" };
             if (ctx.store.openContestFor(ref.id) !== null)
@@ -1945,10 +1950,12 @@ export const MATE_TOOLS = [
     },
     {
         name: "propose_agents",
-        description: "Read get_agents. Change risk/configured role model or clear override; stales approval, refuses running work.",
+        description: "Read get_agents. Change risk, size (small: fast model, no plan; large or risky: strongest agents), configured role model, or clear override; stales approval, refuses running work.",
         inputSchema: schema({
             task: TASK_ARG,
             risk: { type: "string", enum: ["routine", "elevated", "high"] },
+            size: { type: "string", enum: ["small", "medium", "large"] },
+            risky: { type: "boolean" },
             role: { type: "string", enum: ["planner", "builder", "repair"] },
             agent: schema({ provider: { type: "string", maxLength: 20 }, model: { type: "string", maxLength: 120 } }, ["provider", "model"]),
             clear: { type: "boolean" },
@@ -1969,8 +1976,16 @@ export const MATE_TOOLS = [
                 return { ok: false, message: "role is planner, builder, or repair" };
             const clear = args["clear"] === true;
             const agent = args["agent"];
-            if (risk === undefined && phase === null)
-                return { ok: false, message: "say what changes: a risk, or a role with an agent (or clear: true)" };
+            const size = args["size"];
+            const risky = args["risky"];
+            if (size !== undefined && !isTaskSize(size))
+                return { ok: false, message: "size is small, medium, or large" };
+            if (risky !== undefined && typeof risky !== "boolean")
+                return { ok: false, message: "risky is true or false" };
+            const sized = ctx.store.refForId(ref.id)?.sizing ?? null;
+            const sizeChange = size === undefined && risky === undefined ? null : { size: size ?? sized?.size ?? "medium", risky: risky ?? sized?.risky ?? false };
+            if (risk === undefined && phase === null && sizeChange === null)
+                return { ok: false, message: "say what changes: a risk, a size, or a role with an agent (or clear: true)" };
             if (phase !== null && !clear && (agent === null || typeof agent !== "object"))
                 return { ok: false, message: "a role change names an agent from get_agents, or clear: true" };
             if (phase === null && (clear || agent !== undefined))
@@ -2014,6 +2029,7 @@ export const MATE_TOOLS = [
                 taskTitle: task.title,
                 repoId: ref.repoId,
                 ...(risk === undefined ? {} : { risk, riskConsequence: riskConsequence(risk) }),
+                ...(sizeChange === null ? {} : { size: sizeChange.size, risky: sizeChange.risky }),
                 ...(phase === null ? {} : { phase, role: ROLE_WORD[phase] }),
                 ...(chosen === null ? {} : { provider: chosen.provider, model: chosen.model }),
                 ...(clear ? { clear: true } : {}),
@@ -2031,6 +2047,7 @@ export const MATE_TOOLS = [
                     kind: "agents",
                     task: taskId,
                     ...(risk === undefined ? {} : { risk }),
+                    ...(sizeChange === null ? {} : { size: sizeChange.size, risky: sizeChange.risky }),
                     ...(phase === null ? {} : { role: ROLE_WORD[phase], ...(chosen === null ? { clear: true } : { agent: chosen }) }),
                     awaiting: view["approval"] === "approved" ? "the operator's confirmation — the current approval will then need renewing" : "the operator's confirmation",
                 },