@principles/pd-cli 1.151.1 → 1.152.1

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

@@ -328,7 +328,9 @@ describe('planConsoleLaunch — reused (healthy console on preferred port)', ()
       expect(result.reason).toBe('console_authentication_mode_mismatch');
       // PRI-695: the guidance names the actual running state and both ways
       // out — it no longer references "Companion" (meaningless to CLI users)
-      // or PD_CONSOLE_TOKEN (never set by the default install).
+      // or PD_CONSOLE_TOKEN (never set by the default install). PRI-784: the
+      // no-source form stays source-neutral; the env/flag variants have
+      // their own cases below.
       expect(result.nextAction).toContain('without authentication');
       expect(result.nextAction).toContain(`port ${addr.port}`);
       expect(result.nextAction).not.toContain('Companion');
@@ -338,6 +340,56 @@ describe('planConsoleLaunch — reused (healthy console on preferred port)', ()
     }
   });
 
+  it('auth-mismatch guidance names PD_CONSOLE_TOKEN and its durable removal when the token came from the env (PRI-784)', async () => {
+    const server = http.createServer((_req, res) => {
+      res.statusCode = 200;
+      res.end(JSON.stringify({ success: true, data: { authenticationMode: 'no_auth' } }));
+    });
+    await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const addr = server.address();
+    if (typeof addr !== 'object' || !addr) throw new Error('no addr');
+    try {
+      const result = await planConsoleLaunch({
+        workspaceDir: '/tmp/anywhere', preferredPort: addr.port,
+        host: '127.0.0.1', token: 'configured-token', tokenSource: 'env',
+      });
+      expect(result.status).toBe('refused');
+      expect(result.reason).toBe('console_authentication_mode_mismatch');
+      // The env source is the recurring real-world trap: a persistently set
+      // variable makes "reopen without a token" impossible to follow, so the
+      // guidance must name the variable and how to remove it at its source.
+      expect(result.nextAction).toContain('PD_CONSOLE_TOKEN');
+      expect(result.nextAction).toContain("SetEnvironmentVariable('PD_CONSOLE_TOKEN', $null, 'User')");
+      expect(result.nextAction).toContain('--no-auth');
+      expect(result.nextAction).toContain('--token');
+    } finally {
+      await new Promise<void>((resolve) => server.close(resolve));
+    }
+  });
+
+  it('auth-mismatch guidance names --token, never the env var, when the token came from the flag (PRI-784)', async () => {
+    const server = http.createServer((_req, res) => {
+      res.statusCode = 200;
+      res.end(JSON.stringify({ success: true, data: { authenticationMode: 'no_auth' } }));
+    });
+    await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const addr = server.address();
+    if (typeof addr !== 'object' || !addr) throw new Error('no addr');
+    try {
+      const result = await planConsoleLaunch({
+        workspaceDir: '/tmp/anywhere', preferredPort: addr.port,
+        host: '127.0.0.1', token: 'configured-token', tokenSource: 'flag',
+      });
+      expect(result.status).toBe('refused');
+      expect(result.reason).toBe('console_authentication_mode_mismatch');
+      expect(result.nextAction).toContain('--token');
+      expect(result.nextAction).toContain('--no-auth');
+      expect(result.nextAction).not.toContain('PD_CONSOLE_TOKEN');
+    } finally {
+      await new Promise<void>((resolve) => server.close(resolve));
+    }
+  });
+
   it('reuses a no-auth Console for a tokenless caller (PRI-695 default post-install state)', async () => {
     // The installer auto-launches the Console with --no-auth; the documented
     // reopen command carries no flags and no token. That combination must
@@ -724,6 +776,12 @@ describe('CLI command wiring (pd console open)', () => {
       expect(run.parsed.status).toBe('refused');
       expect(run.parsed.reason).toBe('console_authentication_mode_mismatch');
       expect(run.parsed).not.toHaveProperty('serverPid');
+      // PRI-784 review fix (PR #1670): the fresh-start env guidance is part of
+      // the user contract — assert its content, not just the refusal shell.
+      expect(run.parsed.nextAction).toContain('PD_CONSOLE_TOKEN');
+      expect(run.parsed.nextAction).toContain('not forwarded');
+      expect(run.parsed.nextAction).toContain('--token "$PD_CONSOLE_TOKEN"');
+      expect(run.parsed.nextAction).toContain('--no-auth');
       await new Promise((resolve) => setTimeout(resolve, 100));
       expect(await isPortInUse('127.0.0.1', 49391)).toBe(false);
     } finally {

package/tests/commands/run-rulehost-handler.test.ts

@@ -573,6 +573,37 @@ function writeContextV2EnabledConfig(workspaceDir: string): void {
   fs.writeFileSync(path.join(configDir, 'config.yaml'), yaml.dump(cfg), 'utf8');
 }
 
+function writeContextV2KillSwitchConfig(workspaceDir: string): void {
+  const configDir = path.join(workspaceDir, '.pd');
+  fs.mkdirSync(configDir, { recursive: true });
+  const cfg = {
+    version: 1,
+    features: {
+      prompt: { category: 'core', enabled: true },
+      code_tool_hook: { category: 'core', enabled: true },
+      defer_archive: { category: 'core', enabled: true },
+      code_rule_capability: { category: 'core', enabled: true },
+      // PRI-780: explicit kill switch (the flag itself defaults ON).
+      rulecode_context_v2: { category: 'quiet', enabled: false },
+    },
+    workspace: { default: workspaceDir },
+    runtimeProfiles: {
+      'pi-ai.default': { type: 'pi-ai', provider: 'anthropic', model: 'claude-sonnet', apiKeyEnv: 'ANTHROPIC_API_KEY' },
+    },
+    internalAgents: {
+      defaultRuntime: 'pi-ai.default',
+      agents: {
+        dreamer: { enabled: true, runtimeProfile: 'pi-ai.default' },
+        philosopher: { enabled: true, runtimeProfile: 'pi-ai.default' },
+        scribe: { enabled: true, runtimeProfile: 'pi-ai.default' },
+        artificer: { enabled: true, runtimeProfile: 'pi-ai.default' },
+        evaluator: { enabled: true, runtimeProfile: 'pi-ai.default' },
+      },
+    },
+  };
+  fs.writeFileSync(path.join(configDir, 'config.yaml'), yaml.dump(cfg), 'utf8');
+}
+
 describe('handleRunRuleHost — PR #1122 behavior-examples fail-fast (CodeRabbit Comment 1+2)', () => {
   let workspaceDir: string;
   let savedEnv: NodeJS.ProcessEnv;
@@ -648,8 +679,9 @@ describe('handleRunRuleHost — PR #1122 behavior-examples fail-fast (CodeRabbit
   it('text dry-run output uses v2-aware capabilityStatus when --behavior-examples is missing (CodeRabbit Comment 2)', async () => {
     // With contextV2Enabled=true and no --behavior-examples, the handler sets
     // behaviorExamplesReason='behavior_examples_missing'. The text dry-run
-    // branch must surface this reason in capabilityStatus (matching the JSON
-    // branch), not the stale resolvedRuntime.capabilityStatus.
+    // branch must derive capabilityStatus from the EFFECTIVE capability
+    // (PRI-780 review M2), surfacing the reason — not the stale
+    // resolvedRuntime.capabilityStatus ("ON").
     writeContextV2EnabledConfig(workspaceDir);
     const { stdout } = await captureStdio(() =>
       handleRunRuleHost({
@@ -658,6 +690,24 @@ describe('handleRunRuleHost — PR #1122 behavior-examples fail-fast (CodeRabbit
         workspace: workspaceDir,
       }),
     );
-    expect(stdout).toMatch(/code_rule_capability: OFF \(behavior_examples_missing\)/);
+    expect(stdout).toMatch(/code_rule_capability: OFF \(behavior_examples_missing;/);
+    expect(stdout).not.toMatch(/code_rule_capability: ON/);
+  });
+
+  it('PRI-780 M2: kill-switch dry-run reports OFF with the kill-switch reason, never ON', async () => {
+    writeContextV2KillSwitchConfig(workspaceDir);
+    const { stdout } = await captureStdio(() =>
+      handleRunRuleHost({
+        painId: 'pain-1',
+        dryRun: true,
+        workspace: workspaceDir,
+      }),
+    );
+    expect(stdout).toMatch(/code_rule_capability: OFF \(rulecode_context_v2_disabled/);
+    expect(stdout).not.toMatch(/code_rule_capability: ON/);
+    // Codex review round 2 P2: the plain-text "Next" line must derive from the
+    // EFFECTIVE capability too — confirmation cannot run the code-rule pipeline.
+    expect(stdout).not.toMatch(/Next: pass --confirm to actually run the pipeline/);
+    expect(stdout).toMatch(/Next: fix the code-rule capability issue above/);
   });
 });

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

@@ -657,7 +657,9 @@ describe('handleRuntimeActivationList', () => {
       },
     ]);
     // Default mockFeatureFlags has rulecode_context_v2 enabled. Flip it off
-    // to simulate the production default (the flag is quiet/default-off).
+    // to simulate the migration-period kill switch (explicit
+    // features.rulecode_context_v2.enabled: false; the registry default is ON
+    // since PRI-780).
     mockFeatureFlags.flags.rulecode_context_v2.enabled = false;
 
     await handleRuntimeActivationList({

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

@@ -171,15 +171,32 @@ function scribeOut(taskId: string, priorId?: string): unknown {
   };
 }
 
+// PRI-780: v2-only generation — the acceptance chain carries an Owner-labelled
+// pack whose cases match artificerV2's goldenTraceCases (parity is checked).
+const XPKG_RULE_CONTEXT = {
+  version: 2 as const,
+  history: { status: 'available' as const, truncated: false, calls: [] },
+  facts: { priorReadOfTarget: 'unknown' as const, readCount: 0, writeCount: 0, uniqueWritePathCount: 0, sameActionBlockCount: null },
+};
+const XPKG_TEST_PACK = {
+  sourceNegativeCase: { caseId: 'neg-1', kind: 'negative' as const, toolName: 'write_file', params: { path: '/etc/passwd' }, expectedDecision: 'block' as const, ruleContext: XPKG_RULE_CONTEXT },
+  ownerDesiredOutcome: 'block system path writes',
+  positiveCounterexamples: [{ caseId: 'pos-1', kind: 'positive' as const, toolName: 'write_file', params: { path: '/project/f.txt' }, expectedDecision: 'allow' as const, ruleContext: XPKG_RULE_CONTEXT }],
+  evidenceRefs: ['pain://xpkg-1'],
+  redactionNotes: [],
+};
+
 function artificerV2(taskId: string, priorId?: string): unknown {
   return {
     taskId, sourceScribeArtifactId: requireLineage(priorId, 'sourceScribeArtifactId'),
+    requiresContextVersion: 2,
+    evidenceRefs: ['pain://xpkg-1'],
     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 ?? ""); 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' },
-      { caseId: 'neg-1', kind: 'negative', toolName: 'write_file', params: { path: '/etc/passwd' }, expectedDecision: 'block' },
+      { caseId: 'pos-1', kind: 'positive', toolName: 'write_file', params: { path: '/project/f.txt' }, expectedDecision: 'allow', ruleContext: XPKG_RULE_CONTEXT },
+      { caseId: 'neg-1', kind: 'negative', toolName: 'write_file', params: { path: '/etc/passwd' }, expectedDecision: 'block', ruleContext: XPKG_RULE_CONTEXT },
     ],
     affectedTools: ['write_file'],
     sourceTrace: { scribeArtifactId: requireLineage(priorId, 'sourceTrace.scribeArtifactId') },
@@ -267,6 +284,7 @@ describe('Cross-Package Acceptance Test (PRI-408 P1/P2 fixes) — unsplippable c
       pollIntervalMs: 5,
       timeoutMs: 5000,
       codeRuleCapability: capability,
+      behaviorExamplePack: XPKG_TEST_PACK,
       onStoreReady: (store) => { adapter.artifactStore = store; },
     });
 
@@ -377,7 +395,9 @@ describe('Cross-Package Acceptance Test (PRI-408 P1/P2 fixes) — unsplippable c
       {
         writers: [
           new PromptWriter(),
-          new RuleHostWriter({ gateDeps: createProductionGateDeps() }),
+          // PRI-780: rulecode_context_v2 defaults ON — production callers
+          // inject the real flag probe; mirror that here for the v2 artifact.
+          new RuleHostWriter({ gateDeps: createProductionGateDeps(), featureFlagProbe: (flagId) => flagId === 'rulecode_context_v2' }),
           new DeferArchiveWriter(),
         ],
         approvalQueueStore: approvalStore,
@@ -426,12 +446,15 @@ describe('Cross-Package Acceptance Test (PRI-408 P1/P2 fixes) — unsplippable c
     // 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.
+    // PRI-780: production RuleHostInput always carries context (flag on) —
+    // the v2 activation only loads when context.version === 2.
     const makeRuleHostInput = (targetPath: string): RuleHostInput => ({
       action: { toolName: 'write_file', normalizedPath: targetPath, paramsSummary: { path: targetPath } },
       workspace: { isRiskPath: targetPath.startsWith('/etc') },
       session: { currentGfi: 0 },
       evolution: { epTier: 0 },
       derived: { estimatedLineChanges: 1, bashRisk: 'safe' },
+      context: XPKG_RULE_CONTEXT,
     });
     const shadowRuleHost = new RuleHost(
       path.join(tmpDir, '.state'),

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

@@ -168,6 +168,15 @@ describe('runRuleHost production-wiring (PRI-429) — deterministic, no LLM', ()
     const dir = mkTmpDir();
     tmpDirs.push(dir);
     writeConfig(dir, configFactory(dir));
+    // PRI-780: v2-only generation — every dry-run in this suite carries a
+    // valid Owner-labelled behavior-examples file so the capability assertions
+    // isolate their intended variable (agent/flag/key state), not the
+    // behavior_examples_missing refusal.
+    fs.writeFileSync(
+      path.join(dir, 'behavior-examples.json'),
+      JSON.stringify({ ownerDesiredOutcome: 'block system path writes', sourceNegativeToolCallId: 1, positiveToolCallIds: [2] }),
+      'utf8',
+    );
     return dir;
   }
 
@@ -188,6 +197,7 @@ describe('runRuleHost production-wiring (PRI-429) — deterministic, no LLM', ()
     await handleRunRuleHost({
       workspace,
       painId: 'pain-wiring-001',
+      behaviorExamples: 'behavior-examples.json',
       dryRun: true,
       json: true,
     });
@@ -212,7 +222,7 @@ describe('runRuleHost production-wiring (PRI-429) — deterministic, no LLM', ()
       return config;
     });
 
-    await handleRunRuleHost({ workspace, painId: 'pain-flag-default', dryRun: true, json: true });
+    await handleRunRuleHost({ workspace, painId: 'pain-flag-default', behaviorExamples: 'behavior-examples.json', dryRun: true, json: true });
 
     const output = parseJsonOutput();
     const codeRuleCapability = requireRecord(output.codeRuleCapability, 'codeRuleCapability');
@@ -235,7 +245,7 @@ describe('runRuleHost production-wiring (PRI-429) — deterministic, no LLM', ()
       return config;
     });
 
-    await handleRunRuleHost({ workspace, painId: 'pain-emergency-disable', dryRun: true, json: true });
+    await handleRunRuleHost({ workspace, painId: 'pain-emergency-disable', behaviorExamples: 'behavior-examples.json', dryRun: true, json: true });
 
     const output = parseJsonOutput();
     const codeRuleCapability = requireRecord(output.codeRuleCapability, 'codeRuleCapability');
@@ -316,6 +326,7 @@ describe('runRuleHost production-wiring (PRI-429) — deterministic, no LLM', ()
     await handleRunRuleHost({
       workspace,
       painId: 'pain-wiring-002',
+      behaviorExamples: 'behavior-examples.json',
       dryRun: true,
       json: true,
     });
@@ -336,6 +347,7 @@ describe('runRuleHost production-wiring (PRI-429) — deterministic, no LLM', ()
     await handleRunRuleHost({
       workspace,
       painId: 'pain-wiring-003',
+      behaviorExamples: 'behavior-examples.json',
       dryRun: true,
       json: true,
     });
@@ -397,10 +409,16 @@ describe('runRuleHost production-wiring (PRI-429) — deterministic, no LLM', ()
         },
       },
     });
+    fs.writeFileSync(
+      path.join(dir, 'behavior-examples.json'),
+      JSON.stringify({ ownerDesiredOutcome: 'block system path writes', sourceNegativeToolCallId: 1, positiveToolCallIds: [2] }),
+      'utf8',
+    );
 
     await handleRunRuleHost({
       workspace: dir,
       painId: 'pain-wiring-004',
+      behaviorExamples: 'behavior-examples.json',
       dryRun: true,
       json: true,
     });

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

@@ -134,16 +134,33 @@ function scribeOut(taskId: string, priorId?: string): unknown {
   };
 }
 
+// PRI-780: v2-only generation — the pipeline requires an Owner-labelled pack
+// and the artificer output must satisfy the v2 contract (case parity incl.
+// ruleContext + verbatim evidenceRefs).
+const PIPE_RULE_CONTEXT = {
+  version: 2 as const,
+  history: { status: 'available' as const, truncated: false, calls: [] },
+  facts: { priorReadOfTarget: 'unknown' as const, readCount: 0, writeCount: 0, uniqueWritePathCount: 0, sameActionBlockCount: null },
+};
+const PIPE_POS_CASE = { caseId: 'pos-1', kind: 'positive' as const, toolName: 'write_file', params: { path: '/project/f.txt' }, expectedDecision: 'allow' as const, ruleContext: PIPE_RULE_CONTEXT };
+const PIPE_NEG_CASE = { caseId: 'neg-1', kind: 'negative' as const, toolName: 'write_file', params: { path: '/etc/passwd' }, expectedDecision: 'block' as const, ruleContext: PIPE_RULE_CONTEXT };
+const PIPE_PACK = {
+  sourceNegativeCase: PIPE_NEG_CASE,
+  ownerDesiredOutcome: 'block system path writes',
+  positiveCounterexamples: [PIPE_POS_CASE],
+  evidenceRefs: ['pain://pipe-1'],
+  redactionNotes: [],
+};
+
 function artificerV2(taskId: string, priorId?: string): unknown {
   return {
     taskId, sourceScribeArtifactId: requireLineage(priorId, 'sourceScribeArtifactId'),
+    requiresContextVersion: 2,
+    evidenceRefs: ['pain://pipe-1'],
     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 ?? ""); 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' },
-      { caseId: 'neg-1', kind: 'negative', toolName: 'write_file', params: { path: '/etc/passwd' }, expectedDecision: 'block' },
-    ],
+    goldenTraceCases: [PIPE_POS_CASE, PIPE_NEG_CASE],
     affectedTools: ['write_file'],
     sourceTrace: { scribeArtifactId: requireLineage(priorId, 'sourceTrace.scribeArtifactId') },
     risks: [], generatedAt: new Date().toISOString(),
@@ -266,6 +283,7 @@ describe('runRuleHostPipeline (PRI-429) — atomic capability + exact pain match
       workspaceDir: tmpDir, painId: 'pain-test-001', runtimeAdapter: adapter,
       channel: 'code_tool_hook', pollIntervalMs: 5, timeoutMs: 1000,
       codeRuleCapability: capability,
+      behaviorExamplePack: PIPE_PACK,
       onStoreReady: (store) => { adapter.artifactStore = store; },
     });
 
@@ -320,6 +338,7 @@ describe('runRuleHostPipeline (PRI-429) — atomic capability + exact pain match
       painId: 'pain-feedback-001',
       runtimeAdapter: adapter,
       codeRuleCapability: { enabled: true, artificerAdapter: adapter },
+      behaviorExamplePack: PIPE_PACK,
       channel: 'code_tool_hook',
       pollIntervalMs: 5,
       timeoutMs: 1000,
@@ -349,6 +368,7 @@ describe('runRuleHostPipeline (PRI-429) — atomic capability + exact pain match
       workspaceDir: tmpDir, painId: 'pain-test-001', runtimeAdapter: adapter,
       channel: 'code_tool_hook', pollIntervalMs: 5, timeoutMs: 1000,
       codeRuleCapability: capability,
+      behaviorExamplePack: PIPE_PACK,
       onStoreReady: (store) => { adapter.artifactStore = store; },
     });
 
@@ -376,6 +396,7 @@ describe('runRuleHostPipeline (PRI-429) — atomic capability + exact pain match
       workspaceDir: tmpDir, painId: 'pain-test-001', runtimeAdapter: adapter,
       channel: 'code_tool_hook', pollIntervalMs: 5, timeoutMs: 1000,
       codeRuleCapability: capability,
+      behaviorExamplePack: PIPE_PACK,
       onStoreReady: (store) => { adapter.artifactStore = store; },
     });
 
@@ -595,6 +616,7 @@ describe('runRuleHostPipeline (PRI-429) — atomic capability + exact pain match
       channel: 'code_tool_hook', pollIntervalMs: 5, timeoutMs: 1000,
       maxStageRetries: 2,
       codeRuleCapability: capability,
+      behaviorExamplePack: PIPE_PACK,
       onStoreReady: (store) => { adapter.artifactStore = store; },
     });
 
@@ -725,6 +747,7 @@ describe('runRuleHostPipeline — outputLanguage reaches adapter.startRun messag
       workspaceDir: tmpDir, painId: 'pain-lang-en', runtimeAdapter: adapter,
       channel: 'code_tool_hook', pollIntervalMs: 5, timeoutMs: 1000,
       codeRuleCapability: { enabled: true, artificerAdapter: adapter },
+      behaviorExamplePack: PIPE_PACK,
       onStoreReady: (store) => { adapter.artifactStore = store; },
     });
     expect(result.decision, JSON.stringify(result)).toBe('candidate_ready_for_owner_review');
@@ -771,6 +794,7 @@ describe('runRuleHostPipeline — outputLanguage reaches adapter.startRun messag
       workspaceDir: tmpDir, painId: 'pain-lang-zh', runtimeAdapter: adapter,
       channel: 'code_tool_hook', pollIntervalMs: 5, timeoutMs: 1000,
       codeRuleCapability: { enabled: true, artificerAdapter: adapter },
+      behaviorExamplePack: PIPE_PACK,
       onStoreReady: (store) => { adapter.artifactStore = store; },
     });
     expect(result.decision, JSON.stringify(result)).toBe('candidate_ready_for_owner_review');