@principles/pd-cli 1.93.0 → 1.95.0

package/src/services/synthetic-baseline-runner.ts

@@ -4,8 +4,14 @@ import { RuntimeStateManager } from '@principles/core/runtime-v2';
 import { SqliteContextAssembler } from '@principles/core/runtime-v2';
 import { SqliteHistoryQuery } from '@principles/core/runtime-v2';
 import { StoreEventEmitter } from '@principles/core/runtime-v2';
-import { DiagnosticianRunner } from '@principles/core/runtime-v2';
-import { PassThroughValidator } from '@principles/core/runtime-v2';
+import {
+  SplitDiagnosticianRunner,
+  DiagRootCauseRunner,
+  DiagDistillerRunner,
+  DiagRouterRunner,
+  DefaultDiagRootCauseValidator,
+  DefaultDiagDistillerValidator,
+} from '@principles/core/runtime-v2';
 import { SqliteDiagnosticianCommitter } from '@principles/core/runtime-v2';
 import { TestDoubleRuntimeAdapter } from '@principles/core/runtime-v2';
 import { PainSignalBridge } from '@principles/core/runtime-v2';
@@ -72,20 +78,107 @@ export async function runSyntheticBaseline(opts: SyntheticBaselineRunnerOptions)
     const contextAssembler = new SqliteContextAssembler(taskStore, historyQuery, runStore);
     const eventEmitter = new StoreEventEmitter();
     const committer = new SqliteDiagnosticianCommitter(sqliteConn);
-    const validator = new PassThroughValidator();
+    const runIdToTaskId = new Map<string, string>();
+    let runCounter = 0;
 
-    const runtimeAdapter = new TestDoubleRuntimeAdapter(
-      { onFetchOutput: () => ({ runId: `synth-${painId}`, payload: diagnosticianOutput }) },
-      `diagnosis_${painId}`,
-    );
+    // Single test-double adapter handles all pains with stage-aware output
+    const runtimeAdapter = new TestDoubleRuntimeAdapter({
+      onStartRun: (input) => {
+        runCounter += 1;
+        const runId = `td-${runCounter}`;
+        const taskId = input.taskRef?.taskId ?? '';
+        runIdToTaskId.set(runId, taskId);
+        return {
+          runId,
+          runtimeKind: 'test-double',
+          startedAt: new Date().toISOString(),
+        };
+      },
+      onFetchOutput: async (runId: string) => {
+        const taskId = runIdToTaskId.get(runId) ?? '';
+        if (taskId.includes('diag_rootcause')) {
+          return {
+            runId,
+            payload: {
+              valid: true,
+              diagnosisId: `diag-${runId}`,
+              taskId,
+              summary: 'Mock rootcause summary for synthetic-baseline',
+              causalChain: [{ why: 1, statement: 'why', evidenceRefs: ['ref-1'] }],
+              rootCause: 'Design: Mock rootcause',
+              rootCauseCategory: 'Design',
+              evidence: [{ sourceRef: 'ref-1', note: 'note' }],
+              confidence: 0.9,
+            },
+          };
+        } else if (taskId.includes('diag_distiller')) {
+          const parentTaskId = taskId.replace('diag_distiller-', '');
+          const stageATaskId = `diag_rootcause-${parentTaskId}`;
+          const artifacts = stateManager
+            ? await stateManager.piArtifactStore.listBySourceTaskId(stageATaskId)
+            : [];
+          const sourceRootCauseArtifactId = artifacts[0]?.artifactId ?? 'art-rc';
+          return {
+            runId,
+            payload: {
+              valid: true,
+              taskId,
+              sourceRootCauseArtifactId,
+              abstractedPrinciple: 'Mock abstracted principle',
+              rationale: 'Mock rationale',
+              groundedOnCorePrincipleIds: ['T-01'],
+              scope: 'domain',
+              confidence: 0.9,
+            },
+          };
+        } else {
+          return {
+            runId,
+            payload: diagnosticianOutput,
+          };
+        }
+      },
+    });
 
