@principles/pd-cli 1.73.0

package/tests/commands/runtime-internalization-integrity-repair.test.ts

@@ -0,0 +1,169 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const mockRepair = vi.hoisted(() => vi.fn());
+
+vi.mock('../../src/resolve-workspace.js', () => ({
+  resolveWorkspaceDir: vi.fn().mockReturnValue('/fake/workspace'),
+}));
+
+vi.mock('@principles/core/runtime-v2', () => ({
+  InternalizationIntegrityRemediation: vi.fn().mockImplementation(function () {
+    return { repair: mockRepair };
+  }),
+}));
+
+import { Command } from 'commander';
+import { handleRuntimeInternalizationIntegrityRepair } from '../../src/commands/runtime-internalization-integrity-repair.js';
+
+const WS = '/fake/workspace';
+
+function makeResult(overrides: Partial<{ dryRun: boolean; repairedCount: number; skippedCount: number; actions: unknown[] }> = {}) {
+  const dryRun = overrides.dryRun ?? true;
+  return {
+    mode: dryRun ? 'dry_run' : 'confirm',
+    status: dryRun ? 'no_op' : (overrides.repairedCount ?? 0) > 0 ? 'changed' : 'no_op',
+    safeToConfirm: false,
+    dryRun,
+    repairedCount: overrides.repairedCount ?? 0,
+    skippedCount: overrides.skippedCount ?? 0,
+    actions: overrides.actions ?? [],
+    warnings: [],
+    generatedAt: new Date().toISOString(),
+  };
+}
+
+function createTestProgram(): Command {
+  const program = new Command();
+  program.exitOverride();
+
+  const internalizationCmd = program.command('internalization');
+
+  internalizationCmd
+    .command('integrity-repair')
+    .description('Repair broken internalization chain links (operator repair path)')
+    .option('-w, --workspace <path>', 'Workspace directory')
+    .option('--dry-run', 'Report only, no modifications')
+    .option('--confirm', 'Actually repair broken links')
+    .option('--json', 'Output raw JSON')
+    .action(async (opts) => {
+      await handleRuntimeInternalizationIntegrityRepair({ workspace: opts.workspace, confirm: opts.confirm, dryRun: opts.dryRun, json: opts.json });
+    });
+
+  return program;
+}
+
+describe('handleRuntimeInternalizationIntegrityRepair', () => {
+  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
+  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  it('outputs JSON result on dry-run', async () => {
+    mockRepair.mockReturnValue(makeResult({ dryRun: true }));
+
+    await handleRuntimeInternalizationIntegrityRepair({ workspace: WS, dryRun: true, confirm: false, json: true });
+
+    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(jsonOutput.dryRun).toBe(true);
+  });
+
+  it('outputs JSON result on confirm', async () => {
+    mockRepair.mockReturnValue(makeResult({ dryRun: false, repairedCount: 1 }));
+
+    await handleRuntimeInternalizationIntegrityRepair({ workspace: WS, confirm: true, json: true });
+
+    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(jsonOutput.dryRun).toBe(false);
+    expect(jsonOutput.repairedCount).toBe(1);
+  });
+
+  it('outputs text format when --json not specified', async () => {
+    mockRepair.mockReturnValue(makeResult({ dryRun: true }));
+
+    await handleRuntimeInternalizationIntegrityRepair({ workspace: WS, dryRun: true, confirm: false, json: false });
+
+    const allOutput = consoleLogSpy.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(allOutput).toContain('Integrity Repair');
+    expect(allOutput).toContain('DRY-RUN');
+  });
+
+  it('defaults to dry-run when --confirm not specified', async () => {
+    mockRepair.mockReturnValue(makeResult({ dryRun: true }));
+
+    await handleRuntimeInternalizationIntegrityRepair({ workspace: WS, json: true });
+
+    expect(mockRepair).toHaveBeenCalledWith({ dryRun: true });
+  });
+
+  it('enters confirm mode when only --confirm is passed', async () => {
+    mockRepair.mockReturnValue(makeResult({ dryRun: false }));
+
+    await handleRuntimeInternalizationIntegrityRepair({ workspace: WS, confirm: true, json: true });
+
+    expect(mockRepair).toHaveBeenCalledWith({ dryRun: false });
+  });
+
+  it('rejects --dry-run and --confirm together', async () => {
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((code) => { throw new Error(`process.exit:${code}`); });
+
+    await expect(
+      handleRuntimeInternalizationIntegrityRepair({ workspace: WS, dryRun: true, confirm: true, json: true }),
+    ).rejects.toThrow('process.exit:1');
+
+    exitSpy.mockRestore();
+  });
+});
+
+describe('Commander wiring for integrity-repair', () => {
+  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
+  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  it('no flags → dry-run mode (confirm=undefined, dryRun=undefined)', async () => {
+    mockRepair.mockReturnValue(makeResult({ dryRun: true }));
+
+    const program = createTestProgram();
+    await program.parseAsync(['node', 'pd', 'internalization', 'integrity-repair', '--workspace', WS, '--json']);
+
+    expect(mockRepair).toHaveBeenCalledWith({ dryRun: true });
+  });
+
+  it('--confirm alone → confirm mode (not blocked by dryRun default)', async () => {
+    mockRepair.mockReturnValue(makeResult({ dryRun: false }));
+
+    const program = createTestProgram();
+    await program.parseAsync(['node', 'pd', 'internalization', 'integrity-repair', '--workspace', WS, '--confirm', '--json']);
+
+    expect(mockRepair).toHaveBeenCalledWith({ dryRun: false });
+  });
+
+  it('--dry-run alone → dry-run mode', async () => {
+    mockRepair.mockReturnValue(makeResult({ dryRun: true }));
+
+    const program = createTestProgram();
+    await program.parseAsync(['node', 'pd', 'internalization', 'integrity-repair', '--workspace', WS, '--dry-run', '--json']);
+
+    expect(mockRepair).toHaveBeenCalledWith({ dryRun: true });
+  });
+
+  it('--dry-run --confirm together → rejected', async () => {
+    mockRepair.mockReturnValue(makeResult({ dryRun: true }));
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((code) => { throw new Error(`process.exit:${code}`); });
+
+    const program = createTestProgram();
+    await expect(
+      program.parseAsync(['node', 'pd', 'internalization', 'integrity-repair', '--workspace', WS, '--dry-run', '--confirm', '--json']),
+    ).rejects.toThrow('process.exit:1');
+
+    exitSpy.mockRestore();
+  });
+});

