@crouton-kit/crouter 0.1.4 → 0.1.7

package/dist/cli.js

@@ -11,8 +11,9 @@ import { registerUpdateCommand } from './commands/update.js';
 import { registerDoctorCommand } from './commands/doctor.js';
 import { registerPlanCommand } from './commands/plan.js';
 import { registerSpecCommand } from './commands/spec.js';
+import { registerAgentCommand } from './commands/agent.js';
 import { maybeAutoUpdate } from './core/auto-update.js';
-import { ensureOfficialMarketplace } from './core/bootstrap.js';
+import { ensureBootSkill, ensureOfficialMarketplace } from './core/bootstrap.js';
 function readPackageVersion() {
     const here = dirname(fileURLToPath(import.meta.url));
     const pkgPath = join(here, '..', 'package.json');
@@ -34,7 +35,9 @@ registerUpdateCommand(program);
 registerDoctorCommand(program);
 registerPlanCommand(program);
 registerSpecCommand(program);
+registerAgentCommand(program);
 ensureOfficialMarketplace(process.argv);
+ensureBootSkill(process.argv);
 maybeAutoUpdate(process.argv);
 program.parseAsync().catch((err) => {
     process.stderr.write(`crtr: ${err instanceof Error ? err.message : String(err)}\n`);

package/dist/commands/agent.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerAgentCommand(program: Command): void;

package/dist/commands/agent.js

@@ -0,0 +1,265 @@
+import { existsSync } from 'node:fs';
+import { artifactPath, artifactsRoot } from '../core/artifact.js';
+import { readConfig } from '../core/config.js';
+import { spawnAgent, spawnAndDetach, awaitSession, submitToSession, DEFAULT_PANE_OPTS, } from '../core/spawn.js';
+import { pathExists } from '../core/fs-utils.js';
+import { notFound, usage } from '../core/errors.js';
+import { handleError, hint, out, info } from '../core/output.js';
+import { implementHandoffPrompt, planHandoffPrompt, reviewHandoffPrompt, } from '../prompts/agent.js';
+// Seconds before the originating pane is closed in fire-and-forget workflow
+// handoffs (plan/implement/review). Override with --kill-after.
+const DEFAULT_KILL_SECS = 10;
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+async function resolvePrompt(positional) {
+    if (positional !== undefined && positional !== '')
+        return positional;
+    if (!process.stdin.isTTY) {
+        const piped = await readStdin();
+        if (piped.trim() !== '')
+            return piped;
+    }
+    throw usage('no prompt provided. Pass a positional arg or pipe via stdin.');
+}
+function resolveMaxPanes(override) {
+    if (override !== undefined) {
+        const n = Number(override);
+        if (!Number.isFinite(n) || n < 1) {
+            throw usage(`--max-panes must be an integer >= 1 (got: ${override})`);
+        }
+        return Math.floor(n);
+    }
+    const cfg = readConfig('user');
+    return cfg.max_panes_per_window;
+}
+function emitDetach(result, label) {
+    if (result.status === 'spawned') {
+        const paneLabel = result.paneId === undefined ? '(unknown)' : result.paneId;
+        out(`handoff: ${label} launched in pane ${paneLabel}`);
+        hint(result.message);
+        return;
+    }
+    if (result.status === 'not-in-tmux') {
+        throw usage(result.message);
+    }
+    throw new Error(result.message);
+}
+function parseKillAfter(raw) {
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n < 0) {
+        throw usage(`--kill-after must be a non-negative number (got: ${raw})`);
+    }
+    return n;
+}
+function baseDetachOpts() {
+    return {
+        cwd: process.cwd(),
+        placement: 'split-h',
+        killAfterSeconds: DEFAULT_KILL_SECS,
+    };
+}
+export function registerAgentCommand(program) {
+    const agent = program
+        .command('agent')
+        .description('spawn, fork, await, and submit between sibling claude sessions');
+    agent
+        .command('new [prompt]')
+        .description('spawn a fresh claude in a sibling pane; prints session id, returns async')
+        .option('--max-panes <n>', 'max panes per window before overflowing to a new window')
+        .action(async (prompt, options) => {
+        try {
+            const body = await resolvePrompt(prompt);
+            const maxPanes = resolveMaxPanes(options.maxPanes);
+            const result = spawnAgent({
+                prompt: body,
+                cwd: process.cwd(),
+                maxPanesPerWindow: maxPanes,
+            });
+            if (result.status === 'not-in-tmux')
+                throw usage(result.message);
+            if (result.status === 'spawn-failed')
+                throw new Error(result.message);
+            const sessionId = result.sessionId;
+            if (sessionId === undefined) {
+                throw new Error('spawn succeeded but no session id returned');
+            }
+            out(sessionId);
+            info(result.message);
+            hint(`await with: crtr agent await ${sessionId}`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    agent
+        .command('fork [prompt]')
+        .description('fork the current Claude Code session into a sibling pane with a new prompt; prints session id')
+        .option('--max-panes <n>', 'max panes per window before overflowing to a new window')
+        .action(async (prompt, options) => {
+        try {
+            const parentSessionId = process.env.CLAUDE_CODE_SESSION_ID;
+            if (parentSessionId === undefined || parentSessionId === '') {
+                throw usage('crtr agent fork requires $CLAUDE_CODE_SESSION_ID — must run inside Claude Code');
+            }
+            const body = await resolvePrompt(prompt);
+            const maxPanes = resolveMaxPanes(options.maxPanes);
+            const result = spawnAgent({
+                prompt: body,
+                cwd: process.cwd(),
+                fork: { sessionId: parentSessionId },
+                maxPanesPerWindow: maxPanes,
+            });
+            if (result.status === 'not-in-tmux')
+                throw usage(result.message);
+            if (result.status === 'spawn-failed')
+                throw new Error(result.message);
+            const sessionId = result.sessionId;
+            if (sessionId === undefined) {
+                throw new Error('spawn succeeded but no session id returned');
+            }
+            out(sessionId);
+            info(result.message);
+            hint(`await with: crtr agent await ${sessionId}`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    agent
+        .command('await <id>')
+        .description('block until agent <id> calls `crtr agent submit`; prints submitted content')
+        .option('--timeout <seconds>', `seconds before giving up (default ${DEFAULT_PANE_OPTS.timeoutMs / 1000})`)
+        .option('--keep-pane', 'do not kill the child pane after submission')
+        .action(async (id, options) => {
+        try {
+            let timeoutMs = DEFAULT_PANE_OPTS.timeoutMs;
+            if (options.timeout !== undefined) {
+                const n = Number(options.timeout);
+                if (!Number.isFinite(n) || n <= 0) {
+                    throw usage(`--timeout must be a positive number (got: ${options.timeout})`);
+                }
+                timeoutMs = Math.floor(n * 1000);
+            }
+            const killPane = options.keepPane !== true;
+            const result = await awaitSession(id, { timeoutMs, killPane });
+            if (result.status === 'submitted') {
+                process.stdout.write(result.content);
+                if (!result.content.endsWith('\n'))
+                    process.stdout.write('\n');
+                return;
+            }
+            if (result.status === 'timeout') {
+                throw new Error(`agent ${id} did not submit before timeout`);
+            }
+            if (result.status === 'pane-closed') {
+                throw new Error(`agent ${id} pane closed before submission`);
+            }
+            throw new Error(`agent ${id} await failed: ${result.status}`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    agent
+        .command('submit [content]')
+        .description('inside a crtr-spawned session, deliver content back to the parent (uses $CRTR_PIPE)')
+        .action(async (content) => {
+        try {
+            const sessionDir = process.env.CRTR_PIPE;
+            if (sessionDir === undefined || sessionDir === '') {
+                throw usage('not in a crtr session — $CRTR_PIPE is not set. ' +
+                    '`crtr agent submit` is only valid inside a crtr-spawned pane.');
+            }
+            if (!existsSync(sessionDir)) {
+                throw notFound(`session directory not found: ${sessionDir} (the parent may have timed out)`);
+            }
+            let body;
+            if (content !== undefined) {
+                body = content;
+            }
+            else if (!process.stdin.isTTY) {
+                body = await readStdin();
+            }
+            else {
+                throw usage('no content provided. Pass content as a positional arg or pipe via stdin.');
+            }
+            if (body.trim() === '') {
+                throw usage('content is empty');
+            }
+            submitToSession(sessionDir, body);
+            out('submitted');
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    agent
+        .command('plan')
+        .description('launch a planner for an approved spec in a new pane; close current pane')
+        .requiredOption('--spec <name>', 'name of the spec to plan')
+        .option('--kill-after <seconds>', `seconds before closing the originating pane (default ${DEFAULT_KILL_SECS})`, String(DEFAULT_KILL_SECS))
+        .action((options) => {
+        try {
+            const specPath = artifactPath('specs', options.spec);
+            if (!pathExists(specPath)) {
+                throw notFound(`spec not found: ${options.spec} (looked at ${specPath})`);
+            }
+            const killAfter = parseKillAfter(options.killAfter);
+            const result = spawnAndDetach({
+                ...baseDetachOpts(),
+                prompt: planHandoffPrompt(specPath, artifactsRoot('plans')),
+                killAfterSeconds: killAfter,
+            });
+            emitDetach(result, `planner for spec ${options.spec}`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    agent
+        .command('implement')
+        .description('launch an implementer for an approved plan in a new pane; close current pane')
+        .requiredOption('--plan <name>', 'name of the plan to implement')
+        .option('--kill-after <seconds>', `seconds before closing the originating pane (default ${DEFAULT_KILL_SECS})`, String(DEFAULT_KILL_SECS))
+        .action((options) => {
+        try {
+            const planPath = artifactPath('plans', options.plan);
+            if (!pathExists(planPath)) {
+                throw notFound(`plan not found: ${options.plan} (looked at ${planPath})`);
+            }
+            const killAfter = parseKillAfter(options.killAfter);
+            const result = spawnAndDetach({
+                ...baseDetachOpts(),
+                prompt: implementHandoffPrompt(planPath),
+                killAfterSeconds: killAfter,
+            });
+            emitDetach(result, `implementer for plan ${options.plan}`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    agent
+        .command('review')
+        .description('launch a code reviewer of the working tree in a new pane; close current pane')
+        .option('--kill-after <seconds>', `seconds before closing the originating pane (default ${DEFAULT_KILL_SECS})`, String(DEFAULT_KILL_SECS))
+        .action((options) => {
+        try {
+            const killAfter = parseKillAfter(options.killAfter);
+            const result = spawnAndDetach({
+                ...baseDetachOpts(),
+                prompt: reviewHandoffPrompt(),
+                killAfterSeconds: killAfter,
+            });
+            emitDetach(result, 'code reviewer');
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+}

package/dist/commands/config.js

@@ -2,7 +2,12 @@ import { readConfig, writeConfig, configPath } from '../core/config.js';
 import { usage, notFound } from '../core/errors.js';
 import { out, jsonOut, handleError } from '../core/output.js';
 import { scopeRoot, listScopes } from '../core/scope.js';
-const TOP_LEVEL_KEYS = new Set(['auto_update', 'marketplaces', 'plugins']);
+const TOP_LEVEL_KEYS = new Set([
+    'auto_update',
+    'marketplaces',
+    'plugins',
+    'max_panes_per_window',
+]);
 function getNestedValue(obj, key) {
     const parts = key.split('.');
     let current = obj;
@@ -43,6 +48,13 @@ function setNestedValue(cfg, key, value) {
         cfg.auto_update.crtr = coerced;
         return;
     }
+    if (key === 'max_panes_per_window') {
+        if (typeof value !== 'number' || !Number.isFinite(value) || value < 1) {
+            throw usage(`max_panes_per_window must be an integer >= 1`);
+        }
+        cfg.max_panes_per_window = Math.floor(value);
+        return;
+    }
     if (parts.length === 1) {
         cfg[topKey] = value;
         return;

package/dist/commands/plan.js

@@ -1,9 +1,25 @@
-import { registerArtifactCommand } from '../core/artifact.js';
+import { artifactPath, registerArtifactCommand } from '../core/artifact.js';
 import { planPrompt } from '../prompts/plan.js';
+import { planReviewPrompt } from '../prompts/review.js';
 export function registerPlanCommand(program) {
     registerArtifactCommand(program, {
         command: 'plan',
         kind: 'plans',
         promptFn: planPrompt,
+        oversizeWarnLines: 250,
+        reviewer: {
+            extraSaveOptions: [
+                {
+                    flag: '--spec <name>',
+                    description: 'name of the spec this plan implements (enables alignment check)',
+                    key: 'spec',
+                },
+            ],
+            buildPrompt: (planPath, opts) => {
+                const specName = opts.spec;
+                const specPath = specName === undefined ? null : artifactPath('specs', specName);
+                return planReviewPrompt(planPath, specPath);
+            },
+        },
     });
 }

package/dist/commands/skill.js

@@ -1,21 +1,23 @@
 import { join } from 'node:path';
 import { writeFileSync } from 'node:fs';
-import { SKILL_ENTRY_FILE, SKILLS_DIR, } from '../types.js';
+import { SCOPE_SKILL_PLUGIN, SKILL_ENTRY_FILE, SKILLS_DIR, } from '../types.js';
 import { skillConfigKey } from '../types.js';
 import { notFound, usage, general } from '../core/errors.js';
 import { out, hint, info, jsonOut, handleError, } from '../core/output.js';
-import { listScopes, requireScopeRoot, resolveScopeArg, projectScopeRoot, } from '../core/scope.js';
+import { listScopes, requireScopeRoot, resolveScopeArg, projectScopeRoot, scopeSkillsDir, } from '../core/scope.js';
 import { resolveSkill, listAllSkills, listInstalledPlugins, findPluginByName, parseSkillQualifier, } from '../core/resolver.js';
 import { updateConfig, ensureScopeInitialized } from '../core/config.js';
 import { parseFrontmatter, serializeFrontmatter } from '../core/frontmatter.js';
 import { ensureDir, pathExists, readText, walkFiles } from '../core/fs-utils.js';
-import { skillPrompt } from '../prompts/skill.js';
+import { skillPrompt, skillCreatePrompt, skillTemplatePrompt } from '../prompts/skill.js';
 const KNOWN_VERBS = new Set([
     'list',
     'show',
     'path',
     'grep',
     'new',
+    'create',
+    'template',
     'where',
     'enable',
     'disable',
@@ -89,8 +91,10 @@ export function registerSkillCommands(program) {
             for (const sk of skills) {
                 const desc = sk.frontmatter.description !== undefined ? sk.frontmatter.description : '';
                 const marker = sk.enabled ? '' : ` [disabled${sk.disabledIn ? `@${sk.disabledIn}` : ''}]`;
-                const line = `${sk.scope}:${sk.plugin}/${sk.name}${marker}${desc ? `  — ${desc}` : ''}`;
-                out(line);
+                const qualified = sk.plugin === SCOPE_SKILL_PLUGIN
+                    ? `${sk.scope}:${sk.name}`
+                    : `${sk.scope}:${sk.plugin}/${sk.name}`;
+                out(`${qualified}${marker}${desc ? `  — ${desc}` : ''}`);
             }
         }
         catch (e) {
@@ -170,18 +174,23 @@ export function registerSkillCommands(program) {
                 throw usage(`invalid regex pattern: ${pattern}`);
             }
             const scopes = listScopes(opts.scope);
-            const pluginSkillsDirs = [];
+            const skillsDirs = [];
             for (const s of scopes) {
+                if (opts.plugin === undefined || opts.plugin === SCOPE_SKILL_PLUGIN) {
+                    const root = scopeSkillsDir(s);
+                    if (root)
+                        skillsDirs.push(root);
+                }
                 for (const plugin of listInstalledPlugins(s)) {
                     if (!plugin.enabled)
                         continue;
                     if (opts.plugin !== undefined && plugin.name !== opts.plugin)
                         continue;
-                    pluginSkillsDirs.push(join(plugin.root, SKILLS_DIR));
+                    skillsDirs.push(join(plugin.root, SKILLS_DIR));
                 }
             }
             const matchLines = [];
-            for (const skillsDir of pluginSkillsDirs) {
+            for (const skillsDir of skillsDirs) {
                 const files = walkFiles(skillsDir);
                 for (const file of files) {
                     const content = readText(file);
@@ -208,19 +217,47 @@ export function registerSkillCommands(program) {
     // new
     skill
         .command('new <qualifier>')
-        .description('scaffold a new skill as <plugin>:<name>')
+        .description('scaffold a new skill — <name> (scope-direct) or <plugin>:<name>')
         .option('--scope <scope>', 'user|project (default: project then user)')
         .option('--description <text>', 'skill description for frontmatter')
         .action(async (qualifier, opts) => {
         try {
-            if (!qualifier.includes(':')) {
-                throw usage('qualifier must be in the form <plugin>:<name> (e.g. authoring:my-skill)');
-            }
             const { plugin: pluginName, name: skillName } = parseSkillQualifier(qualifier);
-            if (!pluginName) {
-                throw usage('qualifier must be in the form <plugin>:<name>');
+            if (!skillName) {
+                throw usage('skill name required');
             }
             const scopeArg = opts.scope !== undefined ? resolveScopeArg(opts.scope) : undefined;
+            // Scope-direct: no plugin qualifier, or explicit `_:` sentinel
+            if (pluginName === undefined || pluginName === SCOPE_SKILL_PLUGIN) {
+                let scope;
+                if (scopeArg !== undefined && scopeArg !== 'all') {
+                    scope = scopeArg;
+                }
+                else {
+                    scope = projectScopeRoot() !== null ? 'project' : 'user';
+                }
+                const scopeRootPath = requireScopeRoot(scope);
+                ensureScopeInitialized(scope, scopeRootPath);
+                const skillsRoot = scopeSkillsDir(scope);
+                if (!skillsRoot) {
+                    throw general(`no skills dir for scope ${scope}`);
+                }
+                const skillDir = join(skillsRoot, ...skillName.split('/'));
+                const skillFile = join(skillDir, SKILL_ENTRY_FILE);
+                if (pathExists(skillFile)) {
+                    throw general(`skill already exists: ${skillFile}`);
+                }
+                ensureDir(skillDir);
+                const fm = serializeFrontmatter({
+                    name: skillName,
+                    description: opts.description,
+                });
+                writeFileSync(skillFile, fm, 'utf8');
+                out(skillFile);
+                hint(`crtr: scaffolded ${scope}-scope skill ${skillName} — edit directly, then ` +
+                    `\`crtr skill ${AUTHORING_GUIDE_SKILL}\` for SKILL.md authoring guidance`);
+                return;
+            }
             let plugin;
             if (scopeArg !== undefined && scopeArg !== 'all') {
                 plugin = findPluginByName(pluginName, scopeArg);
@@ -250,6 +287,22 @@ export function registerSkillCommands(program) {
             handleError(e);
         }
     });
+    // create — pick a template type
+    skill
+        .command('create [topic...]')
+        .description('pick a template type for a new skill (primer | playbook | freeform)')
+        .action(async (topic) => {
+        const arg = topic && topic.length > 0 ? topic.join(' ') : '';
+        out(skillCreatePrompt(arg));
+    });
+    // template — full workflow + skeleton for one template type
+    skill
+        .command('template <type> [topic...]')
+        .description('full workflow + skeleton for a template type (primer | playbook | freeform)')
+        .action(async (type, topic) => {
+        const arg = topic && topic.length > 0 ? topic.join(' ') : '';
+        out(skillTemplatePrompt(type, arg));
+    });
     // where
     skill
         .command('where <name>')
@@ -374,8 +427,10 @@ export function registerSkillCommands(program) {
                     ? h.skill.frontmatter.description
                     : '';
                 const marker = h.skill.enabled ? '' : ' [disabled]';
-                const line = `${h.skill.scope}:${h.skill.plugin}/${h.skill.name}${marker}\t${h.matched.join(',')}\t${desc}`;
-                out(line);
+                const qualified = h.skill.plugin === SCOPE_SKILL_PLUGIN
+                    ? `${h.skill.scope}:${h.skill.name}`
+                    : `${h.skill.scope}:${h.skill.plugin}/${h.skill.name}`;
+                out(`${qualified}${marker}\t${h.matched.join(',')}\t${desc}`);
             }
         }
         catch (e) {

package/dist/commands/spec.js

@@ -1,9 +1,13 @@
 import { registerArtifactCommand } from '../core/artifact.js';
 import { specPrompt } from '../prompts/spec.js';
+import { specReviewPrompt } from '../prompts/review.js';
 export function registerSpecCommand(program) {
     registerArtifactCommand(program, {
         command: 'spec',
         kind: 'specs',
         promptFn: specPrompt,
+        reviewer: {
+            buildPrompt: (specPath) => specReviewPrompt(specPath),
+        },
     });
 }

package/dist/core/artifact.d.ts

@@ -6,9 +6,21 @@ export declare function sanitizeName(raw: string): string;
 export declare function artifactPath(kind: ArtifactKind, name: string, cwd?: string): string;
 export declare function inTmux(): boolean;
 export declare function openInTmuxPane(path: string): void;
+export interface SaveOptionDef {
+    flag: string;
+    description: string;
+    key: string;
+}
+export interface ReviewerConfig {
+    buildPrompt: (artifactPath: string, opts: Record<string, string | undefined>) => string;
+    extraSaveOptions?: SaveOptionDef[];
+}
 export interface RegisterArtifactOptions {
     command: 'plan' | 'spec';
     kind: ArtifactKind;
     promptFn: (artifactsDir: string) => string;
+    reviewer?: ReviewerConfig;
+    /** If set and the saved body exceeds this many lines, emit a breakdown advisory. */
+    oversizeWarnLines?: number;
 }
 export declare function registerArtifactCommand(program: Command, opts: RegisterArtifactOptions): void;

package/dist/core/artifact.js

@@ -5,7 +5,8 @@ import { writeFileSync } from 'node:fs';
 import { CRTR_DIR_NAME } from '../types.js';
 import { ensureDir, pathExists, readText, walkFiles } from './fs-utils.js';
 import { usage, notFound, general } from './errors.js';
-import { out, hint, jsonOut, handleError } from './output.js';
+import { out, hint, jsonOut, handleError, info } from './output.js';
+import { spawnSidePaneReview, DEFAULT_PANE_OPTS, } from './spawn.js';
 export function mangleCwd(cwd = process.cwd()) {
     return cwd.replace(/\//g, '-');
 }
@@ -69,12 +70,18 @@ function listArtifactNames(kind) {
         .sort();
 }
 export function registerArtifactCommand(program, opts) {
-    const { command, kind, promptFn } = opts;
-    const cmd = program
+    const { command, kind, promptFn, reviewer, oversizeWarnLines } = opts;
+    const saveCmd = program
         .command(`${command} [content]`)
         .description(`print the ${command} prompt, or save a ${command} with --name`)
-        .option('--name <name>', `save the ${command} under this name`)
-        .action(async (content, options) => {
+        .option('--name <name>', `save the ${command} under this name`);
+    if (reviewer !== undefined) {
+        saveCmd.option('--no-review', 'skip the auto-review step (use for trivial artifacts)');
+        for (const extra of reviewer.extraSaveOptions ?? []) {
+            saveCmd.option(extra.flag, extra.description);
+        }
+    }
+    saveCmd.action(async (content, options) => {
         try {
             if (options.name === undefined) {
                 if (content !== undefined) {
@@ -99,15 +106,42 @@ export function registerArtifactCommand(program, opts) {
             }
             const filePath = artifactPath(kind, options.name);
             ensureDir(dirname(filePath));
-            writeFileSync(filePath, body.endsWith('\n') ? body : body + '\n', 'utf8');
+            const finalBody = body.endsWith('\n') ? body : body + '\n';
+            writeFileSync(filePath, finalBody, 'utf8');
             out(filePath);
             if (inTmux())
                 openInTmuxPane(filePath);
+            if (oversizeWarnLines !== undefined) {
+                const lineCount = finalBody.split('\n').length - 1;
+                if (lineCount > oversizeWarnLines) {
+                    out('');
+                    out('--- advisory ---');
+                    out(`This ${command} is ${lineCount} lines (> ${oversizeWarnLines}). ` +
+                        `Consider splitting it into multiple ${command}s under a shared prefix ` +
+                        `(e.g. \`crtr ${command} --name ${options.name}/part-1\`, ` +
+                        `\`crtr ${command} --name ${options.name}/part-2\`) and linking them ` +
+                        `from a brief index ${command} at \`${options.name}\`. ` +
+                        `Smaller ${command}s are easier to execute and review.`);
+                }
+            }
+            if (reviewer !== undefined) {
+                const reviewSkipped = options.review === false;
+                if (reviewSkipped) {
+                    hint('review skipped (--no-review)');
+                }
+                else if (!inTmux()) {
+                    hint('review skipped (not in tmux — auto-review needs a tmux pane)');
+                }
+                else {
+                    await runReviewer(filePath, reviewer, options);
+                }
+            }
         }
         catch (e) {
             handleError(e);
         }
     });
+    const cmd = saveCmd;
     cmd
         .command('list')
         .description(`list ${kind} for the current directory`)
@@ -185,3 +219,31 @@ export function registerArtifactCommand(program, opts) {
         }
     });
 }
+async function runReviewer(artifactFilePath, reviewer, options) {
+    const extraOpts = {};
+    for (const def of reviewer.extraSaveOptions ?? []) {
+        const value = options[def.key];
+        if (typeof value === 'string')
+            extraOpts[def.key] = value;
+    }
+    info('spawning reviewer in side pane (10-min budget) — output below…');
+    const result = await spawnSidePaneReview({
+        prompt: reviewer.buildPrompt(artifactFilePath, extraOpts),
+        cwd: process.cwd(),
+        timeoutMs: DEFAULT_PANE_OPTS.timeoutMs,
+    });
+    out('');
+    out('--- review ---');
+    if (result.status === 'submitted') {
+        out(result.content.trim());
+    }
+    else if (result.status === 'timeout') {
+        out('REVIEW_TIMEOUT: reviewer did not submit within the 10-minute budget.');
+    }
+    else if (result.status === 'pane-closed') {
+        out('REVIEW_ABORTED: reviewer pane closed before submission.');
+    }
+    else {
+        out(`REVIEW_FAILED: ${result.content}`);
+    }
+}

package/dist/core/bootstrap.d.ts

@@ -1,4 +1,5 @@
 export declare const OFFICIAL_MARKETPLACE_NAME = "crouter-official-marketplace";
 export declare const OFFICIAL_MARKETPLACE_URL = "https://github.com/crouton-labs/crouter-official-marketplace.git";
 export declare const OFFICIAL_MARKETPLACE_REF = "main";
+export declare function ensureBootSkill(argv: string[]): void;
 export declare function ensureOfficialMarketplace(argv: string[]): void;