@principles/pd-cli 1.109.3 → 1.110.0

package/src/services/mainline-snapshot-assembler.ts

@@ -235,15 +235,20 @@ async function findDiagnosticianArtifact(
 ): Promise<DiagnosticianArtifactSnapshot | null> {
   const { stateManager, diagnosisTaskId, painId, warnings } = input;
   const db = stateManager.connection.getDb();
+
+  // PRI-411: Split pipeline stores the diagnostician artifact under the
+  // diag_router child task (e.g. "diag_router-diagnosis_xxx"), not the
+  // parent "diagnosis_xxx". Fallback to diag_router-{parentTaskId} when
+  // the parent lookup returns no rows.
   const rows = db
     .prepare(
       `SELECT artifact_id, run_id, task_id, artifact_kind, content_json
        FROM artifacts
-       WHERE task_id = ? AND artifact_kind = 'diagnostician_output'
+       WHERE (task_id = ? OR task_id = 'diag_router-' || ?) AND artifact_kind = 'diagnostician_output'
        ORDER BY created_at DESC
        LIMIT 1`,
     )
-    .all(diagnosisTaskId);
+    .all(diagnosisTaskId, diagnosisTaskId);
 
   const [raw] = rows;
   if (!raw) return null;
@@ -254,6 +259,8 @@ async function findDiagnosticianArtifact(
     return null;
   }
 
+  // EP-07: If artifact was found via diag_router fallback, verify lineage
+  // consistency — the artifact's sourcePainId must match the parent pain.
   let sourcePainId: string | null = painId;
   const parsed = safeJsonParse(row.contentJson);
   if (parsed.ok && isObject(parsed.value)) {
@@ -265,6 +272,14 @@ async function findDiagnosticianArtifact(
     warnings.push(`Artifact ${row.artifactId} content_json parse failed: ${parsed.reason}`);
   }
 
+  // EP-07 mismatch guard: warn when artifact lineage doesn't match parent pain
+  if (painId && sourcePainId && sourcePainId !== painId) {
+    warnings.push(
+      `Artifact ${row.artifactId} (task ${row.taskId}) sourcePainId "${sourcePainId}" ` +
+      `mismatches parent painId "${painId}" — lineage may be broken`,
+    );
+  }
+
   return {
     artifactId: row.artifactId,
     sourcePainId,

package/src/utils/production-workspace-guard.ts

@@ -173,18 +173,6 @@ export function getSafeUatWorkspacePath(): string {
   return uatWorkspace;
 }
 
-/**
- * Check if --allow-production-workspace-for-uat flag is set.
- *
- * This is the escape hatch for cases where the operator explicitly wants to run UAT on production.
- * The flag must be very explicit in both name and output (as required by PRI-334).
- */
-export function isProductionWorkspaceAllowed(): boolean {
-  // Check if the flag was parsed and passed through opts
-  // This will be called from command handlers after Commander parses flags
-  return false; // Placeholder; actual check depends on Commander opts
-}
-
 /**
  * Format guard refusal for console output.
  *

package/tests/commands/candidate-audit-repair.test.ts

@@ -97,9 +97,6 @@ vi.mock('@principles/core/runtime-v2', () => ({
   loadLedger: mockLoadLedger,
   getLedgerFilePathPublic: mockGetLedgerFilePath,
   resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
-}));
-
-vi.mock('../../src/principle-tree-ledger-adapter.js', () => ({
   PrincipleTreeLedgerAdapter: MockPrincipleTreeLedgerAdapter,
 }));
 

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

@@ -71,9 +71,6 @@ vi.mock('@principles/core/runtime-v2', () => ({
   CandidateIntakeError: MockCandidateIntakeError,
   RuntimeStateManager: MockRuntimeStateManager,
   resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
-}));
-
-vi.mock('../../src/principle-tree-ledger-adapter.js', () => ({
   PrincipleTreeLedgerAdapter: MockPrincipleTreeLedgerAdapter,
 }));
 

package/tests/commands/candidate-internalization-backfill.test.ts

@@ -17,19 +17,16 @@ vi.mock('../../src/resolve-workspace.js', () => ({
   resolveWorkspaceDir: vi.fn((workspace?: string) => workspace ?? '/fake/workspace'),
 }));
 
-vi.mock('../../src/principle-tree-ledger-adapter.js', () => ({
-  PrincipleTreeLedgerAdapter: vi.fn().mockImplementation(function () {
-    return {
-      intake: mockIntake,
-      existsForCandidate: mockExistsForCandidate,
-    };
-  }),
-}));
-
 vi.mock('@principles/core/runtime-v2', async (importOriginal) => {
   const original = await importOriginal() as Record<string, unknown>;
   return {
     ...original,
+    PrincipleTreeLedgerAdapter: vi.fn().mockImplementation(function () {
+      return {
+        intake: mockIntake,
+        existsForCandidate: mockExistsForCandidate,
+      };
+    }),
     RuntimeStateManager: vi.fn().mockImplementation(function (opts: Record<string, unknown>) {
       mockRuntimeStateManagerOpts(opts);
       return {

package/tests/commands/diagnose.test.ts

@@ -123,13 +123,10 @@ vi.mock('@principles/core/runtime-v2', () => {
       },
     }),
     status: vi.fn(),
+    PrincipleTreeLedgerAdapter: MockPrincipleTreeLedgerAdapter,
   };
 });
 
-vi.mock('../../src/principle-tree-ledger-adapter.js', () => ({
-  PrincipleTreeLedgerAdapter: MockPrincipleTreeLedgerAdapter,
-}));
-
 vi.mock('../../src/config-reader.js', () => ({
   readOutputLanguageFromWorkspace: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
 }));

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

@@ -130,13 +130,10 @@ vi.mock('@principles/core/runtime-v2', () => {
     redactPdConfig: vi.fn().mockImplementation((c) => c),
     run: mockRun,
     status: vi.fn(),
+    PrincipleTreeLedgerAdapter: MockPrincipleTreeLedgerAdapter,
   };
 });
 
-vi.mock('../../src/principle-tree-ledger-adapter.js', () => ({
-  PrincipleTreeLedgerAdapter: MockPrincipleTreeLedgerAdapter,
-}));
-
 vi.mock('../../src/config-reader.js', () => ({
   readOutputLanguageFromWorkspace: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
 }));

package/tests/services/mainline-snapshot-assembler.test.ts

@@ -216,17 +216,20 @@ describe('assembleMainlineSnapshot', () => {
     rmTmpDir(workspaceDir);
   });
 
-  it('returns a snapshot with degraded readiness when no readiness snapshot is provided', async () => {
+  it('returns a snapshot with default readiness when no readiness snapshot is provided', async () => {
     await sm.initialize();
     const painId = 'pain-empty';
     await seedDiagnosisTask(sm, painId);
 
     const { snapshot, warnings } = await assembleMainlineSnapshot({ workspaceDir, painId });
 
-    expect(snapshot.readiness.diagnosticianReady).toBe(false);
+    // Default config resolves a diagnostician profile, so readiness is "configured"
+    // (actual connectivity is unknown without probe, but config alignment is satisfied)
+    expect(snapshot.readiness.diagnosticianReady).toBe(true);
     expect(warnings.length).toBe(0);
     const verdict = assertMainlineContract(snapshot);
-    expect(verdict.stages.some((s) => s.stage === 'diagnostician_readiness' && s.status === 'violation')).toBe(true);
+    // diagnosis_task should be a violation since the task has no succeeded run
+    expect(verdict.stages.some((s) => s.stage === 'diagnosis_task' && s.status === 'violation')).toBe(true);
   });
 
   it('malformed artifact content_json does not crash; contract reports violation with reason + nextAction', async () => {
@@ -422,4 +425,145 @@ describe('assembleMainlineSnapshot', () => {
 
     expect(resolvedPainId).toBe(painId);
   });
+
+  // ── PRI-411: Split pipeline artifact fallback ─────────────────────────────
+
+  it('finds diagnostician artifact stored under diag_router child task (split pipeline layout)', async () => {
+    await sm.initialize();
+    const painId = 'pain-split-pipeline';
+    const parentTaskId = `diagnosis_${painId}`;
+    const routerTaskId = `diag_router-${parentTaskId}`;
+
+    // Create the parent diagnosis task (split pipeline parent)
+    await sm.createTask({
+      taskId: parentTaskId,
+      taskKind: 'diagnostician',
+      inputRef: painId,
+      status: 'pending',
+      attemptCount: 0,
+      maxAttempts: 3,
+      diagnosticJson: diagnosticianDiagnosticJson(painId),
+    });
+
+    // Create the diag_router child task
+    await sm.createTask({
+      taskId: routerTaskId,
+      taskKind: 'diag_router',
+      inputRef: painId,
+      status: 'pending',
+      attemptCount: 0,
+      maxAttempts: 3,
+      diagnosticJson: diagnosticianDiagnosticJson(painId),
+    });
+
+    // Commit the artifact under the diag_router child task (not the parent)
+    const output = validDiagnosticianOutput(painId);
+    const committer = new SqliteDiagnosticianCommitter(sm.connection);
+    await sm.acquireLease({ taskId: routerTaskId, owner: 'test-owner', durationMs: 60_000, runtimeKind: 'openclaw' });
+    const runs = await sm.getRunsByTask(routerTaskId);
+    const runId = runs[0]?.runId;
+    if (!runId) throw new Error(`No run created for task ${routerTaskId}`);
+    const commitResult = await committer.commit({
+      runId,
+      taskId: routerTaskId,
+      output,
+      idempotencyKey: `idem-${routerTaskId}`,
+    });
+    await sm.markTaskSucceeded(routerTaskId, `artifact://${commitResult.artifactId}`);
+    // Also mark parent as succeeded
+    await sm.markTaskSucceeded(parentTaskId, `artifact://${commitResult.artifactId}`);
+
+    const { snapshot, warnings } = await assembleMainlineSnapshot({ workspaceDir, painId, readiness: healthyReadiness() });
+
+    // PRI-411: fallback should find the artifact under diag_router-*
+    expect(snapshot.chain.diagnosticianArtifact).not.toBeNull();
+    expect(snapshot.chain.diagnosticianArtifact?.artifactId).toBe(commitResult.artifactId);
+    expect(snapshot.chain.diagnosticianArtifact?.sourcePainId).toBe(painId);
+    // No mismatch warning since lineage is consistent
+    expect(warnings.some((w) => w.includes('mismatches'))).toBe(false);
+  });
+
+  it('split pipeline artifact with mismatched sourcePainId emits lineage warning (EP-07)', async () => {
+    await sm.initialize();
+    const painId = 'pain-split-mismatch';
+    const wrongPainId = 'pain-wrong-lineage';
+    const parentTaskId = `diagnosis_${painId}`;
+    const routerTaskId = `diag_router-${parentTaskId}`;
+
+    await sm.createTask({
+      taskId: parentTaskId,
+      taskKind: 'diagnostician',
+      inputRef: painId,
+      status: 'pending',
+      attemptCount: 0,
+      maxAttempts: 3,
+      diagnosticJson: diagnosticianDiagnosticJson(painId),
+    });
+
+    await sm.createTask({
+      taskId: routerTaskId,
+      taskKind: 'diag_router',
+      inputRef: painId,
+      status: 'pending',
+      attemptCount: 0,
+      maxAttempts: 3,
+      diagnosticJson: diagnosticianDiagnosticJson(painId),
+    });
+
+    // Acquire lease + run for the router task (needed for artifact insertion)
+    await sm.acquireLease({ taskId: routerTaskId, owner: 'test-owner', durationMs: 60_000, runtimeKind: 'openclaw' });
+    const runs = await sm.getRunsByTask(routerTaskId);
+    const runId = runs[0]?.runId;
+    if (!runId) throw new Error(`No run created for task ${routerTaskId}`);
+
+    // Directly insert artifact with a DIFFERENT painId in content_json
+    // (simulates lineage mismatch — committer stores DiagnosticianOutputV1
+    // which doesn't have painId, but the assembler reads it for lineage checks)
+    const artifactId = 'mismatch-artifact-001';
+    const contentJson = JSON.stringify({
+      ...validDiagnosticianOutput(painId),
+      painId: wrongPainId, // mismatched lineage
+    });
+    sm.connection.getDb().prepare(
+      `INSERT INTO artifacts (artifact_id, run_id, task_id, artifact_kind, content_json, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`,
+    ).run(artifactId, runId, routerTaskId, 'diagnostician_output', contentJson, new Date().toISOString());
+
+    await sm.markTaskSucceeded(routerTaskId, `artifact://${artifactId}`);
+    await sm.markTaskSucceeded(parentTaskId, `artifact://${artifactId}`);
+
+    const { snapshot, warnings } = await assembleMainlineSnapshot({ workspaceDir, painId, readiness: healthyReadiness() });
+
+    // Artifact should still be found via fallback
+    expect(snapshot.chain.diagnosticianArtifact).not.toBeNull();
+    // EP-07: lineage mismatch warning must be emitted
+    expect(warnings.some((w) => w.includes('mismatches') && w.includes(wrongPainId))).toBe(true);
+  });
+
+  it('monolithic diagnostician artifact lookup still works (no regression)', async () => {
+    await sm.initialize();
+    const painId = 'pain-monolithic-regression';
+    const taskId = `diagnostician-${painId}`;
+
+    // Monolithic layout: artifact stored directly under the parent task
+    await sm.createTask({
+      taskId,
+      taskKind: 'diagnostician',
+      inputRef: painId,
+      status: 'pending',
+      attemptCount: 0,
+      maxAttempts: 3,
+      diagnosticJson: diagnosticianDiagnosticJson(painId),
+    });
+
+    const output = validDiagnosticianOutput(painId);
+    const { artifactId } = await runDiagnosisToSucceeded(sm, taskId, output);
+
+    const { snapshot, warnings } = await assembleMainlineSnapshot({ workspaceDir, painId, readiness: healthyReadiness() });
+
+    expect(snapshot.chain.diagnosticianArtifact).not.toBeNull();
+    expect(snapshot.chain.diagnosticianArtifact?.artifactId).toBe(artifactId);
+    expect(snapshot.chain.diagnosticianArtifact?.sourcePainId).toBe(painId);
+    expect(warnings.some((w) => w.includes('mismatches'))).toBe(false);
+  });
 });

package/dist/principle-tree-ledger-adapter.d.ts

@@ -1,12 +0,0 @@
-/**
- * Re-exports the canonical PrincipleTreeLedgerAdapter from @principles/core/runtime-v2.
- *
- * This adapter uses @principles/core's addPrincipleToLedger/loadLedger, which write to
- * <stateDir>/principle_training_state.json (HybridLedgerStore format), matching the ledger
- * format used by the OpenClaw plugin's pain-signal-bridge.
- *
- * audit/repair commands use this adapter — it ensures consistency between
- * what intake writes and what audit/repair read back.
- */
-export { PrincipleTreeLedgerAdapter, } from '@principles/core/runtime-v2';
-//# sourceMappingURL=principle-tree-ledger-adapter.d.ts.map

package/dist/principle-tree-ledger-adapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"principle-tree-ledger-adapter.d.ts","sourceRoot":"","sources":["../src/principle-tree-ledger-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EACL,0BAA0B,GAC3B,MAAM,6BAA6B,CAAC"}

package/dist/principle-tree-ledger-adapter.js

@@ -1,12 +0,0 @@
-/**
- * Re-exports the canonical PrincipleTreeLedgerAdapter from @principles/core/runtime-v2.
- *
- * This adapter uses @principles/core's addPrincipleToLedger/loadLedger, which write to
- * <stateDir>/principle_training_state.json (HybridLedgerStore format), matching the ledger
- * format used by the OpenClaw plugin's pain-signal-bridge.
- *
- * audit/repair commands use this adapter — it ensures consistency between
- * what intake writes and what audit/repair read back.
- */
-export { PrincipleTreeLedgerAdapter, } from '@principles/core/runtime-v2';
-//# sourceMappingURL=principle-tree-ledger-adapter.js.map

package/dist/principle-tree-ledger-adapter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"principle-tree-ledger-adapter.js","sourceRoot":"","sources":["../src/principle-tree-ledger-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EACL,0BAA0B,GAC3B,MAAM,6BAA6B,CAAC"}

package/src/principle-tree-ledger-adapter.ts

@@ -1,13 +0,0 @@
-/**
- * Re-exports the canonical PrincipleTreeLedgerAdapter from @principles/core/runtime-v2.
- *
- * This adapter uses @principles/core's addPrincipleToLedger/loadLedger, which write to
- * <stateDir>/principle_training_state.json (HybridLedgerStore format), matching the ledger
- * format used by the OpenClaw plugin's pain-signal-bridge.
- *
- * audit/repair commands use this adapter — it ensures consistency between
- * what intake writes and what audit/repair read back.
- */
-export {
-  PrincipleTreeLedgerAdapter,
-} from '@principles/core/runtime-v2';