package/tests/commands/runtime-internalization-integrity.test.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const mockCheck = vi.hoisted(() => vi.fn());
+
+vi.mock('../../src/resolve-workspace.js', () => ({
+  resolveWorkspaceDir: vi.fn().mockReturnValue('/fake/workspace'),
+}));
+
+vi.mock('@principles/core/runtime-v2', () => ({
+  InternalizationChainIntegrityReadModel: vi.fn().mockImplementation(function () {
+    return { check: mockCheck };
+  }),
+}));
+
+import { handleRuntimeInternalizationIntegrity } from '../../src/commands/runtime-internalization-integrity.js';
+
+const WS = '/fake/workspace';
+
+function okResult() {
+  return {
+    overallStatus: 'ok' as const,
+    brokenLinks: [],
+    chainSummaries: {
+      totalCandidates: 1,
+      totalDreamerTasks: 1,
+      totalPhilosopherTasks: 0,
+      totalPIArtifacts: 1,
+      chainsWithBrokenLinks: 0,
+    },
+    generatedAt: new Date().toISOString(),
+  };
+}
+
+function degradedResult() {
+  return {
+    overallStatus: 'degraded' as const,
+    brokenLinks: [{
+      type: 'missing_dreamer_task',
+      severity: 'warning' as const,
+      candidateId: 'c1',
+      reason: 'No dreamer task for candidate c1',
+      recommendedAction: 'Seed a dreamer task.',
+    }],
+    chainSummaries: {
+      totalCandidates: 1,
+      totalDreamerTasks: 0,
+      totalPhilosopherTasks: 0,
+      totalPIArtifacts: 0,
+      chainsWithBrokenLinks: 1,
+    },
+    generatedAt: new Date().toISOString(),
+  };
+}
+
+describe('handleRuntimeInternalizationIntegrity', () => {
+  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
+  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  it('outputs ok JSON result', async () => {
+    mockCheck.mockReturnValue(okResult());
+
+    await handleRuntimeInternalizationIntegrity({ workspace: WS, json: true });
+
+    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(jsonOutput.overallStatus).toBe('ok');
+    expect(jsonOutput.brokenLinks).toEqual([]);
+  });
+
+  it('outputs degraded result with broken links', async () => {
+    mockCheck.mockReturnValue(degradedResult());
+
+    await handleRuntimeInternalizationIntegrity({ workspace: WS, json: true });
+
+    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(jsonOutput.overallStatus).toBe('degraded');
+    expect(jsonOutput.brokenLinks.length).toBeGreaterThan(0);
+  });
+
+  it('outputs text format when --json not specified', async () => {
+    mockCheck.mockReturnValue(okResult());
+
+    await handleRuntimeInternalizationIntegrity({ workspace: WS, json: false });
+
+    const allOutput = consoleLogSpy.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(allOutput).toContain('Internalization Chain Integrity');
+    expect(allOutput).toContain('OK');
+  });
+
+  it('sets exit code on non-ok status', async () => {
+    mockCheck.mockReturnValue(degradedResult());
+
+    await handleRuntimeInternalizationIntegrity({ workspace: WS, json: true });
+
+    expect(process.exitCode).toBe(1);
+  });
+});

