@nemus-cli/nemus 0.5.0 → 0.9.0

package/CHANGELOG.md

@@ -7,6 +7,52 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.0] - 2026-09-01
+
+### Added
+
+- **`nemus config edit`** opens the config file in `$VISUAL`/`$EDITOR` (seeding
+  it with the current resolved config on first run) and re-validates the JSON
+  afterward, warning about unrecognized keys. Refuses to run without an
+  interactive terminal.
+- **Environment-variable reference** in the README documenting every variable
+  Nemus reads (`NEMUS_*`, `WORKSPACE_*`, `NO_COLOR`/`FORCE_COLOR`,
+  `VISUAL`/`EDITOR`).
+
+## [0.8.0] - 2026-09-01
+
+### Added
+
+- **`nemus reflect history`** and **`nemus reflect show [id]`** to review saved
+  reports (under `~/.nemus/reflect/`) without re-running the judge. `show`
+  defaults to the latest, accepts an id or id-prefix, and supports
+  `--json` / `--markdown` / `--group-by`.
+- **`nemus reflect --group-by kind|priority`** (default `priority`) to control
+  how recommendations are grouped in both the human and Markdown output.
+
+## [0.7.0] - 2026-09-01
+
+### Added
+
+- **`nemus reflect --markdown`** — render the reflection report as clean,
+  severity-grouped Markdown to stdout (pipe into a file or an issue:
+  `nemus reflect --markdown > reflection.md`). Fenced example snippets are
+  escaped so they can't break out of their own code block.
+- The human `reflect` report now prints a **severity summary line**
+  (e.g. `2 high · 1 medium`).
+
+## [0.6.0] - 2026-09-01
+
+### Added
+
+- **`nemus config` command** for non-interactive configuration:
+  `config get [key]`, `set <key> <value>`, `unset <key>`, `list` (alias `ls`),
+  and `path`. Values are validated and coerced per field (booleans accept
+  `true/false/yes/no/on/off/1/0`; enums like `cloneProtocol` are checked), an
+  unknown key or invalid value exits non-zero with a clear message, and
+  `get`/`list` support `--json`. Complements the interactive `configure` wizard
+  and pairs well with `--quiet` for scripting.
+
 ## [0.5.0] - 2026-09-01
 
 ### Added

package/README.md

@@ -243,6 +243,42 @@ The workspace-scoped ones (`status`/`doctor`/`analyze-deps`) need an explicit
 workspace name with `--json` (they never prompt). On failure, `--json` prints a
 parseable `{ "ok": false, "error": … }` to stdout and exits non-zero.
 
