clawvault 2.4.3 → 2.4.5

package/bin/clawvault.js

@@ -16,6 +16,8 @@ import { registerResilienceCommands } from './register-resilience-commands.js';
 import { registerSessionLifecycleCommands } from './register-session-lifecycle-commands.js';
 import { registerTemplateCommands } from './register-template-commands.js';
 import { registerVaultOperationsCommands } from './register-vault-operations-commands.js';
+import { registerConfigCommands } from './register-config-commands.js';
+import { registerRouteCommands } from './register-route-commands.js';
 
 import { registerTaskCommands } from './register-task-commands.js';
 
@@ -93,6 +95,8 @@ registerTaskCommands(program, {
 });
 
 registerTailscaleCommands(program, { chalk });
+registerConfigCommands(program, { chalk, resolveVaultPath });
+registerRouteCommands(program, { chalk, resolveVaultPath });
 
 // Parse and run
 program.parse();

package/bin/command-registration.test.js

@@ -9,6 +9,8 @@ import { registerResilienceCommands } from './register-resilience-commands.js';
 import { registerSessionLifecycleCommands } from './register-session-lifecycle-commands.js';
 import { registerTemplateCommands } from './register-template-commands.js';
 import { registerVaultOperationsCommands } from './register-vault-operations-commands.js';
