@nemus-cli/nemus 0.5.0 → 0.8.0

package/dist/utils/reflect.js

@@ -33,7 +33,11 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.REFLECT_REPORTS_DIR = exports.REFLECT_SCHEMA = void 0;
+exports.REFLECT_REPORTS_DIR = exports.REFLECT_SCHEMA = exports.PRIORITY_HEADING = exports.KIND_LABEL = void 0;
+exports.severityCounts = severityCounts;
+exports.severitySummary = severitySummary;
+exports.groupRecommendations = groupRecommendations;
+exports.renderReportMarkdown = renderReportMarkdown;
 exports.isCorrectionPrompt = isCorrectionPrompt;
 exports.distillTranscript = distillTranscript;
 exports.classifyAgentsMd = classifyAgentsMd;
@@ -41,12 +45,117 @@ exports.findLatestTranscriptFile = findLatestTranscriptFile;
 exports.gatherReflectionCorpus = gatherReflectionCorpus;
 exports.parseReflectionReport = parseReflectionReport;
 exports.saveReflectionReport = saveReflectionReport;
+exports.listSavedReports = listSavedReports;
+exports.findSavedMatches = findSavedMatches;
+exports.loadSavedReport = loadSavedReport;
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 const config_1 = require("./config");
 const workspace_meta_1 = require("./workspace-meta");
 const agent_config_1 = require("./agent-config");
 const claude_sessions_1 = require("./claude-sessions");
