@crouton-kit/crouter 0.3.28 → 0.3.29

package/dist/commands/pkg/bridge.d.ts

@@ -1 +0,0 @@
-export declare const bridgeBranch: import("../../core/command.js").BranchDef;

package/dist/commands/pkg/bridge.js

@@ -1,137 +0,0 @@
-// `crtr pkg bridge` — generate crouter substrate docs from a Claude skills root
-// and file-level reconcile the bridge plugin (design §2). The mapping lives in
-// core/bridge-map.ts (one testable source of truth); the extension shells to
-// this command rather than duplicating the transform.
-import { join, basename, dirname, isAbsolute } from 'node:path';
-import { existsSync, readdirSync } from 'node:fs';
-import { defineBranch, defineLeaf } from '../../core/command.js';
-import { usage } from '../../core/errors.js';
-import { userScopeRoot } from '../../core/scope.js';
-import { ensureDir, writeJson, writeText, readText, removePath, walkFiles, } from '../../core/fs-utils.js';
-import { parseFrontmatter, parseFrontmatterGeneric } from '../../core/frontmatter.js';
-import { buildBridgeDoc } from '../../core/bridge-map.js';
-import { PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE } from '../../types.js';
-/** Enumerate `<source>/**\/SKILL.md`, stopping recursion at the first SKILL.md
- *  on any branch — a dir that holds SKILL.md is a skill; its subdirs are assets,
- *  not nested skills. */
-function enumerateSkillFiles(root) {
-    const out = [];
-    if (!existsSync(root))
-        return out;
-    const stack = [root];
-    while (stack.length) {
-        const dir = stack.pop();
-        let entries;
-        try {
-            entries = readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            continue;
-        }
-        const hasSkill = entries.some((e) => e.isFile() && e.name === 'SKILL.md');
-        if (hasSkill) {
-            out.push(join(dir, 'SKILL.md'));
-            continue; // stop descent — deeper dirs are assets
-        }
-        for (const e of entries)
-            if (e.isDirectory())
-                stack.push(join(dir, e.name));
-    }
-    return out;
-}
-const bridgeSync = defineLeaf({
-    name: 'sync',
-    description: 'generate substrate docs from a Claude skills root',
-    whenToUse: 'mirroring a Claude Code skills directory into a crtr bridge plugin: maps each SKILL.md to a substrate memory doc and file-level reconciles the plugin (regenerate, prune stale, preserve hand-authored leaves + INDEX)',
-    help: {
-        name: 'pkg bridge sync',
-        summary: 'mirror a Claude skills root into a crtr bridge plugin (idempotent reconcile)',
-        guide: 'Each <source>/skills/<skillname>/SKILL.md becomes ~/.crouter/plugins/<name>/memory/<skillname>.md, stamped generator:claude-bridge. Stamped leaves whose source skill is gone are pruned; hand-authored leaves and any INDEX.md are never touched.',
-        params: [
-            { kind: 'flag', name: 'source', type: 'path', required: true, constraint: 'Absolute path to a Claude skills root (a dir whose <skillname>/SKILL.md leaves are bridged; recursion stops at the first SKILL.md).' },
-            { kind: 'flag', name: 'name', type: 'string', required: true, constraint: 'Bridge plugin name. Dest plugin dir is ~/.crouter/plugins/<name>/.' },
-            { kind: 'flag', name: 'source-desc', type: 'string', required: false, constraint: 'Optional plugin description written into the generated plugin.json.' },
-        ],
-        output: [
-            { name: 'plugin', type: 'string', required: true, constraint: 'Bridge plugin name.' },
-            { name: 'path', type: 'string', required: true, constraint: 'Absolute path to the bridge plugin directory.' },
-            { name: 'written', type: 'number', required: true, constraint: 'Count of substrate leaves generated from source SKILL.md files.' },
-            { name: 'pruned', type: 'number', required: true, constraint: 'Count of stale generator:claude-bridge leaves deleted (source skill gone).' },
-            { name: 'preserved', type: 'number', required: true, constraint: 'Count of untouched protected leaves (INDEX.md or unstamped hand-authored docs).' },
-        ],
-        outputKind: 'object',
-        effects: ['Writes ~/.crouter/plugins/<name>/.crouter-plugin/plugin.json and memory/*.md. Deletes stale generator:claude-bridge leaves. Never writes or deletes INDEX.md or unstamped docs.'],
-    },
-    run: async (input) => {
-        const source = input['source'];
-        const name = input['name'];
-        const sourceDesc = input['sourceDesc'];
-        if (!isAbsolute(source)) {
-            throw usage(`--source must be an absolute path: ${source}`);
-        }
-        if (!existsSync(source)) {
-            throw usage(`--source does not exist: ${source}`);
-        }
-        const destRoot = join(userScopeRoot(), 'plugins', name);
-        const memoryDir = join(destRoot, 'memory');
-        // 1. Ensure the bridge plugin manifest.
-        const manifestDir = join(destRoot, PLUGIN_MANIFEST_DIR);
-        ensureDir(manifestDir);
-        const manifest = {
-            name,
-            version: '0.0.0',
-            ...(sourceDesc !== undefined ? { description: sourceDesc } : {}),
-            source,
-            generator: 'claude-bridge',
-        };
-        writeJson(join(manifestDir, PLUGIN_MANIFEST_FILE), manifest);
-        // 2 + 3. Regenerate one stamped leaf per source skill.
-        ensureDir(memoryDir);
-        const writtenPaths = new Set();
-        for (const file of enumerateSkillFiles(source)) {
-            const skillName = basename(dirname(file));
-            const parsed = parseFrontmatter(readText(file));
-            const doc = buildBridgeDoc({
-                name: parsed.data?.name ?? skillName,
-                description: parsed.data?.description ?? '',
-                body: parsed.body,
-            });
-            const dest = join(memoryDir, `${skillName}.md`);
-            writeText(dest, doc);
-            writtenPaths.add(dest);
-        }
-        const written = writtenPaths.size;
-        // 4. Reconcile: prune stale stamped leaves; never touch INDEX.md or
-        //    unstamped (hand-authored) leaves.
-        let pruned = 0;
-        let preserved = 0;
-        for (const f of walkFiles(memoryDir, (n) => n.endsWith('.md'))) {
-            if (writtenPaths.has(f))
-                continue; // just regenerated → counted in `written`
-            if (basename(f) === 'INDEX.md') {
-                preserved++;
-                continue;
-            }
-            const generator = parseFrontmatterGeneric(readText(f)).data?.['generator'];
-            if (generator === 'claude-bridge') {
-                removePath(f);
-                pruned++;
-            }
-            else {
-                preserved++;
-            }
-        }
-        return { plugin: name, path: destRoot, written, pruned, preserved };
-    },
-});
-export const bridgeBranch = defineBranch({
-    name: 'bridge',
-    description: 'mirror Claude skills into crtr bridge plugins',
-    whenToUse: 'generating a crtr bridge plugin from a Claude Code skills root — the substrate-doc mapping and file-level reconcile invoked by the pi bridge extension',
-    help: {
-        name: 'pkg bridge',
-        summary: 'mirror Claude skills roots into crtr bridge plugins',
-        model: 'A bridge plugin is a generator:claude-bridge plugin whose memory/ docs are generated from a Claude skills root. Hand-authored leaves and INDEX ceilings are preserved across syncs.',
-    },
-    children: [bridgeSync],
-});