+### Configuration
+
+Run `nemus configure` for the interactive wizard, or manage settings
+non-interactively (handy for scripts and dotfiles):
+
+```bash
+nemus config list                     # all keys, values, and descriptions
+nemus config get cloneProtocol        # print one value (raw, for scripts)
+nemus config set cloneProtocol https  # validated + coerced per key
+nemus config set autoReportBugs yes   # booleans accept true/false/yes/no/on/off/1/0
+nemus config unset githubOrg          # reset a key to its default
+nemus config path                     # print the config file location
+```
+
+`get`/`list` also accept `--json`. An unknown key or an invalid value exits
+non-zero with a clear message (e.g. `cloneProtocol must be one of: ssh, https`).
+`config edit` opens the file in `$VISUAL`/`$EDITOR` (seeding it with the current
+resolved config first) and re-validates the JSON afterward.
+
+### Environment variables
+
+Everything Nemus reads from the environment (all optional):
+
+| Variable | Effect |
+| --- | --- |
+| `NEMUS_DIR` | Override where workspaces are created (also `WORKSPACE_MANAGER_DIR`). |
+| `NEMUS_CACHE_DIR` | Override the cache/config/state dir, default `~/.nemus` (also `WORKSPACE_MANAGER_CACHE_DIR`). |
+| `NEMUS_JUDGE_MODEL` | Model for the `reflect` judge (overrides `--model`'s default). |
+| `NEMUS_JUDGE_THINKING` | Thinking level for the `reflect` judge on pi (`off`…`max`). |
+| `NEMUS_JUDGE_TIMEOUT_MS` | Timeout for the `reflect` judge call. |
+| `NEMUS_BUG_REPORT_REPO` | Repo that `report-bug` files issues against. |
+| `NEMUS_SKIP_CONFIGURE` | Skip the one-time post-install `configure` prompt. |
+| `WORKSPACE_CLONE_TIMEOUT_MS` | Git clone timeout (default 15 min). |
+| `NO_COLOR` / `FORCE_COLOR` | Disable / force ANSI color (see [Global flags](#global-flags)). |
+| `VISUAL` / `EDITOR` | Editor launched by `nemus config edit`. |
+
 ### Global flags
 
 - `--no-color` — disable ANSI color. Nemus also honors the standard
@@ -294,9 +330,25 @@ nemus snapshot restore <id>   # (sr)
 nemus reflect                 # (retro) analyze your last 10 workspaces' sessions
 nemus reflect --limit 5       # narrow the window
 nemus reflect --json          # structured report for tooling
+nemus reflect --markdown      # Markdown report (grouped by severity) to paste/save
+nemus reflect --group-by kind # group recommendations by kind instead of priority
 nemus reflect --dry-run       # show what the judge sees, without calling the agent
 ```
 
+`--markdown` writes a clean, severity-grouped report to stdout — pipe it into a
+file or an issue: `nemus reflect --markdown > reflection.md`. `--group-by
+kind|priority` (default `priority`) controls how recommendations are grouped in
+both the human and Markdown output.
+
+Every run is saved under `~/.nemus/reflect/`. Review past reports without
+re-running the judge:
+
+```bash
+nemus reflect history            # list saved reports, newest first (--json)
+nemus reflect show               # print the latest saved report
+nemus reflect show <id>          # a specific one (--markdown / --json / --group-by)
+```
+
 `reflect` reads your recent agent **session transcripts** (Claude + pi), distills
 the prompts you sent, the failures the agent hit, and the tools it used, then asks
 **your own configured agent** (LLM-as-a-judge — no extra API key) to recommend

package/dist/commands/config.js

@@ -0,0 +1,195 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerConfigCommand = registerConfigCommand;
+const fs = __importStar(require("fs"));
+const config_1 = require("../utils/config");
+const editor_1 = require("../utils/editor");
+const config_schema_1 = require("../utils/config-schema");
+const output_1 = require("../utils/output");
+const logger_1 = require("../utils/logger");
+const colors_1 = require("../utils/colors");
+/**
+ * Non-interactive config management: `nemus config get/set/unset/list/path`.
+ * Complements the interactive `configure` wizard and is script-friendly —
+ * `get`/`list` write DATA to stdout (raw value, or JSON with --json), logs go to
+ * stderr. Values are validated/coerced against config-schema.ts.
+ */
+function registerConfigCommand(parent) {
+    const config = parent.command('config').description('Get or set Nemus configuration');
+    config
+        .command('get')
+        .description('Print a config value (or all values with no key)')
+        .argument('[key]', 'Config key')
+        .option('--json', 'Output as JSON')
+        .action((key, opts) => {
+        const cfg = (0, config_1.getUserConfig)();
+        if (key === undefined) {
+            printAll(cfg, opts.json);
+            return;
+        }
+        if (!(0, config_schema_1.isConfigKey)(key)) {
+            if (opts.json)
+                (0, output_1.outputJsonError)(`Unknown config key "${key}"`);
+            else
+                (0, logger_1.logError)(`Unknown config key "${key}". Run "nemus config list" to see valid keys.`);
+            process.exitCode = 1;
+            return;
+        }
+        const value = cfg[key];
+        if (opts.json)
+            (0, output_1.outputJson)({ key, value });
+        else
+            process.stdout.write((0, config_schema_1.formatConfigValue)(value) + '\n');
+    });
+    config
+        .command('set')
+        .description('Set a config value')
+        .argument('<key>', 'Config key')
+        .argument('<value>', 'New value')
+        .option('--json', 'Output as JSON')
+        .action((key, value, opts) => {
+        const result = (0, config_schema_1.applyConfigSet)((0, config_1.getUserConfig)(), key, value);
+        if (!result.ok) {
+            if (opts.json)
+                (0, output_1.outputJsonError)(result.error);
+            else
+                (0, logger_1.logError)(result.error);
+            process.exitCode = 1;
+            return;
+        }
+        (0, config_1.saveUserConfig)(result.next);
+        if (opts.json)
+            (0, output_1.outputJson)({ ok: true, key, value: result.value });
+        else
+            (0, logger_1.logSuccess)(`Set ${(0, colors_1.colorize)(key, 'cyan')} = ${(0, config_schema_1.formatConfigValue)(result.value)}`);
+    });
+    config
+        .command('unset')
+        .description('Reset a config value to its default')
+        .argument('<key>', 'Config key')
+        .option('--json', 'Output as JSON')
+        .action((key, opts) => {
+        const result = (0, config_schema_1.applyConfigUnset)((0, config_1.getUserConfig)(), key);
+        if (!result.ok) {
+            if (opts.json)
+                (0, output_1.outputJsonError)(result.error);
+            else
+                (0, logger_1.logError)(result.error);
+            process.exitCode = 1;
+            return;
+        }
+        (0, config_1.saveUserConfig)(result.next);
+        if (opts.json)
+            (0, output_1.outputJson)({ ok: true, key, value: result.value });
+        else
+            (0, logger_1.logSuccess)(`Reset ${(0, colors_1.colorize)(key, 'cyan')} to default (${(0, config_schema_1.formatConfigValue)(result.value)})`);
+    });
+    config
+        .command('list')
+        .alias('ls')
+        .description('List all config keys and current values')
+        .option('--json', 'Output as JSON')
+        .action((opts) => printAll((0, config_1.getUserConfig)(), opts.json));
+    config
+        .command('path')
+        .description('Print the path to the config file')
+        .action(() => {
+        process.stdout.write(config_1.CONFIG_PATH + '\n');
+    });
+    config
+        .command('edit')
+        .description('Open the config file in $EDITOR (or $VISUAL)')
+        .action(() => {
+        handleEdit();
+    });
+}
+function handleEdit() {
+    if (!process.stdout.isTTY) {
+        (0, logger_1.logError)('`config edit` needs an interactive terminal. Use `config set <key> <value>` in scripts.');
+        process.exitCode = 1;
+        return;
+    }
+    // Seed the file with the fully-resolved config so there's something complete
+    // to edit on a first run (getUserConfig merges defaults + any overrides).
+    if (!fs.existsSync(config_1.CONFIG_PATH))
+        (0, config_1.saveUserConfig)((0, config_1.getUserConfig)());
+    const result = (0, editor_1.openInEditor)(config_1.CONFIG_PATH);
+    if (!result.ok) {
+        (0, logger_1.logError)(result.error ?? `editor exited with code ${result.code}`);
+        process.exitCode = 1;
+        return;
+    }
+    // Re-validate: a hand-edit can produce invalid JSON or invalid values, which
+    // getUserConfig would silently ignore (falling back to defaults). Surface that
+    // instead, using the SAME schema `config set` uses so both write paths agree.
+    const review = (0, config_schema_1.reviewConfigFileText)(fs.readFileSync(config_1.CONFIG_PATH, 'utf-8'));
+    if (review.parseError) {
+        (0, logger_1.logError)(`${config_1.CONFIG_PATH} is not valid JSON after editing — changes are kept, but Nemus will use defaults until it parses.`);
+        process.exitCode = 1;
+        return;
+    }
+    if (review.notObject) {
+        (0, logger_1.logError)(`${config_1.CONFIG_PATH} must contain a JSON object — changes are kept, but Nemus will use defaults until it does.`);
+        process.exitCode = 1;
+        return;
+    }
+    if (review.unknownKeys.length > 0)
+        (0, logger_1.logWarning)(`Ignoring unrecognized key(s): ${review.unknownKeys.join(', ')}`);
+    if (!review.ok) {
+        for (const e of review.invalid)
+            (0, logger_1.logWarning)(e);
+        (0, logger_1.logError)('Some values are invalid and will fall back to their defaults until fixed.');
+        process.exitCode = 1;
+        return;
+    }
+    (0, logger_1.logSuccess)('Config saved.');
+}
+function printAll(cfg, json) {
+    if (json) {
+        const values = {};
+        for (const key of config_schema_1.CONFIG_KEYS)
+            values[key] = cfg[key];
+        (0, output_1.outputJson)({ path: config_1.CONFIG_PATH, values });
+        return;
+    }
+    const width = Math.max(...config_schema_1.CONFIG_KEYS.map((k) => k.length));
+    console.log((0, colors_1.colorize)('Nemus configuration', 'bright') + (0, colors_1.colorize)(`  (${config_1.CONFIG_PATH})`, 'dim'));
+    for (const key of config_schema_1.CONFIG_KEYS) {
+        const val = (0, config_schema_1.formatConfigValue)(cfg[key]);
+        const shown = val === '' ? (0, colors_1.colorize)('(empty)', 'dim') : val;
+        console.log(`  ${key.padEnd(width)}  ${shown}  ${(0, colors_1.colorize)(config_schema_1.CONFIG_SCHEMA[key].describe, 'dim')}`);
+    }
+}

package/dist/commands/reflect.js

@@ -11,22 +11,55 @@ function registerReflectCommand(parent) {
     parent
         .command('reflect')
         .alias('retro')
-        .description('Analyze your recent workspace sessions and suggest skill/prompt/context improvements (LLM-as-a-judge)')
+        .description('Analyze recent sessions for improvements, or review saved reports ("history"/"show")')
+        .argument('[subcommand]', '"history" or "show" — omit to run a new analysis')
+        .argument('[id]', 'report id when using "show" (default: latest)')
         .option('-n, --limit <n>', 'How many recent workspaces to analyze', '10')
         .option('-w, --workspace <name>', 'Analyze a single workspace by name (ignores --limit)')
         .option('--model <model>', 'Judge model override (agent-native pattern/id)')
         .option('--thinking <level>', 'Judge thinking level for pi: off|minimal|low|medium|high|xhigh|max')
         .option('--json', 'Output the report as JSON')
+        .option('--markdown', 'Output the report as Markdown (paste into an issue/PR)')
+        .option('--group-by <how>', 'Group recommendations by: priority | kind', 'priority')
         .option('--no-save', 'Do not save the report to ~/.nemus/reflect/')
         .option('--dry-run', 'Print the assembled corpus + judge prompt without calling the agent')
-        .action(async (opts) => {
-        await handleReflect(opts);
+        .addHelpText('after', '\nSaved reports:\n  nemus reflect history            List saved reports (newest first)\n  nemus reflect show [id]          Print a saved report (default: latest)\n')
+        // history/show are positional (not commander subcommands) on purpose: as
+        // subcommands they would share --json/--markdown/--group-by with this parent
+        // command, and the only commander fix (enablePositionalOptions on the root)
+        // breaks global flags placed after a subcommand (e.g. `nemus list --quiet`).
+        .action(async (subcommand, id, opts) => {
+        if (subcommand === 'history')
+            return handleHistory(opts);
+        if (subcommand === 'show')
+            return handleShow(id, opts);
+        if (subcommand !== undefined) {
+            const msg = `Unknown reflect subcommand "${subcommand}" (expected "history" or "show").`;
+            if (opts.json)
+                (0, output_1.outputJsonError)(msg);
+            else
+                (0, logger_1.logError)(msg);
+            process.exit(1);
+        }
+        return handleReflect(opts);
     });
 }
+/** Validate --group-by; returns the value or exits non-zero with a clear error. */
+function resolveGroupBy(raw, json) {
+    if (raw === undefined || raw === 'priority' || raw === 'kind')
+        return (raw ?? 'priority');
+    const msg = `--group-by must be "priority" or "kind"; got "${raw}"`;
+    if (json)
+        (0, output_1.outputJsonError)(msg);
+    else
+        (0, logger_1.logError)(msg);
+    process.exit(1);
+}
 async function handleReflect(opts) {
     const limit = Math.max(1, Number.parseInt(opts.limit ?? '10', 10) || 10);
+    const groupBy = resolveGroupBy(opts.groupBy, opts.json);
     try {
-        const showProgress = !opts.json && !opts.dryRun;
+        const showProgress = !opts.json && !opts.markdown && !opts.dryRun;
         if (showProgress) {
             (0, logger_1.logStep)(opts.workspace
                 ? `Analyzing workspace ${(0, colors_1.colorize)(opts.workspace, 'cyan')}…`
@@ -66,7 +99,7 @@ async function handleReflect(opts) {
         const timeoutMs = Number.parseInt(process.env.NEMUS_JUDGE_TIMEOUT_MS ?? '', 10) || undefined;
         const model = opts.model ?? process.env.NEMUS_JUDGE_MODEL ?? undefined;
         const thinking = opts.thinking ?? process.env.NEMUS_JUDGE_THINKING ?? undefined;
-        const stopSpinner = opts.json
+        const stopSpinner = opts.json || opts.markdown
             ? () => { }
             : startSpinner(`Judging ${withSessions} session(s) with your configured agent (this can take a minute)…`);
         let parsed;
@@ -95,7 +128,20 @@ async function handleReflect(opts) {
             (0, output_1.outputJson)({ analyzed: withSessions, workspaces: corpus.workspaces.length, ...report, savedTo });
             return;
         }
-        printReport(report, corpus.workspaces.length, withSessions);
+        if (opts.markdown) {
+            // DATA channel: markdown to stdout, nothing else (a 'Saved report' note
+            // would corrupt a redirected .md file), so surface the path on stderr.
+            process.stdout.write((0, reflect_1.renderReportMarkdown)(report, {
+                analyzed: withSessions,
+                workspaces: corpus.workspaces.length,
+                workspace: opts.workspace,
+                generatedAt: new Date().toISOString(),
+            }, groupBy));
+            if (savedTo)
+                (0, logger_1.logInfo)(`Saved report to ${(0, colors_1.colorize)(savedTo, 'dim')}`);
+            return;
+        }
+        printReport(report, corpus.workspaces.length, withSessions, groupBy);
         if (savedTo)
             (0, logger_1.logInfo)(`Saved report to ${(0, colors_1.colorize)(savedTo, 'dim')}`);
     }
@@ -164,7 +210,7 @@ function priorityBadge(p) {
         return (0, colors_1.colorize)('● med', 'yellow');
     return (0, colors_1.colorize)('● low', 'gray');
 }
-function printReport(report, workspaces, analyzed) {
+function printReport(report, workspaces, analyzed, groupBy = 'priority') {
     console.log('');
     console.log((0, colors_1.colorize)('  Reflection', 'bright') + (0, colors_1.colorize)(`  (${analyzed} sessions across ${workspaces} workspaces)`, 'dim'));
     console.log((0, colors_1.colorize)('  ' + '─'.repeat(56), 'dim'));
@@ -175,19 +221,94 @@ function printReport(report, workspaces, analyzed) {
         console.log('\n  ' + (0, colors_1.colorize)('No specific recommendations — looks solid.', 'green') + '\n');
         return;
     }
-    // High priority first.
-    const order = { high: 0, medium: 1, low: 2 };
-    const recs = [...report.recommendations].sort((a, b) => order[a.priority] - order[b.priority]);
-    console.log('');
-    for (const r of recs) {
-        const target = r.target ? (0, colors_1.colorize)(`  [${r.target}]`, 'cyan') : '';
-        console.log(`  ${priorityBadge(r.priority)}  ${(0, colors_1.colorize)(KIND_LABEL[r.kind], 'bright')}  ${r.title}${target}`);
-        if (r.detail)
-            console.log(`      ${r.detail.replace(/\n/g, '\n      ')}`);
-        if (r.example) {
-            console.log((0, colors_1.colorize)('      example:', 'dim'));
-            console.log((0, colors_1.colorize)(r.example.replace(/^/gm, '        '), 'dim'));
+    console.log('\n  ' + (0, colors_1.colorize)((0, reflect_1.severitySummary)(report.recommendations), 'dim'));
+    for (const group of (0, reflect_1.groupRecommendations)(report.recommendations, groupBy)) {
+        console.log('\n  ' + (0, colors_1.colorize)(group.heading, 'bright'));
+        for (const r of group.recs) {
+            const target = r.target ? (0, colors_1.colorize)(`  [${r.target}]`, 'cyan') : '';
+            // Under a kind heading show the priority badge; under a priority heading
+            // show the kind label (the heading conveys the other axis).
+            const lead = groupBy === 'kind' ? priorityBadge(r.priority) : (0, colors_1.colorize)(KIND_LABEL[r.kind], 'bright');
+            console.log(`    ${lead}  ${r.title}${target}`);
+            if (r.detail)
+                console.log(`      ${r.detail.replace(/\n/g, '\n      ')}`);
+            if (r.example) {
+                console.log((0, colors_1.colorize)('      example:', 'dim'));
+                console.log((0, colors_1.colorize)(r.example.replace(/^/gm, '        '), 'dim'));
+            }
         }
-        console.log('');
     }
+    console.log('');
+}
+async function handleHistory(opts) {
+    const reports = await (0, reflect_1.listSavedReports)();
+    if (opts.json) {
+        (0, output_1.outputJson)({
+            count: reports.length,
+            reports: reports.map((r) => ({
+                id: r.id,
+                generatedAt: r.generatedAt,
+                analyzed: r.analyzed,
+                workspaces: r.workspaces,
+                workspace: r.workspace,
+                recommendations: r.report.recommendations.length,
+                severity: (0, reflect_1.severitySummary)(r.report.recommendations),
+            })),
+        });
+        return;
+    }
+    if (reports.length === 0) {
+        (0, logger_1.logInfo)('No saved reflection reports yet. Run `nemus reflect` to create one.');
+        return;
+    }
+    console.log('');
+    console.log((0, colors_1.colorize)('  Saved reflections', 'bright') + (0, colors_1.colorize)(`  (${reports.length})`, 'dim'));
+    console.log((0, colors_1.colorize)('  ' + '─'.repeat(56), 'dim'));
+    for (const r of reports) {
+        const when = r.generatedAt ? new Date(r.generatedAt).toLocaleString() : r.id;
+        const scope = r.workspace ? (0, colors_1.colorize)(` ${r.workspace}`, 'cyan') : (0, colors_1.colorize)(` ${r.analyzed} sessions`, 'dim');
+        const sev = r.report.recommendations.length
+            ? (0, colors_1.colorize)(`  ${(0, reflect_1.severitySummary)(r.report.recommendations)}`, 'dim')
+            : (0, colors_1.colorize)('  no recs', 'green');
+        console.log(`  ${(0, colors_1.colorize)(r.id, 'bright')}${scope}${sev}`);
+        console.log((0, colors_1.colorize)(`     ${when}`, 'dim'));
+    }
+    console.log('');
+    console.log((0, colors_1.colorize)('  nemus reflect show <id>   (or `latest`)', 'dim'));
+}
+async function handleShow(id, opts) {
+    const groupBy = resolveGroupBy(opts.groupBy, opts.json);
+    const matches = (0, reflect_1.findSavedMatches)(await (0, reflect_1.listSavedReports)(), id);
+    const saved = matches[0];
+    if (!saved) {
+        const msg = id && id !== 'latest'
+            ? `No saved report matching "${id}". Run "nemus reflect history" to list them.`
+            : 'No saved reflection reports yet. Run "nemus reflect" to create one.';
+        if (opts.json)
+            (0, output_1.outputJsonError)(msg);
+        else
+            (0, logger_1.logError)(msg);
+        process.exit(1);
+    }
+    // An id-prefix that matches several reports resolves to the newest — say so
+    // (stderr only, so --json/--markdown stdout stays clean) rather than quietly
+    // showing a possibly-unintended report. An exact id / "latest" never multi-matches.
+    if (matches.length > 1 && !opts.json) {
+        (0, logger_1.logWarning)(`"${id}" matched ${matches.length} reports; showing the newest (${saved.id}). Use a longer id to disambiguate.`);
+    }
+    const meta = {
+        analyzed: saved.analyzed,
+        workspaces: saved.workspaces,
+        workspace: saved.workspace,
+        generatedAt: saved.generatedAt,
+    };
+    if (opts.json) {
+        (0, output_1.outputJson)({ id: saved.id, ...meta, ...saved.report });
+        return;
+    }
+    if (opts.markdown) {
+        process.stdout.write((0, reflect_1.renderReportMarkdown)(saved.report, meta, groupBy));
+        return;
+    }
+    printReport(saved.report, saved.workspaces, saved.analyzed, groupBy);
 }

package/dist/program.js

@@ -84,6 +84,7 @@ const archive_1 = require("./commands/archive");
 const sessions_1 = require("./commands/sessions");
 const generate_docs_1 = require("./commands/generate-docs");
 const configure_1 = require("./commands/configure");
+const config_1 = require("./commands/config");
 const configure_claude_1 = require("./commands/configure-claude");
 const ghq_status_1 = require("./commands/ghq-status");
 const save_context_1 = require("./commands/save-context");
@@ -109,6 +110,7 @@ const reflect_1 = require("./commands/reflect");
 (0, sessions_1.registerSessionsCommand)(exports.program);
 (0, generate_docs_1.registerGenerateDocsCommand)(exports.program);
 (0, configure_1.registerConfigureCommand)(exports.program);
+(0, config_1.registerConfigCommand)(exports.program);
 (0, configure_claude_1.registerConfigureClaudeCommand)(exports.program);
 (0, ghq_status_1.registerGhqStatusCommand)(exports.program);
 (0, save_context_1.registerSaveContextCommand)(exports.program);