+/** Count recommendations by priority. */
+function severityCounts(recs) {
+    const counts = { high: 0, medium: 0, low: 0 };
+    for (const r of recs)
+        counts[r.priority]++;
+    return counts;
+}
+/** "3 high · 2 medium · 1 low", omitting zero buckets; '' when there are none. */
+function severitySummary(recs) {
+    const c = severityCounts(recs);
+    return ['high', 'medium', 'low']
+        .filter((p) => c[p] > 0)
+        .map((p) => `${c[p]} ${p}`)
+        .join(' · ');
+}
+exports.KIND_LABEL = {
+    skill: 'Skill',
+    context: 'Context/AGENTS.md',
+    test: 'Test',
+    prompt: 'Prompt',
+    connectivity: 'Connectivity',
+    workflow: 'Workflow',
+    other: 'Other',
+};
+// Back-compat alias for existing references.
+const MD_KIND_LABEL = exports.KIND_LABEL;
+exports.PRIORITY_HEADING = {
+    high: 'High priority',
+    medium: 'Medium priority',
+    low: 'Low priority',
+};
+const KIND_ORDER = ['skill', 'context', 'test', 'prompt', 'connectivity', 'workflow', 'other'];
+const PRIORITY_ORDER = ['high', 'medium', 'low'];
+const PRIORITY_RANK = { high: 0, medium: 1, low: 2 };
+/**
+ * Split recommendations into ordered, non-empty groups by either priority
+ * (high→low) or kind (a fixed, stable order). When grouping by kind, each
+ * group's recs are sorted high-priority first. Pure + unit-tested; shared by the
+ * Markdown renderer and the human printer so the two never diverge.
+ */
+function groupRecommendations(recs, groupBy) {
+    if (groupBy === 'kind') {
+        return KIND_ORDER.map((k) => ({
+            key: k,
+            heading: exports.KIND_LABEL[k],
+            recs: recs
+                .filter((r) => r.kind === k)
+                .sort((a, b) => PRIORITY_RANK[a.priority] - PRIORITY_RANK[b.priority]),
+        })).filter((g) => g.recs.length > 0);
+    }
+    return PRIORITY_ORDER.map((p) => ({
+        key: p,
+        heading: exports.PRIORITY_HEADING[p],
+        recs: recs.filter((r) => r.priority === p),
+    })).filter((g) => g.recs.length > 0);
+}
+/** A fenced code block whose fence is guaranteed longer than any backtick run
+ *  inside `body`, so the snippet can't break out of its own fence. */
+function fencedBlock(body) {
+    const longest = Math.max(0, ...(body.match(/`+/g) ?? []).map((m) => m.length));
+    const fence = '`'.repeat(Math.max(3, longest + 1));
+    return `${fence}\n${body}\n${fence}`;
+}
+/**
+ * Render a reflection report as clean Markdown — for pasting into an issue/PR or
+ * saving alongside the JSON. Pure (no color, no I/O) so it's unit-tested.
+ * Recommendations are grouped by severity (high→low); each carries its kind,
+ * optional target, detail, and a fenced example.
+ */
+function renderReportMarkdown(report, meta, groupBy = 'priority') {
+    const lines = ['# Reflection', ''];
+    const scope = meta.workspace
+        ? `workspace **${meta.workspace}**`
+        : `${meta.analyzed} session${meta.analyzed === 1 ? '' : 's'} across ${meta.workspaces} workspace${meta.workspaces === 1 ? '' : 's'}`;
+    const stamp = meta.generatedAt ? ` · ${meta.generatedAt}` : '';
+    lines.push(`_${scope}${stamp}_`, '');
+    if (report.summary.trim())
+        lines.push(report.summary.trim(), '');
+    if (report.recommendations.length === 0) {
+        lines.push('## Recommendations', '', '_No specific recommendations — looks solid._', '');
+        return lines.join('\n');
+    }
+    lines.push('## Recommendations', '', `**${severitySummary(report.recommendations)}**`, '');
+    for (const group of groupRecommendations(report.recommendations, groupBy)) {
+        lines.push(`### ${group.heading}`, '');
+        for (const r of group.recs) {
+            const target = r.target ? ` (\`${r.target}\`)` : '';
+            // Under a kind heading the [Kind] prefix is redundant; show a priority tag
+            // instead. Under a priority heading, show the kind.
+            const label = groupBy === 'kind' ? `_${r.priority}_ — ` : `[${exports.KIND_LABEL[r.kind]}] `;
+            lines.push(`- **${label}${r.title}**${target}`);
+            if (r.detail.trim()) {
+                lines.push(...r.detail.trim().split('\n').map((l) => `  ${l}`));
+            }
+            if (r.example?.trim()) {
+                lines.push('', ...fencedBlock(r.example.trim()).split('\n').map((l) => `  ${l}`));
+            }
+            lines.push('');
+        }
+    }
+    return lines.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd() + '\n';
+}
 // --------------------------------------------------------- transcript distill
 // Kept deliberately lean: the judge runs on the user's own (often local, slow)
 // agent, and a 10-workspace corpus at full verbosity produced a ~200KB prompt
@@ -408,3 +517,63 @@ async function saveReflectionReport(report, meta) {
     await fs.writeFile(file, JSON.stringify({ generatedAt: new Date().toISOString(), ...meta, ...report }, null, 2));
     return file;
 }
+/**
+ * List saved reports under `~/.nemus/reflect/`, newest first (filenames start
+ * with an ISO timestamp, so a reverse name sort is chronological). Unreadable /
+ * unparseable files are skipped, not fatal. Returns [] if the dir is absent.
+ */
+async function listSavedReports(dir = exports.REFLECT_REPORTS_DIR) {
+    let names;
+    try {
+        names = await fs.readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const jsons = names.filter((n) => n.endsWith('.json')).sort().reverse();
+    const out = [];
+    for (const name of jsons) {
+        const file = path.join(dir, name);
+        try {
+            const raw = JSON.parse(await fs.readFile(file, 'utf-8'));
+            out.push({
+                id: name.replace(/\.json$/, ''),
+                file,
+                generatedAt: typeof raw.generatedAt === 'string' ? raw.generatedAt : undefined,
+                analyzed: typeof raw.analyzed === 'number' ? raw.analyzed : 0,
+                workspaces: typeof raw.workspaces === 'number' ? raw.workspaces : 0,
+                workspace: typeof raw.workspace === 'string' ? raw.workspace : undefined,
+                report: parseReflectionReport(raw),
+            });
+        }
+        catch {
+            /* skip a corrupt/partial file */
+        }
+    }
+    return out;
+}
+/**
+ * Resolve a report reference against an (already newest-first) list. Returns ALL
+ * matches so a caller can detect ambiguity: `undefined`/`'latest'` -> the newest;
+ * an exact id -> that one; otherwise every id with the prefix (newest-first). An
+ * exact id always wins over prefixes, so an id can't be ambiguous with itself.
+ * Pure + unit-tested.
+ */
+function findSavedMatches(all, ref) {
+    if (all.length === 0)
+        return [];
+    if (!ref || ref === 'latest')
+        return [all[0]];
+    const exact = all.find((r) => r.id === ref);
+    if (exact)
+        return [exact];
+    return all.filter((r) => r.id.startsWith(ref));
+}
+/**
+ * Load one saved report by id. `undefined`/`'latest'` returns the newest; an id
+ * is matched exactly, then as a prefix (newest match wins). Returns null when
+ * nothing matches. For ambiguity-aware callers, use findSavedMatches directly.
+ */
+async function loadSavedReport(ref, dir = exports.REFLECT_REPORTS_DIR) {
+    return findSavedMatches(await listSavedReports(dir), ref)[0] ?? null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nemus-cli/nemus",
-  "version": "0.5.0",
+  "version": "0.8.0",
   "workspaces": [
     "packages/*"
   ],

package/src/commands/config.ts

@@ -0,0 +1,112 @@
+import { Command } from 'commander';
+import { getUserConfig, saveUserConfig, CONFIG_PATH } from '../utils/config';
+import {
+  CONFIG_KEYS,
+  CONFIG_SCHEMA,
+  isConfigKey,
+  applyConfigSet,
+  applyConfigUnset,
+  formatConfigValue,
+} from '../utils/config-schema';
+import { outputJson, outputJsonError } from '../utils/output';
+import { logSuccess, logError } from '../utils/logger';
+import { colorize } from '../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.
+ */
+export function registerConfigCommand(parent: Command): void {
+  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: string | undefined, opts: { json?: boolean }) => {
+      const cfg = getUserConfig();
+      if (key === undefined) {
+        printAll(cfg, opts.json);
+        return;
+      }
+      if (!isConfigKey(key)) {
+        if (opts.json) outputJsonError(`Unknown config key "${key}"`);
+        else logError(`Unknown config key "${key}". Run "nemus config list" to see valid keys.`);
+        process.exitCode = 1;
+        return;
+      }
+      const value = cfg[key];
+      if (opts.json) outputJson({ key, value });
+      else process.stdout.write(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: string, value: string, opts: { json?: boolean }) => {
+      const result = applyConfigSet(getUserConfig(), key, value);
+      if (!result.ok) {
+        if (opts.json) outputJsonError(result.error);
+        else logError(result.error);
+        process.exitCode = 1;
+        return;
+      }
+      saveUserConfig(result.next);
+      if (opts.json) outputJson({ ok: true, key, value: result.value });
+      else logSuccess(`Set ${colorize(key, 'cyan')} = ${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: string, opts: { json?: boolean }) => {
+      const result = applyConfigUnset(getUserConfig(), key);
+      if (!result.ok) {
+        if (opts.json) outputJsonError(result.error);
+        else logError(result.error);
+        process.exitCode = 1;
+        return;
+      }
+      saveUserConfig(result.next);
+      if (opts.json) outputJson({ ok: true, key, value: result.value });
+      else logSuccess(`Reset ${colorize(key, 'cyan')} to default (${formatConfigValue(result.value)})`);
+    });
+
+  config
+    .command('list')
+    .alias('ls')
+    .description('List all config keys and current values')
+    .option('--json', 'Output as JSON')
+    .action((opts: { json?: boolean }) => printAll(getUserConfig(), opts.json));
+
+  config
+    .command('path')
+    .description('Print the path to the config file')
+    .action(() => {
+      process.stdout.write(CONFIG_PATH + '\n');
+    });
+}
+
+function printAll(cfg: ReturnType<typeof getUserConfig>, json?: boolean): void {
+  if (json) {
+    const values: Record<string, unknown> = {};
+    for (const key of CONFIG_KEYS) values[key] = cfg[key];
+    outputJson({ path: CONFIG_PATH, values });
+    return;
+  }
+  const width = Math.max(...CONFIG_KEYS.map((k) => k.length));
+  console.log(colorize('Nemus configuration', 'bright') + colorize(`  (${CONFIG_PATH})`, 'dim'));
+  for (const key of CONFIG_KEYS) {
+    const val = formatConfigValue(cfg[key]);
+    const shown = val === '' ? colorize('(empty)', 'dim') : val;
+    console.log(`  ${key.padEnd(width)}  ${shown}  ${colorize(CONFIG_SCHEMA[key].describe, 'dim')}`);
+  }
+}

package/src/commands/reflect.ts

@@ -1,15 +1,21 @@
 import { Command } from 'commander';
-import { logError, logInfo, logStep } from '../utils/logger';
+import { logError, logInfo, logStep, logWarning } from '../utils/logger';
 import { outputJson, outputJsonError } from '../utils/output';
 import { colorize } from '../utils/colors';
 import {
   gatherReflectionCorpus,
   parseReflectionReport,
   saveReflectionReport,
+  renderReportMarkdown,
+  severitySummary,
+  groupRecommendations,
+  listSavedReports,
+  findSavedMatches,
   REFLECT_SCHEMA,
   ReflectionReport,
   ReflectProgress,
   Recommendation,
+  GroupBy,
 } from '../utils/reflect';
 import { analyzeCorpus, buildAnalysisPrompt } from '../utils/reflect-analyze';
 import { runAgentJsonAsync } from '../utils/agent-judge';
@@ -18,31 +24,63 @@ export function registerReflectCommand(parent: Command) {
   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: string | undefined, id: string | undefined, 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) outputJsonError(msg);
+        else 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: string | undefined, json?: boolean): GroupBy {
+  if (raw === undefined || raw === 'priority' || raw === 'kind') return (raw ?? 'priority') as GroupBy;
+  const msg = `--group-by must be "priority" or "kind"; got "${raw}"`;
+  if (json) outputJsonError(msg);
+  else logError(msg);
+  process.exit(1);
+}
+
 async function handleReflect(opts: {
   limit?: string;
   workspace?: string;
   model?: string;
   thinking?: string;
   json?: boolean;
+  markdown?: boolean;
+  groupBy?: string;
   save?: boolean; // commander sets `save: false` for --no-save
   dryRun?: boolean;
 }) {
   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) {
       logStep(
         opts.workspace
@@ -85,7 +123,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: unknown;
@@ -114,7 +152,25 @@ async function handleReflect(opts: {
       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(
+        renderReportMarkdown(
+          report,
+          {
+            analyzed: withSessions,
+            workspaces: corpus.workspaces.length,
+            workspace: opts.workspace,
+            generatedAt: new Date().toISOString(),
+          },
+          groupBy,
+        ),
+      );
+      if (savedTo) logInfo(`Saved report to ${colorize(savedTo, 'dim')}`);
+      return;
+    }
+    printReport(report, corpus.workspaces.length, withSessions, groupBy);
     if (savedTo) logInfo(`Saved report to ${colorize(savedTo, 'dim')}`);
   } catch (error) {
     const msg = error instanceof Error ? error.message : 'reflect failed';
@@ -183,7 +239,7 @@ function priorityBadge(p: Recommendation['priority']): string {
   return colorize('● low', 'gray');
 }
 
-function printReport(report: ReflectionReport, workspaces: number, analyzed: number) {
+function printReport(report: ReflectionReport, workspaces: number, analyzed: number, groupBy: GroupBy = 'priority') {
   console.log('');
   console.log(colorize('  Reflection', 'bright') + colorize(`  (${analyzed} sessions across ${workspaces} workspaces)`, 'dim'));
   console.log(colorize('  ' + '─'.repeat(56), 'dim'));
@@ -196,19 +252,99 @@ function printReport(report: ReflectionReport, workspaces: number, analyzed: num
     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('\n  ' + colorize(severitySummary(report.recommendations), 'dim'));
 
-  console.log('');
-  for (const r of recs) {
-    const target = r.target ? colorize(`  [${r.target}]`, 'cyan') : '';
-    console.log(`  ${priorityBadge(r.priority)}  ${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(colorize('      example:', 'dim'));
-      console.log(colorize(r.example.replace(/^/gm, '        '), 'dim'));
+  for (const group of groupRecommendations(report.recommendations, groupBy)) {
+    console.log('\n  ' + colorize(group.heading, 'bright'));
+    for (const r of group.recs) {
+      const target = r.target ? 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) : 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(colorize('      example:', 'dim'));
+        console.log(colorize(r.example.replace(/^/gm, '        '), 'dim'));
+      }
     }
-    console.log('');
   }
+  console.log('');
+}
+
+async function handleHistory(opts: { json?: boolean }) {
+  const reports = await listSavedReports();
+  if (opts.json) {
+    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: severitySummary(r.report.recommendations),
+      })),
+    });
+    return;
+  }
+  if (reports.length === 0) {
+    logInfo('No saved reflection reports yet. Run `nemus reflect` to create one.');
+    return;
+  }
+  console.log('');
+  console.log(colorize('  Saved reflections', 'bright') + colorize(`  (${reports.length})`, 'dim'));
+  console.log(colorize('  ' + '─'.repeat(56), 'dim'));
+  for (const r of reports) {
+    const when = r.generatedAt ? new Date(r.generatedAt).toLocaleString() : r.id;
+    const scope = r.workspace ? colorize(` ${r.workspace}`, 'cyan') : colorize(` ${r.analyzed} sessions`, 'dim');
+    const sev = r.report.recommendations.length
+      ? colorize(`  ${severitySummary(r.report.recommendations)}`, 'dim')
+      : colorize('  no recs', 'green');
+    console.log(`  ${colorize(r.id, 'bright')}${scope}${sev}`);
+    console.log(colorize(`     ${when}`, 'dim'));
+  }
+  console.log('');
+  console.log(colorize('  nemus reflect show <id>   (or `latest`)', 'dim'));
+}
+
+async function handleShow(
+  id: string | undefined,
+  opts: { json?: boolean; markdown?: boolean; groupBy?: string },
+) {
+  const groupBy = resolveGroupBy(opts.groupBy, opts.json);
+  const matches = findSavedMatches(await 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) outputJsonError(msg);
+    else 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) {
+    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) {
+    outputJson({ id: saved.id, ...meta, ...saved.report });
+    return;
+  }
+  if (opts.markdown) {
+    process.stdout.write(renderReportMarkdown(saved.report, meta, groupBy));
+    return;
+  }
+  printReport(saved.report, saved.workspaces, saved.analyzed, groupBy);
 }

package/src/program.ts

@@ -53,6 +53,7 @@ import { registerArchiveCommand } from './commands/archive';
 import { registerSessionsCommand } from './commands/sessions';
 import { registerGenerateDocsCommand } from './commands/generate-docs';
 import { registerConfigureCommand } from './commands/configure';
+import { registerConfigCommand } from './commands/config';
 import { registerConfigureClaudeCommand } from './commands/configure-claude';
 import { registerGhqStatusCommand } from './commands/ghq-status';
 import { registerSaveContextCommand } from './commands/save-context';
@@ -79,6 +80,7 @@ registerArchiveCommand(program);
 registerSessionsCommand(program);
 registerGenerateDocsCommand(program);
 registerConfigureCommand(program);
+registerConfigCommand(program);
 registerConfigureClaudeCommand(program);
 registerGhqStatusCommand(program);
 registerSaveContextCommand(program);