@principles/pd-cli 1.152.12 → 1.152.13

package/tests/commands/evolution-tasks-list.test.ts

@@ -1,41 +0,0 @@
-/**
- * pd evolution tasks list command tests — PRI-753 (Trajectory Reader Reality Fix).
- *
- * Before PRI-753 this handler wrapped every error as "No evolution tasks
- * found." — including a missing database and real database failures. A
- * missing trajectory database must now fail loud with reason and next action
- * (cli-6), never masquerade as an empty task list (rc-9).
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-vi.mock('../../src/resolve-workspace.js', () => ({
-  resolveWorkspaceDir: vi.fn().mockReturnValue('/tmp/pri753-missing-workspace'),
-}));
-
-import { handleEvolutionTasksList } from '../../src/commands/evolution-tasks-list.js';
-
-describe('handleEvolutionTasksList — unavailable database (PRI-753)', () => {
-  let errorSpy: ReturnType<typeof vi.spyOn>;
-  let exitSpy: ReturnType<typeof vi.spyOn>;
-
-  beforeEach(() => {
-    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = vi.spyOn(process, 'exit').mockImplementation(((code: number) => {
-      throw new Error(`process.exit:${String(code)}`);
-    }) as never);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('fails loud with reason and next action when trajectory.db is missing', async () => {
-    await expect(handleEvolutionTasksList({ status: 'all' })).rejects.toThrow('process.exit:1');
-
-    const stderrText = errorSpy.mock.calls.map((call) => String(call[0])).join('');
-    expect(stderrText).toContain('Trajectory database unavailable');
-    expect(stderrText).toContain('trajectory.db');
-    expect(stderrText).toContain('pd runtime init --confirm');
-    expect(exitSpy).toHaveBeenCalledWith(1);
-  });
-});

package/tests/commands/evolution-tasks-show.test.ts

@@ -1,46 +0,0 @@
-/**
- * pd evolution tasks show command tests — PRI-753 (Trajectory Reader Reality Fix).
- *
- * "Task not found" (database present, row absent) and "database unavailable"
- * (file missing) are different failures and must stay distinguishable (cli-6).
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-vi.mock('../../src/resolve-workspace.js', () => ({
-  resolveWorkspaceDir: vi.fn().mockReturnValue('/tmp/pri753-missing-workspace'),
-}));
-
-import { handleEvolutionTasksShow } from '../../src/commands/evolution-tasks-show.js';
-
-describe('handleEvolutionTasksShow — unavailable database (PRI-753)', () => {
-  let errorSpy: ReturnType<typeof vi.spyOn>;
-  let exitSpy: ReturnType<typeof vi.spyOn>;
-
-  beforeEach(() => {
-    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = vi.spyOn(process, 'exit').mockImplementation(((code: number) => {
-      throw new Error(`process.exit:${String(code)}`);
-    }) as never);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('fails loud with reason and next action when trajectory.db is missing', async () => {
-    await expect(handleEvolutionTasksShow({ id: 'task-001' })).rejects.toThrow('process.exit:1');
-
-    const stderrText = errorSpy.mock.calls.map((call) => String(call[0])).join('');
-    expect(stderrText).toContain('Trajectory database unavailable');
-    expect(stderrText).toContain('trajectory.db');
-    expect(stderrText).toContain('pd runtime init --confirm');
-    expect(exitSpy).toHaveBeenCalledWith(1);
-  });
-
-  it('reports unavailable instead of "Task not found" when the database is missing', async () => {
-    await expect(handleEvolutionTasksShow({ id: 'task-001' })).rejects.toThrow('process.exit:1');
-
-    const stderrText = errorSpy.mock.calls.map((call) => String(call[0])).join('');
-    expect(stderrText).not.toContain('Task not found');
-  });
-});

package/tests/commands/health-codex.test.ts

@@ -1,349 +0,0 @@
-/**
- * pd health --host codex command tests — §15 health surface (Slice D).
- *
- * Module-boundary mock style (the handler is a read-model aggregator): every
- * collaborator is mocked, the handler logic (§15 ready conjunction, consent
- * states, blockers, exit codes) is exercised for real.
- *
- * Covers:
- * - cli-1: --json outputs exactly one parseable JSON object.
- * - §15 ready conjunction: full green ⇒ ready + exit 0.
- * - "unknown is not healthy": a degraded section ⇒ not ready + blocker.
- * - consent: flag_on_without_consent blocker; stale disclosure; decline.
- * - admissions without task ⇒ blocker with `pd codex reconcile` nextAction.
- * - hooks trust untrusted ⇒ blocker + exit 1.
- * - legacy dual registration ⇒ migration nextAction (§17 retirement).
- * - worker mode manual_action_required/degraded ⇒ not ready.
- * - per-rollout lag detection from checkpoint + transcript stat.
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-const {
-  mockResolveNearestPdWorkspace,
-  mockLoadPdConfigForPlugin,
-  mockComputeFeatureFlagsFromConfig,
-  mockIsFeatureEnabled,
-  mockReadCodexIngestionConsent,
-  mockDeriveConsentState,
-  mockListGovernanceCheckpoints,
-  mockReadObservationStats,
-  mockReadAdmissionCounts,
-  mockComputeWorkerMode,
-  mockLocateTranscript,
-  mockGetInstallLayoutPaths,
-  mockParseInstallManifest,
-  mockExistsSync,
-  mockReadFileSync,
-  mockStatSync,
-  mockHomedir,
-  mockRequireResolve,
-  mockConsoleLog,
-  mockConsoleWarn,
-} = vi.hoisted(() => ({
-  mockResolveNearestPdWorkspace: vi.fn(),
-  mockLoadPdConfigForPlugin: vi.fn(),
-  mockComputeFeatureFlagsFromConfig: vi.fn(),
-  mockIsFeatureEnabled: vi.fn(),
-  mockReadCodexIngestionConsent: vi.fn(),
-  mockDeriveConsentState: vi.fn(),
-  mockListGovernanceCheckpoints: vi.fn(),
-  mockReadObservationStats: vi.fn(),
-  mockReadAdmissionCounts: vi.fn(),
-  mockComputeWorkerMode: vi.fn(),
-  mockLocateTranscript: vi.fn(),
-  mockGetInstallLayoutPaths: vi.fn(),
-  mockParseInstallManifest: vi.fn(),
-  mockExistsSync: vi.fn(),
-  mockReadFileSync: vi.fn(),
-  mockStatSync: vi.fn(),
-  mockHomedir: vi.fn(),
-  mockRequireResolve: vi.fn(),
-  mockConsoleLog: vi.fn(),
-  mockConsoleWarn: vi.fn(),
-}));
-
-vi.mock('@principles/host-runtime', () => ({
-  loadPdConfigForPlugin: mockLoadPdConfigForPlugin,
-  resolveNearestPdWorkspace: mockResolveNearestPdWorkspace,
-  readCodexIngestionConsent: mockReadCodexIngestionConsent,
-  deriveCodexIngestionConsentState: mockDeriveConsentState,
-  listGovernanceCheckpoints: mockListGovernanceCheckpoints,
-  readGovernanceObservationStats: mockReadObservationStats,
-  readGovernanceAdmissionCounts: mockReadAdmissionCounts,
-  detectLegacyCodexHookRegistration: (hooksJsonPath?: string) => {
-    // Mirrors the host-runtime FS edge: read via the mocked fs, delegate the
-    // parse semantics (marker + legacy async PostToolUse) exactly as
-    // codex-legacy-registration.ts does over @principles/core/host.
-    try {
-      const parsed = JSON.parse(mockReadFileSync(hooksJsonPath ?? '/fake/home/.codex/hooks.json', 'utf8')) as Record<string, unknown>;
-      const result = { detected: false, legacyAsyncPostToolUse: false };
-      for (const eventName of ['PreToolUse', 'PostToolUse', 'UserPromptSubmit', 'SessionStart']) {
-        const groups = parsed[eventName];
-        if (!Array.isArray(groups)) continue;
-        for (const group of groups) {
-          if (typeof group !== 'object' || group === null || !Object.hasOwn(group, '__pd_marker') || (group as Record<string, unknown>).__pd_marker !== 'pd-owned') continue;
-          result.detected = true;
-          const entries = (group as Record<string, unknown>).hooks;
-          if (Array.isArray(entries)) {
-            for (const entry of entries) {
-              if (typeof entry === 'object' && entry !== null && eventName === 'PostToolUse' && Object.hasOwn(entry, 'async') && (entry as Record<string, unknown>).async === true) {
-                result.legacyAsyncPostToolUse = true;
-              }
-            }
-          }
-        }
-      }
-      return result;
-    } catch {
-      return { detected: false, legacyAsyncPostToolUse: false };
-    }
-  },
-  CODEX_INGESTION_DISCLOSURE_VERSION: 'g2a-2026-08-28',
-}));
-
-vi.mock('@principles/codex-adapter', () => ({
-  computeCodexWorkerStatusMode: mockComputeWorkerMode,
-  locateCodexTranscriptByRolloutIdentity: mockLocateTranscript,
-  CODEX_INGESTION_MIN_VERSION: '0.148.0',
-  CODEX_INGESTION_VERIFIED_VERSION: '0.150.1',
-}));
-
-vi.mock('@principles/install-layout', () => ({
-  getInstallLayoutPaths: mockGetInstallLayoutPaths,
-  parseInstallManifest: mockParseInstallManifest,
-}));
-
-vi.mock('@principles/core/runtime-v2', () => ({
-  SqliteConnection: class {},
-  SqliteTaskStore: class {
-    listTasks = vi.fn().mockResolvedValue([]);
-  },
-  computeFeatureFlagsFromConfig: mockComputeFeatureFlagsFromConfig,
-  isFeatureEnabled: mockIsFeatureEnabled,
-}));
-
-vi.mock('../../src/resolve-workspace.js', () => ({
-  resolveWorkspaceDir: vi.fn().mockReturnValue('/fake/workspace'),
-}));
-
-vi.mock('fs', () => ({
-  existsSync: mockExistsSync,
-  readFileSync: mockReadFileSync,
-  statSync: mockStatSync,
-}));
-
-vi.mock('os', () => ({
-  default: { homedir: mockHomedir, userInfo: vi.fn().mockReturnValue({ username: 'tester' }) },
-  homedir: mockHomedir,
-  userInfo: vi.fn().mockReturnValue({ username: 'tester' }),
-}));
-
-vi.mock('module', () => ({
-  createRequire: () => ({ resolve: mockRequireResolve }),
-}));
-
-import { handleHealthCodex } from '../../src/commands/health-codex.js';
-
-function flagMap(): Record<string, { enabled: boolean }> {
-  return {
-    'host.codex': { enabled: true },
-    codex_conversation_ingestion: { enabled: true },
-  };
-}
-
-function grantedConsentRecord(): Record<string, unknown> {
-  return { decision: 'granted', disclosureVersion: 'g2a-2026-08-28', decidedAt: '2026-09-06T00:00:00.000Z', decidedVia: 'pd_codex_setup', schemaVersion: '1' };
-}
-
-function greenSetup(): void {
-  mockResolveNearestPdWorkspace.mockReturnValue({ ok: true, workspaceDir: '/fake/workspace', configPath: '/fake/workspace/.pd/config.yaml', source: 'nearest' });
-  mockLoadPdConfigForPlugin.mockReturnValue({ ok: true, source: 'user_config', effective: {}, configPath: '/fake/workspace/.pd/config.yaml', warnings: [], errors: [] });
-  mockComputeFeatureFlagsFromConfig.mockReturnValue({ flags: flagMap() });
-  mockIsFeatureEnabled.mockImplementation((_flags: unknown, id: string) => (flagMap())[id]?.enabled ?? false);
-  mockReadCodexIngestionConsent.mockReturnValue({ ok: true, existed: true, record: grantedConsentRecord() });
-  mockDeriveConsentState.mockReturnValue('granted');
-  mockListGovernanceCheckpoints.mockReturnValue({ ok: true, checkpoints: [] });
-  mockReadObservationStats.mockReturnValue({ ok: true, stats: { operational: 3, promoted: 1, quarantined: 0, terminalOther: 0, nextExpiryAt: '2026-09-07T00:00:00.000Z', lastObservationAt: '2026-09-06T00:00:00.000Z' } });
-  mockReadAdmissionCounts.mockReturnValue({ ok: true, counts: { admitted: 1, admittedWithoutTask: 0, pendingTails: 0, staleTails: 0, completedTails: 1, lastAdmissionAt: '2026-09-06T00:00:00.000Z' } });
-  mockComputeWorkerMode.mockReturnValue({ mode: 'ready' });
-  mockLocateTranscript.mockReturnValue({ ok: false, reason: 'not_found' });
-  mockGetInstallLayoutPaths.mockReturnValue({ manifest: '/fake/manifest.json' });
-  mockParseInstallManifest.mockReturnValue({ manifest: { workspaces: ['/fake/workspace'] } });
-  // Green hooks environment: ~/.codex exists with config.toml hooks = true.
-  // NOTE: the handler joins paths with the REAL path module, so on Windows
-  // the separators are backslashes — match by suffix, never full equality.
-  mockHomedir.mockReturnValue('/fake/home');
-  mockExistsSync.mockImplementation((candidate: string | Buffer) => {
-    const value = String(candidate);
-    return value.endsWith('.codex') || value.endsWith('config.toml');
-  });
-  mockRequireResolve.mockImplementation((name: string) => `/fake/node_modules/${name}/package.json`);
-  mockReadFileSync.mockImplementation((candidate: string | Buffer) => {
-    const value = String(candidate);
-    if (value.endsWith('config.toml')) return '[features]\nhooks = true\n';
-    if (value.includes('package.json')) return JSON.stringify({ version: '0.1.0' });
-    return '';
-  });
-  mockStatSync.mockReturnValue({ size: 0 });
-}
-
-async function runJson(): Promise<Record<string, unknown>> {
-  await handleHealthCodex({ json: true });
-  expect(mockConsoleLog).toHaveBeenCalledTimes(1);
-  return JSON.parse(mockConsoleLog.mock.calls[0]?.[0] as string) as Record<string, unknown>;
-}
-
-beforeEach(() => {
-  vi.clearAllMocks();
-  greenSetup();
-  vi.spyOn(console, 'log').mockImplementation(mockConsoleLog);
-  vi.spyOn(console, 'warn').mockImplementation(mockConsoleWarn);
-});
-
-afterEach(() => {
-  process.exitCode = undefined;
-  vi.restoreAllMocks();
-});
-
-describe('pd health --host codex — §15 ready semantics', () => {
-  it('cli-1 + full green ⇒ ready true, exit 0, one JSON object with §15 fields', async () => {
-    const report = await runJson();
-    expect(report.ready, JSON.stringify(report.readyBlockers)).toBe(true);
-    expect(report.readyBlockers).toHaveLength(0);
-    expect(report.host).toBe('codex');
-    expect(report.codexIngestionMinVersion).toBe('0.148.0');
-    expect((report.consent as { state: string }).state).toBe('granted');
-    expect((report.workspaceInit as { initialized: boolean }).initialized).toBe(true);
-    expect((report.observations as { operational: number }).operational).toBe(3);
-    expect((report.diagnosticianTasks as { pending: number }).pending).toBe(0);
-    expect(process.exitCode ?? 0).toBe(0);
-  });
-
-  it('untrusted hooks ⇒ not ready with blocker and exit 1', async () => {
-    mockExistsSync.mockImplementation((candidate: string | Buffer) => String(candidate).endsWith('config.toml'));
-    mockReadFileSync.mockImplementation((candidate: string | Buffer) => (String(candidate).endsWith('config.toml') ? '[features]\nhooks = false\n' : ''));
-    const report = await runJson();
-    expect(report.ready).toBe(false);
-    expect((report.readyBlockers as string[]).some((blocker) => blocker.startsWith('hooks_trust'))).toBe(true);
-    expect(process.exitCode).toBe(1);
-  });
-
-  it('degraded admission counts ⇒ unknown is not healthy (§15)', async () => {
-    mockReadAdmissionCounts.mockReturnValue({ ok: false, reason: 'governance_admission_counts_unavailable', nextAction: 'inspect trajectory.db' });
-    const report = await runJson();
-    expect(report.ready).toBe(false);
-    expect((report.readyBlockers as string[]).some((blocker) => blocker.startsWith('admissions'))).toBe(true);
-    expect((report.admissions as { reason: string }).reason).toBe('governance_admission_counts_unavailable');
-  });
-
-  it('admitted pains without task ⇒ blocker recommending reconcile', async () => {
-    mockReadAdmissionCounts.mockReturnValue({ ok: true, counts: { admitted: 2, admittedWithoutTask: 1, pendingTails: 0, staleTails: 0, completedTails: 0, lastAdmissionAt: null } });
-    const report = await runJson();
-    expect(report.ready).toBe(false);
-    const blocker = (report.readyBlockers as string[]).find((entry) => entry.startsWith('admissions'));
-    expect(blocker).toContain('reconcile');
-  });
-
-  it('worker degraded ⇒ not ready', async () => {
-    mockComputeWorkerMode.mockReturnValue({ mode: 'degraded', reason: 'workspace_missing', nextAction: 'restore the workspace' });
-    const report = await runJson();
-    expect(report.ready).toBe(false);
-    expect((report.worker as { mode: string }).mode).toBe('degraded');
-  });
-
-  it('no Companion worker ⇒ manual_action_required, never ready (no automatic closure)', async () => {
-    mockParseInstallManifest.mockReturnValue({ manifest: { workspaces: [] } });
-    mockComputeWorkerMode.mockReturnValue({ mode: 'manual_action_required', reason: 'workspace_not_in_install_manifest' });
-    const report = await runJson();
-    expect((report.worker as { mode: string }).mode).toBe('manual_action_required');
-    expect(report.ready).toBe(false);
-  });
-
-  it('diagnostician needs_human_review tasks ⇒ not ready with review blocker', async () => {
-    // Override the task store default via the mocked class instance.
-    const coreModule = (await vi.importMock('@principles/core/runtime-v2')) as { SqliteTaskStore: new () => { listTasks: (filter: { status: string }) => Promise<unknown[]> } };
-    const original = coreModule.SqliteTaskStore;
-    class FakeStore {
-      listTasks(filter: { status: string }): Promise<unknown[]> {
-        return Promise.resolve(filter.status === 'needs_human_review' ? [{ id: 't1' }] : []);
-      }
-    }
-    vi.doMock('@principles/core/runtime-v2', () => ({ SqliteConnection: class {}, SqliteTaskStore: FakeStore, computeFeatureFlagsFromConfig: mockComputeFeatureFlagsFromConfig, isFeatureEnabled: mockIsFeatureEnabled }));
-    void original;
-    vi.resetModules();
-    const { handleHealthCodex: freshHandler } = await import('../../src/commands/health-codex.js');
-    await freshHandler({ json: true });
-    const output = mockConsoleLog.mock.calls[mockConsoleLog.mock.calls.length - 1]?.[0] as string;
-    const report = JSON.parse(output) as { ready: boolean; readyBlockers: string[] };
-    expect(report.ready).toBe(false);
-    expect(report.readyBlockers.some((blocker) => blocker.includes('human review'))).toBe(true);
-    process.exitCode = undefined;
-  });
-});
-
-describe('pd health --host codex — consent surface (no captured text)', () => {
-  it('flag on without consent record ⇒ governance blocker with setup nextAction', async () => {
-    mockReadCodexIngestionConsent.mockReturnValue({ ok: true, existed: false, record: null });
-    mockDeriveConsentState.mockReturnValue('flag_on_without_grant');
-    const report = await runJson();
-    const consent = report.consent as { state: string; nextAction?: string };
-    expect(consent.state).toBe('flag_on_without_grant');
-    expect(consent.nextAction).toContain('pd codex setup');
-    expect(report.ready).toBe(false);
-  });
-
-  it('declined consent with flag off does not block readiness on consent', async () => {
-    mockIsFeatureEnabled.mockImplementation((_flags: unknown, id: string) => id === 'host.codex');
-    mockReadCodexIngestionConsent.mockReturnValue({ ok: true, existed: true, record: { ...grantedConsentRecord(), decision: 'revoked' } });
-    mockDeriveConsentState.mockReturnValue('revoked');
-    const report = await runJson();
-    expect((report.consent as { state: string }).state).toBe('revoked');
-    expect((report.readyBlockers as string[]).some((blocker) => blocker.startsWith('consent'))).toBe(false);
-  });
-
-  it('stale disclosure version is surfaced as re-consent nextAction', async () => {
-    mockReadCodexIngestionConsent.mockReturnValue({ ok: true, existed: true, record: { ...grantedConsentRecord(), disclosureVersion: 'g2a-2020-01-01' } });
-    const report = await runJson();
-    expect((report.consent as { disclosureStale: boolean }).disclosureStale).toBe(true);
-  });
-});
-
-describe('pd health --host codex — legacy registration (§17 retirement)', () => {
-  it('legacy async PostToolUse registration ⇒ migration nextAction', async () => {
-    mockHomedir.mockReturnValue('/fake/home');
-    mockExistsSync.mockImplementation((candidate: string | Buffer) => {
-      const value = String(candidate);
-      return value.endsWith('.codex') || value.endsWith('hooks.json') || value.endsWith('config.toml');
-    });
-    mockReadFileSync.mockImplementation((candidate: string | Buffer) => {
-      const value = String(candidate);
-      if (value.endsWith('hooks.json')) {
-        return JSON.stringify({
-          PreToolUse: [{ matcher: 'Bash|apply_patch', hooks: [{ type: 'command', command: 'node pd-hook.cjs' }], __pd_marker: 'pd-owned' }],
-          PostToolUse: [{ matcher: '.*', hooks: [{ type: 'command', command: 'node pd-hook.cjs', timeout: 5, async: true }], __pd_marker: 'pd-owned' }],
-        });
-      }
-      if (value.endsWith('config.toml')) return '[features]\nhooks = true\n';
-      if (value.includes('package.json')) return JSON.stringify({ version: '0.1.0' });
-      return '';
-    });
-    const report = await runJson();
-    expect((report.dualRegistration as { detected: boolean; legacyAsyncPostToolUse: boolean }).legacyAsyncPostToolUse, JSON.stringify(report.dualRegistration)).toBe(true);
-    expect((report.dualRegistration as { nextAction?: string }).nextAction).toContain('Marketplace');
-  });
-});
-
-describe('pd health --host codex — per-rollout lag', () => {
-  it('checkpoint lag over zero ⇒ rollout blocker with byte lag', async () => {
-    mockListGovernanceCheckpoints.mockReturnValue({
-      ok: true,
-      checkpoints: [{ hostKind: 'codex', rolloutIdentity: 'r-1', byteOffset: 10, lastOrdinal: 1, cliVersion: null, rootSessionId: 'root', incompleteTail: false, lastDegradationReason: null, lastDegradationOrdinal: null, updatedAt: '2026-09-06T00:00:00.000Z' }],
-    });
-    mockLocateTranscript.mockReturnValue({ ok: true, transcriptPath: '/fake/home/.codex/sessions/r-1.jsonl' });
-    mockStatSync.mockReturnValue({ size: 512 });
-    const report = await runJson();
-    expect(report.ready).toBe(false);
-    expect(((report.rollouts as { checkpoints: { lagBytes: number | null }[] }).checkpoints[0]?.lagBytes) ?? -1).toBe(502);
-    expect((report.readyBlockers as string[]).some((blocker) => blocker.includes('r-1'))).toBe(true);
-  });
-});

package/tests/commands/health-host-wiring.test.ts

@@ -1,76 +0,0 @@
-/**
- * cli-7 test-wiring: prove the real `registerHealthCommand` (used by the CLI
- * entrypoint) wires the `--host codex` flag, dispatches to handleHealthCodex,
- * and rejects unknown host values with a structured error + non-zero exit.
- *
- * Handlers are injected so the test exercises the real production registration
- * without executing real workspace/DB I/O.
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { Command } from 'commander';
-import { registerHealthCommand } from '../../src/commands/health.js';
-
-const mockHandleHealth = vi.fn();
-const mockHandleHealthCodex = vi.fn();
-
-const originalExitCode = process.exitCode;
-
-function buildHealthCommand(): Command {
-  const program = new Command();
-  registerHealthCommand(program, { health: mockHandleHealth, healthCodex: mockHandleHealthCodex });
-  return program;
-}
-
-describe('cli-7: pd health --host flag wiring (production registration)', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    process.exitCode = originalExitCode;
-  });
-
-  afterEach(() => {
-    process.exitCode = originalExitCode;
-  });
-
-  it('dispatches to handleHealthCodex when --host codex is passed', async () => {
-    const program = buildHealthCommand();
-    await program.parseAsync(['node', 'pd', 'health', '--host', 'codex', '--json']);
-    expect(mockHandleHealthCodex).toHaveBeenCalledTimes(1);
-    expect(mockHandleHealthCodex).toHaveBeenCalledWith(expect.objectContaining({ host: 'codex', json: true }));
-    expect(mockHandleHealth).not.toHaveBeenCalled();
-  });
-
-  it('dispatches to handleHealth when --host is omitted (defaults to openclaw)', async () => {
-    const program = buildHealthCommand();
-    await program.parseAsync(['node', 'pd', 'health']);
-    expect(mockHandleHealth).toHaveBeenCalledTimes(1);
-    expect(mockHandleHealthCodex).not.toHaveBeenCalled();
-  });
-
-  it('dispatches to handleHealth when --host openclaw is passed', async () => {
-    const program = buildHealthCommand();
-    await program.parseAsync(['node', 'pd', 'health', '--host', 'openclaw']);
-    expect(mockHandleHealth).toHaveBeenCalledTimes(1);
-    expect(mockHandleHealthCodex).not.toHaveBeenCalled();
-  });
-
-  it('passes --workspace through to handleHealthCodex', async () => {
-    const program = buildHealthCommand();
-    await program.parseAsync(['node', 'pd', 'health', '--host', 'codex', '-w', '/some/path']);
-    expect(mockHandleHealthCodex).toHaveBeenCalledWith(expect.objectContaining({ workspace: '/some/path' }));
-  });
-
-  it('rejects an unknown --host value without dispatching', async () => {
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    const program = buildHealthCommand();
-    await program.parseAsync(['node', 'pd', 'health', '--host', 'codxe', '--json']);
-    expect(mockHandleHealth).not.toHaveBeenCalled();
-    expect(mockHandleHealthCodex).not.toHaveBeenCalled();
-    expect(process.exitCode).toBe(1);
-    const payload = JSON.parse(String(logSpy.mock.calls[0][0]));
-    expect(payload.ok).toBe(false);
-    expect(payload.reason).toBe('invalid_host');
-    expect(payload.host).toBe('codxe');
-    expect(payload.nextAction).toBeTruthy();
-    logSpy.mockRestore();
-  });
-});

package/tests/commands/health-reliability.test.ts

@@ -1,99 +0,0 @@
-/**
- * PRI-662 — reliability readiness section of `pd health`, against REAL
- * declaration files on disk (no fs mock, no host-runtime mock): the upgrade
- * validation surface must observe exactly what the production paths observe.
- */
-import { describe, it, expect, afterEach, vi } from 'vitest';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { saveHostToolDeclaration } from '@principles/host-runtime';
-import { handleHealth } from '../../src/commands/health.js';
-
-const dirs: string[] = [];
-
-function makeWorkspace(): string {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-health-reliability-'));
-  dirs.push(dir);
-  return dir;
-}
-
-afterEach(() => {
-  vi.restoreAllMocks();
-  for (const dir of dirs.splice(0)) {
-    try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* temp */ }
-  }
-});
-
-describe('pd health reliability section (real declaration files)', () => {
-  it('fresh workspace (no declaration): explicit degraded + host_tool_declaration_missing, informational only', async () => {
-    const workspaceDir = makeWorkspace();
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    try {
-      await handleHealth({ workspace: workspaceDir, json: true });
-      const parsed = JSON.parse(logSpy.mock.calls[0][0]) as {
-        reliability: { registry: { status: string }; resolver: string; replay: string; reason?: string; nextAction?: string };
-      };
-      expect(parsed.reliability.registry.status).toBe('degraded');
-      expect(parsed.reliability.resolver).toBe('not_ready');
-      expect(parsed.reliability.replay).toBe('not_ready');
-      expect(parsed.reliability.reason).toBe('host_tool_declaration_missing');
-      expect(parsed.reliability.nextAction ?? '').not.toBe('');
-    } finally {
-      vi.restoreAllMocks();
-    }
-  });
-
-  it('declared workspace: registry ok with per-host counts, resolver/replay ready', async () => {
-    const workspaceDir = makeWorkspace();
-    saveHostToolDeclaration(workspaceDir, {
-      version: 1,
-      hostKind: 'openclaw',
-      mappings: [
-        { rawToolName: 'Write', canonicalKind: 'write' },
-        { rawToolName: 'Edit', canonicalKind: 'write' },
-        { rawToolName: 'Bash', canonicalKind: 'execute' },
-      ],
-      declaredAt: new Date().toISOString(),
-    });
-    saveHostToolDeclaration(workspaceDir, {
-      version: 1,
-      hostKind: 'codex',
-      mappings: [{ rawToolName: 'shell', canonicalKind: 'execute' }],
-      declaredAt: new Date().toISOString(),
-    });
-
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    try {
-      await handleHealth({ workspace: workspaceDir, json: false });
-      const allOutput = logSpy.mock.calls.map((c) => c.join(' ')).join('\n');
-      expect(allOutput).toContain('reliability.registry.status: ok');
-      expect(allOutput).toContain('reliability.registry.hosts: codex+openclaw');
-      expect(allOutput).toContain('reliability.registry.declaredTools: 4');
-      expect(allOutput).toContain('reliability.resolver: ready');
-      expect(allOutput).toContain('reliability.replay: ready');
-    } finally {
-      vi.restoreAllMocks();
-    }
-  });
-
-  it('malformed declaration: explicit invalid reason with a repair action', async () => {
-    const workspaceDir = makeWorkspace();
-    const dir = path.join(workspaceDir, '.pd', 'host-tool-semantics');
-    fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(path.join(dir, 'openclaw.json'), '{broken', 'utf-8');
-
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    try {
-      await handleHealth({ workspace: workspaceDir, json: true });
-      const parsed = JSON.parse(logSpy.mock.calls[0][0]) as {
-        reliability: { registry: { status: string }; reason?: string; nextAction?: string };
-      };
-      expect(parsed.reliability.registry.status).toBe('degraded');
-      expect(parsed.reliability.reason).toContain('host_tool_declaration_invalid');
-      expect(parsed.reliability.nextAction ?? '').not.toBe('');
-    } finally {
-      vi.restoreAllMocks();
-    }
-  });
-});