package/dist/commands/skill/author.d.ts

@@ -1,3 +0,0 @@
-export declare const authorGuide: import("../../core/command.js").LeafDef;
-export declare const authorScaffold: import("../../core/command.js").LeafDef;
-export declare const authorBranch: import("../../core/command.js").BranchDef;

package/dist/commands/skill/author.js

@@ -1,140 +0,0 @@
-import { dirname } from 'node:path';
-import { writeFileSync } from 'node:fs';
-import { defineLeaf, defineBranch } from '../../core/command.js';
-import { usage, general, notFound } from '../../core/errors.js';
-import { SKILL_TYPES, isSkillType } from '../../types.js';
-import { parseSkillQualifier, findPluginByName, } from '../../core/resolver.js';
-import { resolveScopeArg, requireScopeRoot, scopeMemoryDir, pluginMemoryDir, } from '../../core/scope.js';
-import { ensureScopeInitialized } from '../../core/config.js';
-import { ensureDir, pathExists } from '../../core/fs-utils.js';
-import { skillCreatePrompt, skillTemplatePrompt } from '../../prompts/skill.js';
-import { memoryFilePath, serializeMemoryDoc } from '../memory/shared.js';
-import { VALID_TYPES, resolveWriteScope } from './shared.js';
-export const authorGuide = defineLeaf({
-    name: 'guide',
-    description: 'load authoring workflow + skeleton for a type',
-    whenToUse: 'REQUIRED reading before you author a new skill OR edit an existing one — it carries the SKILL.md format, the description-drives-discovery rule (when-to-use lives in the frontmatter description, never the body), the voice constraints, and the per-type workflow. Editing an existing skill counts: read this first, because the format and voice rules govern every change, not just new files.',
-    help: {
-        name: 'skill author guide',
-        summary: 'load the skill authoring workflow — two stages: omit type to pick one, pass type for its full skeleton',
-        params: [
-            { kind: 'flag', name: 'type', type: 'enum', choices: [...VALID_TYPES], required: false, constraint: 'OMIT to receive the template-picker guide first; pass on the second call for that type\'s full workflow + skeleton.' },
-            { kind: 'flag', name: 'topic', type: 'string', required: false, constraint: 'Optional topic context injected into the guide.' },
-        ],
-        output: [
-            { name: 'guide', type: 'string', required: true, constraint: 'Stage 1 (no type): the template-picker workflow. Stage 2 (type given): that type\'s authoring workflow + skeleton.' },
-            { name: 'type', type: 'string | null', required: true, constraint: 'Echo of the requested type, or null on the picker stage.' },
-        ],
-        outputKind: 'object',
-        effects: ['None. Read-only.'],
-    },
-    run: async (input) => {
-        const type = input['type'];
-        const topic = input['topic'];
-        const topicArg = topic !== undefined ? topic : '';
-        // Progressive disclosure: no type → template picker (stage 1);
-        // type given → that type's full workflow + skeleton (stage 2).
-        if (type === undefined) {
-            return { guide: skillCreatePrompt(topicArg), type: null };
-        }
-        return { guide: skillTemplatePrompt(type, topicArg), type };
-    },
-});
-export const authorScaffold = defineLeaf({
-    name: 'scaffold',
-    description: 'create an empty skill substrate doc stub',
-    whenToUse: 'creating the empty `kind: skill` substrate doc at a `<plugin>/<skill>` qualifier (or a bare `<skill>` name for a scope-owned doc) before you fill in content — it writes the frontmatter and file, then points you at the authoring guide.',
-    help: {
-        name: 'skill author scaffold',
-        summary: 'create an empty kind:skill substrate doc stub at the given qualifier',
-        params: [
-            { kind: 'positional', name: 'qualifier', required: true, constraint: 'Skill identifier: <plugin>/<skill> to scaffold into a plugin\'s memory/, or a bare <skill> for the scope-owned memory/.' },
-            { kind: 'flag', name: 'type', type: 'enum', choices: [...VALID_TYPES], required: false, constraint: 'One of: playbook, primer, reference, runbook, freeform. Drives the follow-up authoring guide only — not stored on the substrate doc.' },
-            { kind: 'flag', name: 'description', type: 'string', required: false, constraint: 'Read-routing line written to the doc\'s when-and-why-to-read frontmatter.' },
-            { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: 'Default: project if available, else user.' },
-        ],
-        output: [
-            { name: 'path', type: 'string', required: true, constraint: 'Absolute path to the scaffolded substrate doc.' },
-            { name: 'follow_up', type: 'string', required: true, constraint: 'Recommended next call to load the authoring guide.' },
-        ],
-        outputKind: 'object',
-        effects: [
-            'Creates a `kind: skill` substrate doc stub under the resolved memory/ dir (scope-owned, or the named plugin\'s).',
-            'Writes substrate frontmatter: kind:skill, when-and-why-to-read (from --description if given), system-prompt-visibility:name, file-read-visibility:none.',
-        ],
-    },
-    run: async (input) => {
-        const qualifier = input['qualifier'];
-        const typeStr = input['type'];
-        const description = input['description'];
-        const scopeStr = input['scope'];
-        const parsed = parseSkillQualifier(qualifier);
-        if (parsed.segments.length === 0) {
-            throw usage('skill name required in qualifier');
-        }
-        // For scaffold, the qualifier is always <plugin>/<skill>. If it's a single segment,
-        // treat it as a scope-direct skill name. Otherwise first segment is the plugin.
-        const pluginName = parsed.segments.length > 1 ? parsed.segments[0] : undefined;
-        const skillName = parsed.segments.length > 1
-            ? parsed.segments.slice(1).join('/')
-            : parsed.segments[0];
-        if (typeStr !== undefined && !isSkillType(typeStr)) {
-            throw usage(`unknown skill type: ${typeStr} / valid: ${SKILL_TYPES.join(' | ')}`);
-        }
-        const skillType = typeStr !== undefined && isSkillType(typeStr) ? typeStr : undefined;
-        // Resolve the memory/ dir to scaffold into: the named plugin's, or the
-        // scope-owned one. One substrate, one author path.
-        let memoryDir;
-        if (pluginName === undefined) {
-            const scope = resolveWriteScope(scopeStr);
-            const scopeRootPath = requireScopeRoot(scope);
-            ensureScopeInitialized(scope, scopeRootPath);
-            const dir = scopeMemoryDir(scope);
-            if (!dir) {
-                throw general(`no memory dir for scope ${scope}`);
-            }
-            memoryDir = dir;
-        }
-        else {
-            const scopeForLookup = scopeStr !== undefined
-                ? (() => {
-                    const r = resolveScopeArg(scopeStr);
-                    return r !== 'all' ? r : undefined;
-                })()
-                : undefined;
-            const plugin = scopeForLookup !== undefined
-                ? findPluginByName(pluginName, scopeForLookup)
-                : findPluginByName(pluginName);
-            if (!plugin) {
-                throw notFound(`plugin not found: ${pluginName}`);
-            }
-            memoryDir = pluginMemoryDir(plugin);
-        }
-        const skillFile = memoryFilePath(memoryDir, skillName);
-        if (pathExists(skillFile)) {
-            throw general(`skill already exists: ${skillFile}`);
-        }
-        ensureDir(dirname(skillFile));
-        // Catalog-default substrate frontmatter (design §1.5): a name-rung,
-        // file-read-none skill doc. --description becomes the read-routing line.
-        const frontmatter = { kind: 'skill' };
-        if (description !== undefined)
-            frontmatter['when-and-why-to-read'] = description;
-        frontmatter['system-prompt-visibility'] = 'name';
-        frontmatter['file-read-visibility'] = 'none';
-        writeFileSync(skillFile, serializeMemoryDoc(frontmatter, ''), 'utf8');
-        const typeHint = skillType !== undefined ? `--type ${skillType} ` : '';
-        const follow_up = `crtr skill author guide ${typeHint}--topic "${skillName}"`;
-        return { path: skillFile, follow_up };
-    },
-});
-export const authorBranch = defineBranch({
-    name: 'author',
-    description: 'create and scaffold skills',
-    whenToUse: 'you have a reusable workflow, methodology, or hard-won convention worth capturing so future agents adopt it instead of re-deriving it — author carries you from picking a template through scaffolding the file. Reach for it when a task just taught you a repeatable procedure, when the same guidance keeps getting re-explained across sessions, or when the house conventions for a tool deserve to be written down once. Always start with `crtr skill author guide` — required reading before you author OR edit any skill (the SKILL.md format, the description-vs-body rule, and the voice constraints all live there) — then use `crtr skill author scaffold` to stub the SKILL.md file.',
-    help: {
-        name: 'skill author',
-        summary: 'create and scaffold new skills',
-    },
-    children: [authorGuide, authorScaffold],
-});