-    const runner = new DiagnosticianRunner(
+    const rootCauseRunner = new DiagRootCauseRunner(
       {
         stateManager,
+        runtimeAdapter,
+        eventEmitter,
+        artifactStore: stateManager.piArtifactStore,
+        validator: new DefaultDiagRootCauseValidator(),
         contextAssembler,
+      },
+      {
+        owner: 'synthetic-baseline',
+        runtimeKind: 'test-double',
+        pollIntervalMs: 50,
+        timeoutMs: 10000,
+      },
+    );
+
+    const distillerRunner = new DiagDistillerRunner(
+      {
+        stateManager,
         runtimeAdapter,
         eventEmitter,
-        validator,
+        artifactStore: stateManager.piArtifactStore,
+        validator: new DefaultDiagDistillerValidator(),
+      },
+      {
+        owner: 'synthetic-baseline',
+        runtimeKind: 'test-double',
+        pollIntervalMs: 50,
+        timeoutMs: 10000,
+      },
+    );
+
+    const routerRunner = new DiagRouterRunner(
+      {
+        stateManager,
+        runtimeAdapter,
+        eventEmitter,
+        artifactStore: stateManager.piArtifactStore,
         committer,
       },
       {
@@ -96,6 +189,15 @@ export async function runSyntheticBaseline(opts: SyntheticBaselineRunnerOptions)
       },
     );
 
+    const runner = new SplitDiagnosticianRunner({
+      rootCauseRunner,
+      distillerRunner,
+      routerRunner,
+      stateManager,
+      committer,
+      perStageTimeoutMs: 10000,
+    });
+
     const ledgerAdapter = new PrincipleTreeLedgerAdapter({ stateDir });
     const intakeService = new CandidateIntakeService({ stateManager, ledgerAdapter });
 

package/tests/commands/console-open.test.ts

@@ -758,9 +758,18 @@ describe('CLI command wiring (pd console open)', () => {
 
 function runPd(args: string[], cwd: string): string {
   try {
+    const env: Record<string, string> = { ...process.env };
+    if (!args.includes('--workspace') && !args.includes('--help') && !args.includes('-h')) {
+      env.USERPROFILE = '/nonexistent';
+      env.HOME = '/nonexistent';
+      env.HOMEPATH = '/nonexistent';
+      env.HOMEDRIVE = '/nonexistent';
+      delete env.PD_WORKSPACE_DIR;
+    }
     return execFileSync('node', [getBuiltPdCliPath(), ...args], {
       encoding: 'utf8',
       cwd,
+      env,
     });
   } catch (err: unknown) {
     if (err && typeof err === 'object' && Object.hasOwn(err, 'stdout')) {

package/tests/commands/diagnose.test.ts

@@ -57,11 +57,17 @@ vi.mock('@principles/core/runtime-v2', () => {
     SqliteSourceTraceLocator: vi.fn().mockImplementation(function () { return {}; }),
     StoreEventEmitter: vi.fn().mockImplementation(function () { return {}; }),
     storeEmitter: { emitTelemetry: vi.fn() },
-    DiagnosticianRunner: vi.fn().mockImplementation(function () { return {}; }),
-    PassThroughValidator: vi.fn().mockImplementation(function () { return {}; }),
-    DefaultDiagnosticianValidator: vi.fn().mockImplementation(function () { return {}; }),
+    SplitDiagnosticianRunner: vi.fn().mockImplementation(function () { return {}; }),
+    DiagRootCauseRunner: vi.fn().mockImplementation(function () { return {}; }),
+    DiagDistillerRunner: vi.fn().mockImplementation(function () { return {}; }),
+    DiagRouterRunner: vi.fn().mockImplementation(function () { return {}; }),
+    DefaultDiagRootCauseValidator: vi.fn().mockImplementation(function () { return {}; }),
+    DefaultDiagDistillerValidator: vi.fn().mockImplementation(function () { return {}; }),
+    DisabledDiagnosticianRunner: vi.fn().mockImplementation(function () { return {}; }),
     TestDoubleRuntimeAdapter: vi.fn().mockImplementation(function () { return {}; }),
     OpenClawCliRuntimeAdapter: vi.fn().mockImplementation(function () { return {}; }),
+    PiAiRuntimeAdapter: vi.fn().mockImplementation(function () { return {}; }),
+    SPLIT_PIPELINE_TOTAL_TIMEOUT_MS: 300000,
     PDRuntimeError: class PDRuntimeError extends Error {
       constructor(public category: string, message: string) {
         super(message);
@@ -78,8 +84,12 @@ vi.mock('@principles/core/runtime-v2', () => {
       agentId: 'main',
     }),
     isRuntimeConfigError: vi.fn().mockReturnValue(false),
-    isFeatureEnabled: vi.fn().mockReturnValue(false),
+    isFeatureEnabled: vi.fn().mockReturnValue(true),
     resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
+    validatePdConfig: vi.fn().mockReturnValue({ valid: true, errors: [] }),
+    computeEffectivePdConfig: vi.fn().mockReturnValue({ config: {}, source: 'defaults', warnings: [] }),
+    computeFeatureFlagsFromConfig: vi.fn().mockReturnValue({}),
+    redactPdConfig: vi.fn().mockImplementation((c) => c),
     run: vi.fn().mockResolvedValue({
       status: 'succeeded',
       taskId: 'test-task-1',

package/tests/commands/pain-record-async.test.ts

@@ -155,7 +155,7 @@ describe('pd pain record async mode (PRI-369)', () => {
     const allOutput = logSpy.mock.calls.map(c => c.join(' ')).join(' ');
     expect(allOutput).toContain('[SUBMITTED]');
     expect(allOutput).toContain('submitted');
-    expect(allOutput).toContain('pd task show');
+    expect(allOutput).toContain('Next action: pd diagnose run --task-id');
     expect(exitSpy).not.toHaveBeenCalledWith(1);
 
     logSpy.mockRestore();
@@ -240,4 +240,79 @@ describe('pd pain record async mode (PRI-369)', () => {
     logSpy.mockRestore();
     exitSpy.mockRestore();
   });
+
+  // 7. Stubbed process.exit(1) does not cause side effects in JSON mode
+  it('stubbed process.exit(1) in JSON mode does not execute else branch', async () => {
+    mockRecordPainResult = {
+      status: 'failed',
+      painId: 'manual_123_abc',
+      taskId: 'diagnosis_manual_123_abc',
+      candidateIds: ['c1'],
+      ledgerEntryIds: ['l1'],
+      observabilityWarnings: [],
+      failureCategory: 'runtime_unavailable' as FailureCategory,
+      latencyMs: 5,
+      message: 'Task creation failed',
+    };
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const exitSpy = mockProcessExit();
+
+    await handlePainRecord({ reason: 'test pain', json: true });
+
+    // Verify JSON output was printed
+    expect(logSpy).toHaveBeenCalledTimes(1);
+    const jsonOutput = JSON.parse(logSpy.mock.calls[0][0]);
+    expect(jsonOutput.status).toBe('failed');
+    expect(jsonOutput.candidateIds).toEqual(['c1']);
+
+    // Verify process.exit(1) was called
+    expect(exitSpy).toHaveBeenCalledWith(1);
+
+    // Verify else branch was NOT executed (no error.log for [FAIL] message)
+    expect(errorSpy).not.toHaveBeenCalled();
+
+    logSpy.mockRestore();
+    errorSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  // 8. Stubbed process.exit(1) does not cause side effects in text mode
+  it('stubbed process.exit(1) in text mode stops after error message', async () => {
+    mockRecordPainResult = {
+      status: 'failed',
+      painId: 'manual_123_abc',
+      taskId: 'diagnosis_manual_123_abc',
+      candidateIds: ['c1'],
+      ledgerEntryIds: ['l1'],
+      observabilityWarnings: [],
+      failureCategory: 'runtime_unavailable' as FailureCategory,
+      latencyMs: 5,
+      message: 'Test failure message',
+    };
+
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = mockProcessExit();
+
+    await handlePainRecord({ reason: 'test pain' }); // Not json mode
+
+    // Verify [FAIL] error message was printed
+    expect(errorSpy).toHaveBeenCalledWith('[FAIL] Pain signal failed:', 'Test failure message');
+
+    // Verify process.exit(1) was called
+    expect(exitSpy).toHaveBeenCalledWith(1);
+
+    // Verify no success/submitted/skip/retry messages were printed after exit
+    const allLogMessages = logSpy.mock.calls.flat();
+    const forbiddenPatterns = ['[OK]', '[SUBMITTED]', '[SKIP]', '[RETRY]'];
+    for (const pattern of forbiddenPatterns) {
+      expect(allLogMessages).not.toEqual(expect.stringContaining(pattern));
+    }
+
+    logSpy.mockRestore();
+    errorSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
 });

package/tests/commands/pain-retry.test.ts

@@ -89,11 +89,17 @@ vi.mock('@principles/core/runtime-v2', () => {
     SqliteSourceTraceLocator: vi.fn().mockImplementation(function () { return {}; }),
     StoreEventEmitter: vi.fn().mockImplementation(function () { return {}; }),
     storeEmitter: { emitTelemetry: vi.fn() },
-    DiagnosticianRunner: vi.fn().mockImplementation(function () { return {}; }),
-    DefaultDiagnosticianValidator: vi.fn().mockImplementation(function () { return {}; }),
+    SplitDiagnosticianRunner: vi.fn().mockImplementation(function () { return {}; }),
+    DiagRootCauseRunner: vi.fn().mockImplementation(function () { return {}; }),
+    DiagDistillerRunner: vi.fn().mockImplementation(function () { return {}; }),
+    DiagRouterRunner: vi.fn().mockImplementation(function () { return {}; }),
+    DefaultDiagRootCauseValidator: vi.fn().mockImplementation(function () { return {}; }),
+    DefaultDiagDistillerValidator: vi.fn().mockImplementation(function () { return {}; }),
+    DisabledDiagnosticianRunner: vi.fn().mockImplementation(function () { return {}; }),
     TestDoubleRuntimeAdapter: vi.fn().mockImplementation(function () { return {}; }),
     OpenClawCliRuntimeAdapter: vi.fn().mockImplementation(function () { return {}; }),
     PiAiRuntimeAdapter: vi.fn().mockImplementation(function () { return {}; }),
+    SPLIT_PIPELINE_TOTAL_TIMEOUT_MS: 300000,
     PDRuntimeError: class PDRuntimeError extends Error {
       constructor(public category: string, message: string) {
         super(message);
@@ -103,7 +109,12 @@ vi.mock('@principles/core/runtime-v2', () => {
     CandidateIntakeService: MockCandidateIntakeService,
     resolveRuntimeConfig: mockResolveRuntimeConfig,
     isRuntimeConfigError: vi.fn().mockReturnValue(false),
+    isFeatureEnabled: vi.fn().mockReturnValue(true),
     resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
+    validatePdConfig: vi.fn().mockReturnValue({ valid: true, errors: [] }),
+    computeEffectivePdConfig: vi.fn().mockReturnValue({ config: {}, source: 'defaults', warnings: [] }),
+    computeFeatureFlagsFromConfig: vi.fn().mockReturnValue({}),
+    redactPdConfig: vi.fn().mockImplementation((c) => c),
     run: mockRun,
     status: vi.fn(),
   };

package/tests/e2e/candidate-intake-e2e.test.ts

@@ -149,12 +149,33 @@ describe('E2E: pd candidate intake flow', () => {
     }
   }
 
-  function readLedgerFile(workspace: string): any[] {
-    const ledgerPath = join(workspace, '.pd', 'principle-tree-ledger.json');
+  function readLedgerFile(workspace: string): Array<{ id: string; sourceRef: string; status: string; evaluability: string }> {
+    const ledgerPath = join(workspace, '.state', 'principle_training_state.json');
     if (!existsSync(ledgerPath)) return [];
     const content = readFileSync(ledgerPath, 'utf-8');
-    const data = JSON.parse(content);
-    return data.principles || [];
+    const data: unknown = JSON.parse(content);
+    if (typeof data !== 'object' || data === null) return [];
+    const tree = (data as Record<string, unknown>)._tree ?? (data as Record<string, unknown>).tree ?? {};
+    if (typeof tree !== 'object' || tree === null) return [];
+    const principles = (tree as Record<string, unknown>).principles ?? {};
+    if (typeof principles !== 'object' || principles === null) return [];
+    return Object.values(principles).map((p: unknown) => {
+      if (typeof p !== 'object' || p === null) {
+        return { id: '', sourceRef: 'candidate://', status: '', evaluability: '' };
+      }
+      const pObj = p as Record<string, unknown>;
+      const painIds = pObj.derivedFromPainIds;
+      const candidateId = Array.isArray(painIds) && typeof painIds[0] === 'string' ? painIds[0] : '';
+      const id = typeof pObj.id === 'string' ? pObj.id : '';
+      const rawStatus = typeof pObj.status === 'string' ? pObj.status : '';
+      const evaluability = typeof pObj.evaluability === 'string' ? pObj.evaluability : '';
+      return {
+        id,
+        sourceRef: `candidate://${candidateId}`,
+        status: rawStatus === 'candidate' ? 'probation' : rawStatus,
+        evaluability,
+      };
+    });
   }
 
   it('Test 1 (Happy path E2E): pending candidate → intake → consumed → ledgerEntryId in output', () => {