@aragon-agent/tui 0.0.0-stage → 0.0.1

package/dist/model/prompts/validate.js

@@ -0,0 +1,69 @@
+/**
+ * Pure prompt-draft validation, split out of `store.ts` (tui-package-split S3).
+ *
+ * ASCII ONLY - `src/prompts/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * NO I/O. The prompt-library editor (a terminal-UI view model) calls these on every keystroke
+ * to decide which field owns an error, while the store that persists the library also reads
+ * and writes files. Splitting them lets the editor live in a package without filesystem
+ * persistence. `store.ts` re-exports both names, so every existing importer is unchanged.
+ */
+import { PROMPT_LIMITS } from './limits.js';
+export function codePoints(text) {
+    return [...text].length;
+}
+/**
+ * Validate one draft, at the boundary where a draft becomes data (I-5).
+ *
+ * The editor calls this too, so the code that decides "that title is too long" and
+ * the code that decides which ROW owns the error cannot disagree - which is why it
+ * lives here rather than in the view model.
+ */
+export function validatePromptDraft(input) {
+    const title = input.title.trim();
+    const content = input.content;
+    if (title.length === 0)
+        return { ok: false, code: 'title_required', field: 'title' };
+    if (codePoints(title) > PROMPT_LIMITS.titleMaxChars) {
+        return { ok: false, code: 'title_too_long', field: 'title' };
+    }
+    if (content.trim().length === 0)
+        return { ok: false, code: 'content_required', field: 'content' };
+    if (codePoints(content) > PROMPT_LIMITS.contentMaxChars) {
+        return { ok: false, code: 'content_too_long', field: 'content' };
+    }
+    const description = (input.description ?? '').trim();
+    if (codePoints(description) > PROMPT_LIMITS.descriptionMaxChars) {
+        return { ok: false, code: 'description_too_long', field: 'description' };
+    }
+    const tags = input.tags ?? [];
+    if (tags.length > PROMPT_LIMITS.maxTags) {
+        return { ok: false, code: 'too_many_tags', field: 'tags' };
+    }
+    if (tags.some((tag) => codePoints(tag) > PROMPT_LIMITS.tagMaxChars)) {
+        return { ok: false, code: 'tag_too_long', field: 'tags' };
+    }
+    const verdict = { title, content };
+    if (description.length > 0)
+        verdict.description = description;
+    if (tags.length > 0)
+        verdict.tags = [...tags];
+    if (input.favorite === true)
+        verdict.favorite = true;
+    return { ok: true, input: verdict };
+}
+/** Parsed tags from the editor's raw comma/space separated field. Never throws. */
+export function parsePromptTags(raw) {
+    const seen = new Set();
+    const tags = [];
+    for (const part of raw.split(/[,;\s]+/)) {
+        const tag = part.trim();
+        if (tag.length === 0 || seen.has(tag))
+            continue;
+        seen.add(tag);
+        tags.push(tag);
+        if (tags.length >= PROMPT_LIMITS.maxTags)
+            break;
+    }
+    return tags;
+}