package/dist/commands/skill/shared.d.ts

@@ -1,3 +0,0 @@
-import type { Scope } from '../../types.js';
-export declare function resolveWriteScope(scopeStr: string | undefined): Scope;
-export declare const VALID_TYPES: readonly ["playbook", "primer", "reference", "runbook", "freeform"];

package/dist/commands/skill/shared.js

@@ -1,19 +0,0 @@
-import { usage } from '../../core/errors.js';
-import { resolveScopeArg, projectScopeRoot } from '../../core/scope.js';
-// ---------------------------------------------------------------------------
-// Resolve scope for scaffold
-// ---------------------------------------------------------------------------
-export function resolveWriteScope(scopeStr) {
-    if (scopeStr !== undefined) {
-        const resolved = resolveScopeArg(scopeStr);
-        if (resolved === 'all') {
-            throw usage('scope must be user or project, not all');
-        }
-        return resolved;
-    }
-    return projectScopeRoot() !== null ? 'project' : 'user';
-}
-// ---------------------------------------------------------------------------
-// Valid skill types (used by author sub-branch)
-// ---------------------------------------------------------------------------
-export const VALID_TYPES = ['playbook', 'primer', 'reference', 'runbook', 'freeform'];

package/dist/commands/skill.d.ts

@@ -1,2 +0,0 @@
-import type { BranchDef } from '../core/command.js';
-export declare function registerSkill(): BranchDef;

