@principles/pd-cli 1.73.0

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

@@ -0,0 +1,96 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const mockDetectExpiredLeases = vi.hoisted(() => vi.fn());
+const mockRecoverTask = vi.hoisted(() => vi.fn());
+const mockServiceClose = vi.hoisted(() => vi.fn());
+
+vi.mock('../../src/resolve-workspace.js', () => ({
+  resolveWorkspaceDir: vi.fn().mockReturnValue('/fake/workspace'),
+}));
+
+vi.mock('@principles/core/runtime-v2', () => ({
+  createRecoverySweepService: vi.fn().mockResolvedValue({
+    service: {
+      detectExpiredLeases: mockDetectExpiredLeases,
+      recoverTask: mockRecoverTask,
+    },
+    close: mockServiceClose,
+  }),
+  createRemediationResult: vi.fn((input) => ({
+    mode: input.mode,
+    status: input.status ?? (input.mode === 'dry_run'
+      ? (input.actions?.length > 0 ? 'would_change' : 'no_op')
+      : (input.repairedCount > 0 ? 'changed' : 'no_op')),
+    safeToConfirm: input.safeToConfirm ?? false,
+    repairedCount: input.repairedCount ?? 0,
+    skippedCount: input.skippedCount ?? 0,
+    actions: input.actions ?? [],
+    warnings: input.warnings ?? [],
+  })),
+  remediationAction: vi.fn((input) => input),
+}));
+
+import { handleRuntimeRecoverySweep } from '../../src/commands/runtime-recovery.js';
+
+describe('pd runtime recovery sweep remediation contract', () => {
+  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
+  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockDetectExpiredLeases.mockResolvedValue([]);
+    mockRecoverTask.mockResolvedValue(null);
+    mockServiceClose.mockResolvedValue(undefined);
+    process.exitCode = 0;
+    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  it('dry-run JSON uses shared remediation contract and does not recover tasks', async () => {
+    mockDetectExpiredLeases.mockResolvedValue(['task-1']);
+
+    await handleRuntimeRecoverySweep({ workspace: '/fake/workspace', dryRun: true, json: true });
+
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0] as string);
+    expect(output).toMatchObject({
+      mode: 'dry_run',
+      status: 'would_change',
+      safeToConfirm: true,
+      repairedCount: 0,
+      skippedCount: 0,
+    });
+    expect(output.actions[0]).toMatchObject({ action: 'recover_expired_lease', targetId: 'task-1' });
+    expect(mockRecoverTask).not.toHaveBeenCalled();
+    expect(mockServiceClose).toHaveBeenCalledTimes(1);
+  });
+
+  it('confirm JSON reports changed after recovering expired leases', async () => {
+    mockDetectExpiredLeases.mockResolvedValue(['task-1']);
+    mockRecoverTask.mockResolvedValue({ previousStatus: 'leased', newStatus: 'retry_wait' });
+
+    await handleRuntimeRecoverySweep({ workspace: '/fake/workspace', confirm: true, json: true });
+
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0] as string);
+    expect(output.mode).toBe('confirm');
+    expect(output.status).toBe('changed');
+    expect(output.repairedCount).toBe(1);
+    expect(mockRecoverTask).toHaveBeenCalledWith('task-1');
+    expect(mockServiceClose).toHaveBeenCalledTimes(1);
+  });
+
+  it('rejects --dry-run and --confirm together before writing (no service created)', async () => {
+    await handleRuntimeRecoverySweep({ workspace: '/fake/workspace', dryRun: true, confirm: true, json: true });
+
+    expect(mockRecoverTask).not.toHaveBeenCalled();
+    expect(mockServiceClose).not.toHaveBeenCalled();
+    expect(process.exitCode).toBe(1);
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('mutually exclusive'));
+  });
+
+  it('uses createRecoverySweepService (no RuntimeStateManager)', async () => {
+    const fs = await import('fs');
+    const src = fs.readFileSync(require.resolve('../../src/commands/runtime-recovery.ts'), 'utf-8');
+    expect(src).not.toContain('RuntimeStateManager');
+    expect(src).toContain('createRecoverySweepService');
+  });
+});

package/tests/commands/runtime-synthetic-baseline.test.ts

