@principles/pd-cli 1.133.0 → 1.135.0

package/tests/commands/runtime-canary.test.ts

@@ -1,4 +1,15 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const expectedCliVersion: string = ((): string => {
+  const pkg: unknown = require('../../package.json');
+  if (typeof pkg === 'object' && pkg !== null && Object.hasOwn(pkg, 'version')) {
+    const v: unknown = Reflect.get(pkg, 'version');
+    if (typeof v === 'string') return v;
+  }
+  return 'unknown';
+})();
 
 const {
   mockSchemaCheck,
@@ -88,6 +99,7 @@ function healthyHealthSnapshot() {
     gfi: { active: null, staleSessionCount: 0, totalSessionCount: 0, activeSessionCount: 0, generatedAt: new Date().toISOString() },
     overallStatus: 'healthy' as const,
     recommendedActions: [],
+    totalTaskCount: 1,
   };
 }
 
@@ -165,6 +177,44 @@ describe('runCanaryChecks', () => {
     expect(schemaCheck?.status).toBe('degraded');
   });
 
+  it('reports an unexercised runtime as degraded with a next action', async () => {
+    mockHealthSnapshot.mockResolvedValue({
+      ...healthyHealthSnapshot(), totalTaskCount: 0,
+      recommendedActions: ['Runtime V2 pipeline has never been exercised.'],
+    });
+    const result = await runCanaryChecks(WS);
+    const runtimeCheck = result.checks.find(check => check.name === 'runtime_health');
+    expect(result.overallStatus).toBe('degraded');
+    expect(runtimeCheck?.status).toBe('degraded');
+    expect(runtimeCheck?.summary).toContain('not been exercised');
+    expect(result.recommendedNextActions).toContainEqual(expect.stringContaining('pain record'));
+  });
+
+  it('surfaces a real error (e.g. DB missing) as error, not masked by cold-start totalTaskCount=0', async () => {
+    // Simulates DB-missing scenario: overallStatus='error' while totalTaskCount stays 0
+    // (getTotalTaskCount() throws and the snapshot keeps the default 0).
+    mockHealthSnapshot.mockResolvedValue({
+      ...healthyHealthSnapshot(),
+      overallStatus: 'error' as const,
+      totalTaskCount: 0,
+      recommendedActions: ['Re-initialize the runtime database.'],
+    });
+    const result = await runCanaryChecks(WS);
+    const runtimeCheck = result.checks.find(check => check.name === 'runtime_health');
+    expect(runtimeCheck?.status).toBe('error');
+    // Summary must surface the error, NOT the cold-start "not been exercised" message.
+    expect(runtimeCheck?.summary).not.toContain('not been exercised');
+    expect(runtimeCheck?.summary).toContain('error');
+    expect(runtimeCheck?.summary).toContain('Re-initialize the runtime database.');
+    expect(result.overallStatus).toBe('error');
+  });
+
+  it('reports the package version instead of a hard-coded shim version', async () => {
+    const result = await runCanaryChecks(WS);
+    const shimCheck = result.checks.find(check => check.name === 'pd_shim_info');
+    expect(shimCheck?.details).toMatchObject({ version: expectedCliVersion });
+  });
+
   it('continues other checks when one throws', async () => {
     mockAuditConsistency.mockRejectedValue(new Error('DB error'));
 

package/tests/commands/runtime-features.test.ts

@@ -44,6 +44,8 @@ function makeValidConfigYaml(): string {
       empathy_observer: { category: 'quiet', enabled: false },
     },
     runtimeProfiles: {
+      // Include pd.default (the M9 default) to avoid "profile not found" warnings
+      'pd.default': { type: 'pi-ai', provider: 'anthropic', model: 'claude-3-5-sonnet', apiKeyEnv: 'ANTHROPIC_API_KEY' },
       'openclaw.default': { type: 'openclaw', source: 'default' },
     },
     internalAgents: {

package/tests/commands/runtime-init-empty-workspace.test.ts

@@ -0,0 +1,234 @@
+/**
+ * runtime-init empty-workspace integration tests — verifies real DB initialization.
+ *
+ * Does NOT mock the DB layer. Uses real better-sqlite3 to create actual database
+ * files in a temp workspace, then verifies all expected tables exist.
+ *
+ * Covers:
+ *   - EMPTY-01: initialize empty workspace → all 3 DBs have full schema
+ *   - EMPTY-02: idempotency — running twice does not error or lose data
+ *
+ * Prerequisites: @principles/core and principles-disciple must be built.
+ *
+ * ERR refs:
+ * - rc-7-loop-state-freshness: idempotency test uses fresh workspace each run
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import Database from 'better-sqlite3';
+import { buildRuntimeInitOutput } from '../../src/commands/runtime-init.js';
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+function mkTmpDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'pd-runtime-init-empty-'));
+}
+
+function rmTmpDir(dir: string): void {
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+}
+
+function getTableNames(dbPath: string): string[] {
+  const db = new Database(dbPath, { readonly: true });
+  try {
+    const rows = db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name"
+    ).all() as { name: string }[];
+    return rows.map(r => r.name);
+  } finally {
+    db.close();
+  }
+}
+
+function getIndexNames(dbPath: string): string[] {
+  const db = new Database(dbPath, { readonly: true });
+  try {
+    const rows = db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='index' AND name NOT LIKE 'sqlite_%' ORDER BY name"
+    ).all() as { name: string }[];
+    return rows.map(r => r.name);
+  } finally {
+    db.close();
+  }
+}
+
+// ── Expected schema ─────────────────────────────────────────────────────────
+
+const EXPECTED_STATE_TABLES = [
+  'tasks', 'runs', 'artifacts', 'commits',
+  'principle_candidates', 'pi_artifacts',
+  'approvals', 'activations', 'intent_decisions',
+  'schema_version',
+];
+
+const EXPECTED_TRAJECTORY_TABLES = [
+  'schema_version', 'ingest_checkpoint', 'sessions', 'assistant_turns',
+  'user_turns', 'tool_calls', 'pain_events', 'gate_blocks', 'trust_changes',
+  'principle_events', 'task_outcomes', 'correction_samples', 'sample_reviews',
+  'exports_audit', 'evolution_tasks', 'evolution_events',
+];
+
+const EXPECTED_WORKFLOW_TABLES = [
+  'schema_version', 'subagent_workflows', 'subagent_workflow_events',
+];
+
+const EXPECTED_TRAJECTORY_INDEXES = [
+  'idx_assistant_turns_session_id',
+  'idx_assistant_turns_created_at',
+  'idx_assistant_turns_provider_model',
+  'idx_user_turns_session_id',
+  'idx_tool_calls_session_id',
+  'idx_tool_calls_created_at',
+  'idx_pain_events_session_id',
+  'idx_pain_events_canonical_pain_id',
+  'idx_correction_samples_review_status',
+  'idx_evolution_tasks_trace_id',
+  'idx_evolution_tasks_status',
+  'idx_evolution_tasks_created_at',
+  'idx_evolution_events_trace_id',
+  'idx_evolution_events_created_at',
+];
+
+// ── Tests ───────────────────────────────────────────────────────────────────
+
+describe('pd runtime init — empty workspace integration', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = mkTmpDir();
+  });
+
+  afterEach(() => {
+    rmTmpDir(tmpDir);
+  });
+
+  // ── EMPTY-01: initialize empty workspace ───────────────────────────────────
+
+  describe('EMPTY-01: initialize empty workspace', () => {
+    it('returns ok=true with 3 initialized databases', () => {
+      const output = buildRuntimeInitOutput(tmpDir, true);
+      expect(output.ok).toBe(true);
+      expect(output.mode).toBe('confirm');
+      expect(output.databases).toHaveLength(3);
+      for (const db of output.databases) {
+        expect(db.status).toBe('initialized');
+      }
+    });
+
+    it('creates state.db with all expected tables', () => {
+      buildRuntimeInitOutput(tmpDir, true);
+      const stateDbPath = path.join(tmpDir, '.pd', 'state.db');
+      expect(fs.existsSync(stateDbPath)).toBe(true);
+      const tables = getTableNames(stateDbPath);
+      for (const expected of EXPECTED_STATE_TABLES) {
+        expect(tables).toContain(expected);
+      }
+    });
+
+    it('creates trajectory.db with all 16 expected tables', () => {
+      buildRuntimeInitOutput(tmpDir, true);
+      const trajDbPath = path.join(tmpDir, '.state', 'trajectory.db');
+      expect(fs.existsSync(trajDbPath)).toBe(true);
+      const tables = getTableNames(trajDbPath);
+      expect(tables).toHaveLength(EXPECTED_TRAJECTORY_TABLES.length);
+      for (const expected of EXPECTED_TRAJECTORY_TABLES) {
+        expect(tables).toContain(expected);
+      }
+    });
+
+    it('creates trajectory.db with all expected indexes', () => {
+      buildRuntimeInitOutput(tmpDir, true);
+      const trajDbPath = path.join(tmpDir, '.state', 'trajectory.db');
+      const indexes = getIndexNames(trajDbPath);
+      for (const expected of EXPECTED_TRAJECTORY_INDEXES) {
+        expect(indexes).toContain(expected);
+      }
+    });
+
+    it('creates subagent_workflows.db with all expected tables', () => {
+      buildRuntimeInitOutput(tmpDir, true);
+      const wfDbPath = path.join(tmpDir, '.state', 'subagent_workflows.db');
+      expect(fs.existsSync(wfDbPath)).toBe(true);
+      const tables = getTableNames(wfDbPath);
+      for (const expected of EXPECTED_WORKFLOW_TABLES) {
+        expect(tables).toContain(expected);
+      }
+    });
+
+    it('pain_events table has canonical_pain_id and runtime_task_id columns', () => {
+      buildRuntimeInitOutput(tmpDir, true);
+      const trajDbPath = path.join(tmpDir, '.state', 'trajectory.db');
+      const db = new Database(trajDbPath, { readonly: true });
+      try {
+        const cols = db.prepare('PRAGMA table_info(pain_events)').all() as { name: string }[];
+        const colNames = cols.map(c => c.name);
+        expect(colNames).toContain('canonical_pain_id');
+        expect(colNames).toContain('runtime_task_id');
+        expect(colNames).toContain('text');
+      } finally {
+        db.close();
+      }
+    });
+
+    it('evolution_tasks table has V2 migration columns', () => {
+      buildRuntimeInitOutput(tmpDir, true);
+      const trajDbPath = path.join(tmpDir, '.state', 'trajectory.db');
+      const db = new Database(trajDbPath, { readonly: true });
+      try {
+        const cols = db.prepare('PRAGMA table_info(evolution_tasks)').all() as { name: string }[];
+        const colNames = cols.map(c => c.name);
+        expect(colNames).toContain('task_kind');
+        expect(colNames).toContain('priority');
+        expect(colNames).toContain('retry_count');
+        expect(colNames).toContain('max_retries');
+        expect(colNames).toContain('last_error');
+        expect(colNames).toContain('result_ref');
+      } finally {
+        db.close();
+      }
+    });
+  });
+
+  // ── EMPTY-02: idempotency ──────────────────────────────────────────────────
+
+  describe('EMPTY-02: idempotency', () => {
+    it('running twice does not error and tables remain intact', () => {
+      // First initialization
+      const output1 = buildRuntimeInitOutput(tmpDir, true);
+      expect(output1.ok).toBe(true);
+
+      // Capture table counts after first init
+      const trajDbPath = path.join(tmpDir, '.state', 'trajectory.db');
+      const tables1 = getTableNames(trajDbPath);
+
+      // Second initialization (should be idempotent)
+      const output2 = buildRuntimeInitOutput(tmpDir, true);
+      expect(output2.ok).toBe(true);
+      expect(output2.databases).toHaveLength(3);
+      for (const db of output2.databases) {
+        expect(db.status).toBe('initialized');
+      }
+
+      // Table set should be unchanged
+      const tables2 = getTableNames(trajDbPath);
+      expect(tables2).toEqual(tables1);
+    });
+
+    it('dry-run after confirm does not modify existing DBs', () => {
+      // First: confirm mode (real init)
+      buildRuntimeInitOutput(tmpDir, true);
+      const trajDbPath = path.join(tmpDir, '.state', 'trajectory.db');
+      const tablesBefore = getTableNames(trajDbPath);
+
+      // Second: dry-run mode (should not modify)
+      const output = buildRuntimeInitOutput(tmpDir, false);
+      expect(output.mode).toBe('dry-run');
+
+      const tablesAfter = getTableNames(trajDbPath);
+      expect(tablesAfter).toEqual(tablesBefore);
+    });
+  });
+});

package/tests/commands/runtime-init.test.ts

@@ -0,0 +1,346 @@
+/**
+ * runtime-init tests — pd runtime init command (unit tests with mocked DB layer).
+ *
+ * Covers:
+ *   - INIT-01: --dry-run (default) reports 3 DBs as 'skipped', no real writes
+ *   - INIT-02: --confirm calls all 3 init functions, output shows 'initialized'
+ *   - INIT-03: --json outputs single parseable JSON object (cli-1)
+ *   - INIT-04: --dry-run + --confirm mutually exclusive (cli-4)
+ *   - INIT-05: --confirm failure sets exitCode=1 with reason + nextAction (cli-6)
+ *   - INIT-06: missing --workspace falls back to resolveWorkspaceDir()
+ *
+ * ERR refs:
+ * - ERR-001/ERR-005: no `as` casts in test code; uses typeof guards
+ * - ERR-009: flag conflict fails loud (cli-4)
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import * as fs from 'node:fs';
+
+// ── Hoisted mocks ───────────────────────────────────────────────────────────
+
+const mockState = vi.hoisted(() => {
+  return {
+    initTrajectorySchema: vi.fn(),
+    initWorkflowSchema: vi.fn(),
+    sqliteConnectionCtor: vi.fn(),
+    sqliteConnectionGetDb: vi.fn(),
+    sqliteConnectionGetWarnings: vi.fn(),
+    sqliteConnectionClose: vi.fn(),
+    schemaConformanceCtor: vi.fn(),
+    schemaConformanceCheck: vi.fn(),
+    resolveWorkspaceDir: vi.fn(),
+  };
+});
+
+vi.mock('principles-disciple', () => ({
+  initTrajectorySchema: mockState.initTrajectorySchema,
+  initWorkflowSchema: mockState.initWorkflowSchema,
+}));
+
+vi.mock('@principles/core/runtime-v2', () => ({
+  SqliteConnection: mockState.sqliteConnectionCtor,
+  SchemaConformanceReadModel: mockState.schemaConformanceCtor,
+}));
+
+vi.mock('../../src/resolve-workspace.js', () => ({
+  resolveWorkspaceDir: mockState.resolveWorkspaceDir,
+}));
+
+// Import after mocks are set up
+import { buildRuntimeInitOutput, handleRuntimeInit } from '../../src/commands/runtime-init.js';
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+function mkTmpDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'pd-runtime-init-test-'));
+}
+
+function rmTmpDir(dir: string): void {
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+}
+
+function setupDefaultConfirmMocks(): void {
+  // SqliteConnection mock: constructor returns instance with getDb/getSchemaInitWarnings/close
+  // NOTE: Must use `function` (not arrow function) because vitest 4.x requires
+  // function/class implementations for mocks called with `new`.
+  mockState.sqliteConnectionCtor.mockImplementation(function () {
+    return {
+      getDb: mockState.sqliteConnectionGetDb,
+      getSchemaInitWarnings: mockState.sqliteConnectionGetWarnings,
+      close: mockState.sqliteConnectionClose,
+    };
+  });
+  mockState.sqliteConnectionGetDb.mockReturnValue({});
+  mockState.sqliteConnectionGetWarnings.mockReturnValue([]);
+  mockState.sqliteConnectionClose.mockReturnValue(undefined);
+
+  // initTrajectorySchema mock
+  mockState.initTrajectorySchema.mockReturnValue({
+    tables: ['schema_version', 'sessions', 'pain_events', 'evolution_tasks'],
+    warnings: [],
+  });
+
+  // initWorkflowSchema mock
+  mockState.initWorkflowSchema.mockReturnValue({
+    tables: ['schema_version', 'subagent_workflows', 'subagent_workflow_events'],
+    warnings: [],
+  });
+
+  // SchemaConformanceReadModel mock
+  mockState.schemaConformanceCtor.mockImplementation(function () {
+    return {
+      check: mockState.schemaConformanceCheck,
+    };
+  });
+  mockState.schemaConformanceCheck.mockReturnValue({ overallStatus: 'ok' });
+}
+
+// ── Tests ───────────────────────────────────────────────────────────────────
+
+describe('pd runtime init', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    setupDefaultConfirmMocks();
+  });
+
+  // ── INIT-01: dry-run (default) ─────────────────────────────────────────────
+
+  describe('INIT-01: dry-run (default)', () => {
+    it('reports 3 DBs as skipped without calling init functions', () => {
+      const tmp = mkTmpDir();
+      try {
+        const output = buildRuntimeInitOutput(tmp, false);
+        expect(output.ok).toBe(true);
+        expect(output.mode).toBe('dry-run');
+        expect(output.databases).toHaveLength(3);
+        for (const db of output.databases) {
+          expect(db.status).toBe('skipped');
+        }
+        // No init functions should be called in dry-run mode
+        expect(mockState.initTrajectorySchema).not.toHaveBeenCalled();
+        expect(mockState.initWorkflowSchema).not.toHaveBeenCalled();
+        expect(mockState.sqliteConnectionCtor).not.toHaveBeenCalled();
+      } finally { rmTmpDir(tmp); }
+    });
+
+    it('includes expected table names in dry-run output for each DB', () => {
+      const tmp = mkTmpDir();
+      try {
+        const output = buildRuntimeInitOutput(tmp, false);
+        const stateDb = output.databases.find(d => d.name === 'state.db');
+        const trajDb = output.databases.find(d => d.name === 'trajectory.db');
+        const wfDb = output.databases.find(d => d.name === 'subagent_workflows.db');
+        expect(stateDb?.tables).toContain('tasks');
+        expect(stateDb?.tables).toContain('runs');
+        expect(trajDb?.tables).toContain('pain_events');
+        expect(trajDb?.tables).toContain('sessions');
+        expect(wfDb?.tables).toContain('subagent_workflows');
+      } finally { rmTmpDir(tmp); }
+    });
+  });
+
+  // ── INIT-02: --confirm ─────────────────────────────────────────────────────
+
+  describe('INIT-02: --confirm', () => {
+    it('calls all 3 init functions and reports initialized status', () => {
+      const tmp = mkTmpDir();
+      try {
+        const output = buildRuntimeInitOutput(tmp, true);
+        expect(output.ok).toBe(true);
+        expect(output.mode).toBe('confirm');
+        expect(output.databases).toHaveLength(3);
+        for (const db of output.databases) {
+          expect(db.status).toBe('initialized');
+        }
+        expect(mockState.sqliteConnectionCtor).toHaveBeenCalledTimes(1);
+        expect(mockState.sqliteConnectionGetDb).toHaveBeenCalledTimes(1);
+        expect(mockState.initTrajectorySchema).toHaveBeenCalledWith(tmp);
+        expect(mockState.initWorkflowSchema).toHaveBeenCalledWith(tmp);
+      } finally { rmTmpDir(tmp); }
+    });
+
+    it('runs schema conformance check after initialization', () => {
+      const tmp = mkTmpDir();
+      try {
+        buildRuntimeInitOutput(tmp, true);
+        expect(mockState.schemaConformanceCtor).toHaveBeenCalledTimes(1);
+        expect(mockState.schemaConformanceCheck).toHaveBeenCalledTimes(1);
+      } finally { rmTmpDir(tmp); }
+    });
+  });
+
+  // ── INIT-03: --json output (cli-1) ─────────────────────────────────────────
+
+  describe('INIT-03: --json output (cli-1)', () => {
+    let stdoutSpy: ReturnType<typeof vi.spyOn>;
+    let originalExitCode: number | undefined;
+
+    beforeEach(() => {
+      stdoutSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      originalExitCode = process.exitCode;
+      process.exitCode = undefined;
+    });
+
+    afterEach(() => {
+      stdoutSpy.mockRestore();
+      process.exitCode = originalExitCode;
+    });
+
+    it('outputs exactly one parseable JSON object to stdout', async () => {
+      const tmp = mkTmpDir();
+      try {
+        await handleRuntimeInit({ workspace: tmp, json: true });
+        expect(stdoutSpy).toHaveBeenCalledTimes(1);
+        const output = stdoutSpy.mock.calls[0][0] as string;
+        const parsed = JSON.parse(output);
+        expect(typeof parsed).toBe('object');
+        expect(parsed).not.toBeNull();
+        expect(Array.isArray(parsed)).toBe(false);
+        expect(parsed).toHaveProperty('ok');
+        expect(parsed).toHaveProperty('mode');
+        expect(parsed).toHaveProperty('databases');
+      } finally { rmTmpDir(tmp); }
+    });
+
+    it('does not set exitCode=1 on successful dry-run', async () => {
+      const tmp = mkTmpDir();
+      try {
+        await handleRuntimeInit({ workspace: tmp, json: true });
+        expect(process.exitCode).toBeUndefined();
+      } finally { rmTmpDir(tmp); }
+    });
+  });
+
+  // ── INIT-04: --dry-run + --confirm mutex (cli-4) ───────────────────────────
+
+  describe('INIT-04: --dry-run + --confirm mutex (cli-4)', () => {
+    let stdoutSpy: ReturnType<typeof vi.spyOn>;
+    let stderrSpy: ReturnType<typeof vi.spyOn>;
+    let originalExitCode: number | undefined;
+
+    beforeEach(() => {
+      stdoutSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      stderrSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      originalExitCode = process.exitCode;
+      process.exitCode = undefined;
+    });
+
+    afterEach(() => {
+      stdoutSpy.mockRestore();
+      stderrSpy.mockRestore();
+      process.exitCode = originalExitCode;
+    });
+
+    it('sets exitCode=1 when both --dry-run and --confirm are specified', async () => {
+      await handleRuntimeInit({ dryRun: true, confirm: true, json: true });
+      expect(process.exitCode).toBe(1);
+    });
+
+    it('emits flag conflict JSON with reason and nextAction', async () => {
+      await handleRuntimeInit({ dryRun: true, confirm: true, json: true });
+      expect(stdoutSpy).toHaveBeenCalledTimes(1);
+      const output = stdoutSpy.mock.calls[0][0] as string;
+      const parsed = JSON.parse(output);
+      expect(parsed.ok).toBe(false);
+      expect(parsed.reason).toBeTruthy();
+      expect(parsed.nextAction).toBeTruthy();
+    });
+
+    it('does not call any init functions on flag conflict', async () => {
+      await handleRuntimeInit({ dryRun: true, confirm: true, json: true });
+      expect(mockState.initTrajectorySchema).not.toHaveBeenCalled();
+      expect(mockState.initWorkflowSchema).not.toHaveBeenCalled();
+      expect(mockState.sqliteConnectionCtor).not.toHaveBeenCalled();
+    });
+  });
+
+  // ── INIT-05: --confirm failure (cli-6) ─────────────────────────────────────
+
+  describe('INIT-05: --confirm failure (cli-6)', () => {
+    let stdoutSpy: ReturnType<typeof vi.spyOn>;
+    let originalExitCode: number | undefined;
+
+    beforeEach(() => {
+      stdoutSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      originalExitCode = process.exitCode;
+      process.exitCode = undefined;
+    });
+
+    afterEach(() => {
+      stdoutSpy.mockRestore();
+      process.exitCode = originalExitCode;
+    });
+
+    it('sets exitCode=1 and includes reason + nextAction when state.db fails', () => {
+      const tmp = mkTmpDir();
+      try {
+        mockState.sqliteConnectionGetDb.mockImplementation(() => {
+          throw new Error('disk full');
+        });
+        const output = buildRuntimeInitOutput(tmp, true);
+        expect(output.ok).toBe(false);
+        expect(output.reason).toContain('state.db');
+        expect(output.reason).toContain('disk full');
+        expect(output.nextAction).toBeTruthy();
+      } finally { rmTmpDir(tmp); }
+    });
+
+    it('sets exitCode=1 and includes reason when trajectory.db fails', () => {
+      const tmp = mkTmpDir();
+      try {
+        mockState.initTrajectorySchema.mockImplementation(() => {
+          throw new Error('permission denied');
+        });
+        const output = buildRuntimeInitOutput(tmp, true);
+        expect(output.ok).toBe(false);
+        expect(output.reason).toContain('trajectory.db');
+        expect(output.reason).toContain('permission denied');
+      } finally { rmTmpDir(tmp); }
+    });
+
+    it('sets exitCode=1 and includes reason when subagent_workflows.db fails', () => {
+      const tmp = mkTmpDir();
+      try {
+        mockState.initWorkflowSchema.mockImplementation(() => {
+          throw new Error('locked');
+        });
+        const output = buildRuntimeInitOutput(tmp, true);
+        expect(output.ok).toBe(false);
+        expect(output.reason).toContain('subagent_workflows.db');
+        expect(output.reason).toContain('locked');
+      } finally { rmTmpDir(tmp); }
+    });
+
+    it('handler sets process.exitCode=1 on failure with --json', async () => {
+      const tmp = mkTmpDir();
+      try {
+        mockState.sqliteConnectionGetDb.mockImplementation(() => {
+          throw new Error('init failed');
+        });
+        await handleRuntimeInit({ workspace: tmp, confirm: true, json: true });
+        expect(process.exitCode).toBe(1);
+        const output = stdoutSpy.mock.calls[0][0] as string;
+        const parsed = JSON.parse(output);
+        expect(parsed.ok).toBe(false);
+        expect(parsed.reason).toBeTruthy();
+        expect(parsed.nextAction).toBeTruthy();
+      } finally { rmTmpDir(tmp); }
+    });
+  });
+
+  // ── INIT-06: missing --workspace ───────────────────────────────────────────
+
+  describe('INIT-06: missing --workspace', () => {
+    it('falls back to resolveWorkspaceDir() when workspace is not specified', async () => {
+      const tmp = mkTmpDir();
+      mockState.resolveWorkspaceDir.mockReturnValue(tmp);
+      try {
+        await handleRuntimeInit({ json: true });
+        expect(mockState.resolveWorkspaceDir).toHaveBeenCalledTimes(1);
+      } finally { rmTmpDir(tmp); }
+    });
+  });
+});