package/dist/commands/skill.js

@@ -1,21 +0,0 @@
-// `crtr skill` subtree handlers.
-// Sub-branch: author {guide, scaffold}.
-// Discovery and reading are now `crtr memory` verbs.
-import { defineBranch } from '../core/command.js';
-import { authorBranch } from './skill/author.js';
-export function registerSkill() {
-    return defineBranch({
-        name: 'skill',
-        rootEntry: {
-            concept: 'a SKILL.md you author and manage',
-            desc: 'author and manage skills',
-            useWhen: 'authoring a new skill (`crtr skill author`). To discover and read skills use `crtr memory` — `crtr memory read <name>`, `crtr memory find`, `crtr memory list`.',
-        },
-        help: {
-            name: 'skill',
-            summary: 'author skills — use `crtr memory` to discover and read them',
-            model: '`author` when you are writing a new skill — it carries the template workflow and the scaffolder. Discovery and reading are `crtr memory` verbs: `crtr memory list`, `crtr memory find`, `crtr memory read`. Visibility is governed by the substrate (INDEX/rung/gate), not a per-skill on/off. Append `-h` at any branch or leaf for its full schema.',
-        },
-        children: [authorBranch],
-    });
-}

package/dist/commands/tmux-spread.d.ts

@@ -1,2 +0,0 @@
-import type { LeafDef } from '../core/command.js';
-export declare const tmuxSpreadLeaf: LeafDef;