@@ -0,0 +1,249 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const { mockRunSyntheticBaseline } = vi.hoisted(() => ({
+  mockRunSyntheticBaseline: vi.fn(),
+}));
+
+vi.mock('../../src/services/synthetic-baseline-runner.js', () => ({
+  runSyntheticBaseline: mockRunSyntheticBaseline,
+}));
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { handleRuntimeSyntheticBaseline } from '../../src/commands/runtime-synthetic-baseline.js';
+
+function makePassedSummary() {
+  return {
+    status: 'passed' as const,
+    workspaceMode: 'temp' as const,
+    generatedAt: new Date().toISOString(),
+    stages: [
+      { name: 'pain_intake' as const, status: 'passed' as const },
+      { name: 'diagnostician_task_created' as const, status: 'passed' as const },
+      { name: 'candidate_created' as const, status: 'passed' as const },
+      { name: 'ledger_consistent' as const, status: 'passed' as const },
+      { name: 'internalization_queue_ready' as const, status: 'passed' as const },
+      { name: 'canary_health' as const, status: 'passed' as const },
+    ],
+  };
+}
+
+describe('handleRuntimeSyntheticBaseline (CLI handler)', () => {
+  let tempDir = '';
+  const originalExitCode = process.exitCode;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-cli-synth-test-'));
+    mockRunSyntheticBaseline.mockReset();
+    process.exitCode = undefined as unknown as number;
+  });
+
+  afterEach(() => {
+    try {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+      // ignore
+    }
+    process.exitCode = originalExitCode;
+  });
+
+  it('uses temp workspace when no workspace specified', async () => {
+    mockRunSyntheticBaseline.mockResolvedValue({
+      ...makePassedSummary(),
+      workspaceMode: 'temp',
+    });
+
+    await handleRuntimeSyntheticBaseline({});
+
+    expect(mockRunSyntheticBaseline).toHaveBeenCalledWith(
+      expect.objectContaining({ workspaceMode: 'temp' }),
+    );
+    const calledDir = mockRunSyntheticBaseline.mock.calls[0][0].workspaceDir;
+    expect(calledDir).toContain('pd-synth-baseline-');
+  });
+
+  it('uses explicit workspace when --workspace is provided', async () => {
+    mockRunSyntheticBaseline.mockResolvedValue({
+      ...makePassedSummary(),
+      workspaceMode: 'explicit_workspace',
+    });
+
+    await handleRuntimeSyntheticBaseline({ workspace: tempDir });
+
+    expect(mockRunSyntheticBaseline).toHaveBeenCalledWith(
+      expect.objectContaining({
+        workspaceDir: tempDir,
+        workspaceMode: 'explicit_workspace',
+      }),
+    );
+  });
+
+  it('--json output contains status, workspaceMode, generatedAt, stages', async () => {
+    const summary = makePassedSummary();
+    mockRunSyntheticBaseline.mockResolvedValue(summary);
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    try {
+      await handleRuntimeSyntheticBaseline({ json: true });
+
+      expect(logSpy).toHaveBeenCalledTimes(1);
+      const output = logSpy.mock.calls[0][0];
+      const parsed = JSON.parse(output);
+      expect(parsed).toHaveProperty('status');
+      expect(parsed).toHaveProperty('workspaceMode');
+      expect(parsed).toHaveProperty('generatedAt');
+      expect(parsed).toHaveProperty('stages');
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+
+  it('sets process.exitCode = 1 when status is failed', async () => {
+    mockRunSyntheticBaseline.mockResolvedValue({
+      ...makePassedSummary(),
+      status: 'failed',
+      stages: [
+        { name: 'pain_intake', status: 'failed', reason: 'test failure' },
+        { name: 'diagnostician_task_created', status: 'failed', reason: 'prerequisite' },
+        { name: 'candidate_created', status: 'failed', reason: 'prerequisite' },
+        { name: 'ledger_consistent', status: 'failed', reason: 'prerequisite' },
+        { name: 'internalization_queue_ready', status: 'failed', reason: 'prerequisite' },
+        { name: 'canary_health', status: 'failed', reason: 'prerequisite' },
+      ],
+    });
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    try {
+      await handleRuntimeSyntheticBaseline({ workspace: tempDir });
+      expect(process.exitCode).toBe(1);
+    } finally {
+      logSpy.mockRestore();
+      errorSpy.mockRestore();
+    }
+  });
+
+  it('sets process.exitCode = 1 when status is degraded', async () => {
+    mockRunSyntheticBaseline.mockResolvedValue({
+      ...makePassedSummary(),
+      status: 'degraded',
+    });
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    try {
+      await handleRuntimeSyntheticBaseline({ workspace: tempDir });
+      expect(process.exitCode).toBe(1);
+    } finally {
+      logSpy.mockRestore();
+      errorSpy.mockRestore();
+    }
+  });
+
+  it('cleans up temp workspace on success', async () => {
+    mockRunSyntheticBaseline.mockResolvedValue(makePassedSummary());
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    try {
+      await handleRuntimeSyntheticBaseline({});
+
+      const calledDir = mockRunSyntheticBaseline.mock.calls[0][0].workspaceDir;
+      expect(fs.existsSync(calledDir)).toBe(false);
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+
+  it('does not delete explicit workspace after run', async () => {
+    fs.mkdirSync(path.join(tempDir, '.pd'), { recursive: true });
+    fs.mkdirSync(path.join(tempDir, '.state'), { recursive: true });
+
+    mockRunSyntheticBaseline.mockResolvedValue({
+      ...makePassedSummary(),
+      workspaceMode: 'explicit_workspace',
+    });
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    try {
+      await handleRuntimeSyntheticBaseline({ workspace: tempDir });
+      expect(fs.existsSync(tempDir)).toBe(true);
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+
+  it('injected failure produces structured reason and recommendedNextIssue', async () => {
+    mockRunSyntheticBaseline.mockResolvedValue({
+      status: 'failed',
+      workspaceMode: 'temp',
+      generatedAt: new Date().toISOString(),
+      stages: [
+        { name: 'pain_intake', status: 'failed', reason: 'Injected failure: pain intake stage forced to fail' },
+        { name: 'diagnostician_task_created', status: 'failed', reason: 'Prerequisite stage pain_intake failed' },
+      ],
+      recommendedNextIssue: 'PRI-207: Pain intake pipeline broken — check PainSignalBridge and DiagnosticianRunner',
+    });
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    try {
+      await handleRuntimeSyntheticBaseline({ json: true });
+      const output = logSpy.mock.calls[0][0];
+      const parsed = JSON.parse(output);
+      expect(parsed.status).toBe('failed');
+      expect(parsed.recommendedNextIssue).toContain('PRI-207');
+      expect(process.exitCode).toBe(1);
+    } finally {
+      logSpy.mockRestore();
+      errorSpy.mockRestore();
+    }
+  });
+
+  it('no RuleHost/autoCorrect evidence, case-insensitive', async () => {
+    mockRunSyntheticBaseline.mockResolvedValue({
+      ...makePassedSummary(),
+      stages: [
+        { name: 'pain_intake', status: 'passed', evidence: { painId: 'test', bridgeStatus: 'succeeded' } },
+        { name: 'diagnostician_task_created', status: 'passed', evidence: { taskId: 't1', taskStatus: 'succeeded' } },
+        { name: 'candidate_created', status: 'passed', evidence: { candidateCount: 1 } },
+        { name: 'ledger_consistent', status: 'passed', evidence: { auditStatus: 'ok' } },
+        { name: 'internalization_queue_ready', status: 'passed', evidence: { readyCount: 1 } },
+        { name: 'canary_health', status: 'passed', evidence: { overallStatus: 'healthy' } },
+      ],
+    });
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    try {
+      await handleRuntimeSyntheticBaseline({ json: true });
+      const output = logSpy.mock.calls[0][0];
+      const parsed = JSON.parse(output);
+      const evidenceStr = JSON.stringify(parsed.stages).toLowerCase();
+      expect(evidenceStr).not.toContain('rulehost');
+      expect(evidenceStr).not.toContain('autocorrect');
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+
+  it('runner rejection propagates and temp workspace is still cleaned up', async () => {
+    mockRunSyntheticBaseline.mockRejectedValue(new Error('EACCES: permission denied, mkdir'));
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    try {
+      await expect(handleRuntimeSyntheticBaseline({})).rejects.toThrow('EACCES');
+      const calledDir = mockRunSyntheticBaseline.mock.calls[0][0].workspaceDir;
+      expect(fs.existsSync(calledDir)).toBe(false);
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+});