@principles/pd-cli 1.133.0 → 1.134.0

package/tests/commands/runtime-internalization-context-trace.test.ts

@@ -0,0 +1,110 @@
+/**
+ * Command-registration / parser tests for context-trace (PR 5 task 11.2, cli-7).
+ *
+ * Tests the real Commander program — exercises actual flag parsing, not just
+ * the handler. Verifies:
+ *   - --task / --artifact / --workspace / --json parse correctly
+ *   - --dry-run / --confirm do NOT exist (read-only command, cli-4)
+ *   - no new feature flag is introduced (registry diff is empty)
+ *
+ * @see .kiro/specs/internalization-progressive-disclosure/design.md §6.7
+ */
+
+import { describe, it, expect } from 'vitest';
+import { Command } from 'commander';
+import { DEFAULT_FEATURE_FLAGS } from '@principles/core/runtime-v2';
+
+// Build a minimal program that mirrors the real registration.
+function buildTestProgram(): Command {
+  const program = new Command();
+  const runtime = program.command('runtime');
+  const internalization = runtime.command('internalization', { hidden: true });
+
+  internalization
+    .command('context-trace')
+    .description('Trace the internalization context chain')
+    .requiredOption('-t, --task <taskId>', 'Task ID to trace')
+    .option('-a, --artifact <artifactId>', 'Specific artifact ID to start from')
+    .option('-w, --workspace <path>', 'Workspace directory')
+    .option('--json', 'Output raw JSON (default)')
+    .action(() => {});
+
+  return program;
+}
+
+describe('context-trace command registration (cli-7)', () => {
+  it('parses --task correctly', () => {
+    const program = buildTestProgram();
+    program.parse(['node', 'pd', 'runtime', 'internalization', 'context-trace', '--task', 'task-123']);
+    const cmd = program.commands[0]?.commands[0]?.commands[0];
+    expect(cmd).toBeDefined();
+    expect(cmd?.opts().task).toBe('task-123');
+  });
+
+  it('parses --artifact correctly', () => {
+    const program = buildTestProgram();
+    program.parse(['node', 'pd', 'runtime', 'internalization', 'context-trace', '--task', 't1', '--artifact', 'art-1']);
+    const cmd = program.commands[0]?.commands[0]?.commands[0];
+    expect(cmd?.opts().artifact).toBe('art-1');
+  });
+
+  it('parses --workspace correctly', () => {
+    const program = buildTestProgram();
+    program.parse(['node', 'pd', 'runtime', 'internalization', 'context-trace', '--task', 't1', '--workspace', '/tmp/pd']);
+    const cmd = program.commands[0]?.commands[0]?.commands[0];
+    expect(cmd?.opts().workspace).toBe('/tmp/pd');
+  });
+
+  it('parses --json flag', () => {
+    const program = buildTestProgram();
+    program.parse(['node', 'pd', 'runtime', 'internalization', 'context-trace', '--task', 't1', '--json']);
+    const cmd = program.commands[0]?.commands[0]?.commands[0];
+    expect(cmd?.opts().json).toBe(true);
+  });
+
+  it('requires --task (exits with error if missing)', () => {
+    const program = buildTestProgram();
+    // Commander calls process.exit on missing required option; stub it.
+    const originalExit = process.exit;
+    let exitCode: number | undefined;
+    process.exit = ((code?: number) => { exitCode = code; }) as never;
+    try {
+      program.parse(['node', 'pd', 'runtime', 'internalization', 'context-trace']);
+    } catch {
+      // Commander may throw after stubbed exit
+    } finally {
+      process.exit = originalExit;
+    }
+    expect(exitCode).toBe(1);
+  });
+
+  it('does NOT have --dry-run option (read-only command, cli-4)', () => {
+    const program = buildTestProgram();
+    program.parse(['node', 'pd', 'runtime', 'internalization', 'context-trace', '--task', 't1']);
+    const cmd = program.commands[0]?.commands[0]?.commands[0];
+    expect(cmd?.opts().dryRun).toBeUndefined();
+    // Verify the option doesn't exist at all.
+    const dryRunOption = cmd?.options.find((o) => o.long === '--dry-run');
+    expect(dryRunOption).toBeUndefined();
+  });
+
+  it('does NOT have --confirm option (read-only command, cli-4)', () => {
+    const program = buildTestProgram();
+    program.parse(['node', 'pd', 'runtime', 'internalization', 'context-trace', '--task', 't1']);
+    const cmd = program.commands[0]?.commands[0]?.commands[0];
+    expect(cmd?.opts().confirm).toBeUndefined();
+    const confirmOption = cmd?.options.find((o) => o.long === '--confirm');
+    expect(confirmOption).toBeUndefined();
+  });
+
+  it('context-trace does not introduce a new feature flag (registry diff empty)', () => {
+    // design §8: Layer 3 (CLI) does not add a new flag. The command is always
+    // available (read-only); it reads the EXISTING 3 flags.
+    const knownFlags = new Set(DEFAULT_FEATURE_FLAGS.map((f) => f.id));
+    expect(knownFlags.has('artifact_summary_redundancy')).toBe(true);
+    expect(knownFlags.has('context_manifest_budget')).toBe(true);
+    expect(knownFlags.has('progressive_evaluator')).toBe(true);
+    // No 'context_trace' flag should exist.
+    expect(knownFlags.has('context_trace')).toBe(false);
+  });
+});

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