package/dist/model/team/activity.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Activity strings for the live roster (team-live-activity F-1).
+ *
+ * ASCII ONLY: `src/team/**` is inside the glyph scanner's scope. That rule binds
+ * the LITERALS IN THIS FILE, not the runtime data flowing through it - a child
+ * may well be reading a CJK path, and `run.description` already carries model
+ * text into the same row.
+ */
+/**
+ * The only part of a tool call this module will ever render (P1-4).
+ *
+ * A PICKED SUBSET, NOT THE ARGS OBJECT. Storing `event.args` whole would put
+ * `write_file`'s `content` - a whole file - on the run, and `TeamRuntime.publish`
+ * shallow-copies the run into the live snapshot AND into every `agent_update`
+ * event, and `dispatch()` copies it again into `DispatchOutcome.runs`, which
+ * `TeamCard` holds in the transcript for the rest of the session. Two facts make
+ * that unacceptable rather than merely wasteful: the retention is unbounded in
+ * the file's size, and one `JSON.stringify` anywhere downstream would put a file
+ * body into a log - the exact liability the logging section spends a paragraph
+ * avoiding.
+ *
+ * This costs nothing in maintenance: the switch below is ALREADY a per-tool
+ * table, so a new tool is one entry either way.
+ */
+export interface ActivityArgs {
+    path?: string;
+    pattern?: string;
+    command?: string;
+    to?: string;
+    from?: string;
+}
+/** Pick at capture time. Called once per `tool_execution_start`. */
+export declare function pickActivityArgs(args: unknown): ActivityArgs;
+/**
+ * Strip anything that could corrupt the frame, collapse whitespace, and clamp.
+ *
+ * THE CONTROL-CHARACTER STRIP IS A CORRECTNESS BOUNDARY, NOT TIDINESS. This
+ * string is model-chosen and reaches an Ink <Text> unescaped. A child running
+ * `bash` with an ANSI escape in the command line would otherwise write that
+ * escape into the roster: at best a mangled row, at worst a cleared screen or a
+ * moved cursor in the middle of someone's transcript. `bash`'s own output never
+ * reaches the panel; its ARGUMENTS now do.
+ *
+ * SURROGATES ARE GUARDED AT BOTH ENDS (P2-3). The trailing guard is the obvious
+ * one. The LEADING one is needed because the caller feeds this a rolling tail
+ * built with `String.slice(-n)`, which cuts on a UTF-16 code-unit boundary and
+ * can therefore hand us a lone LOW surrogate at index 0. Either half of a split
+ * pair renders as a replacement character - the same failure `truncateBytes`
+ * guards one layer down (report.ts).
+ */
+export declare function sanitizeActivity(raw: string, maxChars: number): string;
+/**
+ * One short phrase describing a tool call.
+ *
+ * `wide` false is the narrow-terminal form (D-4). For a path-valued argument
+ * that is the basename; for `bash` it is the PROGRAM NAME (P1-6). Running the
+ * command line through `basename` is wrong twice over: `basename` splits on `/`,
+ * so `npm test -w cli` comes back whole and `./scripts/build.sh --prod` comes
+ * back as `build.sh --prod`. Neither is shorter and the second is a lie about
+ * what ran.
+ *
+ * Anything not in the table renders as its own name. That is the correct
+ * degradation for `skill_find` and for any tool a later round registers on a
+ * child: a name is always true, and inventing an argument mapping for a tool
+ * this module has not been taught is how a formatter starts lying.
+ */
+export declare function describeToolActivity(toolName: string, args: ActivityArgs | undefined, wide: boolean): string;

package/dist/model/team/activity.js

