@principles/pd-cli 1.135.1 → 1.136.0

package/src/services/__tests__/evaluator-runner-deps.test.ts

@@ -100,6 +100,8 @@ function createMockStateManager(): {
 } {
   const createdTasks: TaskRecord[] = [];
   const stateManager = {
+    getTask: vi.fn(async (taskId: string) =>
+      createdTasks.find((t) => t.taskId === taskId) ?? null),
     createTask: vi.fn(async (record: Omit<TaskRecord, 'createdAt' | 'updatedAt'>) => {
       const now = new Date().toISOString();
       const task: TaskRecord = { ...record, createdAt: now, updatedAt: now };
@@ -185,7 +187,7 @@ describe('PRI-510 (DEFECT-004): createEvaluatorRunnerDeps wires repair loop into
     expect(deps.isRepairLoopEnabled()).toBe(false);
   });
 
-  it('flag absent in config → isRepairLoopEnabled() returns false (defaults apply)', () => {
+  it('flag absent in config → isRepairLoopEnabled() returns true (P0-D: default-on since core-loop closure)', () => {
     const workspaceDir = createTempWorkspace(null);
     tmpWorkspaces.push(workspaceDir);
     const { stateManager } = createMockStateManager();
@@ -201,10 +203,11 @@ describe('PRI-510 (DEFECT-004): createEvaluatorRunnerDeps wires repair loop into
 
     expect(typeof deps.isRepairLoopEnabled).toBe('function');
     if (typeof deps.isRepairLoopEnabled !== 'function') throw new Error('isRepairLoopEnabled missing');
-    expect(deps.isRepairLoopEnabled()).toBe(false);
+    // 契约变更 (2026-08-18, INV-02): registry 默认 ON;flag 缺省 = 默认生效
+    expect(deps.isRepairLoopEnabled()).toBe(true);
   });
 
-  it('malformed config → isRepairLoopEnabled() returns false (rc-9: fail safe, not throw)', () => {
+  it('malformed config → isRepairLoopEnabled() falls back to registry defaults (default-on), never throws', () => {
     // CodeQL: use mkdtempSync for atomic, unpredictable temp dir creation.
     const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-pri-510-malformed-'));
     tmpWorkspaces.push(tmpDir);
@@ -223,10 +226,11 @@ describe('PRI-510 (DEFECT-004): createEvaluatorRunnerDeps wires repair loop into
       workspaceDir: tmpDir,
     });
 
-    // Malformed config must NOT throw — return false so the legacy path runs.
+    // Malformed config must NOT throw — falls back to registry defaults
+    // (P0-D: evaluator_artificer_repair_loop default-on since core-loop closure).
     expect(typeof deps.isRepairLoopEnabled).toBe('function');
     if (typeof deps.isRepairLoopEnabled !== 'function') throw new Error('isRepairLoopEnabled missing');
-    expect(deps.isRepairLoopEnabled()).toBe(false);
+    expect(deps.isRepairLoopEnabled()).toBe(true);
   });
 
   it('seedArtificerRepairTask → creates artificer task with repairPayload in diagnosticJson (rc-1, rc-6)', async () => {
@@ -286,7 +290,7 @@ describe('PRI-510 (DEFECT-004): createEvaluatorRunnerDeps wires repair loop into
     expect(meta.inputArtifactRefs).toEqual(params.inheritedInputArtifactRefs);
   });
 
-  it('seedArtificerRepairTask → each call returns a UNIQUE task ID (rc-7: no stale state)', async () => {
+  it('seedArtificerRepairTask → deterministic id + replay reuse (P0-4); 不同 iteration 不同 id (rc-7)', async () => {
     const workspaceDir = createTempWorkspace(true);
     tmpWorkspaces.push(workspaceDir);
     const { stateManager } = createMockStateManager();
@@ -303,9 +307,17 @@ describe('PRI-510 (DEFECT-004): createEvaluatorRunnerDeps wires repair loop into
 
     if (typeof deps.seedArtificerRepairTask !== 'function') throw new Error('seedArtificerRepairTask missing');
     const id1 = await deps.seedArtificerRepairTask(params);
+    // P0-4: 同一 evaluator+iteration 的重放 (consumer 重复周期 / crash 恢复)
+    // reuse 同一确定性 id,不重复创建
+    expect(id1).toBe(`artificer-repair-${params.repairPayload.sourceEvaluatorTaskId}-r${params.repairPayload.repairIteration}`);
     const id2 = await deps.seedArtificerRepairTask(params);
-
-    expect(id1).not.toBe(id2);
+    expect(id2).toBe(id1);
+    // 不同 iteration (下一逻辑修复轮) → 不同 id
+    const id3 = await deps.seedArtificerRepairTask({
+      ...params,
+      repairPayload: { ...params.repairPayload, repairIteration: params.repairPayload.repairIteration + 1 },
+    });
+    expect(id3).not.toBe(id1);
   });
 
   it('deps spread contains all required base PeerRunnerDeps fields (EP-02: real path gets full deps)', () => {

package/src/services/rulehost-pipeline-runner.ts

@@ -66,7 +66,7 @@ import type {
   SeedArtificerRepairParams,
   EvaluatorValidator,
 } from '@principles/core/runtime-v2';
-import { randomUUID, createHash } from 'node:crypto';
+import { createHash } from 'node:crypto';
 import { loadPdConfig } from './pd-config-loader.js';
 /* eslint-disable @typescript-eslint/no-use-before-define -- helpers declared after main, matching codebase convention */
 import { compileDemoRule } from './demo-rule-compiler.js';
@@ -646,7 +646,10 @@ export function createEvaluatorRunnerDeps(inputs: CreateEvaluatorRunnerDepsInput
     },
     seedArtificerRepairTask: async (params: SeedArtificerRepairParams): Promise<string> => {
       // rc-7: each call gets a fresh task ID — never reuse a cached ID.
-      const repairTaskId = `artificer-repair-${randomUUID()}`;
+      // P0-4: deterministic revision identity + reuse on replay
+      const repairTaskId = `artificer-repair-${params.repairPayload.sourceEvaluatorTaskId}-r${params.repairPayload.repairIteration}`;
+      const existing = await stateManager.getTask(repairTaskId);
+      if (existing) return repairTaskId;
       await stateManager.createTask({
         taskId: repairTaskId,
         // D1 (PRI-509): task kind is 'artificer' — reuses the artificer

package/tests/commands/cli-command-tree.test.ts

@@ -126,4 +126,19 @@ describe('CLI command tree structure', () => {
     const output = runPdHelp(['legacy', 'cleanup', '--help']);
     expect(output).toContain('V1 Artificer');
   });
+
+  // cli-7-test-wiring (PR #1358 known gap 补齐): retry 是 INV-03 的核心 Owner
+  // 出边,command-tree 注册必须有 wiring 证明,不能只靠 handler 测试。
+  it('internalization retry command exists under runtime internalization (pd runtime internalization retry --help)', () => {
+    const output = runPdHelp(['runtime', 'internalization', 'retry', '--help']);
+    expect(output).toContain('--task');
+    expect(output).toContain('--confirm');
+    expect(output).toContain('--workspace');
+    expect(output).toContain('--json');
+  });
+
+  it('internalization subcommand list includes retry (pd runtime internalization --help)', () => {
+    const output = runPdHelp(['runtime', 'internalization', '--help']);
+    expect(output).toMatch(/retry\s/);
+  });
 });

package/tests/commands/demo-story-a.test.ts

@@ -238,6 +238,69 @@ describe('pd demo story-a CLI', () => {
     expect(parsed.narrative).toContain('[SIMULATED]');
     expect(parsed.narrative).toContain('[REAL]');
   });
+  // ── Demo isolation (2026-08-19): demo must not pollute real PD workspaces ──
+
+  it('refuses to write into a workspace that already contains PD state (default)', async () => {
+    const existing = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-demo-isolation-'));
+    try {
+      fs.mkdirSync(path.join(existing, '.pd'), { recursive: true });
+      fs.writeFileSync(path.join(existing, '.pd', 'state.db'), '');
+
+      await handleDemoStoryA({ workspace: existing, json: true });
+
+      expect(process.exitCode).toBe(1);
+      const output = stdoutSpy.mock.calls.map(c => c[0]).join('');
+      const parsed = JSON.parse(output);
+      expect(parsed.status).toBe('refused');
+      expect(parsed.refusal.reason).toBe('demo_write_to_existing_workspace');
+      expect(parsed.refusal.nextAction).toContain('--allow-demo-write-to-existing-workspace');
+      // cli-5: no mutation on the refused path — the marker file is untouched.
+      const stat = fs.statSync(path.join(existing, '.pd', 'state.db'));
+      expect(stat.size).toBe(0);
+    } finally {
+      fs.rmSync(existing, { recursive: true, force: true });
+    }
+  });
+
+  it('text mode refusal points at the override flag', async () => {
+    const existing = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-demo-isolation-'));
+    try {
+      fs.mkdirSync(path.join(existing, '.pd'), { recursive: true });
+      fs.writeFileSync(path.join(existing, '.pd', 'state.db'), '');
+
+      await handleDemoStoryA({ workspace: existing });
+
+      expect(process.exitCode).toBe(1);
+      const output = stderrSpy.mock.calls.map(c => c[0]).join('');
+      expect(output).toContain('existing PD workspace');
+      expect(output).toContain('--allow-demo-write-to-existing-workspace');
+    } finally {
+      fs.rmSync(existing, { recursive: true, force: true });
+    }
+  });
+
+  it('developer override allows writing into the existing workspace with origin:demo provenance', async () => {
+    const existing = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-demo-override-'));
+    try {
+      fs.mkdirSync(path.join(existing, '.pd'), { recursive: true });
+      fs.writeFileSync(path.join(existing, '.pd', 'config.yaml'), 'features: {}');
+
+      await handleDemoStoryA({ workspace: existing, json: true, allowDemoWriteToExistingWorkspace: true });
+
+      const output = stdoutSpy.mock.calls.map(c => c[0]).join('');
+      const parsed = JSON.parse(output);
+      expect(parsed.status).not.toBe('refused');
+      const db = new Database(path.join(existing, '.pd', 'state.db'), { readonly: true });
+      const rows = db.prepare('SELECT content_json FROM pi_artifacts').all() as { content_json: string }[];
+      db.close();
+      expect(rows.length).toBeGreaterThan(0);
+      for (const row of rows) {
+        expect(JSON.parse(row.content_json).origin).toBe('demo');
+      }
+    } finally {
+      fs.rmSync(existing, { recursive: true, force: true });
+    }
+  });
 });
 
 describe('cleanupTempWorkspace', () => {

package/tests/commands/runtime-compatibility-scan.test.ts

@@ -0,0 +1,146 @@
+/**
+ * runtime compatibility-scan tests — pd runtime compatibility-scan (P1-3).
+ *
+ * Real persisted-workspace fixtures (SqliteConnection + activation store) —
+ * no DB mocks, the production read path is exercised end to end (EP-09).
+ *
+ * Covers:
+ *   - SCAN-01: clean RuleContextV2-only active rule → exit 0, status clean (cli-1/cli-6)
+ *   - SCAN-02: active rule reading session.recentThinking → exit 1,
+ *     reason legacy_rule_contract_dependency, remediation names the rule (cli-6)
+ *   - SCAN-03: workspace without state.db → exit 0, status no_state_db
+ *   - SCAN-04: --json emits exactly one parseable JSON object (cli-1)
+ *   - SCAN-05: command wiring — real Commander registration (cli-7)
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import * as fs from 'node:fs';
+import { SqliteConnection, SqliteActivationStateStore } from '@principles/core/runtime-v2';
+import { handleRuntimeCompatibilityScan } from '../../src/commands/runtime-compatibility-scan.js';
+
+const LEGACY_CODE = `
+function evaluate(input, helpers) {
+  if (input.session && input.session.recentThinking === true) {
+    return { decision: 'block', matched: true };
+  }
+  return { decision: 'allow', matched: false };
+}
+`;
+
+const CLEAN_CODE = `
+function evaluate(input, helpers) {
+  var h = input.context && input.context.history;
+  return { decision: 'allow', matched: false };
+}
+`;
+
+let tempWorkspaceDir: string;
+let conn: SqliteConnection;
+
+beforeEach(() => {
+  vi.spyOn(console, 'log').mockImplementation(() => undefined);
+  vi.spyOn(console, 'error').mockImplementation(() => undefined);
+  process.exitCode = undefined;
+  tempWorkspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-compat-cmd-'));
+  conn = new SqliteConnection(tempWorkspaceDir);
+  conn.getDb();
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  try { conn?.close(); } catch { /* best-effort */ }
+  try { fs.rmSync(tempWorkspaceDir, { recursive: true, force: true }); } catch { /* Windows */ }
+});
+
+async function seedActiveRule(artifactId: string, ruleId: string, implementationCode: string): Promise<void> {
+  const now = new Date().toISOString();
+  conn.getDb().prepare(`
+    INSERT INTO pi_artifacts (artifact_id, artifact_kind, source_task_id, source_principle_id, source_rule_id, lineage_artifact_ids, validation_status, content_json, created_at, updated_at)
+    VALUES (?, 'rule', ?, ?, ?, '[]', 'validated', ?, ?, ?)
+  `).run(artifactId, `task-${artifactId}`, `principle-${ruleId}`, ruleId, JSON.stringify({ ruleId, implementationCode }), now, now);
+  await new SqliteActivationStateStore(conn).recordActivation({
+    activationId: `act-${artifactId}`,
+    idempotencyKey: `${artifactId}::code_tool_hook`,
+    artifactId,
+    channel: 'code_tool_hook',
+    action: 'code_tool_hook_live_activate',
+    targetRef: `impl://${ruleId}`,
+    activatedAt: now,
+    deactivatedAt: null,
+  });
+}
+
+function capturedStdout(): string {
+  const calls = (console.log as unknown as { mock: { calls: unknown[][] } }).mock.calls;
+  return calls.map(c => String(c[0] ?? '')).join('\n');
+}
+
+describe('pd runtime compatibility-scan', () => {
+  it('SCAN-01: clean current-contract rule exits 0 with status clean', async () => {
+    await seedActiveRule('art-clean', 'rule-clean', CLEAN_CODE);
+    await handleRuntimeCompatibilityScan({ workspace: tempWorkspaceDir, json: true });
+    expect(process.exitCode).toBeUndefined();
+    const parsed = JSON.parse(capturedStdout()) as Record<string, unknown>;
+    expect(parsed['status']).toBe('clean');
+    expect(parsed['ok']).toBe(true);
+    expect(parsed['findings']).toEqual([]);
+  });
+
+  it('SCAN-02: legacy recentThinking rule exits 1 with structured reason + remediation', async () => {
+    await seedActiveRule('art-legacy', 'rule-real-diagnosis-first', LEGACY_CODE);
+    await handleRuntimeCompatibilityScan({ workspace: tempWorkspaceDir, json: true });
+    expect(process.exitCode).toBe(1);
+    const parsed = JSON.parse(capturedStdout()) as Record<string, unknown>;
+    expect(parsed['ok']).toBe(false);
+    expect(parsed['status']).toBe('legacy_dependency');
+    expect(parsed['reason']).toBe('legacy_rule_contract_dependency');
+    const findings = parsed['findings'] as Array<Record<string, unknown>>;
+    expect(findings).toHaveLength(1);
+    expect(findings[0]).toMatchObject({ symbol: 'recentThinking', ruleId: 'rule-real-diagnosis-first' });
+    const remediation = parsed['remediation'] as string;
+    expect(remediation).toContain('rule-real-diagnosis-first');
+    expect(remediation).toContain('igrate or deactivate');
+  });
+
+  it('SCAN-03: workspace without state.db exits 0 with status no_state_db', async () => {
+    const emptyDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-compat-empty-cmd-'));
+    try {
+      await handleRuntimeCompatibilityScan({ workspace: emptyDir, json: true });
+      expect(process.exitCode).toBeUndefined();
+      const parsed = JSON.parse(capturedStdout()) as Record<string, unknown>;
+      expect(parsed['status']).toBe('no_state_db');
+      expect(parsed['ok']).toBe(true);
+      // Side-effect-free: the scan must not create a state.db (cli-5).
+      expect(fs.existsSync(path.join(emptyDir, '.pd', 'state.db'))).toBe(false);
+    } finally {
+      fs.rmSync(emptyDir, { recursive: true, force: true });
+    }
+  });
+
+  it('SCAN-04: --json stdout is exactly one parseable JSON object (cli-1)', async () => {
+    await seedActiveRule('art-clean2', 'rule-clean2', CLEAN_CODE);
+    await handleRuntimeCompatibilityScan({ workspace: tempWorkspaceDir, json: true });
+    const out = capturedStdout().trim();
+    expect(out.startsWith('{')).toBe(true);
+    expect(out.endsWith('}')).toBe(true);
+    expect(() => JSON.parse(out)).not.toThrow();
+    expect((out.match(/\{/g) ?? []).length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('SCAN-05: command is registered on a real Commander program (cli-7)', async () => {
+    const { Command } = await import('commander');
+    const { registerRuntimeCompatibilityScanCommand } = await import('../../src/commands/runtime-compatibility-scan.js');
+    const program = new Command();
+    program.name('pd').exitOverride();
+    const runtimeCmd = program.command('runtime').description('Runtime inspection and health checks');
+    registerRuntimeCompatibilityScanCommand(runtimeCmd);
+    const scanCmd = runtimeCmd.commands.find(c => c.name() === 'compatibility-scan');
+    expect(scanCmd).toBeDefined();
+    expect(scanCmd?.description()).toContain('retired RuleHost contract');
+    // Flag wiring: -w/--workspace and --json registered; no mutating flags exist.
+    expect(scanCmd?.options.map(o => o.long)).toContain('--workspace');
+    expect(scanCmd?.options.map(o => o.long)).toContain('--json');
+  });
+});