package/dist/commands/tmux-spread.js

@@ -1,144 +0,0 @@
-// `crtr canvas tmux-spread <id>` — expand a node + its live children into one
-// tiled tmux window: the target wide in the LEFT (main) pane, its live children
-// stacked as panes on the RIGHT, then grab focus.
-//
-// Reuses the presence/tmux machinery: revive a dormant target/child so it has a
-// live pane, `join-pane` each child's existing pane into the target's window
-// (preserving its running pi), `select-layout main-vertical`, then focus.
-//
-// CRITICAL fix-up: a joined child physically changes windows, so its
-// meta.{tmux_session,window} goes stale — `windowAlive` would then report it
-// dormant and the daemon would spuriously revive it. After each join we
-// re-derive the child's location from its (stable) pane id and updateNode it,
-// mirroring the swap fix-up in placement.ts.
-import { defineLeaf } from '../core/command.js';
-import { InputError } from '../core/io.js';
-import { readConfig } from '../core/config.js';
-import { reviveNode } from '../core/runtime/revive.js';
-import { isNodePaneAlive, spreadNode, inTmux } from '../core/runtime/placement.js';
-import { nodeInPane } from './node.js';
-import { getNode, subscriptionsOf } from '../core/canvas/index.js';
-export const tmuxSpreadLeaf = defineLeaf({
-    name: 'tmux-spread',
-    description: 'tile a node + its live children into one window and focus it',
-    whenToUse: 'tiling a node and its live children into one window — the node wide on the left, its workers stacked on the right — to watch an orchestrator and its team together (alt+c → e / GRAPH e)',
-    help: {
-        name: 'canvas tmux-spread',
-        summary: 'tile a node and its live children into one window — target wide on the left, children stacked on the right — and focus it. Revives dormant nodes first; caps children by max_panes_per_window.',
-        params: [
-            {
-                kind: 'positional',
-                name: 'node',
-                required: false,
-                constraint: 'Node id to spread. Defaults to the node occupying --pane (or your current pane).',
-            },
-            {
-                kind: 'flag',
-                name: 'pane',
-                type: 'string',
-                required: false,
-                constraint: 'tmux pane id to resolve the node from when no positional is given. The alt+c menu passes this for you.',
-            },
-        ],
-        output: [
-            { name: 'window', type: 'string', required: false, constraint: 'The window all panes were tiled into.' },
-            { name: 'session', type: 'string', required: false, constraint: 'The tmux session that window lives in.' },
-            { name: 'children_joined', type: 'string[]', required: true, constraint: 'Child node ids whose panes were joined into the window.' },
-            { name: 'overflow', type: 'string[]', required: true, constraint: 'Live children left out because max_panes_per_window was reached.' },
-            { name: 'focused', type: 'boolean', required: true, constraint: 'True when the window was brought forefront.' },
-        ],
-        outputKind: 'object',
-        effects: [
-            'Revives the target (and joined children) if dormant — opens tmux windows running pi.',
-            'Moves each joined child\'s pane into the target window (join-pane) and re-points its canvas record to the new window.',
-            'Applies a main-vertical layout and focuses the window.',
-        ],
-    },
-    run: async (input) => {
-        if (!inTmux()) {
-            throw new InputError({
-                error: 'not_in_tmux',
-                message: 'tmux-spread needs a tmux server (no $TMUX)',
-                next: 'Run from inside the shared crtr tmux session.',
-            });
-        }
-        const pane = input['pane'];
-        let id = input['node'];
-        if (id === undefined || id === '')
-            id = nodeInPane(pane);
-        if (id === undefined || id === '') {
-            throw new InputError({
-                error: 'no_node',
-                message: 'no node to spread (pass a node id, or run from inside its pane)',
-                next: 'Pass `crtr canvas tmux-spread <id>` or --pane <pane-id>.',
-            });
-        }
-        if (getNode(id) === null) {
-            throw new InputError({
-                error: 'not_found',
-                message: `no node: ${id}`,
-                next: 'List nodes with `crtr node inspect list`.',
-            });
-        }
-        // 1. Revive the target if it has no live pane (placement is pane-keyed).
-        if (!isNodePaneAlive(id)) {
-            try {
-                reviveNode(id, { resume: true });
-            }
-            catch { /* fall through */ }
-        }
-        if (!isNodePaneAlive(id)) {
-            throw new InputError({
-                error: 'no_window',
-                message: `could not open a live window for ${id}`,
-                next: 'Try `crtr canvas revive <id>` then retry.',
-            });
-        }
-        // 2. Live children, capped: the target owns one pane, so up to max-1 join.
-        const max = readConfig('user').max_panes_per_window;
-        const budget = Math.max(0, max - 1);
-        const liveChildren = subscriptionsOf(id)
-            .map((r) => r.node_id)
-            .filter((cid) => {
-            const s = getNode(cid)?.status;
-            return s === 'active' || s === 'idle';
-        });
-        const selected = liveChildren.slice(0, budget);
-        const overflow = liveChildren.slice(budget);
-        // 3. Revive any dormant selected child so it has a live pane, then hand the
-        //    join + pane-fix-up (reconcile FOLLOWS each joined pane) + layout + focus
-        //    to placement.
-        for (const cid of selected) {
-            if (!isNodePaneAlive(cid)) {
-                try {
-                    reviveNode(cid, { resume: true });
-                }
-                catch { /* skip on failure */ }
-            }
-        }
-        const spread = spreadNode(id, selected);
-        return {
-            window: spread.window,
-            session: spread.session,
-            children_joined: spread.joined,
-            overflow,
-            focused: spread.focused,
-        };
-    },
-    render: (r) => {
-        const joined = r['children_joined'] ?? [];
-        const overflow = r['overflow'] ?? [];
-        const where = r['window'] !== undefined && r['window'] !== ''
-            ? ` into window ${r['window']}${r['session'] !== undefined ? ` (session ${r['session']})` : ''}`
-            : '';
-        const lead = `Spread node${where} — ${joined.length} child pane(s) joined, ${overflow.length} overflow, ${r['focused'] === true ? 'window focused' : 'window not focused'}.`;
-        const blocks = [lead];
-        if (joined.length > 0) {
-            blocks.push(['Children joined:', ...joined.map((c) => `- ${c}`)].join('\n'));
-        }
-        if (overflow.length > 0) {
-            blocks.push(['Overflow (max_panes_per_window reached):', ...overflow.map((c) => `- ${c}`)].join('\n'));
-        }
-        return blocks.join('\n\n');
-    },
-});