@@ -0,0 +1,130 @@
+/**
+ * Activity strings for the live roster (team-live-activity F-1).
+ *
+ * ASCII ONLY: `src/team/**` is inside the glyph scanner's scope. That rule binds
+ * the LITERALS IN THIS FILE, not the runtime data flowing through it - a child
+ * may well be reading a CJK path, and `run.description` already carries model
+ * text into the same row.
+ */
+import { TEAM_LIMITS } from './limits.js';
+/** Pick at capture time. Called once per `tool_execution_start`. */
+export function pickActivityArgs(args) {
+    const a = (args ?? {});
+    const str = (v) => typeof v === 'string' && v.length > 0 ? v.slice(0, TEAM_LIMITS.activityArgChars) : undefined;
+    const picked = {};
+    const path = str(a.path);
+    const pattern = str(a.pattern);
+    const command = str(a.command);
+    const to = str(a.to);
+    const from = str(a.from);
+    if (path !== undefined)
+        picked.path = path;
+    if (pattern !== undefined)
+        picked.pattern = pattern;
+    if (command !== undefined)
+        picked.command = command;
+    if (to !== undefined)
+        picked.to = to;
+    if (from !== undefined)
+        picked.from = from;
+    return picked;
+}
+/**
+ * Strip anything that could corrupt the frame, collapse whitespace, and clamp.
+ *
+ * THE CONTROL-CHARACTER STRIP IS A CORRECTNESS BOUNDARY, NOT TIDINESS. This
+ * string is model-chosen and reaches an Ink <Text> unescaped. A child running
+ * `bash` with an ANSI escape in the command line would otherwise write that
+ * escape into the roster: at best a mangled row, at worst a cleared screen or a
+ * moved cursor in the middle of someone's transcript. `bash`'s own output never
+ * reaches the panel; its ARGUMENTS now do.
+ *
+ * SURROGATES ARE GUARDED AT BOTH ENDS (P2-3). The trailing guard is the obvious
+ * one. The LEADING one is needed because the caller feeds this a rolling tail
+ * built with `String.slice(-n)`, which cuts on a UTF-16 code-unit boundary and
+ * can therefore hand us a lone LOW surrogate at index 0. Either half of a split
+ * pair renders as a replacement character - the same failure `truncateBytes`
+ * guards one layer down (report.ts).
+ */
+export function sanitizeActivity(raw, maxChars) {
+    let src = raw;
+    const head = src.charCodeAt(0);
+    if (head >= 0xdc00 && head <= 0xdfff)
+        src = src.slice(1);
+    const flat = src
+        // eslint-disable-next-line no-control-regex
+        .replace(/[\x00-\x1f\x7f]/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (maxChars <= 0)
+        return '';
+    if (flat.length <= maxChars)
+        return flat;
+    if (maxChars <= 3)
+        return flat.slice(0, maxChars);
+    let cut = maxChars - 3;
+    const code = flat.charCodeAt(cut - 1);
+    if (code >= 0xd800 && code <= 0xdbff)
+        cut -= 1;
+    return `${flat.slice(0, cut)}...`;
+}
+/** The basename of a path, for the narrow form. Pure string work: no `path`. */
+function basename(p) {
+    const parts = p.split(/[\\/]/);
+    return parts[parts.length - 1] || p;
+}
+/** The program name of a command line, for the narrow form. */
+function program(commandLine) {
+    const first = commandLine.trim().split(/\s+/)[0] ?? '';
+    return basename(first) || commandLine;
+}
+/**
+ * One short phrase describing a tool call.
+ *
+ * `wide` false is the narrow-terminal form (D-4). For a path-valued argument
+ * that is the basename; for `bash` it is the PROGRAM NAME (P1-6). Running the
+ * command line through `basename` is wrong twice over: `basename` splits on `/`,
+ * so `npm test -w cli` comes back whole and `./scripts/build.sh --prod` comes
+ * back as `build.sh --prod`. Neither is shorter and the second is a lie about
+ * what ran.
+ *
+ * Anything not in the table renders as its own name. That is the correct
+ * degradation for `skill_find` and for any tool a later round registers on a
+ * child: a name is always true, and inventing an argument mapping for a tool
+ * this module has not been taught is how a formatter starts lying.
+ */
+export function describeToolActivity(toolName, args, wide) {
+    const a = args ?? {};
+    switch (toolName) {
+        case 'read_file':
+            return detail('read', a.path, wide, basename);
+        case 'write_file':
+            return detail('write', a.path, wide, basename);
+        case 'edit_file':
+            return detail('edit', a.path, wide, basename);
+        case 'list_dir':
+            return detail('list', a.path ?? '.', wide, basename);
+        case 'glob':
+            return detail('glob', a.pattern, wide, basename);
+        case 'grep':
+            return detail('grep', a.pattern, wide, basename);
+        case 'bash':
+            return detail('bash', a.command, wide, program);
+        case 'team_send': {
+            const to = (a.to ?? '').trim();
+            return to ? `messaging ${to}` : 'messaging';
+        }
+        case 'team_wait': {
+            const from = (a.from ?? '').trim();
+            return from ? `waiting for ${from}` : 'waiting for mail';
+        }
+        default:
+            return toolName;
+    }
+}
+function detail(verb, value, wide, narrow) {
+    const v = (value ?? '').trim();
+    if (v.length === 0)
+        return verb;
+    return `${verb}: ${wide ? v : narrow(v)}`;
+}

package/dist/model/team/limits.d.ts

@@ -0,0 +1,308 @@
+/**
+ * TEAM_LIMITS — the single authority on every bound this subsystem enforces
+ * (team-subagents §3.5 / §3.6).
+ *
+ * ASCII ONLY: `src/team/**` is inside the glyph scanner's scope
+ * (`glyphs.test.ts`), so no literal in this tree may hold a non-ASCII byte.
+ *
+ * TWO KINDS OF NUMBER LIVE HERE AND THEY ARE NOT INTERCHANGEABLE.
+ *
+ *  - The `TEAM_LIMITS` entries below are STRUCTURAL: they describe what the
+ *    report format, the message channel and the panel can physically carry, and
+ *    a user has no business tuning them. They are constants.
+ *  - The six `team.*` config keys (`config/schema.ts`) are POLICY: how wide to
+ *    fan out, how long to wait. They are clamped, persisted and user-facing.
+ *
+ * `hardMaxSubagents` sits on the structural side ON PURPOSE even though it
+ * bounds a config key: the requirement caps the fan-out at 10 (R-g), so a
+ * hand-edited `config.json` must not be able to raise it. It is applied twice —
+ * once in `clampTeamConfig` and once in `normalizeSubagentSpecs` — because a
+ * clamp that only runs on the read path leaves a bad value on disk.
+ *
+ * BYTES, NOT CHARACTERS, for every report budget (D-8 / I-9). `ToolExecutor`
+ * truncates combined tool text at 100 000 BYTES; a 24 000-character CJK report
+ * is 72 000 bytes, so a character-denominated cap would let the executor chop
+ * the report mid-section and take the failure count with it.
+ */
+export declare const TEAM_LIMITS: {
+    /**
+     * The requirement's ceiling (R-g). Enforced in `clampTeamConfig` AND in
+     * `normalizeSubagentSpecs`, so neither a hand-edited file nor a model asking
+     * for thirty can exceed it.
+     *
+     * 10 IS THE CEILING, 8 IS THE DEFAULT (`DEFAULT_TEAM_CONFIG`): different
+     * numbers on purpose (subagent-fanout D-1 / D-2). The default is a policy
+     * choice the user may move in either direction from the settings screen; this
+     * bound is what no user may move.
+     */
+    readonly hardMaxSubagents: 10;
+    /** `SubagentSpec.description`, clamped (never rejected). */
+    readonly descriptionChars: 60;
+    /** `SubagentSpec.prompt`, clamped. The child cannot see the conversation, so
+     *  this has to be generous enough to carry a whole brief. */
+    readonly promptChars: 8000;
+    /**
+     * The brief `/subagent <brief>` copies into its forced-directive turn
+     * (subagent-fanout 3.5.4 / R-10). CHARACTERS, not bytes, because this bound
+     * feeds a user-visible truncation marker rather than a wire budget: past it
+     * the directive says `[brief truncated]` so a clipped instruction is never
+     * mistaken for a complete one.
+     */
+    readonly forcedBriefChars: 4000;
+    /**
+     * Parts `/subagent --parts a,b,c` may name BEFORE `maxSubagents` narrows them
+     * (subagent-fanout 3.5.2 rule 3). The second, smaller ceiling is the policy
+     * number and belongs to the command body; this one only bounds what one
+     * argument can carry.
+     */
+    readonly forcedPartsMax: 8;
+    /** Slugified `SubagentSpec.label`. Long enough to be meaningful in the panel,
+     *  short enough that five of them fit one row of an 80-column terminal. */
+    readonly labelChars: 12;
+    readonly reportMaxBytes: 48000;
+    readonly summaryMaxBytes: 6000;
+    /**
+     * Floor a summary is trimmed TO, never below. A section trimmed to nothing is
+     * indistinguishable from a child that reported nothing, which is exactly the
+     * distinction the report exists to preserve.
+     */
+    readonly summaryFloorBytes: 400;
+    /** Deduped `write_file` / `edit_file` paths recorded per child (§3.4). */
+    readonly filesTouchedMax: 30;
+    /** `team_send` calls one child may spend on a whole dispatch. */
+    readonly messagesPerAgent: 6;
+    /** `team_send` calls the whole dispatch may spend. */
+    readonly messagesPerDispatch: 24;
+    /** Minimum gap between one child's sends. */
+    readonly minSendIntervalMs: 15000;
+    /** Quota units a `to: "all"` broadcast costs. */
+    readonly broadcastCost: 2;
+    readonly subjectChars: 80;
+    readonly bodyChars: 800;
+    /** `team_wait` timeout clamp, in seconds. */
+    readonly waitMinSeconds: 5;
+    readonly waitMaxSeconds: 120;
+    readonly waitDefaultSeconds: 30;
+    /**
+     * `agent_update` coalescing window (§5.2). Five children streaming tokens must
+     * not push five React renders per token; phase transitions always pass.
+     */
+    readonly agentUpdateThrottleMs: 120;
+    /** Agent rows the live panel renders before collapsing to `+N more` (§6.1). */
+    readonly panelMaxRows: 5;
+    /** Below this many terminal rows the panel collapses to its header line. */
+    readonly panelCollapseRows: 20;
+    /** Below this many columns the status-bar readout degrades to `[3]` (D-20). */
+    readonly statusCompactCols: 100;
+    /**
+     * STORAGE ceiling for a prose activity tail (P0-1). The most a `SubagentRun`
+     * may carry, NOT the width of the column: `TeamPanel.activityBudget(cols)`
+     * derives the display budget from the terminal and is always <= this.
+     */
+    readonly activityChars: 64;
+    /**
+     * Floor under `activityBudget`. Below roughly 46 columns the roster has bigger
+     * problems than an elided activity line, and a column narrower than this shows
+     * nothing but an ellipsis - at which point the phase word is more informative.
+     */
+    readonly activityMinChars: 12;
+    /** Rolling text buffer kept per child. The only per-token allocation. */
+    readonly activityTailChars: 160;
+    /** Per picked tool argument (P1-4). A path or a command longer than this is
+     *  elided on capture, so a run can never carry more than a few hundred bytes
+     *  of argument however large the real call was. */
+    readonly activityArgChars: 120;
+    /** At or above this many columns the activity line carries a full path or
+     *  command; below it, a basename or a program name. Mirrors `statusCompactCols`.
+     *  This chooses WHICH FACT to show; `activityBudget` chooses how much of it. */
+    readonly activityWideCols: 100;
+    /**
+     * Below this many columns the roster's activity cell gives way ENTIRELY
+     * (tui-subagent-panel §4.2.2).
+     *
+     * STRUCTURAL, like everything else in this block: twelve characters of prose in
+     * a 40-column terminal push the description column below its own twelve-column
+     * floor, and "who is doing what" outranks "what they are writing right now" when
+     * there is room for only one. That is why the cell returns 0 rather than
+     * `activityMinChars` below this width.
+     */
+    readonly activityDropCols: 56;
+    /**
+     * Events kept per child in `SubagentRun.timeline` (§4.5.3). Twenty-four covers
+     * a typical dispatch's complete tool sequence; ten children x 24 x 120 chars is
+     * about 29 KB at peak, and the ring is EPHEMERAL - it never reaches a file.
+     */
+    readonly timelineEntries: 24;
+    /** Display clamp on one timeline line; the same order as `activityArgChars`. */
+    readonly timelineTextChars: 120;
+    /**
+     * Row ceiling of the Agents board's projection. The overlay scrolls, so this is
+     * a memory bound rather than a fit: one row per fact and at most ten children
+     * plus one detail section, which no healthy dispatch can reach.
+     */
+    readonly boardMaxRows: 240;
+    /** Retries of a child that produced NOTHING. One, and not configurable: a
+     *  second retry doubles the worst-case latency of a failing dispatch and buys
+     *  nothing a re-dispatch by the lead would not buy better. */
+    readonly maxColdStartRetries: 1;
+    readonly retryBackoffMs: 2000;
+    /**
+     * Wall-clock budget of everything one SINGLE inspection may carry (the
+     * silence-triggered path). The digest holds run facts, the supervisor's own
+     * memory and the tail of the child's live history; unbounded, one look at a
+     * child that read five big files would make the "cheap" supervision call
+     * cost more than the child (the argument FAST_LIMITS.digestMaxChars makes,
+     * one level up).
+     */
+    readonly overseerDigestBytes: 8000;
+    /** Clamp on a `nudge` guidance text. Advice, not a second brief. */
+    readonly overseerGuidanceChars: 1200;
+    /** Clamp on the decision `reason` recorded in the report. */
+    readonly overseerReasonChars: 200;
+    /**
+     * Per-child slice of a BATCH digest (D-3 / R-P2-5). 6.7x tighter than the
+     * single-inspection budget above: a batch carries up to ten children in one
+     * call, and memory plus the history tail are the first to give way (the
+     * facts-first assembly order already puts them last).
+     */
+    readonly overseerPerChildDigestBytes: 1200;
+    /** Whole-batch digest ceiling (D-3): 10 children x 1 200 B fits exactly. */
+    readonly overseerBatchDigestBytes: 12000;
+    /**
+     * Output budget of ONE batch inspection (R-P0-1). The single-inspection path
+     * keeps `FAST_LIMITS.reviewOutputTokens` (512); a batch must return up to
+     * ten decision objects, and 512 tokens cannot physically hold ten x
+     * (reason <= 200 + guidance <= 1200). A truncated batch reply fails
+     * "first `[` to last `]`" parsing and degrades to all-wait - exactly the
+     * failure this separate, larger budget exists to prevent.
+     */
+    readonly overseerBatchOutputTokens: 2048;
+    /** Tighter `reason` clamp inside the batch protocol (R-P0-1). */
+    readonly overseerBatchReasonChars: 80;
+    /** Tighter `guidance` clamp inside the batch protocol (R-P0-1). */
+    readonly overseerBatchGuidanceChars: 400;
+    /**
+     * LOOKS per child per dispatch (D-5). A look is cost, not mutation: every
+     * inspection of a child - silence-triggered, cadence tick or post-mortem -
+     * spends one, including a call that failed softly. Twelve with the cadence
+     * ladder covers hours of healthy slow work; past the budget the supervisor
+     * says so once (`trigger: 'quiet'`) and stops waking that child up.
+     */
+    readonly overseerMaxLooksPerChild: 12;
+    /**
+     * LOOKS per dispatch, the fool-proof total (R-P1-6):
+     * hardMaxSubagents x overseerMaxLooksPerChild = 120. A mathematical upper
+     * bound, not a tuning knob - the per-child budget always binds first; this
+     * one exists so a bug cannot loop calls forever. When it trips, the whole
+     * MonitorLoop stops with one aggregate notice.
+     */
+    readonly overseerMaxLooksPerDispatch: number;
+    /**
+     * NUDGES per child per dispatch (D-5). Advice is cheap but not free: a
+     * supervisor that steers the same child forever is one that never decided.
+     */
+    readonly overseerMaxNudgesPerChild: 3;
+    /**
+     * Rebuilds PER CHILD per dispatch. One: a replacement that also stalls dies
+     * on its own watchdog rather than ping-ponging fresh children at a task the
+     * supervisor already failed to rescue once.
+     */
+    readonly overseerMaxReplacementsPerChild: 1;
+    /**
+     * Abandons PER CHILD per dispatch (D-5). One, so a supervisor that has
+     * already given up on a brief cannot keep re-killing bodies of it.
+     */
+    readonly overseerMaxAbandonsPerChild: 1;
+    /**
+     * Cadence ladder growth factor (D-2). Each no-action inspection schedules
+     * the next `previous * ratio` out, so a healthy slow child is looked at
+     * logarithmically in its run time rather than every five minutes.
+     */
+    readonly overseerCadenceRatio: 1.6;
+    /**
+     * First cadence check when neither `team.overseerIntervalMs` nor
+     * `team.subagentTimeoutMs` names one (the shipped defaults): the supervisor
+     * still looks even when no ceiling was configured.
+     */
+    readonly overseerDefaultCheckMs: 300000;
+    /** Clamp on a ladder step / model-chosen `nextCheckMs`, lower bound. */
+    readonly overseerNextCheckMinMs: 60000;
+    /** Clamp on a ladder step / model-chosen `nextCheckMs`, upper bound. */
+    readonly overseerNextCheckMaxMs: 900000;
+    /**
+     * A child's OWN idle watchdog, multiplied by this while the supervisor is
+     * active, so the soft silence inspection at `idleTimeoutMs` always precedes
+     * the hard abort. The watchdog stays as the backstop for a child that
+     * wedges past every inspection.
+     */
+    readonly overseerWatchdogFactor: 4;
+};
+/**
+ * The pseudo-label the runtime's AGGREGATE supervisor notices travel under
+ * (subagent-overseer-v2 D-5 / R-P1-6): the dispatch-total look-budget notice
+ * is one fact about the whole roster, not a row any child owns. RESERVED at
+ * normalization (`normalizeSubagentSpecs` seeds `dedupeLabel` with it), so a
+ * spec asking for the bare label `team` is handed `team-2` instead - the
+ * report ledger and the exec stream can then never attribute an aggregate
+ * notice to a real child, or swallow that child's own quiet note.
+ */
+export declare const TEAM_AGGREGATE_LABEL = "team";
+/**
+ * The two comm tools, which are POLICY-EXEMPT inside a child (§3.11).
+ *
+ * They are not in the lead's registered tool list, so evaluating them against
+ * the lead's `allowed-tools` ceiling would refuse them and dead-end the channel
+ * — the same dead end `SKILL_TOOL_FLOOR` exists to prevent one level up.
+ *
+ * Deliberately NOT added to `HOST_TOOL_NAMES` (P2-5). That constant answers
+ * "can a skill's `allowed-tools` declaration ever take effect?", and these two
+ * are never registered on a lead — so a skill naming them genuinely IS
+ * unenforceable, and `aragon skills doctor` reporting it as such is correct
+ * rather than a gap.
+ */
+export declare const TEAM_SUBAGENT_TOOL_NAMES: ReadonlySet<string>;
+/**
+ * Bumped whenever the wording of either prompt block changes, so a behaviour
+ * report can be tied to a block revision with one grep.
+ */
+export declare const TEAM_BLOCK_VERSION = "v3-2026-10";
+/**
+ * The version string on `<forced_team_mode>`'s first line.
+ *
+ * The block's words are a CONTRACT with the model, so a behaviour report ("it
+ * still did the work itself") has to be tieable to one revision. Kept beside
+ * `TEAM_BLOCK_VERSION` rather than reusing it: the two blocks answer different
+ * questions ("can dispatch" versus "must dispatch") and a shared number would
+ * name neither revision.
+ */
+export declare const FORCED_TEAM_BLOCK_VERSION = "v1-2026-10";
+/**
+ * Length ceiling of the `<forced_team_mode>` text.
+ *
+ * THE FIRST BLOCK LENGTH IN THIS SUBSYSTEM THAT A TEST ASSERTS: the `<team_mode>`
+ * block's 1200 is a comment in `team/prompt.ts`, and unifying the two is a
+ * separate small refactor (deliberately out of scope here). Looser than 1200
+ * because this block is only ever paid for while the session is ARMED, and it
+ * carries three layers of instruction rather than one.
+ */
+export declare const FORCED_TEAM_BLOCK_MAX_CHARS = 1400;
+/**
+ * Fallback nudges per user turn. ONE, and not configurable.
+ *
+ * The gate exists because the first two layers (the directive and the prompt
+ * block) both depend on the model cooperating. A second nudge would double the
+ * worst case of a model that is simply not going to dispatch - at N children per
+ * attempt - and D-8's whole argument is that the mechanical layer must be
+ * bounded by something other than the model's willingness.
+ */
+export declare const FORCED_NUDGE_LIMIT = 1;
+/**
+ * Grace window before the fallback nudge fires, in milliseconds.
+ *
+ * SAME ORDER AS THE TODO FOLLOW-THROUGH GRACE, for a structural reason rather
+ * than a stylistic one: both continuations share ONE `followTimer` in `App`
+ * (I-9), so "at most one armed continuation" is only explicable while the two
+ * numbers stay in the same order of magnitude. **Changing todo's grace means
+ * re-reading this constant.**
+ */
+export declare const FORCED_NUDGE_GRACE_MS = 3000;