@principles/pd-cli 1.100.0 → 1.102.0

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

@@ -82,6 +82,44 @@ describe('handleRuntimeInternalizationIntegrityRepair', () => {
     expect(jsonOutput.repairedCount).toBe(1);
   });
 
+  it('emits malformed_run_row quarantine actions as a single JSON object', async () => {
+    // Verifies the new malformed-run repair pass flows through the CLI contract
+    // unchanged: exactly one JSON object on stdout, with the quarantine action present.
+    mockRepair.mockReturnValue(makeResult({
+      dryRun: false,
+      repairedCount: 1,
+      actions: [
+        {
+          action: 'quarantine_malformed_run',
+          targetId: 'run-malf-1',
+          taskId: 'task-1',
+          type: 'malformed_run_row',
+          severity: 'warning',
+          previousState: 'queued',
+          nextState: 'failed',
+          previousStatus: 'queued',
+          newStatus: 'failed',
+          recommendedAction: 'quarantine_malformed_run',
+          reason: 'Run run-malf-1 (task task-1) failed schema validation — quarantined',
+        },
+      ],
+    }));
+
+    await handleRuntimeInternalizationIntegrityRepair({ workspace: WS, confirm: true, json: true });
+
+    // Exactly one console.log call (single JSON object, no banners/extra stdout).
+    expect(consoleLogSpy).toHaveBeenCalledTimes(1);
+    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(jsonOutput.repairedCount).toBe(1);
+    expect(jsonOutput.actions).toHaveLength(1);
+    expect(jsonOutput.actions[0]).toMatchObject({
+      type: 'malformed_run_row',
+      recommendedAction: 'quarantine_malformed_run',
+      newStatus: 'failed',
+      targetId: 'run-malf-1',
+    });
+  });
+
   it('outputs text format when --json not specified', async () => {
     mockRepair.mockReturnValue(makeResult({ dryRun: true }));
 

package/tests/commands/runtime-internalization-run-once.test.ts

@@ -20,6 +20,27 @@ vi.mock('../../src/resolve-workspace.js', () => ({
   resolveWorkspaceDir: vi.fn().mockReturnValue('/fake/workspace'),
 }));
 
+const { mockResolveRuntimeFromPdConfig } = vi.hoisted(() => {
+  const mockResolveRuntimeFromPdConfig = vi.fn().mockReturnValue({
+    result: {
+      runtimeKind: 'pi-ai',
+      provider: 'test-provider',
+      model: 'test-model',
+      apiKeyEnv: 'TEST_API_KEY',
+      timeoutMs: 300_000,
+      agentId: 'main',
+    },
+    legacyWarnings: [],
+    configSource: '.pd/config.yaml',
+    configLoadResult: { ok: true, effective: {}, defaults: {}, legacyFilesDetected: [] },
+  });
+  return { mockResolveRuntimeFromPdConfig };
+});
+
+vi.mock('../../src/services/resolve-runtime-from-pd-config.js', () => ({
+  resolveRuntimeFromPdConfig: mockResolveRuntimeFromPdConfig,
+}));
+
 vi.mock('@principles/core/runtime-v2', () => ({
   RuntimeStateManager: vi.fn().mockImplementation(function () {
     return {
@@ -120,8 +141,9 @@ vi.mock('@principles/core/runtime-v2', () => ({
     model: 'test-model',
     apiKeyEnv: 'TEST_API_KEY',
   }),
-  isRuntimeConfigError: vi.fn().mockReturnValue(false),
+  isRuntimeConfigError: vi.fn().mockImplementation((result: unknown) => result != null && typeof result === 'object' && Object.hasOwn(result, 'reason') && !Object.hasOwn(result, 'runtimeKind')),
   validateRuntimeConfig: vi.fn(),
+  resolveRuntimeConfigFromPdConfig: vi.fn().mockReturnValue({ runtimeKind: 'pi-ai', provider: 'test-provider', model: 'test-model', apiKeyEnv: 'TEST_API_KEY', timeoutMs: 300_000, agentId: 'main' }),
   resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
 }));
 
@@ -381,12 +403,16 @@ describe('handleRuntimeInternalizationRunOnce', () => {
   });
 
   it('--runtime openclaw-cli resolves OpenClawCliRuntimeAdapter', async () => {
-    const { resolveRuntimeConfig } = await import('@principles/core/runtime-v2');
-    vi.mocked(resolveRuntimeConfig).mockReturnValue({
-      runtimeKind: 'openclaw-cli',
-      openclawMode: 'local',
-      timeoutMs: 300_000,
-      agentId: 'main',
+    mockResolveRuntimeFromPdConfig.mockReturnValueOnce({
+      result: {
+        runtimeKind: 'openclaw-cli',
+        openclawMode: 'local',
+        timeoutMs: 300_000,
+        agentId: 'main',
+      },
+      legacyWarnings: [],
+      configSource: '.pd/config.yaml',
+      configLoadResult: { ok: true, effective: {}, defaults: {}, legacyFilesDetected: [] },
     });
 
     mockWakeOnce.mockResolvedValue({
@@ -412,31 +438,7 @@ describe('handleRuntimeInternalizationRunOnce', () => {
     expect(OpenClawMock).toHaveBeenCalled();
   });
 
-  it('--runtime config resolves adapter from workflows.yaml', async () => {
-    mockWakeOnce.mockResolvedValue({
-      decision: 'would_lease',
-      taskId: 'task-dreamer-008',
-      taskKind: 'dreamer',
-    });
-
-    mockRun.mockResolvedValue({
-      status: 'succeeded',
-      taskId: 'task-dreamer-008',
-      runId: 'run-008',
-      artifactId: 'pi-art-task-dreamer-008-run-008',
-      resultRef: 'dreamer://run-008',
-      attemptCount: 1,
-    });
-
-    await handleRuntimeInternalizationRunOnce({ workspace: WS, runtime: 'config', json: true });
-
-    const ResolveConfigMock = vi.mocked(
-      await import('@principles/core/runtime-v2').then(m => m.resolveRuntimeConfig),
-    );
-    expect(ResolveConfigMock).toHaveBeenCalled();
-  });
-
-  it('--runtime config reads from workspaceDir/.state (not .pd)', async () => {
+  it('--runtime config resolves adapter from .pd/config.yaml with workspace path (PRI-393)', async () => {
     mockWakeOnce.mockResolvedValue({
       decision: 'would_lease',
       taskId: 'task-dreamer-009',
@@ -455,12 +457,10 @@ describe('handleRuntimeInternalizationRunOnce', () => {
     const customWs = '/tmp/test-workspace';
     await handleRuntimeInternalizationRunOnce({ workspace: customWs, runtime: 'config', json: true });
 
-    const ResolveConfigMock = vi.mocked(
-      await import('@principles/core/runtime-v2').then(m => m.resolveRuntimeConfig),
+    // PRI-393: verify resolveRuntimeFromPdConfig was called with workspace dir
+    expect(mockResolveRuntimeFromPdConfig).toHaveBeenCalledWith(
+      expect.stringContaining('test-workspace'),
     );
-    const resolvedWorkspace = path.resolve(customWs);
-    const expectedStateDir = path.join(resolvedWorkspace, '.state');
-    expect(ResolveConfigMock).toHaveBeenCalledWith(expectedStateDir, { requestedRuntimeKind: 'config' });
   });
 
   it('--runner philosopher dispatches PhilosopherRunner', async () => {
@@ -810,7 +810,7 @@ describe('handleRuntimeInternalizationRunOnce', () => {
     expect(output.timeoutSource).toBe('runner_poll');
   });
 
-  it('--timeout-ms overrides workflows.yaml timeoutMs for PiAiRuntimeAdapter', async () => {
+  it('--timeout-ms overrides .pd/config.yaml timeoutMs for PiAiRuntimeAdapter (PRI-393)', async () => {
     mockWakeOnce.mockResolvedValue({
       decision: 'would_lease',
       taskId: 'task-dreamer-ov',
@@ -1258,14 +1258,17 @@ describe('handleRuntimeInternalizationRunOnce', () => {
   });
 
   it('--runtime config with missing config outputs structured JSON error', async () => {
-    const { resolveRuntimeConfig, isRuntimeConfigError } = await import('@principles/core/runtime-v2');
-    vi.mocked(resolveRuntimeConfig).mockReturnValue({
-      ok: false,
-      reason: 'explicit_config_missing',
-      message: 'runtime=config requested but no workflows.yaml funnel policy found',
-      nextAction: 'Create a pd-runtime-v2-diagnosis funnel policy in workflows.yaml',
+    // PRI-393: mock resolveRuntimeFromPdConfig to return config error
+    mockResolveRuntimeFromPdConfig.mockReturnValueOnce({
+      result: {
+        reason: 'explicit_config_missing',
+        message: 'runtime=config requested but no .pd/config.yaml runtime binding found',
+        nextAction: 'Add runtime binding to .pd/config.yaml',
+      },
+      legacyWarnings: [],
+      configSource: '.pd/config.yaml',
+      configLoadResult: { ok: false, effective: {}, defaults: {}, legacyFilesDetected: [] },
     });
-    vi.mocked(isRuntimeConfigError).mockReturnValue(true);
 
     mockWakeOnce.mockResolvedValue({
       decision: 'would_lease',
@@ -1283,14 +1286,17 @@ describe('handleRuntimeInternalizationRunOnce', () => {
   });
 
   it('--runtime config with missing config outputs text error', async () => {
-    const { resolveRuntimeConfig, isRuntimeConfigError } = await import('@principles/core/runtime-v2');
-    vi.mocked(resolveRuntimeConfig).mockReturnValue({
-      ok: false,
-      reason: 'explicit_config_missing',
-      message: 'runtime=config requested but no workflows.yaml funnel policy found',
-      nextAction: 'Create a pd-runtime-v2-diagnosis funnel policy in workflows.yaml',
-    });
-    vi.mocked(isRuntimeConfigError).mockReturnValue(true);
+    // PRI-393: mock resolveRuntimeFromPdConfig to return config error
+    mockResolveRuntimeFromPdConfig.mockReturnValueOnce({
+      result: {
+        reason: 'explicit_config_missing',
+        message: 'runtime=config requested but no .pd/config.yaml runtime binding found',
+        nextAction: 'Add runtime binding to .pd/config.yaml',
+      },
+      legacyWarnings: [],
+      configSource: '.pd/config.yaml',
+      configLoadResult: { ok: false, effective: {}, defaults: {}, legacyFilesDetected: [] },
+    });
 
     mockWakeOnce.mockResolvedValue({
       decision: 'would_lease',

package/tests/commands/runtime.test.ts

@@ -1,7 +1,36 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { handleRuntimeProbe, type RuntimeProbeOptions } from '../../src/commands/runtime.js';
 
-// Mock probeRuntime
+// Mock resolveRuntimeWithOverrides
+const { mockResolveRuntimeWithOverrides } = vi.hoisted(() => {
+  const fn = vi.fn().mockReturnValue({
+    result: {
+      runtimeKind: 'pi-ai',
+      provider: 'test-provider',
+      model: 'test-model',
+      apiKeyEnv: 'TEST_API_KEY',
+      maxRetries: 2,
+      timeoutMs: 180_000,
+    },
+    mergedConfig: {
+      runtimeKind: 'pi-ai',
+      provider: 'test-provider',
+      model: 'test-model',
+      apiKeyEnv: 'TEST_API_KEY',
+      maxRetries: 2,
+      timeoutMs: 180_000,
+    },
+    legacyWarnings: [],
+    configSource: '.pd/config.yaml',
+    configLoadResult: { ok: true, effective: {}, defaults: {}, legacyFilesDetected: [] },
+  });
+  return { mockResolveRuntimeWithOverrides: fn };
+});
+
+vi.mock('../../src/services/resolve-runtime-from-pd-config.js', () => ({
+  resolveRuntimeWithOverrides: mockResolveRuntimeWithOverrides,
+}));
+
 vi.mock('@principles/core/runtime-v2', () => ({
   probeRuntime: vi.fn().mockResolvedValue({
     runtimeKind: 'openclaw-cli',
@@ -260,4 +289,98 @@ describe('pd runtime probe', () => {
     consoleErrorSpy.mockRestore();
     exitSpy.mockRestore();
   });
+
+  // ── pi-ai probe: maxRetries backfill from .pd/config.yaml ───────────────
+  it('PRI-393: pi-ai probe reads maxRetries from .pd/config.yaml when --maxRetries not passed', async () => {
+    process.env.TEST_API_KEY = 'test-value';
+    const { probeRuntime } = await import('@principles/core/runtime-v2');
+    vi.mocked(probeRuntime).mockResolvedValue({
+      runtimeKind: 'pi-ai',
+      provider: 'test-provider',
+      model: 'test-model',
+      health: { healthy: true, degraded: false, warnings: [], lastCheckedAt: '2026-06-14T00:00:00.000Z' },
+      capabilities: {},
+    });
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    // mockResolveRuntimeWithOverrides returns maxRetries: 2
+    // No --maxRetries CLI flag
+    await handleRuntimeProbe({
+      runtime: 'pi-ai',
+      provider: 'test-provider',
+      model: 'test-model',
+      apiKeyEnv: 'TEST_API_KEY',
+      workspace: '/tmp/ws',
+      json: true,
+    } as RuntimeProbeOptions);
+
+    expect(vi.mocked(probeRuntime)).toHaveBeenCalledWith(
+      expect.objectContaining({ maxRetries: 2 }),
+    );
+
+    delete process.env.TEST_API_KEY;
+    consoleSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  it('PRI-393: CLI --maxRetries overrides .pd/config.yaml maxRetries', async () => {
+    process.env.TEST_API_KEY = 'test-value';
+    const { probeRuntime } = await import('@principles/core/runtime-v2');
+    vi.mocked(probeRuntime).mockResolvedValue({
+      runtimeKind: 'pi-ai',
+      provider: 'test-provider',
+      model: 'test-model',
+      health: { healthy: true, degraded: false, warnings: [], lastCheckedAt: '2026-06-14T00:00:00.000Z' },
+      capabilities: {},
+    });
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handleRuntimeProbe({
+      runtime: 'pi-ai',
+      provider: 'test-provider',
+      model: 'test-model',
+      apiKeyEnv: 'TEST_API_KEY',
+      maxRetries: 5,
+      workspace: '/tmp/ws',
+      json: true,
+    } as RuntimeProbeOptions);
+
+    expect(vi.mocked(probeRuntime)).toHaveBeenCalledWith(
+      expect.objectContaining({ maxRetries: 5 }),
+    );
+
+    delete process.env.TEST_API_KEY;
+    consoleSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  it('PRI-393: env var missing → process.exit(1) and does NOT call probeRuntime', async () => {
+    const { probeRuntime } = await import('@principles/core/runtime-v2');
+    vi.mocked(probeRuntime).mockClear();
+
+    // Ensure NONEXISTENT_VAR is NOT set
+    delete process.env.NONEXISTENT_VAR;
+
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handleRuntimeProbe({
+      runtime: 'pi-ai',
+      provider: 'test-provider',
+      model: 'test-model',
+      apiKeyEnv: 'NONEXISTENT_VAR',
+      json: true,
+    } as RuntimeProbeOptions);
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('NONEXISTENT_VAR'));
+    expect(exitSpy).toHaveBeenCalledWith(1);
+    expect(vi.mocked(probeRuntime)).not.toHaveBeenCalled();
+
+    consoleErrorSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
 });

package/tests/commands/task.test.ts

@@ -30,6 +30,7 @@ import { MalformedRunError } from '@principles/core';
 describe('pd task show command handler', () => {
   let consoleLogSpy: ReturnType<typeof vi.spyOn>;
   let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+  let consoleWarnSpy: ReturnType<typeof vi.spyOn>;
   let processExitSpy: ReturnType<typeof vi.spyOn>;
 
   beforeEach(() => {
@@ -55,6 +56,7 @@ describe('pd task show command handler', () => {
     process.exitCode = 0;
     consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
     consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
     processExitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined as never);
   });
 
@@ -111,8 +113,11 @@ describe('pd task show command handler', () => {
       runs: [{ runId: 'run-valid' }],
       degradedRuns: [{ runId: 'run-bad', error: 'runtimeKind missing' }],
       reason: expect.stringContaining('Malformed schema'),
-      nextAction: expect.stringContaining('integrity-repair'),
+      // Honest nextAction: must NOT promise an auto-repair that doesn't exist,
+      // and must point at the real quarantine command (integrity-repair --confirm).
+      nextAction: expect.stringContaining('not auto-repaired'),
     });
+    expect(output.nextAction).toContain('integrity-repair --confirm');
     expect(process.exitCode).toBe(1);
     expect(processExitSpy).not.toHaveBeenCalled();
   });
@@ -139,6 +144,9 @@ describe('pd task show command handler', () => {
 
     expect(consoleErrorSpy).not.toHaveBeenCalled();
     expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('Task: task-123'));
+    // The text-mode warning must also carry the honest nextAction.
+    expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining('not auto-repaired'));
+    expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining('integrity-repair --confirm'));
     expect(process.exitCode).toBe(1);
     expect(processExitSpy).not.toHaveBeenCalled();
   });