@crouton-kit/crouter 0.2.6 → 0.3.2

package/dist/core/__tests__/sys.test.js

@@ -0,0 +1,208 @@
+// Tests for the sys subtree after argv migration.
+// Exercises: positional key, --value coercion, enum validation (--scope, --target),
+// bool presence flags (--fix, --remote, --check).
+// Run with: node --import tsx/esm --test 'src/core/__tests__/**/*.test.ts'
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { parseArgv } from '../command.js';
+// ---------------------------------------------------------------------------
+// Shared param schemas (mirror sys.ts definitions)
+// ---------------------------------------------------------------------------
+const configGetParams = [
+    { kind: 'positional', name: 'key', type: 'string', required: true, constraint: 'Dotted key path.' },
+    { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project', 'all'], required: false, constraint: 'Scope.' },
+];
+const configSetParams = [
+    { kind: 'positional', name: 'key', type: 'string', required: true, constraint: 'Dotted key path.' },
+    { kind: 'flag', name: 'value', type: 'string', required: true, constraint: 'Value to write.' },
+    { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: 'Scope.' },
+];
+const configPathParams = [
+    { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project', 'all'], required: false, constraint: 'Scope.' },
+];
+const sysDoctorParams = [
+    { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: 'Scope.' },
+    { kind: 'flag', name: 'fix', type: 'bool', required: false, constraint: '' },
+    { kind: 'flag', name: 'remote', type: 'bool', required: false, constraint: '' },
+];
+const sysUpdateParams = [
+    { kind: 'flag', name: 'target', type: 'enum', choices: ['self', 'content', 'all'], required: false, constraint: '' },
+    { kind: 'flag', name: 'check', type: 'bool', required: false, constraint: '' },
+];
+// ---------------------------------------------------------------------------
+// sys config get
+// ---------------------------------------------------------------------------
+describe('sys config get: argv parsing', () => {
+    test('positional key is required — missing throws', async () => {
+        await assert.rejects(() => parseArgv(configGetParams, []), (err) => { assert.match(err.message, /required parameter is missing/); return true; });
+    });
+    test('positional key is captured', async () => {
+        const result = await parseArgv(configGetParams, ['auto_update.crtr']);
+        assert.equal(result['key'], 'auto_update.crtr');
+    });
+    test('--scope valid enum passes', async () => {
+        const result = await parseArgv(configGetParams, ['some.key', '--scope', 'project']);
+        assert.equal(result['scope'], 'project');
+    });
+    test('--scope "all" is valid', async () => {
+        const result = await parseArgv(configGetParams, ['some.key', '--scope', 'all']);
+        assert.equal(result['scope'], 'all');
+    });
+    test('--scope invalid enum throws', async () => {
+        await assert.rejects(() => parseArgv(configGetParams, ['some.key', '--scope', 'global']), (err) => { assert.match(err.message, /must be one of/); return true; });
+    });
+    test('--scope absent leaves field undefined', async () => {
+        const result = await parseArgv(configGetParams, ['some.key']);
+        assert.equal(result['scope'], undefined);
+    });
+});
+// ---------------------------------------------------------------------------
+// sys config set — value coercion
+// ---------------------------------------------------------------------------
+describe('sys config set: --value coercion', () => {
+    test('string value passed through unchanged', async () => {
+        const result = await parseArgv(configSetParams, ['some.key', '--value', 'hello']);
+        assert.equal(result['value'], 'hello');
+    });
+    test('"true" string arrives as string (handler coerces)', async () => {
+        const result = await parseArgv(configSetParams, ['some.key', '--value', 'true']);
+        // The argv layer keeps it as a string; the handler calls parseConfigValue
+        assert.equal(result['value'], 'true');
+    });
+    test('"false" string arrives as string', async () => {
+        const result = await parseArgv(configSetParams, ['some.key', '--value', 'false']);
+        assert.equal(result['value'], 'false');
+    });
+    test('integer string arrives as string', async () => {
+        const result = await parseArgv(configSetParams, ['some.key', '--value', '42']);
+        assert.equal(result['value'], '42');
+    });
+    test('--value is required — missing throws', async () => {
+        await assert.rejects(() => parseArgv(configSetParams, ['some.key']), (err) => { assert.match(err.message, /required parameter is missing/); return true; });
+    });
+    test('key positional is required — missing throws', async () => {
+        await assert.rejects(() => parseArgv(configSetParams, ['--value', 'x']), (err) => { assert.match(err.message, /required parameter is missing/); return true; });
+    });
+    test('--scope valid enum passes', async () => {
+        const result = await parseArgv(configSetParams, ['some.key', '--value', 'x', '--scope', 'user']);
+        assert.equal(result['scope'], 'user');
+    });
+    test('--scope "all" rejected (not in choices)', async () => {
+        await assert.rejects(() => parseArgv(configSetParams, ['some.key', '--value', 'x', '--scope', 'all']), (err) => { assert.match(err.message, /must be one of/); return true; });
+    });
+});
+// ---------------------------------------------------------------------------
+// parseConfigValue coercion (via a thin harness)
+// ---------------------------------------------------------------------------
+// We re-implement parseConfigValue's logic inline here to keep the test
+// self-contained (it's a private helper in sys.ts).
+function parseConfigValue(raw) {
+    if (raw === 'true')
+        return true;
+    if (raw === 'false')
+        return false;
+    if (/^-?\d+$/.test(raw))
+        return parseInt(raw, 10);
+    return raw;
+}
+describe('parseConfigValue coercion', () => {
+    test('"true" → boolean true', () => { assert.strictEqual(parseConfigValue('true'), true); });
+    test('"false" → boolean false', () => { assert.strictEqual(parseConfigValue('false'), false); });
+    test('"42" → number 42', () => { assert.strictEqual(parseConfigValue('42'), 42); });
+    test('"-1" → number -1', () => { assert.strictEqual(parseConfigValue('-1'), -1); });
+    test('"notify" → string', () => { assert.strictEqual(parseConfigValue('notify'), 'notify'); });
+    test('"3.14" → string (non-integer float stays string)', () => { assert.strictEqual(parseConfigValue('3.14'), '3.14'); });
+    test('empty string → string', () => { assert.strictEqual(parseConfigValue(''), ''); });
+});
+// ---------------------------------------------------------------------------
+// sys config path
+// ---------------------------------------------------------------------------
+describe('sys config path: argv parsing', () => {
+    test('no args parses cleanly', async () => {
+        const result = await parseArgv(configPathParams, []);
+        assert.equal(result['scope'], undefined);
+    });
+    test('--scope user', async () => {
+        const result = await parseArgv(configPathParams, ['--scope', 'user']);
+        assert.equal(result['scope'], 'user');
+    });
+    test('--scope all', async () => {
+        const result = await parseArgv(configPathParams, ['--scope', 'all']);
+        assert.equal(result['scope'], 'all');
+    });
+    test('invalid --scope throws', async () => {
+        await assert.rejects(() => parseArgv(configPathParams, ['--scope', 'bogus']), (err) => { assert.match(err.message, /must be one of/); return true; });
+    });
+});
+// ---------------------------------------------------------------------------
+// sys doctor — bool presence flags
+// ---------------------------------------------------------------------------
+describe('sys doctor: bool presence flags', () => {
+    test('no args: fix=false, remote=false, scope=undefined', async () => {
+        const result = await parseArgv(sysDoctorParams, []);
+        assert.equal(result['fix'], false);
+        assert.equal(result['remote'], false);
+        assert.equal(result['scope'], undefined);
+    });
+    test('--fix sets fix=true', async () => {
+        const result = await parseArgv(sysDoctorParams, ['--fix']);
+        assert.equal(result['fix'], true);
+    });
+    test('--remote sets remote=true', async () => {
+        const result = await parseArgv(sysDoctorParams, ['--remote']);
+        assert.equal(result['remote'], true);
+    });
+    test('--fix --remote both set', async () => {
+        const result = await parseArgv(sysDoctorParams, ['--fix', '--remote']);
+        assert.equal(result['fix'], true);
+        assert.equal(result['remote'], true);
+    });
+    test('--scope user is valid', async () => {
+        const result = await parseArgv(sysDoctorParams, ['--scope', 'user']);
+        assert.equal(result['scope'], 'user');
+    });
+    test('--scope project is valid', async () => {
+        const result = await parseArgv(sysDoctorParams, ['--scope', 'project']);
+        assert.equal(result['scope'], 'project');
+    });
+    test('--scope all rejected (not in choices for doctor)', async () => {
+        await assert.rejects(() => parseArgv(sysDoctorParams, ['--scope', 'all']), (err) => { assert.match(err.message, /must be one of/); return true; });
+    });
+    test('--fix=true rejected (bool takes no value)', async () => {
+        await assert.rejects(() => parseArgv(sysDoctorParams, ['--fix=true']), (err) => { assert.match(err.message, /takes no value/); return true; });
+    });
+});
+// ---------------------------------------------------------------------------
+// sys update — enum target + --check bool
+// ---------------------------------------------------------------------------
+describe('sys update: argv parsing', () => {
+    test('no args: check=false, target=undefined', async () => {
+        const result = await parseArgv(sysUpdateParams, []);
+        assert.equal(result['check'], false);
+        assert.equal(result['target'], undefined);
+    });
+    test('--check sets check=true', async () => {
+        const result = await parseArgv(sysUpdateParams, ['--check']);
+        assert.equal(result['check'], true);
+    });
+    test('--target self is valid', async () => {
+        const result = await parseArgv(sysUpdateParams, ['--target', 'self']);
+        assert.equal(result['target'], 'self');
+    });
+    test('--target content is valid', async () => {
+        const result = await parseArgv(sysUpdateParams, ['--target', 'content']);
+        assert.equal(result['target'], 'content');
+    });
+    test('--target all is valid', async () => {
+        const result = await parseArgv(sysUpdateParams, ['--target', 'all']);
+        assert.equal(result['target'], 'all');
+    });
+    test('--target bogus throws invalid_type', async () => {
+        await assert.rejects(() => parseArgv(sysUpdateParams, ['--target', 'bogus']), (err) => { assert.match(err.message, /must be one of/); return true; });
+    });
+    test('--check --target self combined', async () => {
+        const result = await parseArgv(sysUpdateParams, ['--check', '--target', 'self']);
+        assert.equal(result['check'], true);
+        assert.equal(result['target'], 'self');
+    });
+});

package/dist/core/artifact.d.ts

@@ -1,26 +1,37 @@
-import { Command } from 'commander';
 export type ArtifactKind = 'plans' | 'specs';
 export declare function mangleCwd(cwd?: string): string;
 export declare function artifactsRoot(kind: ArtifactKind, cwd?: string): string;
+/** Per-cwd interactions root, mirroring artifactsRoot construction.
+ *  `~/.crouter/<mangled-cwd>/interactions/`. */
+export declare function interactionsRoot(cwd?: string): string;
+/** Directory for one interaction. `id` is sanitized like an artifact name. */
+export declare function interactionDir(id: string, cwd?: string): string;
 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;
+/** Lines above this threshold trigger an oversize advisory in follow_up. */
+export declare const OVERSIZE_WARN_LINES = 200;
+export interface SaveArtifactResult {
+    path: string;
+    oversize: boolean;
+    lineCount: number;
 }
-export interface ReviewerConfig {
-    buildPrompt: (artifactPath: string, opts: Record<string, string | undefined>) => string;
-    extraSaveOptions?: SaveOptionDef[];
+/**
+ * Atomically write an artifact. Prepends a minimal frontmatter block when
+ * `meta` is non-empty so readers can extract structured fields without
+ * parsing the full body. Returns the written path and oversize status.
+ */
+export declare function saveArtifact(kind: ArtifactKind, name: string, body: string, meta?: Record<string, string>): SaveArtifactResult;
+export interface ArtifactRecord {
+    name: string;
+    path: string;
+    body: string;
+    /** Present only in plan artifacts; null if not set. */
+    spec: string | null;
 }
-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 readArtifact(kind: ArtifactKind, name: string): ArtifactRecord;
+export interface ArtifactListItem {
+    name: string;
+    path: string;
+    updated_at: string;
 }
-export declare function registerArtifactCommand(program: Command, opts: RegisterArtifactOptions): void;
+export declare function listArtifacts(kind: ArtifactKind): ArtifactListItem[];

package/dist/core/artifact.js

@@ -1,19 +1,27 @@
+// Core artifact primitives for plan and spec subtrees.
+// No commander, no spawn, no output helpers — pure data logic only.
+// Old registerArtifactCommand (commander-based) is removed; callers ported to JSON I/O.
 import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
-import { spawn, spawnSync } from 'node:child_process';
-import { writeFileSync } from 'node:fs';
+import { writeFileSync, statSync } 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, info } from './output.js';
-import { spawnSidePaneReview, countPanesInCurrentWindow, DEFAULT_PANE_OPTS, } from './spawn.js';
-import { readConfig } from './config.js';
+import { notFound, usage } from './errors.js';
 export function mangleCwd(cwd = process.cwd()) {
     return cwd.replace(/\//g, '-');
 }
 export function artifactsRoot(kind, cwd) {
     return join(homedir(), CRTR_DIR_NAME, mangleCwd(cwd), kind);
 }
+/** Per-cwd interactions root, mirroring artifactsRoot construction.
+ *  `~/.crouter/<mangled-cwd>/interactions/`. */
+export function interactionsRoot(cwd) {
+    return join(homedir(), CRTR_DIR_NAME, mangleCwd(cwd), 'interactions');
+}
+/** Directory for one interaction. `id` is sanitized like an artifact name. */
+export function interactionDir(id, cwd) {
+    return join(interactionsRoot(cwd), sanitizeName(id));
+}
 export function sanitizeName(raw) {
     const trimmed = raw.trim().replace(/^\/+|\/+$/g, '');
     if (trimmed === '')
@@ -29,232 +37,81 @@ export function sanitizeName(raw) {
 export function artifactPath(kind, name, cwd) {
     return join(artifactsRoot(kind, cwd), `${sanitizeName(name)}.md`);
 }
-export function inTmux() {
-    return Boolean(process.env.TMUX);
-}
-export function openInTmuxPane(path) {
-    // Always pass --watch so the pane live-updates when the agent edits the
-    // file. The watcher re-detects width on resize and survives parse errors.
-    const args = ['--tmux', '--watch'];
-    // If the current tmux window is already at the configured pane budget,
-    // open in a new window instead of cramping the existing split further.
-    const maxPanes = readConfig('user').max_panes_per_window;
-    if (countPanesInCurrentWindow() >= maxPanes) {
-        args.push('--tmux-new-window');
+/** Lines above this threshold trigger an oversize advisory in follow_up. */
+export const OVERSIZE_WARN_LINES = 200;
+/**
+ * Atomically write an artifact. Prepends a minimal frontmatter block when
+ * `meta` is non-empty so readers can extract structured fields without
+ * parsing the full body. Returns the written path and oversize status.
+ */
+export function saveArtifact(kind, name, body, meta = {}) {
+    const filePath = artifactPath(kind, name);
+    ensureDir(dirname(filePath));
+    const metaKeys = Object.keys(meta);
+    let content;
+    if (metaKeys.length > 0) {
+        const fm = '---\n' + metaKeys.map((k) => `${k}: ${meta[k]}`).join('\n') + '\n---\n';
+        content = fm + body;
     }
-    args.push(path);
-    const result = spawnSync('termrender', args, {
-        stdio: ['ignore', 'pipe', 'pipe'],
-    });
-    if (result.error) {
-        const code = result.error.code;
-        if (code === 'ENOENT') {
-            hint('termrender not found on $PATH — install it to auto-open in tmux');
-        }
-        else {
-            hint(`termrender failed: ${result.error.message}`);
-        }
-        return;
+    else {
+        content = body;
     }
-    if (result.status !== 0) {
-        const stderrText = result.stderr.toString().trim();
-        hint(`termrender exited with ${result.status}${stderrText ? `: ${stderrText}` : ''}`);
-        return;
+    const finalContent = content.endsWith('\n') ? content : content + '\n';
+    writeFileSync(filePath, finalContent, 'utf8');
+    const lineCount = finalContent.split('\n').length - 1;
+    return { path: filePath, oversize: lineCount > OVERSIZE_WARN_LINES, lineCount };
+}
+const FRONTMATTER_BLOCK_RE = /^---\s*\r?\n([\s\S]*?)\r?\n---\s*\r?\n?/;
+function parseArtifactFrontmatter(source) {
+    const match = source.match(FRONTMATTER_BLOCK_RE);
+    if (!match)
+        return { fields: {}, body: source };
+    const raw = match[1];
+    const body = source.slice(match[0].length);
+    const fields = {};
+    for (const line of raw.split(/\r?\n/)) {
+        const colon = line.indexOf(':');
+        if (colon === -1)
+            continue;
+        const k = line.slice(0, colon).trim();
+        const v = line.slice(colon + 1).trim();
+        if (k !== '')
+            fields[k] = v;
     }
-    const paneId = result.stdout.toString().trim();
-    if (paneId)
-        hint(`opened in tmux pane ${paneId} (live — edits to the file refresh the view)`);
+    return { fields, body };
 }
-async function readStdin() {
-    const chunks = [];
-    for await (const chunk of process.stdin) {
-        chunks.push(chunk);
+export function readArtifact(kind, name) {
+    const filePath = artifactPath(kind, name);
+    if (!pathExists(filePath)) {
+        throw notFound(`${kind.slice(0, -1)} not found: ${name} (looked at ${filePath})`);
     }
-    return Buffer.concat(chunks).toString('utf8');
+    const raw = readText(filePath);
+    const { fields, body } = parseArtifactFrontmatter(raw);
+    const specField = fields['spec'];
+    return {
+        name,
+        path: filePath,
+        body,
+        spec: specField !== undefined ? specField : null,
+    };
 }
-function listArtifactNames(kind) {
+export function listArtifacts(kind) {
     const root = artifactsRoot(kind);
     if (!pathExists(root))
         return [];
-    return walkFiles(root, (n) => n.endsWith('.md'))
-        .map((abs) => abs.substring(root.length + 1).replace(/\.md$/, ''))
-        .sort();
-}
-export function registerArtifactCommand(program, opts) {
-    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`);
-    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) => {
+    const files = walkFiles(root, (n) => n.endsWith('.md'));
+    const items = files.map((abs) => {
+        const name = abs.substring(root.length + 1).replace(/\.md$/, '');
+        let updated_at = '';
         try {
-            if (options.name === undefined) {
-                if (content !== undefined) {
-                    throw usage(`positional content requires --name (try \`crtr ${command} --name <name> ...\`)`);
-                }
-                out(promptFn(artifactsRoot(kind)));
-                return;
-            }
-            let body;
-            if (content !== undefined) {
-                body = content;
-            }
-            else if (!process.stdin.isTTY) {
-                body = await readStdin();
-            }
-            else {
-                throw usage(`no content provided. Pipe via stdin (heredoc) or pass as a positional arg:\n` +
-                    `  crtr ${command} --name <name> <<'EOF'\n  <content>\n  EOF`);
-            }
-            if (body.trim() === '') {
-                throw usage('content is empty');
-            }
-            const filePath = artifactPath(kind, options.name);
-            ensureDir(dirname(filePath));
-            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);
-                }
-            }
+            updated_at = statSync(abs).mtime.toISOString();
         }
-        catch (e) {
-            handleError(e);
+        catch {
+            updated_at = new Date(0).toISOString();
         }
+        return { name, path: abs, updated_at };
     });
-    const cmd = saveCmd;
-    cmd
-        .command('list')
-        .description(`list ${kind} for the current directory`)
-        .option('--json', 'emit JSON')
-        .action(async (options) => {
-        try {
-            const names = listArtifactNames(kind);
-            if (options.json) {
-                jsonOut({
-                    [kind]: names.map((name) => ({ name, path: artifactPath(kind, name) })),
-                });
-                return;
-            }
-            for (const n of names)
-                out(n);
-        }
-        catch (e) {
-            handleError(e, { json: options.json });
-        }
-    });
-    cmd
-        .command('show <name>')
-        .description(`print the body of a ${command}`)
-        .action(async (name) => {
-        try {
-            const filePath = artifactPath(kind, name);
-            if (!pathExists(filePath)) {
-                throw notFound(`${command} not found: ${name} (looked at ${filePath})`);
-            }
-            out(readText(filePath));
-            hint(`crtr: edit with \`crtr ${command} edit ${name}\` (${filePath})`);
-        }
-        catch (e) {
-            handleError(e);
-        }
-    });
-    cmd
-        .command('path [name]')
-        .description(`print the absolute path of a ${command} or the ${kind} directory`)
-        .action(async (name) => {
-        try {
-            out(name === undefined ? artifactsRoot(kind) : artifactPath(kind, name));
-        }
-        catch (e) {
-            handleError(e);
-        }
-    });
-    cmd
-        .command('edit <name>')
-        .description(`open the ${command} in $EDITOR`)
-        .action(async (name) => {
-        try {
-            const filePath = artifactPath(kind, name);
-            if (!pathExists(filePath)) {
-                throw notFound(`${command} not found: ${name} (looked at ${filePath})`);
-            }
-            const editor = process.env.EDITOR !== undefined && process.env.EDITOR !== ''
-                ? process.env.EDITOR
-                : 'vi';
-            await new Promise((resolve, reject) => {
-                const child = spawn(editor, [filePath], { stdio: 'inherit' });
-                child.on('error', (e) => reject(general(`failed to launch editor: ${e.message}`)));
-                child.on('close', (code) => {
-                    if (code !== 0 && code !== null) {
-                        reject(general(`editor exited with code ${code}`));
-                    }
-                    else {
-                        resolve();
-                    }
-                });
-            });
-        }
-        catch (e) {
-            handleError(e);
-        }
-    });
-}
-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}`);
-    }
+    // Sort ascending by name (stable key for pagination cursor).
+    items.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    return items;
 }

package/dist/core/auto-update.js

@@ -2,7 +2,7 @@ import { spawn } from 'node:child_process';
 import { readConfig, readState, updateState } from './config.js';
 import { nowIso } from './fs-utils.js';
 import { info } from './output.js';
-import { selfCheck, contentCheck } from '../commands/update.js';
+import { selfCheck, contentCheck } from './self-update.js';
 const HOUR_MS = 60 * 60 * 1000;
 const SKIP_SUBCOMMANDS = new Set([
     'update',
@@ -27,7 +27,7 @@ function withinInterval(lastIso, intervalHours) {
     return Date.now() - last < intervalHours * HOUR_MS;
 }
 function spawnDetachedSelfUpdate() {
-    const child = spawn('npm', ['i', '-g', '@crouton-kit/crtr@latest'], {
+    const child = spawn('npm', ['i', '-g', '@crouton-kit/crouter@latest'], {
         detached: true,
         stdio: 'ignore',
     });
@@ -63,14 +63,21 @@ export function maybeAutoUpdate(argv) {
             s.last_self_check = nowIso();
         });
         if (crtr === 'notify') {
-            selfCheck();
+            const r = selfCheck();
+            if (r !== null && r.latest !== r.current) {
+                process.stderr.write(`crtr: v${r.latest} available (current ${r.current}) — run \`crtr sys update\`\n`);
+            }
         }
         else if (crtr === 'apply') {
             info('applying self-update in background');
             spawnDetachedSelfUpdate();
         }
         if (content === 'notify') {
-            contentCheck();
+            const stale = contentCheck().filter((e) => !e.up_to_date && !e.unreachable);
+            if (stale.length > 0) {
+                const list = stale.map((e) => `${e.kind} ${e.name}`).join(', ');
+                process.stderr.write(`crtr: updates available for ${list} — run \`crtr sys update\`\n`);
+            }
         }
         else if (content === 'apply') {
             info('applying content updates in background');