package/tests/commands/runtime-internalization-queue.test.ts

@@ -0,0 +1,252 @@
+/**
+ * pd runtime internalization queue CLI unit tests.
+ *
+ * Tests the queue command handler: delegation to InternalizationQueueReadModel,
+ * JSON/text output formatting, and exit code behavior.
+ * The read model is mocked — its contract is tested in principles-core.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const { mockGetSnapshot, mockClose } = vi.hoisted(() => ({
+  mockGetSnapshot: vi.fn(),
+  mockClose: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock('../../src/resolve-workspace.js', () => ({
+  resolveWorkspaceDir: vi.fn().mockReturnValue('/fake/workspace'),
+}));
+
+vi.mock('@principles/core/runtime-v2', () => ({
+  createInternalizationQueueReadModel: vi.fn().mockResolvedValue({
+    readModel: { getSnapshot: mockGetSnapshot, close: mockClose },
+    close: mockClose,
+  }),
+}));
+
+vi.mock('../../src/services/feature-flag-loader.js', () => ({
+  loadEffectiveFeatureFlags: vi.fn().mockReturnValue({
+    flags: {
+      prompt: { id: 'prompt', enabled: true, category: 'core' },
+      code_tool_hook: { id: 'code_tool_hook', enabled: true, category: 'core' },
+      defer_archive: { id: 'defer_archive', enabled: true, category: 'core' },
+    },
+    source: 'defaults',
+    configPath: '/fake/workspace/.pd/feature-flags.yaml',
+    warnings: [],
+  }),
+}));
+
+import { handleRuntimeInternalizationQueue } from '../../src/commands/runtime-internalization-queue.js';
+
+const WS = '/fake/workspace';
+
+function emptySnapshot() {
+  return {
+    pendingCount: 0,
+    retryWaitCount: 0,
+    countsByTaskKind: {},
+    countsByChannel: {},
+    invalidMetadataCount: 0,
+    sampleInvalidTaskIds: [],
+    blockedSummary: { count: 0, samples: [] },
+    dependencyFailedSummary: { count: 0, samples: [] },
+    retryWaitPendingSummary: { count: 0, samples: [] },
+    leaseConflictSummary: { count: 0, samples: [] },
+    unresolvableSummary: { count: 0, samples: [] },
+    readyTasks: [],
+    noReadyTasks: { reason: 'no_candidates', inspectedCount: 0 },
+    suppressedTasks: [],
+  };
+}
+
+describe('handleRuntimeInternalizationQueue', () => {
+  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
+  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    consoleLogSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+  });
+
+  // ── Empty queue ─────────────────────────────────────────────────────────────
+
+  it('empty queue returns no_candidates reason in JSON', async () => {
+    mockGetSnapshot.mockResolvedValue(emptySnapshot());
+
+    await handleRuntimeInternalizationQueue({ workspace: WS, json: true });
+
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(output.noReadyTasks.reason).toBe('no_candidates');
+    expect(output.pendingCount).toBe(0);
+    expect(output.readyTasks).toEqual([]);
+  });
+
+  it('empty queue text output is human-readable', async () => {
+    mockGetSnapshot.mockResolvedValue(emptySnapshot());
+
+    await handleRuntimeInternalizationQueue({ workspace: WS, json: false });
+
+    const text = consoleLogSpy.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(text).toContain('no_ready_tasks');
+    expect(text).toContain('no_candidates');
+  });
+
+  // ── Invalid metadata ────────────────────────────────────────────────────────
+
+  it('invalid metadata is counted and sampled in JSON', async () => {
+    mockGetSnapshot.mockResolvedValue({
+      ...emptySnapshot(),
+      invalidMetadataCount: 2,
+      sampleInvalidTaskIds: ['task_bad_1', 'task_bad_2'],
+      noReadyTasks: { reason: 'all_hydration_failed', inspectedCount: 2 },
+    });
+
+    await handleRuntimeInternalizationQueue({ workspace: WS, json: true });
+
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(output.invalidMetadataCount).toBe(2);
+    expect(output.sampleInvalidTaskIds).toEqual(['task_bad_1', 'task_bad_2']);
+    expect(output.noReadyTasks.reason).toBe('all_hydration_failed');
+  });
+
+  it('invalid metadata appears in text output', async () => {
+    mockGetSnapshot.mockResolvedValue({
+      ...emptySnapshot(),
+      invalidMetadataCount: 3,
+      sampleInvalidTaskIds: ['task_bad_1'],
+    });
+
+    await handleRuntimeInternalizationQueue({ workspace: WS, json: false });
+
+    const text = consoleLogSpy.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(text).toContain('invalid_metadata');
+    expect(text).toContain('task_bad_1');
+  });
+
+  // ── Blocked dependency ─────────────────────────────────────────────────────
+
+  it('blocked task surfaces blockedBy task IDs in JSON', async () => {
+    mockGetSnapshot.mockResolvedValue({
+      ...emptySnapshot(),
+      pendingCount: 1,
+      blockedSummary: {
+        count: 1,
+        samples: [{ taskId: 'task_001', taskKind: 'dreamer', blockedBy: ['task_000'] }],
+      },
+      noReadyTasks: { reason: 'all_blocked', inspectedCount: 1 },
+    });
+
+    await handleRuntimeInternalizationQueue({ workspace: WS, json: true });
+
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(output.blockedSummary.count).toBe(1);
+    expect(output.blockedSummary.samples[0].blockedBy).toContain('task_000');
+  });
+
+  it('blocked task text output shows blockedBy', async () => {
+    mockGetSnapshot.mockResolvedValue({
+      ...emptySnapshot(),
+      blockedSummary: {
+        count: 1,
+        samples: [{ taskId: 'task_001', taskKind: 'dreamer', blockedBy: ['task_000'] }],
+      },
+      noReadyTasks: { reason: 'all_blocked', inspectedCount: 1 },
+    });
+
+    await handleRuntimeInternalizationQueue({ workspace: WS, json: false });
+
+    const text = consoleLogSpy.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(text).toContain('blocked');
+    expect(text).toContain('task_000');
+  });
+
+  // ── Dependency failed ───────────────────────────────────────────────────────
+
+  it('dependency_failed surfaces failedDependencies in JSON', async () => {
+    mockGetSnapshot.mockResolvedValue({
+      ...emptySnapshot(),
+      dependencyFailedSummary: {
+        count: 1,
+        samples: [{ taskId: 'task_002', taskKind: 'philosopher', failedDependencies: ['task_001'] }],
+      },
+      noReadyTasks: { reason: 'all_dependency_failed', inspectedCount: 1 },
+    });
+
+    await handleRuntimeInternalizationQueue({ workspace: WS, json: true });
+
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(output.dependencyFailedSummary.count).toBe(1);
+    expect(output.dependencyFailedSummary.samples[0].failedDependencies).toContain('task_001');
+  });
+
+  it('dependency_failed text output shows failed deps', async () => {
+    mockGetSnapshot.mockResolvedValue({
+      ...emptySnapshot(),
+      dependencyFailedSummary: {
+        count: 1,
+        samples: [{ taskId: 'task_002', taskKind: 'philosopher', failedDependencies: ['task_001'] }],
+      },
+      noReadyTasks: { reason: 'all_dependency_failed', inspectedCount: 1 },
+    });
+
+    await handleRuntimeInternalizationQueue({ workspace: WS, json: false });
+
+    const text = consoleLogSpy.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(text).toContain('dependency_failed');
+    expect(text).toContain('task_001');
+  });
+
+  // ── Ready tasks ─────────────────────────────────────────────────────────────
+
+  it('ready task appears in readyTasks array', async () => {
+    mockGetSnapshot.mockResolvedValue({
+      ...emptySnapshot(),
+      pendingCount: 1,
+      readyTasks: [{ taskId: 'task_003', taskKind: 'scribe', channel: 'prompt' }],
+      noReadyTasks: null,
+    });
+
+    await handleRuntimeInternalizationQueue({ workspace: WS, json: true });
+
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(output.readyTasks).toContainEqual({ taskId: 'task_003', taskKind: 'scribe', channel: 'prompt' });
+  });
+
+  it('ready task text output shows ready count', async () => {
+    mockGetSnapshot.mockResolvedValue({
+      ...emptySnapshot(),
+      readyTasks: [{ taskId: 'task_003', taskKind: 'scribe', channel: 'prompt' }],
+      noReadyTasks: null,
+    });
+
+    await handleRuntimeInternalizationQueue({ workspace: WS, json: false });
+
+    const text = consoleLogSpy.mock.calls.map(c => c.join(' ')).join('\n');
+    expect(text).toContain('ready:');
+  });
+
+  // ── Counts by kind / channel ──────────────────────────────────────────────
+
+  it('countsByTaskKind and countsByChannel are included in JSON', async () => {
+    mockGetSnapshot.mockResolvedValue({
+      ...emptySnapshot(),
+      pendingCount: 2,
+      retryWaitCount: 1,
+      countsByTaskKind: { dreamer: 2, scribe: 1 },
+      countsByChannel: { prompt: 3 },
+    });
+
+    await handleRuntimeInternalizationQueue({ workspace: WS, json: true });
+
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(output.countsByTaskKind.dreamer).toBe(2);
+    expect(output.countsByTaskKind.scribe).toBe(1);
+    expect(output.countsByChannel.prompt).toBe(3);
+  });
+});