toolroll 0.9.26 → 0.9.28

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/integrations-ui.js

@@ -6,12 +6,13 @@
  */
 import { STATE_WORDS } from "./integrations.js";
 import { whenUtc } from "./when-html.js";
+import { brandMarkHtml } from "./brand-mark.js";
 const e = (value) => String(value ?? "").replace(/[&<>"']/g, c => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
 const when = (at) => whenUtc(at);
 export const INTEGRATIONS_CSS = `.integrations{max-width:760px;min-width:0}.integrations h2{margin:24px 0 6px;font-size:.9375rem}` +
     `.integrations .integration{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:4px 16px;align-items:start;padding:12px 0;border-top:1px solid var(--so-line);min-width:0}` +
     `.integrations .integration>:not(.integration-action),.integrations .integration-body>*{grid-column:1}.integrations .integration-body{display:contents}.integrations .integration:first-of-type{border-top:0}.integrations .integration-head{margin:0;display:flex;flex-wrap:wrap;gap:6px 10px;align-items:center;min-width:0}` +
-    `.integrations .integration-head strong{overflow-wrap:anywhere}.integrations .integration p{margin:2px 0 0;min-width:0;overflow-wrap:anywhere}` +
+    `.integrations .integration .integration-body>*{margin-left:calc(var(--brand-mark) + 10px)}.integrations .integration-head strong{overflow-wrap:anywhere}.integrations .integration p{margin:2px 0 0;min-width:0;overflow-wrap:anywhere}` +
     `.integrations .integration-action{grid-column:2;grid-row:1 / span 3;align-self:center;margin:0}.integrations .integration-action button,.integrations .integration-action .button-link{min-height:44px;white-space:nowrap}` +
     `.integrations .integration .integration-action button{width:auto}.integrations .integration .integration-action a.integration-quiet{background:var(--so-paper);color:var(--so-ink);border:1px solid var(--so-input-line)}` +
     `.integrations .integration-fix{color:var(--so-danger)}.integrations code{overflow-wrap:anywhere}.integrations details{margin-top:4px;font-size:.8125rem}.integrations summary{cursor:pointer;padding:4px 0}` +
@@ -21,7 +22,7 @@ export const INTEGRATIONS_CSS = `.integrations{max-width:760px;min-width:0}.inte
     `.integration-state--not-set-up,.integration-state--checking{color:var(--so-muted);background:var(--so-neutral-soft)}` +
     // A phone: the action sits at the right of the name line, and the facts under it run on as one line.
     `@media (max-width:760px){.integrations h2{margin:16px 0 0}.integrations .integration{gap:0 12px;padding:6px 0 8px}.integrations .integration-head{min-height:44px}` +
-    `.integrations .integration-action{grid-row:1;align-self:center}.integrations .integration-body{display:block;grid-column:1 / -1;line-height:1.35}` +
+    `.integrations .integration-action{grid-row:1;align-self:center}.integrations .integration-body{display:block;grid-column:1 / -1;line-height:1.35;padding-left:calc(var(--brand-mark) + 10px)}.integrations .integration .integration-body>*{margin-left:0}` +
     `.integrations .integration-body>p{margin:0}.integrations .integration-body>p.meta{display:inline}.integrations .integration-body>p.meta+p.meta::before{content:" · "}` +
     `.integrations .integration-body>:not(.meta){margin-top:4px}.integrations .integration-body>:not(.meta)+p.meta{display:block;margin-top:2px}.integrations details{margin-top:2px}}`;
 const GROUPS = [
@@ -39,6 +40,12 @@ function action(one, csrf) {
         return `<p class="integration-action"><a class="button-link${a.kind === "setup" ? " integration-quiet" : ""}" href="${e(a.href)}">${a.label}</a></p>`;
     return "";
 }
+/** Which mark a row shows: email is Gmail's only when the account is a Gmail address; a custom tool is a letter. */
+function markFor(one) {
+    if (one.custom)
+        return null;
+    return one.key === "email" && /@(gmail|googlemail)\.com$/i.test(one.account ?? "") ? "gmail" : one.key;
+}
 function row(one, csrf) {
     const badge = !one.checked && one.state === "connected"
         ? `<span class="integration-state integration-state--checking"><i aria-hidden="true"></i>Checking</span>`
@@ -53,7 +60,7 @@ function row(one, csrf) {
         ? `<p class="meta">Failed ${when(one.lastErrorAt ?? "")}</p>`
         : `<details><summary>Last error ${one.lastErrorAt === null ? "" : when(one.lastErrorAt)}</summary><p class="meta">${e(one.lastError)}</p></details>`;
     return `<div class="integration" data-integration="${e(one.key)}" data-state="${one.state}">` +
-        `<p class="integration-head"><strong>${e(one.name)}</strong> ${badge}</p>` +
+        `<p class="integration-head">${brandMarkHtml(markFor(one), one.name, one.state === "connected")}<strong>${e(one.name)}</strong> ${badge}</p>` +
         action(one, csrf) +
         `<div class="integration-body">${facts === "" ? "" : `<p class="meta">${facts}</p>`}${fix}${run}${history}${lastError}</div></div>`;
 }

package/dist/integrations.d.ts

@@ -36,6 +36,8 @@ export type Integration = {
     lastErrorAt: string | null;
     usedBy: string[];
     action: IntegrationAction;
+    /** A project's own MCP tool: it shows a letter, never a logo matched by name. */
+    custom?: true;
 };
 export declare const STATE_WORDS: Record<IntegrationState, string>;
 export type ProbeResult = {

package/dist/integrations.js

@@ -383,7 +383,7 @@ function targets(io) {
             const href = `/settings/tools?repo=${encodeURIComponent(repo)}#tool-${encodeURIComponent(tool.name)}`;
             const test = tool.lastTest;
             list.push({
-                key: `mcp:${repo}:${tool.name}`, group: "tools", name: tool.name, configured: true, account: basename(repo),
+                key: `mcp:${repo}:${tool.name}`, group: "tools", name: tool.name, configured: true, account: basename(repo), ...(tool.source === "custom" ? { custom: true } : {}),
                 setup: place(href), fix: place(href), usedBy: [`Tasks in ${basename(repo)}`],
                 activity: test === null ? NO_ACTIVITY : test.ok ? { okAt: test.at, error: null, errorAt: null, failing: false } : { okAt: null, error: test.problem, errorAt: test.at, failing: false },
                 probe: async (check) => {
@@ -432,7 +432,7 @@ function targets(io) {
 }
 // ---------------------------------------------------------------- the list
 function combine(target, row) {
-    const base = { key: target.key, group: target.group, name: target.name, usedBy: target.usedBy };
+    const base = { key: target.key, group: target.group, name: target.name, usedBy: target.usedBy, ...(target.custom ? { custom: true } : {}) };
     const checked = target.probe === null || row !== undefined;
     const lastSuccessAt = later(row?.okAt ?? null, target.activity.okAt);
     const checkError = row?.error ?? null, checkErrorAt = row?.errorAt ?? null;

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",
                 },

package/dist/mate.js

@@ -9,7 +9,8 @@ import { redactSecretAssignments } from "./builder.js";
 import { MATE_CONTRACT } from "./mate-contract.js";
 import { MATE_MAX_PROPOSALS_PER_TURN, MATE_TOOL_SCHEMAS, executeMateTool, isMateTool, mateViewContextFor, projectLabelForMate, redactForMate, toolResultBytes } from "./mate-tools.js";
 import { composeSubscriptionMatePrompt, performSubscriptionMateRequest } from "./subscription-chat.js";
-import { leadContext } from './lead-context.js';
+import { LEAD_REPLY_LIMITS, leadContext } from './lead-context.js';
+import { shortenAsk } from './text-limits.js';
 import { envValue } from "./names.js";
 import { deliverableClaim, deliverableRepair, dropDeliverableClaims, replyCarriesDeliverable } from "./reply-shape.js";
 export const MATE_MESSAGE_MAX_CHARS = 2_000;
@@ -317,6 +318,9 @@ export async function runMateTurn(input) {
     let shownControl = false;
     /** The turn's one repair step for a reply that claims an attachment it does not carry. */
     let repaired = false;
+    /** The turn's one shorten step for a reply over its channel's message limit (LEAD_REPLY_LIMITS); still over, it is split. */
+    let shortened = false;
+    const replyLimit = input.channel === undefined ? null : LEAD_REPLY_LIMITS[input.channel];
     const unbacked = (text) => {
         const claim = deliverableClaim(text);
         if (claim === null || shownControl || replyCarriesDeliverable(text) || store.listMateTurnEvidence(turnId).length > 0)
@@ -447,7 +451,14 @@ export async function runMateTurn(input) {
                 history.push({ role: "operator", text: deliverableRepair(claim) });
                 continue;
             }
-            reply = claim === null ? answer.text : dropDeliverableClaims(answer.text);
+            const candidate = claim === null ? answer.text : dropDeliverableClaims(answer.text);
+            if (replyLimit !== null && candidate.length > replyLimit && !shortened && steps < maxSteps) {
+                shortened = true;
+                history.push({ role: "assistant", text: answer.text, calls: [] });
+                history.push({ role: "operator", text: shortenAsk([{ field: "Your reply", limit: replyLimit, length: candidate.length }]) });
+                continue;
+            }
+            reply = candidate;
             break;
         }
         if (answer.calls.length > MATE_MAX_CALLS_PER_STEP)

package/dist/operate.d.ts

@@ -1,5 +1,6 @@
 import { type IntegrationIo } from "./integrations.js";
 import { type OnboardIo } from "./agent-onboard.js";
+import { type Sizer } from "./task-sizing.js";
 import { type TriggerIo } from "./flow-triggers.js";
 import type { StepIo } from "./flow-steps.js";
 import type { FetchLike } from "./flow-share.js";
@@ -83,6 +84,8 @@ export type OperateOptions = {
         env?: Record<string, string | undefined>;
         openBrowser?: (url: string) => void;
     };
+    /** Injected by tests: the classifier that sizes filed tasks (none by default under test). */
+    filingSizer?: Sizer;
 };
 export type OnboardSeams = Partial<Pick<OnboardIo, "home" | "env" | "cwd" | "interactive" | "confirm" | "findRepo" | "checkConnection" | "pullRequests">>;
 export declare const OPERATE_HELP: string;