@@ -46,8 +46,8 @@ describe('CLI command tree: pd runtime internalization', () => {
     expect(output).toContain('--json');
   });
 
-  it('runtime subcommand list does NOT include internalization (PRI-455: hidden from --help)', () => {
+  it('runtime subcommand list includes internalization (PRI-419 amendment: un-hidden for operator visibility)', () => {
     const output = runPdHelp(['runtime', '--help']);
-    expect(output).not.toMatch(/internalization\s/);
+    expect(output).toMatch(/internalization\s/);
   });
 });

package/tests/config-reader.test.ts

@@ -22,15 +22,16 @@ vi.mock('fs', () => ({
   readFileSync: vi.fn(),
 }));
 
+// Mock js-yaml with NAMED exports (matches `import * as yaml from 'js-yaml'`
+// in config-reader.ts). js-yaml 5.x removed the default export, so the mock
+// must provide `load` and `JSON_SCHEMA` as named members, not under `default`.
 vi.mock('js-yaml', () => ({
-  default: {
-    load: vi.fn(),
-    JSON_SCHEMA: 'JSON_SCHEMA',
-  },
+  load: vi.fn(),
+  JSON_SCHEMA: 'JSON_SCHEMA',
 }));
 
 import * as fs from 'fs';
-import yaml from 'js-yaml';
+import * as yaml from 'js-yaml';
 
 const mockExistsSync = vi.mocked(fs.existsSync);
 const mockReadFileSync = vi.mocked(fs.readFileSync);

package/tests/e2e/cross-package-acceptance.test.ts

