@principles/pd-cli 1.111.0 → 1.112.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principles/pd-cli",
-  "version": "1.111.0",
+  "version": "1.112.0",
   "description": "PD CLI — Pain recording, sample management, and evolution tasks",
   "type": "module",
   "bin": {

package/tests/commands/diagnose.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach, beforeAll } from 'vitest';
 import { Command } from 'commander';
 
 const { MockRuntimeStateManager, mockGetCandidatesByTaskId, mockUpdateCandidateStatus } = vi.hoisted(() => {
@@ -20,6 +20,11 @@ const { MockRuntimeStateManager, mockGetCandidatesByTaskId, mockUpdateCandidateS
     connection = {} as Record<string, unknown>;
     taskStore = {};
     runStore = {};
+    piArtifactStore = {};
+    getRetryPolicy = vi.fn().mockReturnValue({
+      shouldRetry: () => true,
+      calculateBackoff: () => 10,
+    });
   }
   return { MockRuntimeStateManager, mockGetCandidatesByTaskId, mockUpdateCandidateStatus };
 }, { validateType: true });
@@ -161,6 +166,16 @@ const SUCCEEDED_RESULT = {
   attemptCount: 1,
 };
 
+// ERR-067: reset the mocked run() to a clean successful default after each test
+// so later tests don't see leftover mockResolvedValueOnce() chains or call counts.
+const DEFAULT_SUCCEEDED_RUN_RESULT = {
+  status: 'succeeded' as const,
+  taskId: 'test-task-1',
+  output: SUCCEEDED_RESULT.output,
+};
+
+
+
 describe('pd diagnose run --runtime routing', () => {
   let mockResolveRuntimeConfig: ReturnType<typeof vi.fn>;
   let mockIsRuntimeConfigError: ReturnType<typeof vi.fn>;
@@ -928,3 +943,165 @@ describe('pd status stalled-threshold validation', () => {
     consoleSpy.mockRestore();
   });
 });
+
+// ERR-067: 1 initial run + maxRetryLoops(10) before the safety limit converts retried to failed.
+const EXPECTED_MAX_RETRY_CALLS = 11;
+
+describe('ERR-067: pd diagnose run retry loop for retried status', () => {
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    const { run } = await import('@principles/core/runtime-v2');
+    vi.mocked(run).mockResolvedValue(DEFAULT_SUCCEEDED_RUN_RESULT);
+  });
+
+  afterEach(async () => {
+    const { run } = await import('@principles/core/runtime-v2');
+    vi.mocked(run).mockResolvedValue(DEFAULT_SUCCEEDED_RUN_RESULT);
+  });
+
+  it('ERR-067-01: retried status triggers retry loop, succeeds on second attempt', async () => {
+    const { run } = await import('@principles/core/runtime-v2');
+    const runMock = vi.mocked(run);
+    runMock
+      .mockResolvedValueOnce({
+        status: 'retried' as const,
+        taskId: 'test-task-1',
+        attemptCount: 1,
+      })
+      .mockResolvedValueOnce(SUCCEEDED_RESULT);
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handleDiagnoseRun({
+      taskId: 'test-task-1',
+      workspace: '/tmp/fake-workspace',
+      runtime: 'test-double',
+      json: false,
+    } as DiagnoseRunOptions);
+
+    expect(runMock).toHaveBeenCalledTimes(2);
+    expect(exitSpy).not.toHaveBeenCalledWith(1);
+
+    consoleSpy.mockRestore();
+    exitSpy.mockRestore();
+    runMock.mockResolvedValue(DEFAULT_SUCCEEDED_RUN_RESULT);
+  });
+
+  it('ERR-067-02: retried status loops until maxRetryLoops, then converts to failed (P0-1 fix)', async () => {
+    const { run } = await import('@principles/core/runtime-v2');
+    const runMock = vi.mocked(run);
+    runMock.mockResolvedValue({
+      status: 'retried' as const,
+      taskId: 'test-task-1',
+      attemptCount: 1,
+    });
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handleDiagnoseRun({
+      taskId: 'test-task-1',
+      workspace: '/tmp/fake-workspace',
+      runtime: 'test-double',
+      json: false,
+    } as DiagnoseRunOptions);
+
+    expect(runMock).toHaveBeenCalledTimes(EXPECTED_MAX_RETRY_CALLS);
+    expect(exitSpy).toHaveBeenCalledWith(1);
+
+    consoleSpy.mockRestore();
+    exitSpy.mockRestore();
+    runMock.mockResolvedValue(DEFAULT_SUCCEEDED_RUN_RESULT);
+  });
+
+  it('ERR-067-03: retried with failureReason propagates to failed status (P0-1 fix)', async () => {
+    const { run } = await import('@principles/core/runtime-v2');
+    const runMock = vi.mocked(run);
+    runMock.mockResolvedValue({
+      status: 'retried' as const,
+      taskId: 'test-task-1',
+      attemptCount: 1,
+      failureReason: 'Schema validation failed',
+    });
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handleDiagnoseRun({
+      taskId: 'test-task-1',
+      workspace: '/tmp/fake-workspace',
+      runtime: 'test-double',
+      json: true,
+    } as DiagnoseRunOptions);
+
+    expect(runMock).toHaveBeenCalledTimes(EXPECTED_MAX_RETRY_CALLS);
+
+    const jsonOutput = consoleSpy.mock.calls.find(call => {
+      try {
+        const parsed = JSON.parse(call[0] as string);
+        return parsed.status === 'failed';
+      } catch { return false; }
+    });
+    expect(jsonOutput).toBeDefined();
+    const parsed = JSON.parse((jsonOutput as [string])[0]);
+    expect(parsed.status).toBe('failed');
+    expect(parsed.failureReason).toContain('Max retry loops');
+    expect(parsed.failureReason).toContain('Schema validation failed');
+
+    consoleSpy.mockRestore();
+    exitSpy.mockRestore();
+    runMock.mockResolvedValue(DEFAULT_SUCCEEDED_RUN_RESULT);
+  });
+
+  it('ERR-067-04: succeeded status does NOT trigger retry loop', async () => {
+    const { run } = await import('@principles/core/runtime-v2');
+    const runMock = vi.mocked(run);
+    runMock.mockResolvedValue(SUCCEEDED_RESULT);
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handleDiagnoseRun({
+      taskId: 'test-task-1',
+      workspace: '/tmp/fake-workspace',
+      runtime: 'test-double',
+      json: false,
+    } as DiagnoseRunOptions);
+
+    expect(runMock).toHaveBeenCalledTimes(1);
+    expect(exitSpy).not.toHaveBeenCalledWith(1);
+
+    consoleSpy.mockRestore();
+    exitSpy.mockRestore();
+    runMock.mockResolvedValue(DEFAULT_SUCCEEDED_RUN_RESULT);
+  });
+
+  it('ERR-067-05: failed status does NOT trigger retry loop', async () => {
+    const { run } = await import('@principles/core/runtime-v2');
+    const runMock = vi.mocked(run);
+    runMock.mockResolvedValue({
+      status: 'failed' as const,
+      taskId: 'test-task-1',
+      attemptCount: 3,
+      failureReason: 'Max attempts exceeded',
+    });
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handleDiagnoseRun({
+      taskId: 'test-task-1',
+      workspace: '/tmp/fake-workspace',
+      runtime: 'test-double',
+      json: false,
+    } as DiagnoseRunOptions);
+
+    expect(runMock).toHaveBeenCalledTimes(1);
+    expect(exitSpy).toHaveBeenCalledWith(1);
+
+    consoleSpy.mockRestore();
+    exitSpy.mockRestore();
+    runMock.mockResolvedValue(DEFAULT_SUCCEEDED_RUN_RESULT);
+  });
+});