+import { registerConfigCommands } from './register-config-commands.js';
+import { registerRouteCommands } from './register-route-commands.js';
 import {
   chalkStub,
   createGetVaultStub,
@@ -107,6 +109,14 @@ describe('CLI command registration modules', () => {
       runQmd: async () => {}
     });
     registerTemplateCommands(program, { chalk: chalkStub });
+    registerConfigCommands(program, {
+      chalk: chalkStub,
+      resolveVaultPath: stubResolveVaultPath
+    });
+    registerRouteCommands(program, {
+      chalk: chalkStub,
+      resolveVaultPath: stubResolveVaultPath
+    });
 
     const names = listCommandNames(program);
     expect(names).toEqual(expect.arrayContaining([
@@ -129,7 +139,9 @@ describe('CLI command registration modules', () => {
       'sleep',
       'handoff',
       'recap',
-      'template'
+      'template',
+      'config',
+      'route'
     ]));
 
     const templateCommand = program.commands.find((command) => command.name() === 'template');

package/bin/help-contract.test.js

@@ -12,6 +12,8 @@ describe('CLI help contract', () => {
     expect(help).toContain('replay');
     expect(help).toContain('repair-session');
     expect(help).toContain('template');
+    expect(help).toContain('config');
+    expect(help).toContain('route');
   });
 
   it('documents context auto profile and compat strict options', () => {

package/bin/register-config-commands.js

@@ -0,0 +1,153 @@
+/**
+ * Runtime config command registrations backed by .clawvault.json.
+ */
+
+function stringifyValue(value) {
+  if (Array.isArray(value)) {
+    if (value.every((item) => typeof item === 'string' || typeof item === 'number' || typeof item === 'boolean')) {
+      return value.join(', ');
+    }
+    return JSON.stringify(value);
+  }
+  if (value && typeof value === 'object') {
+    return JSON.stringify(value);
+  }
+  if (value === null || value === undefined) {
+    return '(unset)';
+  }
+  return String(value);
+}
+
+function flattenConfig(value, prefix = '') {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return [{ key: prefix || '(root)', value: stringifyValue(value) }];
+  }
+
+  const rows = [];
+  const keys = Object.keys(value).sort((left, right) => left.localeCompare(right));
+  for (const key of keys) {
+    const next = prefix ? `${prefix}.${key}` : key;
+    const entry = value[key];
+    if (entry && typeof entry === 'object' && !Array.isArray(entry)) {
+      rows.push(...flattenConfig(entry, next));
+      continue;
+    }
+    rows.push({ key: next, value: stringifyValue(entry) });
+  }
+  return rows;
+}
+
+function printTable(rows) {
+  if (rows.length === 0) {
+    console.log('No config values found.');
+    return;
+  }
+  const keyWidth = Math.max(
+    'KEY'.length,
+    ...rows.map((row) => row.key.length)
+  );
+  const valueWidth = Math.max(
+    'VALUE'.length,
+    ...rows.map((row) => row.value.length)
+  );
+  const header = `${'KEY'.padEnd(keyWidth)}  ${'VALUE'.padEnd(valueWidth)}`;
+  const divider = `${'-'.repeat(keyWidth)}  ${'-'.repeat(valueWidth)}`;
+  console.log(header);
+  console.log(divider);
+  for (const row of rows) {
+    console.log(`${row.key.padEnd(keyWidth)}  ${row.value}`);
+  }
+}
+
+function normalizeConfigKey(key) {
+  return String(key || '').trim();
+}
+
+export function registerConfigCommands(program, { chalk, resolveVaultPath }) {
+  const config = program
+    .command('config')
+    .description('Read and modify runtime config');
+
+  config
+    .command('get <key>')
+    .description('Read a runtime config value (dot-notation supported)')
+    .option('-v, --vault <path>', 'Vault path')
+    .action(async (key, options) => {
+      try {
+        const { getConfigValue, SUPPORTED_CONFIG_KEYS } = await import('../dist/index.js');
+        const normalizedKey = normalizeConfigKey(key);
+        if (!SUPPORTED_CONFIG_KEYS.includes(normalizedKey)) {
+          throw new Error(`Unsupported config key: ${normalizedKey}`);
+        }
+
+        const value = getConfigValue(resolveVaultPath(options.vault), normalizedKey);
+        if (Array.isArray(value)) {
+          console.log(value.join(','));
+          return;
+        }
+        if (value && typeof value === 'object') {
+          console.log(JSON.stringify(value, null, 2));
+          return;
+        }
+        console.log(value === undefined || value === null ? '' : String(value));
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  config
+    .command('set <key> <value>')
+    .description('Set a runtime config value')
+    .option('-v, --vault <path>', 'Vault path')
+    .action(async (key, value, options) => {
+      try {
+        const { setConfigValue, SUPPORTED_CONFIG_KEYS } = await import('../dist/index.js');
+        const normalizedKey = normalizeConfigKey(key);
+        if (!SUPPORTED_CONFIG_KEYS.includes(normalizedKey)) {
+          throw new Error(`Unsupported config key: ${normalizedKey}`);
+        }
+        const result = setConfigValue(resolveVaultPath(options.vault), normalizedKey, value);
+        console.log(chalk.green(`✓ Updated ${normalizedKey}`));
+        console.log(chalk.dim(`  Value: ${stringifyValue(result.value)}`));
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  config
+    .command('list')
+    .description('List all config values')
+    .option('-v, --vault <path>', 'Vault path')
+    .action(async (options) => {
+      try {
+        const { listConfig } = await import('../dist/index.js');
+        const values = listConfig(resolveVaultPath(options.vault));
+        const rows = flattenConfig(values);
+        printTable(rows);
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  config
+    .command('reset')
+    .description('Reset runtime config values to defaults')
+    .option('--confirm', 'Confirm reset')
+    .option('-v, --vault <path>', 'Vault path')
+    .action(async (options) => {
+      try {
+        if (!options.confirm) {
+          throw new Error('Refusing to reset config without --confirm.');
+        }
+        const { resetConfig } = await import('../dist/index.js');
+        resetConfig(resolveVaultPath(options.vault));
+        console.log(chalk.green('✓ Config reset to defaults'));
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+}

package/bin/register-config-route-commands.test.js

@@ -0,0 +1,114 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { Command } from 'commander';
+import { registerConfigCommands } from './register-config-commands.js';
+import { registerRouteCommands } from './register-route-commands.js';
+import { chalkStub } from './test-helpers/cli-command-fixtures.js';
+
+const {
+  getConfigValueMock,
+  setConfigValueMock,
+  listConfigMock,
+  resetConfigMock,
+  addRouteRuleMock,
+  listRouteRulesMock,
+  removeRouteRuleMock,
+  testRouteRuleMock
+} = vi.hoisted(() => ({
+  getConfigValueMock: vi.fn(),
+  setConfigValueMock: vi.fn(),
+  listConfigMock: vi.fn(),
+  resetConfigMock: vi.fn(),
+  addRouteRuleMock: vi.fn(),
+  listRouteRulesMock: vi.fn(),
+  removeRouteRuleMock: vi.fn(),
+  testRouteRuleMock: vi.fn()
+}));
+
+vi.mock('../dist/index.js', () => ({
+  SUPPORTED_CONFIG_KEYS: [
+    'name',
+    'categories',
+    'theme',
+    'observe.model',
+    'observe.provider',
+    'context.maxResults',
+    'context.defaultProfile',
+    'graph.maxHops'
+  ],
+  getConfigValue: getConfigValueMock,
+  setConfigValue: setConfigValueMock,
+  listConfig: listConfigMock,
+  resetConfig: resetConfigMock,
+  addRouteRule: addRouteRuleMock,
+  listRouteRules: listRouteRulesMock,
+  removeRouteRule: removeRouteRuleMock,
+  testRouteRule: testRouteRuleMock
+}));
+
+function buildProgram() {
+  const program = new Command();
+  const resolveVaultPath = (value) => value ?? '/vault';
+  registerConfigCommands(program, { chalk: chalkStub, resolveVaultPath });
+  registerRouteCommands(program, { chalk: chalkStub, resolveVaultPath });
+  return program;
+}
+
+async function runCommand(args) {
+  const program = buildProgram();
+  await program.parseAsync(args, { from: 'user' });
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  getConfigValueMock.mockReturnValue('demo-vault');
+  setConfigValueMock.mockReturnValue({ value: 'demo-vault' });
+  listConfigMock.mockReturnValue({ name: 'demo-vault', context: { maxResults: 5 } });
+  resetConfigMock.mockReturnValue(undefined);
+  addRouteRuleMock.mockReturnValue({ pattern: 'Pedro', target: 'people/pedro', priority: 1 });
+  listRouteRulesMock.mockReturnValue([{ pattern: 'Pedro', target: 'people/pedro', priority: 1 }]);
+  removeRouteRuleMock.mockReturnValue(true);
+  testRouteRuleMock.mockReturnValue({ pattern: 'Pedro', target: 'people/pedro', priority: 1 });
+});
+
+describe('config and route command registrations', () => {
+  it('executes config get/set/list subcommands', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      await runCommand(['config', 'get', 'name']);
+      expect(getConfigValueMock).toHaveBeenCalledWith('/vault', 'name');
+
+      await runCommand(['config', 'set', 'categories', 'people,projects']);
+      expect(setConfigValueMock).toHaveBeenCalledWith('/vault', 'categories', 'people,projects');
+
+      await runCommand(['config', 'list']);
+      expect(listConfigMock).toHaveBeenCalledWith('/vault');
+
+      const output = logSpy.mock.calls.map((call) => call.join(' ')).join('\n');
+      expect(output).toContain('context.maxResults');
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+
+  it('executes route add/remove/test subcommands', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      await runCommand(['route', 'add', 'Pedro', 'people/pedro']);
+      expect(addRouteRuleMock).toHaveBeenCalledWith('/vault', 'Pedro', 'people/pedro');
+
+      await runCommand(['route', 'remove', 'Pedro']);
+      expect(removeRouteRuleMock).toHaveBeenCalledWith('/vault', 'Pedro');
+
+      await runCommand(['route', 'test', 'Talked to Pedro']);
+      expect(testRouteRuleMock).toHaveBeenCalledWith('/vault', 'Talked to Pedro');
+
+      await runCommand(['route', 'list']);
+      expect(listRouteRulesMock).toHaveBeenCalledWith('/vault');
+
+      const output = logSpy.mock.calls.map((call) => call.join(' ')).join('\n');
+      expect(output).toContain('Route matched');
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+});

package/bin/register-resilience-commands.js

@@ -45,13 +45,48 @@ export function registerResilienceCommands(program, { chalk, resolveVaultPath })
     .command('recover')
     .description('Check for context death and recover state')
     .option('--clear', 'Clear the dirty death flag after recovery')
+    .option('--check', 'Check dirty death flag without clearing it')
+    .option('--list', 'List saved checkpoints (newest first)')
     .option('--verbose', 'Show full checkpoint and handoff content')
     .option('-v, --vault <path>', 'Vault path')
     .option('--json', 'Output as JSON')
     .action(async (options) => {
       try {
-        const { recover, formatRecoveryInfo } = await import('../dist/commands/recover.js');
-        const info = await recover(resolveVaultPath(options.vault), {
+        if (options.check && options.list) {
+          throw new Error('--check and --list cannot be used together.');
+        }
+
+        const {
+          recover,
+          formatRecoveryInfo,
+          checkRecoveryStatus,
+          formatRecoveryCheckStatus,
+          listCheckpoints,
+          formatCheckpointList
+        } = await import('../dist/commands/recover.js');
+        const vaultPath = resolveVaultPath(options.vault);
+
+        if (options.check) {
+          const status = await checkRecoveryStatus(vaultPath);
+          if (options.json) {
+            console.log(JSON.stringify(status, null, 2));
+          } else {
+            console.log(formatRecoveryCheckStatus(status));
+          }
+          return;
+        }
+
+        if (options.list) {
+          const checkpoints = listCheckpoints(vaultPath);
+          if (options.json) {
+            console.log(JSON.stringify(checkpoints, null, 2));
+          } else {
+            console.log(formatCheckpointList(checkpoints));
+          }
+          return;
+        }
+
+        const info = await recover(vaultPath, {
           clearFlag: options.clear,
           verbose: options.verbose
         });

package/bin/register-resilience-commands.test.js

@@ -0,0 +1,81 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { Command } from 'commander';
+import { registerResilienceCommands } from './register-resilience-commands.js';
+import { chalkStub } from './test-helpers/cli-command-fixtures.js';
+
+const {
+  recoverMock,
+  formatRecoveryInfoMock,
+  checkRecoveryStatusMock,
+  formatRecoveryCheckStatusMock,
+  listCheckpointsMock,
+  formatCheckpointListMock
+} = vi.hoisted(() => ({
+  recoverMock: vi.fn(),
+  formatRecoveryInfoMock: vi.fn(),
+  checkRecoveryStatusMock: vi.fn(),
+  formatRecoveryCheckStatusMock: vi.fn(),
+  listCheckpointsMock: vi.fn(),
+  formatCheckpointListMock: vi.fn()
+}));
+
+vi.mock('../dist/commands/recover.js', () => ({
+  recover: recoverMock,
+  formatRecoveryInfo: formatRecoveryInfoMock,
+  checkRecoveryStatus: checkRecoveryStatusMock,
+  formatRecoveryCheckStatus: formatRecoveryCheckStatusMock,
+  listCheckpoints: listCheckpointsMock,
+  formatCheckpointList: formatCheckpointListMock
+}));
+
+function buildProgram() {
+  const program = new Command();
+  registerResilienceCommands(program, {
+    chalk: chalkStub,
+    resolveVaultPath: (value) => value ?? '/vault'
+  });
+  return program;
+}
+
+async function runCommand(args) {
+  const program = buildProgram();
+  await program.parseAsync(args, { from: 'user' });
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  recoverMock.mockResolvedValue({ died: false });
+  formatRecoveryInfoMock.mockReturnValue('recover');
+  checkRecoveryStatusMock.mockResolvedValue({ died: false, deathTime: null, checkpoint: null });
+  formatRecoveryCheckStatusMock.mockReturnValue('check');
+  listCheckpointsMock.mockReturnValue([]);
+  formatCheckpointListMock.mockReturnValue('list');
+});
+
+describe('register-resilience-commands', () => {
+  it('routes recover --check through check helpers', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      await runCommand(['recover', '--check']);
+      expect(checkRecoveryStatusMock).toHaveBeenCalledWith('/vault');
+      expect(formatRecoveryCheckStatusMock).toHaveBeenCalled();
+      expect(recoverMock).not.toHaveBeenCalled();
+      expect(logSpy).toHaveBeenCalledWith('check');
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+
+  it('routes recover --list through checkpoint listing helpers', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    try {
+      await runCommand(['recover', '--list']);
+      expect(listCheckpointsMock).toHaveBeenCalledWith('/vault');
+      expect(formatCheckpointListMock).toHaveBeenCalled();
+      expect(recoverMock).not.toHaveBeenCalled();
+      expect(logSpy).toHaveBeenCalledWith('list');
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+});

package/bin/register-route-commands.js

@@ -0,0 +1,114 @@
+/**
+ * Route command registrations for custom observation entity routing.
+ */
+
+function printRoutesTable(routes) {
+  if (routes.length === 0) {
+    console.log('No custom routes configured.');
+    return;
+  }
+
+  const priorityWidth = Math.max(
+    'PRIORITY'.length,
+    ...routes.map((route) => String(route.priority).length)
+  );
+  const patternWidth = Math.max(
+    'PATTERN'.length,
+    ...routes.map((route) => route.pattern.length)
+  );
+  const targetWidth = Math.max(
+    'TARGET'.length,
+    ...routes.map((route) => route.target.length)
+  );
+
+  const header = `${'PRIORITY'.padEnd(priorityWidth)}  ${'PATTERN'.padEnd(patternWidth)}  ${'TARGET'.padEnd(targetWidth)}`;
+  const divider = `${'-'.repeat(priorityWidth)}  ${'-'.repeat(patternWidth)}  ${'-'.repeat(targetWidth)}`;
+
+  console.log(header);
+  console.log(divider);
+  for (const route of routes) {
+    console.log(
+      `${String(route.priority).padEnd(priorityWidth)}  ${route.pattern.padEnd(patternWidth)}  ${route.target}`
+    );
+  }
+}
+
+export function registerRouteCommands(program, { chalk, resolveVaultPath }) {
+  const route = program
+    .command('route')
+    .description('Manage custom observation routing rules');
+
+  route
+    .command('list')
+    .description('List custom routing rules')
+    .option('-v, --vault <path>', 'Vault path')
+    .action(async (options) => {
+      try {
+        const { listRouteRules } = await import('../dist/index.js');
+        const rules = listRouteRules(resolveVaultPath(options.vault));
+        printRoutesTable(rules);
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  route
+    .command('add <pattern> <target>')
+    .description('Add a custom routing rule')
+    .option('-v, --vault <path>', 'Vault path')
+    .action(async (pattern, target, options) => {
+      try {
+        const { addRouteRule } = await import('../dist/index.js');
+        const rule = addRouteRule(resolveVaultPath(options.vault), pattern, target);
+        console.log(chalk.green('✓ Route added'));
+        console.log(chalk.dim(`  Pattern: ${rule.pattern}`));
+        console.log(chalk.dim(`  Target: ${rule.target}`));
+        console.log(chalk.dim(`  Priority: ${rule.priority}`));
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  route
+    .command('remove <pattern>')
+    .description('Remove a custom routing rule by pattern')
+    .option('-v, --vault <path>', 'Vault path')
+    .action(async (pattern, options) => {
+      try {
+        const { removeRouteRule } = await import('../dist/index.js');
+        const removed = removeRouteRule(resolveVaultPath(options.vault), pattern);
+        if (!removed) {
+          console.log(chalk.yellow(`No route found for pattern: ${pattern}`));
+          return;
+        }
+        console.log(chalk.green(`✓ Removed route: ${pattern}`));
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  route
+    .command('test <text>')
+    .description('Test custom routes against text')
+    .option('-v, --vault <path>', 'Vault path')
+    .action(async (text, options) => {
+      try {
+        const { testRouteRule } = await import('../dist/index.js');
+        const match = testRouteRule(resolveVaultPath(options.vault), text);
+        if (!match) {
+          console.log('No route matched.');
+          return;
+        }
+        console.log(chalk.green('✓ Route matched'));
+        console.log(chalk.dim(`  Pattern: ${match.pattern}`));
+        console.log(chalk.dim(`  Target: ${match.target}`));
+        console.log(chalk.dim(`  Priority: ${match.priority}`));
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+}

package/bin/register-task-commands.js

@@ -80,6 +80,8 @@ export function registerTaskCommands(
     .option('--priority <priority>', 'New priority')
     .option('--blocked-by <blocker>', 'What is blocking this task')
     .option('--due <date>', 'New due date')
+    .option('--confidence <value>', 'Transition confidence (0-1)', parseFloat)
+    .option('--reason <reason>', 'Reason for status change')
     .action(async (slug, options) => {
       try {
         const vaultPath = resolveVaultPath(options.vault);
@@ -92,7 +94,9 @@ export function registerTaskCommands(
             project: options.project,
             priority: options.priority,
             blockedBy: options.blockedBy,
-            due: options.due
+            due: options.due,
+            confidence: options.confidence,
+            reason: options.reason
           }
         });
       } catch (err) {
@@ -106,11 +110,45 @@ export function registerTaskCommands(
     .command('done <slug>')
     .description('Mark a task as done')
     .option('-v, --vault <path>', 'Vault path')
+    .option('--confidence <value>', 'Transition confidence (0-1)', parseFloat)
+    .option('--reason <reason>', 'Reason for completion')
     .action(async (slug, options) => {
       try {
         const vaultPath = resolveVaultPath(options.vault);
         const { taskCommand } = await import('../dist/commands/task.js');
-        await taskCommand(vaultPath, 'done', { slug });
+        await taskCommand(vaultPath, 'done', {
+          slug,
+          options: {
+            confidence: options.confidence,
+            reason: options.reason
+          }
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
+  // task transitions
+  taskCmd
+    .command('transitions [task_id]')
+    .description('Show transition history')
+    .option('-v, --vault <path>', 'Vault path')
+    .option('--agent <id>', 'Filter by agent')
+    .option('--failed', 'Show only regression transitions')
+    .option('--json', 'Output as JSON')
+    .action(async (taskId, options) => {
+      try {
+        const vaultPath = resolveVaultPath(options.vault);
+        const { taskCommand } = await import('../dist/commands/task.js');
+        await taskCommand(vaultPath, 'transitions', {
+          slug: taskId,
+          options: {
+            agent: options.agent,
+            failed: options.failed,
+            json: options.json
+          }
+        });
       } catch (err) {
         console.error(chalk.red(`Error: ${err.message}`));
         process.exit(1);
@@ -221,6 +259,7 @@ export function registerTaskCommands(
     .description('View blocked tasks')
     .option('-v, --vault <path>', 'Vault path')
     .option('--project <project>', 'Filter by project')
+    .option('--escalated', 'Show only escalated tasks (3+ blocked transitions)')
     .option('--json', 'Output as JSON')
     .action(async (options) => {
       try {
@@ -228,6 +267,7 @@ export function registerTaskCommands(
         const { blockedCommand } = await import('../dist/commands/blocked.js');
         await blockedCommand(vaultPath, {
           project: options.project,
+          escalated: options.escalated,
           json: options.json
         });
       } catch (err) {

package/bin/test-helpers/cli-command-fixtures.js

@@ -8,6 +8,8 @@ import { registerResilienceCommands } from '../register-resilience-commands.js';
 import { registerSessionLifecycleCommands } from '../register-session-lifecycle-commands.js';
 import { registerTemplateCommands } from '../register-template-commands.js';
 import { registerVaultOperationsCommands } from '../register-vault-operations-commands.js';
+import { registerConfigCommands } from '../register-config-commands.js';
+import { registerRouteCommands } from '../register-route-commands.js';
 
 export const chalkStub = {
   cyan: (value) => value,
@@ -89,6 +91,14 @@ export function registerAllCommandModules(program = new Command()) {
     runQmd: async () => {}
   });
   registerTemplateCommands(program, { chalk: chalkStub });
+  registerConfigCommands(program, {
+    chalk: chalkStub,
+    resolveVaultPath: stubResolveVaultPath
+  });
+  registerRouteCommands(program, {
+    chalk: chalkStub,
+    resolveVaultPath: stubResolveVaultPath
+  });
 
   return program;
 }