@@ -173,7 +173,7 @@ function artificerV2(taskId: string, priorId?: string): unknown {
   return {
     taskId, sourceScribeArtifactId: requireLineage(priorId, 'sourceScribeArtifactId'),
     implementationPlan: { summary: 'Block /etc writes', targetSurface: 'rule-host', changes: ['matcher'], tests: ['unit'], rolloutNotes: ['shadow'], confidence: 0.85 },
-    implementationCode: 'function evaluate(input, helpers) { const p = String(input?.action?.paramsSummary?.path ?? input?.action?.normalizedPath ?? ""); return p.startsWith("/etc") ? { decision: "block", matched: true, reason: "system path" } : { decision: "allow", matched: false, reason: "ok" }; }',
+    implementationCode: 'function evaluate(input, helpers) { const p = String(input?.action?.paramsSummary?.path ?? input?.action?.normalizedPath ?? ""); if (p.startsWith("/etc")) return { decision: "block", matched: true, reason: "system path" }; const ctx = input?.context; if (ctx && ctx.facts && ctx.facts.priorReadOfTarget === "no") { return { decision: "block", matched: true, reason: "no prior read" }; } return { decision: "allow", matched: false, reason: "ok" }; }',
     implementationSummary: 'Block system path writes',
     goldenTraceCases: [
       { caseId: 'pos-1', kind: 'positive', toolName: 'write_file', params: { path: '/project/f.txt' }, expectedDecision: 'allow' },
@@ -397,21 +397,23 @@ describe('Cross-Package Acceptance Test (PRI-408 P1/P2 fixes) — unsplippable c
     expect(activationRecord!.artifactId).toBe(revisedArtifactId);
     expect(activationRecord!.channel).toBe('code_tool_hook');
     expect(activationRecord!.deactivatedAt).toBeNull();
+    // PRI-489: Owner approval creates a SHADOW activation first (not live).
+    // Shadow activations are observation-only — they record would-block into
+    // shadowDecisions but never actually block the tool call. The only
+    // shadow -> live transition is `pd activation promote --confirm`.
+    expect(activationRecord!.action).toBe('code_tool_hook_shadow_activate');
 
     // Verify via listCodeToolHookActivations (P2 #5: default excludes deactivated)
     const activeActivations = await stateStore.listCodeToolHookActivations();
     const ourActivation = activeActivations.find(a => a.artifactId === revisedArtifactId);
     expect(ourActivation).toBeDefined();
     expect(ourActivation!.deactivatedAt).toBeNull();
+    expect(ourActivation!.action).toBe('code_tool_hook_shadow_activate');
 
-    // ── Step 7b: Verify the rule actually affects behavior via the gate (P1 #4)
-    // The production RuleHost gate loads all active rules, compiles their code,
-    // and calls evaluate() on each tool call. This step simulates that:
-    // 1. Load active rules from the activation state store
-    // 2. Compile the rule code in the production vm sandbox
-    // 3. Call evaluate() with system-path and normal-path inputs
-    // 4. Verify the rule blocks system paths and allows normal paths
-
+    // ── Step 7a: Verify shadow activation does NOT block (PRI-489) ────────
+    // Shadow mode is observation-only. The RuleHost loads the activation but
+    // records shadowDecisions instead of blocking. evaluate() must return
+    // undefined (no block) for shadow activations, even for /etc/passwd.
     const makeRuleHostInput = (targetPath: string): RuleHostInput => ({
       action: { toolName: 'write_file', normalizedPath: targetPath, paramsSummary: { path: targetPath } },
       workspace: { isRiskPath: targetPath.startsWith('/etc'), planStatus: 'NONE', hasPlanFile: false },
@@ -419,6 +421,43 @@ describe('Cross-Package Acceptance Test (PRI-408 P1/P2 fixes) — unsplippable c
       evolution: { epTier: 0 },
       derived: { estimatedLineChanges: 1, bashRisk: 'safe' },
     });
+    const shadowRuleHost = new RuleHost(
+      path.join(tmpDir, '.state'),
+      { warn: () => {} },
+      { workspaceDir: tmpDir },
+    );
+    try {
+      const report = shadowRuleHost.evaluateDetailed(makeRuleHostInput('/etc/passwd'));
+      expect(report.liveDecision).toBeUndefined();
+      expect(report.shadowDecisions).toContainEqual(
+        expect.objectContaining({ activationId: activationRecord!.activationId }),
+      );
+    } finally {
+      shadowRuleHost.dispose();
+    }
+
+    // ── Step 7b: Promote shadow → live (PRI-489) ──────────────────────────
+    // `pd activation promote --activation-id ... --confirm` is the ONLY
+    // shadow → live entry. SqliteActivationStateStore.promoteActivation
+    // atomically rewrites action to `code_tool_hook_live_activate` inside a
+    // BEGIN IMMEDIATE transaction.
+    const activationId = activationRecord!.activationId;
+    const promoteResult = await stateStore.promoteActivation(activationId, new Date().toISOString());
+    expect(promoteResult).toBe(true);
+
+    // Verify the action is now live
+    const liveActivationRecord = await stateStore.getActivationStatus(idempotencyKey);
+    expect(liveActivationRecord).not.toBeNull();
+    expect(liveActivationRecord!.action).toBe('code_tool_hook_live_activate');
+    expect(liveActivationRecord!.promotedAt).not.toBeNull();
+
+    // ── Step 7c: Verify the rule actually blocks in live mode (P1 #4) ────
+    // The production RuleHost gate loads all active rules, compiles their code,
+    // and calls evaluate() on each tool call. This step simulates that:
+    // 1. Load active rules from the activation state store
+    // 2. Compile the rule code in the production vm sandbox
+    // 3. Call evaluate() with system-path and normal-path inputs
+    // 4. Verify the rule blocks system paths and allows normal paths
     const ruleHost = new RuleHost(
       path.join(tmpDir, '.state'),
       { warn: () => {} },
@@ -431,7 +470,6 @@ describe('Cross-Package Acceptance Test (PRI-408 P1/P2 fixes) — unsplippable c
     expect(ruleHost.evaluate(makeRuleHostInput('/project/src/main.ts'))).toBeUndefined();
 
     // ── Step 8: Owner deactivates (rollback) ───────────────────────────────
-    const activationId = activationRecord!.activationId;
     const deactivateResult = await stateStore.deactivateActivation(activationId, new Date().toISOString());
     expect(deactivateResult).toBe(true);
 
@@ -461,10 +499,14 @@ describe('Cross-Package Acceptance Test (PRI-408 P1/P2 fixes) — unsplippable c
     expect(deactivatedRecord).toBeDefined();
     expect(deactivatedRecord!.deactivatedAt).not.toBeNull();
 
-    // ── Step 10: Verify the activation status record reflects deactivation ─
+    // ── Step 10: Verify getActivationStatus reflects deactivation (Bug-Q) ─
+    // Bug-Q fix: getActivationStatus now filters out deactivated records
+    // (WHERE deactivated_at IS NULL), returning null when no active activation
+    // exists. This allows re-activation after deactivation. The deactivated
+    // record itself is already verified via listCodeToolHookActivations(true)
+    // above (L459-462, Step 9). Here we verify the new null semantics.
     const activationAfterDeactivate = await stateStore.getActivationStatus(idempotencyKey);
-    expect(activationAfterDeactivate).not.toBeNull();
-    expect(activationAfterDeactivate!.deactivatedAt).not.toBeNull();
+    expect(activationAfterDeactivate).toBeNull();
 
     await sm2.close();
   }, 60_000);

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

@@ -401,11 +401,14 @@ describe('assembleMainlineSnapshot', () => {
     await sm.updateCandidateStatus(candidate!.candidateId, { status: 'consumed' });
 
     // Insert a row with empty candidate_id to exercise the malformed-row path.
+    // F13 (PRI-442): include consumed_at so the row satisfies the schema
+    // CHECK constraint (status='consumed' → consumed_at IS NOT NULL). The
+    // malformation under test is the empty candidate_id, not the timestamp.
     const db = sm.connection.getDb();
     db.prepare(
-      `INSERT INTO principle_candidates (candidate_id, task_id, artifact_id, source_run_id, title, description, idempotency_key, status, created_at, recommendation_kind)
-       VALUES ('', ?, ?, ?, 'malformed', '', ?, 'consumed', ?, 'principle')`,
-    ).run(taskId, candidate!.artifactId, candidate!.sourceRunId, `idemp-${Date.now()}`, new Date().toISOString());
+      `INSERT INTO principle_candidates (candidate_id, task_id, artifact_id, source_run_id, title, description, idempotency_key, status, created_at, consumed_at, recommendation_kind)
+       VALUES ('', ?, ?, ?, 'malformed', '', ?, 'consumed', ?, ?, 'principle')`,
+    ).run(taskId, candidate!.artifactId, candidate!.sourceRunId, `idemp-${Date.now()}`, new Date().toISOString(), new Date().toISOString());
 
     const { snapshot, warnings } = await assembleMainlineSnapshot({ workspaceDir, painId, readiness: healthyReadiness() });
 

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

@@ -266,6 +266,8 @@ describe('resolveRuntimeFromPdConfig', () => {
     const tmp = mkTmpDir();
     try {
       const result = resolveRuntimeFromPdConfig(tmp);
+      // Default profile is openclaw.default (MVP default runtime) → resolves
+      // successfully without env var.
       expect(isRuntimeConfigError(result.result)).toBe(false);
       expect(result.configSource).toBe('.pd/config.yaml');
       expect(result.runtimeProfileId).toBe('openclaw.default');

package/tests/services/rulehost-pipeline-runner.test.ts

@@ -137,7 +137,7 @@ function artificerV2(taskId: string, priorId?: string): unknown {
   return {
     taskId, sourceScribeArtifactId: requireLineage(priorId, 'sourceScribeArtifactId'),
     implementationPlan: { summary: 'Block /etc writes', targetSurface: 'rule-host', changes: ['matcher'], tests: ['unit'], rolloutNotes: ['shadow'], confidence: 0.85 },
-    implementationCode: 'function evaluate(input, helpers) { const p = String(input?.action?.paramsSummary?.path ?? input?.action?.normalizedPath ?? ""); return p.startsWith("/etc") ? { decision: "block", matched: true, reason: "system path" } : { decision: "allow", matched: false, reason: "ok" }; }',
+    implementationCode: 'function evaluate(input, helpers) { const p = String(input?.action?.paramsSummary?.path ?? input?.action?.normalizedPath ?? ""); if (p.startsWith("/etc")) return { decision: "block", matched: true, reason: "system path" }; const ctx = input?.context; if (ctx && ctx.facts && ctx.facts.priorReadOfTarget === "no") { return { decision: "block", matched: true, reason: "no prior read" }; } return { decision: "allow", matched: false, reason: "ok" }; }',
     implementationSummary: 'Block system path writes',
     goldenTraceCases: [
       { caseId: 'pos-1', kind: 'positive', toolName: 'write_file', params: { path: '/project/f.txt' }, expectedDecision: 'allow' },

package/vitest.config.ts

@@ -3,7 +3,7 @@ import { defineConfig } from 'vitest/config';
 export default defineConfig({
   test: {
     environment: 'node',
-    include: ['tests/**/*.test.ts', 'src/**/*.test.ts'],
+    include: ['tests/bdd/**/*.{test,steps}.ts', 'tests/**/*.test.ts', 'src/**/*.test.ts'],
     exclude: ['**/node_modules/**', '**/dist/**'],
   },
 });