package/tests/services/resolve-runtime-from-pd-config.test.ts

@@ -421,4 +421,63 @@ describe('resolveRuntimeWithOverrides', () => {
       expect(result.runtimeProfileLabel).toBe('pi-ai: anthropic/claude-3-5-sonnet');
     } finally { rmTmpDir(tmp); }
   });
+
+  describe('empty-string normalization (PRI-402)', () => {
+    it('normalizes empty-string provider override to undefined', () => {
+      const tmp = mkTmpDir();
+      writeConfig(tmp, makeValidPiAiConfigYaml(tmp));
+      try {
+        const result = resolveRuntimeWithOverrides(tmp, { provider: '' }, mockEnvWithKeys);
+        expect(result.mergedConfig).not.toBeNull();
+        if (!result.mergedConfig) throw new Error('Expected mergedConfig');
+        expect(result.mergedConfig.provider).toBe(undefined);
+      } finally { rmTmpDir(tmp); }
+    });
+
+    it('normalizes empty-string model override to undefined', () => {
+      const tmp = mkTmpDir();
+      writeConfig(tmp, makeValidPiAiConfigYaml(tmp));
+      try {
+        const result = resolveRuntimeWithOverrides(tmp, { model: '' }, mockEnvWithKeys);
+        expect(result.mergedConfig).not.toBeNull();
+        if (!result.mergedConfig) throw new Error('Expected mergedConfig');
+        expect(result.mergedConfig.model).toBe(undefined);
+      } finally { rmTmpDir(tmp); }
+    });
+
+    it('normalizes empty-string apiKeyEnv override to undefined', () => {
+      const tmp = mkTmpDir();
+      writeConfig(tmp, makeValidPiAiConfigYaml(tmp));
+      try {
+        const result = resolveRuntimeWithOverrides(tmp, { apiKeyEnv: '' }, mockEnvWithKeys);
+        expect(result.mergedConfig).not.toBeNull();
+        if (!result.mergedConfig) throw new Error('Expected mergedConfig');
+        expect(result.mergedConfig.apiKeyEnv).toBe(undefined);
+      } finally { rmTmpDir(tmp); }
+    });
+
+    it('normalizes empty-string baseUrl override to undefined', () => {
+      const tmp = mkTmpDir();
+      writeConfig(tmp, makeValidPiAiConfigYaml(tmp));
+      try {
+        const result = resolveRuntimeWithOverrides(tmp, { baseUrl: '' }, mockEnvWithKeys);
+        expect(result.mergedConfig).not.toBeNull();
+        if (!result.mergedConfig) throw new Error('Expected mergedConfig');
+        expect(result.mergedConfig.baseUrl).toBe(undefined);
+      } finally { rmTmpDir(tmp); }
+    });
+
+    it('preserves non-empty string values', () => {
+      const tmp = mkTmpDir();
+      writeConfig(tmp, makeValidPiAiConfigYaml(tmp));
+      try {
+        const result = resolveRuntimeWithOverrides(tmp, {}, mockEnvWithKeys);
+        expect(result.mergedConfig).not.toBeNull();
+        if (!result.mergedConfig) throw new Error('Expected mergedConfig');
+        expect(result.mergedConfig.provider).toBe('anthropic');
+        expect(result.mergedConfig.model).toBe('claude-3-5-sonnet');
+        expect(result.mergedConfig.apiKeyEnv).toBe('ANTHROPIC_API_KEY');
+      } finally { rmTmpDir(tmp); }
+    });
+  });
 });