@principles/pd-cli 1.133.0 → 1.134.0

package/src/commands/__tests__/intent-flag-wiring.test.ts

@@ -8,7 +8,7 @@
 
 import { describe, it, expect } from 'vitest';
 import { Command } from 'commander';
-import { registerIntentCommand } from '../intent.js';
+import { registerIntentCommand, parseLang } from '../intent.js';
 
 type ActionOptions = Record<string, unknown>;
 interface CapturedAction {
@@ -54,7 +54,7 @@ describe('pd intent — command registration', () => {
 });
 
 describe('pd intent init — option metadata', () => {
-  it('has --workspace (-w), --force, --dry-run, --confirm, and --json options', () => {
+  it('has --workspace (-w), --force, --dry-run, --confirm, --lang, and --json options', () => {
     const program = freshProgram();
     registerIntentCommand(program);
     const intentCmd = requireCmd(program.commands.find((c) => c.name() === 'intent'), 'intent');
@@ -65,6 +65,7 @@ describe('pd intent init — option metadata', () => {
     expect(initCmd.options.find((o) => o.long === '--force')).toBeDefined();
     expect(initCmd.options.find((o) => o.long === '--dry-run')).toBeDefined();
     expect(initCmd.options.find((o) => o.long === '--confirm')).toBeDefined();
+    expect(initCmd.options.find((o) => o.long === '--lang')).toBeDefined();
     expect(initCmd.options.find((o) => o.long === '--json')).toBeDefined();
   });
 
@@ -82,7 +83,7 @@ describe('pd intent init — option metadata', () => {
 });
 
 describe('pd intent show — option metadata', () => {
-  it('has --workspace (-w) and --json options, no --force', () => {
+  it('has --workspace (-w), --lang, and --json options, no --force', () => {
     const program = freshProgram();
     registerIntentCommand(program);
     const intentCmd = requireCmd(program.commands.find((c) => c.name() === 'intent'), 'intent');
@@ -90,6 +91,7 @@ describe('pd intent show — option metadata', () => {
 
     expect(showCmd.options.find((o) => o.long === '--workspace')).toBeDefined();
     expect(showCmd.options.find((o) => o.long === '--workspace')?.short).toBe('-w');
+    expect(showCmd.options.find((o) => o.long === '--lang')).toBeDefined();
     expect(showCmd.options.find((o) => o.long === '--json')).toBeDefined();
     expect(showCmd.options.find((o) => o.long === '--force')).toBeUndefined();
   });
@@ -195,3 +197,86 @@ describe('pd intent show — parser-level dispatch', () => {
     expect(captured.opts?.workspace).toBe('/tmp/ws');
   });
 });
+
+describe('pd intent --lang — parser-level dispatch (cli-7)', () => {
+  it('init: parses --lang zh-CN', async () => {
+    const program = freshProgram();
+    const intentCmd = registerIntentCommand(program);
+    const initCmd = requireCmd(intentCmd.commands.find((c) => c.name() === 'init'), 'init');
+    const captured: CapturedAction = { opts: null };
+    attachCapture(initCmd, captured);
+
+    await program.parseAsync(['node', 'pd', 'intent', 'init', '--lang', 'zh-CN']);
+    expect(captured.opts).not.toBeNull();
+    expect(captured.opts?.lang).toBe('zh-CN');
+  });
+
+  it('init: parses --lang en', async () => {
+    const program = freshProgram();
+    const intentCmd = registerIntentCommand(program);
+    const initCmd = requireCmd(intentCmd.commands.find((c) => c.name() === 'init'), 'init');
+    const captured: CapturedAction = { opts: null };
+    attachCapture(initCmd, captured);
+
+    await program.parseAsync(['node', 'pd', 'intent', 'init', '--lang', 'en']);
+    expect(captured.opts).not.toBeNull();
+    expect(captured.opts?.lang).toBe('en');
+  });
+
+  it('init: lang defaults to undefined when not passed', async () => {
+    const program = freshProgram();
+    const intentCmd = registerIntentCommand(program);
+    const initCmd = requireCmd(intentCmd.commands.find((c) => c.name() === 'init'), 'init');
+    const captured: CapturedAction = { opts: null };
+    attachCapture(initCmd, captured);
+
+    await program.parseAsync(['node', 'pd', 'intent', 'init']);
+    expect(captured.opts).not.toBeNull();
+    expect(captured.opts?.lang).toBeUndefined();
+  });
+
+  it('show: parses --lang en', async () => {
+    const program = freshProgram();
+    const intentCmd = registerIntentCommand(program);
+    const showCmd = requireCmd(intentCmd.commands.find((c) => c.name() === 'show'), 'show');
+    const captured: CapturedAction = { opts: null };
+    attachCapture(showCmd, captured);
+
+    await program.parseAsync(['node', 'pd', 'intent', 'show', '--lang', 'en']);
+    expect(captured.opts).not.toBeNull();
+    expect(captured.opts?.lang).toBe('en');
+  });
+
+  it('show: lang defaults to undefined when not passed', async () => {
+    const program = freshProgram();
+    const intentCmd = registerIntentCommand(program);
+    const showCmd = requireCmd(intentCmd.commands.find((c) => c.name() === 'show'), 'show');
+    const captured: CapturedAction = { opts: null };
+    attachCapture(showCmd, captured);
+
+    await program.parseAsync(['node', 'pd', 'intent', 'show']);
+    expect(captured.opts).not.toBeNull();
+    expect(captured.opts?.lang).toBeUndefined();
+  });
+});
+
+describe('parseLang — invalid value rejection (rc-9)', () => {
+  it('returns zh-CN when value is undefined (default)', () => {
+    expect(parseLang(undefined)).toBe('zh-CN');
+  });
+
+  it('returns zh-CN when value is zh-CN', () => {
+    expect(parseLang('zh-CN')).toBe('zh-CN');
+  });
+
+  it('returns en when value is en', () => {
+    expect(parseLang('en')).toBe('en');
+  });
+
+  it('returns null for invalid value (no silent fallback)', () => {
+    expect(parseLang('fr')).toBeNull();
+    expect(parseLang('zh')).toBeNull();
+    expect(parseLang('english')).toBeNull();
+    expect(parseLang('')).toBeNull();
+  });
+});

package/src/commands/__tests__/pain-retry-maxTokens-flag.test.ts

@@ -0,0 +1,73 @@
+/**
+ * CLI flag-wiring tests for `pd pain retry --maxTokens` (PRI-509 follow-up).
+ *
+ * Covers:
+ *   - `--maxTokens <n>` parses to a number and is passed to the handler
+ *   - `--maxTokens` falls back to undefined when the flag is omitted
+ *
+ * Mirrors the flag-wiring test pattern from run-rulehost-flag-wiring.test.ts.
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { Command } from 'commander';
+import { registerPainRetryCommand } from '../pain-retry.js';
+
+function freshProgram(): Command {
+  return new Command();
+}
+
+function attachCapture(cmd: Command, captured: { opts: Record<string, unknown> | null }) {
+  const origAction = cmd.action.bind(cmd);
+  cmd.action = ((handler: (opts: Record<string, unknown>) => void) => {
+    return origAction((opts: Record<string, unknown>) => {
+      captured.opts = opts;
+      return handler(opts);
+    });
+  }) as typeof cmd.action;
+}
+
+function register(painCmd: Command, captured: { opts: Record<string, unknown> | null }) {
+  const cmd = registerPainRetryCommand(painCmd, async (opts) => {
+    captured.opts = opts as unknown as Record<string, unknown>;
+  });
+  attachCapture(cmd, captured);
+}
+
+describe('pd pain retry --maxTokens flag wiring', () => {
+  let captured: { opts: Record<string, unknown> | null };
+
+  beforeEach(() => {
+    captured = { opts: null };
+  });
+
+  it('parses --maxTokens to a number and passes it to the handler', async () => {
+    const program = freshProgram();
+    const painCmd = program.command('pain');
+    register(painCmd, captured);
+
+    await program.parseAsync(['node', 'pd', 'pain', 'retry', '--pain-id', 'pain-1', '--runtime', 'pi-ai', '--maxTokens', '16000']);
+
+    expect(captured.opts).not.toBeNull();
+    expect(captured.opts?.maxTokens).toBe(16000);
+    expect(typeof captured.opts?.maxTokens).toBe('number');
+  });
+
+  it('parses --maxTokens with a numeric string (parseInt path)', async () => {
+    const program = freshProgram();
+    const painCmd = program.command('pain');
+    register(painCmd, captured);
+
+    await program.parseAsync(['node', 'pd', 'pain', 'retry', '--pain-id', 'pain-1', '--runtime', 'pi-ai', '--maxTokens', '32000']);
+
+    expect(captured.opts?.maxTokens).toBe(32000);
+  });
+
+  it('keeps maxTokens undefined when flag is omitted (falls back to config)', async () => {
+    const program = freshProgram();
+    const painCmd = program.command('pain');
+    register(painCmd, captured);
+
+    await program.parseAsync(['node', 'pd', 'pain', 'retry', '--pain-id', 'pain-1', '--runtime', 'pi-ai']);
+
+    expect(captured.opts?.maxTokens).toBeUndefined();
+  });
+});

package/src/commands/__tests__/rulecode-flag-wiring.test.ts

@@ -52,6 +52,13 @@ function freshProgram(): Command {
   return program;
 }
 
+/** Find a subcommand by name, throwing if absent (replaces non-null assertions). */
+function requireSubcommand(parent: Command, name: string): Command {
+  const cmd = parent.commands.find((c) => c.name() === name);
+  if (!cmd) throw new Error(`Expected subcommand "${name}" to be registered`);
+  return cmd;
+}
+
 describe('pd rulecode — flag wiring (CLI gate rule 7)', () => {
   // ── spec subcommand ───────────────────────────────────────────────────────
 
@@ -62,10 +69,10 @@ describe('pd rulecode — flag wiring (CLI gate rule 7)', () => {
     const specCmd = rulecodeCmd.commands.find((c) => c.name() === 'spec');
     expect(specCmd).toBeDefined();
 
-    const jsonOpt = specCmd!.options.find((o) => o.long === '--json');
+    const jsonOpt = (specCmd as Command).options.find((o) => o.long === '--json');
     expect(jsonOpt).toBeDefined();
 
-    const wsOpt = specCmd!.options.find((o) => o.long === '--workspace');
+    const wsOpt = (specCmd as Command).options.find((o) => o.long === '--workspace');
     expect(wsOpt).toBeDefined();
     expect(wsOpt?.short).toBe('-w');
   });
@@ -75,7 +82,7 @@ describe('pd rulecode — flag wiring (CLI gate rule 7)', () => {
     const rulecodeCmd = registerRulecodeCommand(program);
 
     const specCmd = rulecodeCmd.commands.find((c) => c.name() === 'spec');
-    const codeOpt = specCmd!.options.find((o) => o.long === '--code');
+    const codeOpt = (specCmd as Command).options.find((o) => o.long === '--code');
     expect(codeOpt).toBeUndefined();
   });
 
@@ -88,16 +95,16 @@ describe('pd rulecode — flag wiring (CLI gate rule 7)', () => {
     const validateCmd = rulecodeCmd.commands.find((c) => c.name() === 'validate');
     expect(validateCmd).toBeDefined();
 
-    const codeOpt = validateCmd!.options.find((o) => o.long === '--code');
+    const codeOpt = (validateCmd as Command).options.find((o) => o.long === '--code');
     expect(codeOpt).toBeDefined();
 
-    const codeFileOpt = validateCmd!.options.find((o) => o.long === '--code-file');
+    const codeFileOpt = (validateCmd as Command).options.find((o) => o.long === '--code-file');
     expect(codeFileOpt).toBeDefined();
 
-    const jsonOpt = validateCmd!.options.find((o) => o.long === '--json');
+    const jsonOpt = (validateCmd as Command).options.find((o) => o.long === '--json');
     expect(jsonOpt).toBeDefined();
 
-    const wsOpt = validateCmd!.options.find((o) => o.long === '--workspace');
+    const wsOpt = (validateCmd as Command).options.find((o) => o.long === '--workspace');
     expect(wsOpt).toBeDefined();
     expect(wsOpt?.short).toBe('-w');
   });
@@ -105,7 +112,7 @@ describe('pd rulecode — flag wiring (CLI gate rule 7)', () => {
   it('validate --code is NOT required at parser level (can use --code-file instead)', async () => {
     const program = freshProgram();
     const rulecodeCmd = registerRulecodeCommand(program);
-    const validateCmd = rulecodeCmd.commands.find((c) => c.name() === 'validate')!;
+    const validateCmd = requireSubcommand(rulecodeCmd, 'validate');
     const captured: CapturedAction = { opts: null };
     attachCapture(validateCmd, captured);
 
@@ -113,7 +120,7 @@ describe('pd rulecode — flag wiring (CLI gate rule 7)', () => {
     await program.parseAsync(['node', 'pd', 'rulecode', 'validate', '--json']);
 
     expect(captured.opts).not.toBeNull();
-    expect(captured.opts!.code).toBeUndefined();
+    expect((captured.opts as ActionOptions).code).toBeUndefined();
   });
 
   // ── replay subcommand ─────────────────────────────────────────────────────
@@ -125,19 +132,19 @@ describe('pd rulecode — flag wiring (CLI gate rule 7)', () => {
     const replayCmd = rulecodeCmd.commands.find((c) => c.name() === 'replay');
     expect(replayCmd).toBeDefined();
 
-    const codeOpt = replayCmd!.options.find((o) => o.long === '--code');
+    const codeOpt = (replayCmd as Command).options.find((o) => o.long === '--code');
     expect(codeOpt).toBeDefined();
 
-    const codeFileOpt = replayCmd!.options.find((o) => o.long === '--code-file');
+    const codeFileOpt = (replayCmd as Command).options.find((o) => o.long === '--code-file');
     expect(codeFileOpt).toBeDefined();
 
-    const gtOpt = replayCmd!.options.find((o) => o.long === '--golden-trace');
+    const gtOpt = (replayCmd as Command).options.find((o) => o.long === '--golden-trace');
     expect(gtOpt).toBeDefined();
 
-    const jsonOpt = replayCmd!.options.find((o) => o.long === '--json');
+    const jsonOpt = (replayCmd as Command).options.find((o) => o.long === '--json');
     expect(jsonOpt).toBeDefined();
 
-    const wsOpt = replayCmd!.options.find((o) => o.long === '--workspace');
+    const wsOpt = (replayCmd as Command).options.find((o) => o.long === '--workspace');
     expect(wsOpt).toBeDefined();
     expect(wsOpt?.short).toBe('-w');
   });
@@ -147,7 +154,7 @@ describe('pd rulecode — flag wiring (CLI gate rule 7)', () => {
     const rulecodeCmd = registerRulecodeCommand(program);
 
     const replayCmd = rulecodeCmd.commands.find((c) => c.name() === 'replay');
-    const gtOpt = replayCmd!.options.find((o) => o.long === '--golden-trace');
+    const gtOpt = (replayCmd as Command).options.find((o) => o.long === '--golden-trace');
     expect(gtOpt?.required).toBe(true);
   });
 
@@ -168,20 +175,20 @@ describe('pd rulecode — flag wiring (CLI gate rule 7)', () => {
   it('parseAsync dispatches spec subcommand with json=true', async () => {
     const program = freshProgram();
     const rulecodeCmd = registerRulecodeCommand(program);
-    const specCmd = rulecodeCmd.commands.find((c) => c.name() === 'spec')!;
+    const specCmd = requireSubcommand(rulecodeCmd, 'spec');
     const captured: CapturedAction = { opts: null };
     attachCapture(specCmd, captured);
 
     await program.parseAsync(['node', 'pd', 'rulecode', 'spec', '--json']);
 
     expect(captured.opts).not.toBeNull();
-    expect(captured.opts!.json).toBe(true);
+    expect((captured.opts as ActionOptions).json).toBe(true);
   });
 
   it('parseAsync dispatches validate with --code', async () => {
     const program = freshProgram();
     const rulecodeCmd = registerRulecodeCommand(program);
-    const validateCmd = rulecodeCmd.commands.find((c) => c.name() === 'validate')!;
+    const validateCmd = requireSubcommand(rulecodeCmd, 'validate');
     const captured: CapturedAction = { opts: null };
     attachCapture(validateCmd, captured);
 
@@ -192,14 +199,14 @@ describe('pd rulecode — flag wiring (CLI gate rule 7)', () => {
     ]);
 
     expect(captured.opts).not.toBeNull();
-    expect(captured.opts!.code).toContain('function evaluate');
-    expect(captured.opts!.json).toBe(true);
+    expect((captured.opts as ActionOptions).code).toContain('function evaluate');
+    expect((captured.opts as ActionOptions).json).toBe(true);
   });
 
   it('parseAsync dispatches replay with --code and --golden-trace', async () => {
     const program = freshProgram();
     const rulecodeCmd = registerRulecodeCommand(program);
-    const replayCmd = rulecodeCmd.commands.find((c) => c.name() === 'replay')!;
+    const replayCmd = requireSubcommand(rulecodeCmd, 'replay');
     const captured: CapturedAction = { opts: null };
     attachCapture(replayCmd, captured);
 
@@ -211,9 +218,9 @@ describe('pd rulecode — flag wiring (CLI gate rule 7)', () => {
     ]);
 
     expect(captured.opts).not.toBeNull();
-    expect(captured.opts!.code).toContain('function evaluate');
-    expect(captured.opts!.goldenTrace).toBe('/tmp/trace.json');
-    expect(captured.opts!.json).toBe(true);
+    expect((captured.opts as ActionOptions).code).toContain('function evaluate');
+    expect((captured.opts as ActionOptions).goldenTrace).toBe('/tmp/trace.json');
+    expect((captured.opts as ActionOptions).json).toBe(true);
   });
 
   it('parseAsync rejects replay without --golden-trace (requiredOption)', async () => {

package/src/commands/__tests__/run-rulehost-flag-wiring.test.ts

@@ -88,6 +88,18 @@ describe('pd runtime internalization run-rulehost — flag wiring (CLI gate rule
     expect(opt?.long).toBe('--json');
   });
 
+  it('parses --behavior-examples as the Owner-labelled evidence file', async () => {
+    const program = freshProgram();
+    const intCmd = program.command('internalization');
+    const runCmd = registerRunRuleHostCommand(intCmd);
+    const captured: CapturedAction = { opts: null };
+    attachCapture(runCmd, captured);
+
+    await program.parseAsync(['node', 'pd', 'internalization', 'run-rulehost', '--pain-id', 'pain-1', '--behavior-examples', 'examples.json']);
+
+    expect(captured.opts?.behaviorExamples).toBe('examples.json');
+  });
+
   it('registers --pain-id as required option', () => {
     const program = freshProgram();
     const intCmd = program.command('internalization');

package/src/commands/admission-gate.ts

@@ -0,0 +1,30 @@
+/**
+ * Shared admission gate helper for CLI commands that call intakeService.intake().
+ *
+ * PRI-442 Stage 4 / PRI-503: previously only `candidate.ts` checked the gate;
+ * `pain-retry.ts` and `diagnose.ts` bypassed it (ERR-089 sibling-branch defect).
+ * This shared helper is the single entry point so future CLI commands that
+ * call intake() can reuse it instead of re-implementing (or skipping) the check.
+ *
+ * Runtime Contract: rc-9-no-silent-fallback — refusal includes reason + nextAction
+ * (callers MUST surface these in their structured CLI output).
+ */
+import { evaluateCandidateAdmissionFromRecord, type AdmissionGateResult } from '@principles/core/runtime-v2';
+
+/**
+ * Check admission gate for a candidate. Returns null if admitted (caller may
+ * proceed); returns AdmissionGateResult with reason + nextAction if refused
+ * (caller must refuse and surface reason/nextAction in CLI output).
+ *
+ * @param candidate - Must carry recommendationKind and confidence from the candidate record
+ */
+export function checkAdmissionGate(
+  candidate: { recommendationKind: string; confidence: number | null },
+): AdmissionGateResult | null {
+  const admission = evaluateCandidateAdmissionFromRecord({
+    recommendationKind: candidate.recommendationKind as Parameters<typeof evaluateCandidateAdmissionFromRecord>[0]['recommendationKind'],
+    confidence: candidate.confidence,
+  });
+  if (admission.decision === 'admitted') return null;
+  return admission;
+}

package/src/commands/candidate.ts

@@ -27,6 +27,7 @@ import { loadLedger, getLedgerFilePathPublic } from '@principles/core/principle-
 import { resolveWorkspaceDir } from '../resolve-workspace.js';
 import { createRemediationResult, remediationAction } from './remediation-output.js';
 import type { RemediationResult } from './remediation-output.js';
+import { checkAdmissionGate } from './admission-gate.js';
 
 // ── Interfaces ────────────────────────────────────────────────────────────────
 
@@ -353,6 +354,7 @@ export async function handleCandidateInternalize(opts: CandidateInternalizeOptio
     }
 
     const seed = buildDreamerSeedFromCandidate(candidate, { route: decision.route, ready: decision.ready, sourcePainId });
+    // eslint-disable-next-line no-restricted-syntax -- 'in' required for discriminated union narrowing (BridgeTaskSeed | BridgeDecision)
     if ('decision' in seed) {
       const decisionResult = seed as { decision: string; reason?: string; taskId?: string };
       const reason = decisionResult.decision === 'already_exists'
@@ -494,6 +496,13 @@ export async function handleCandidateShow(opts: CandidateShowOptions): Promise<v
     if (result.ledgerEntryId) {
       console.log(`  Ledger Entry: ${result.ledgerEntryId}`);
     }
+    // F10-1: surface dangling sourceRunId warning in text mode (rc-9).
+    if (result.warning) {
+      console.log(`  ⚠ WARNING:   ${result.warning}`);
+    }
+    if (result.nextAction) {
+      console.log(`  Next Action: ${result.nextAction}`);
+    }
     console.log('');
   } finally {
     await stateManager.close();
@@ -520,12 +529,37 @@ export async function handleCandidateIntake(opts: CandidateIntakeOptions): Promi
     const ledgerAdapter = new PrincipleTreeLedgerAdapter({ stateDir: path.join(workspaceDir, '.state') });
     const service = new CandidateIntakeService({ stateManager, ledgerAdapter });
 
-    if (opts.dryRun) {
-      const candidate = await stateManager.getCandidate(opts.candidateId);
-      if (!candidate) {
-        console.error(`Candidate not found: ${opts.candidateId}`);
-        process.exit(1);
+    // Fetch candidate once for admission gate check and downstream paths.
+    const candidate = await stateManager.getCandidate(opts.candidateId);
+    if (!candidate) {
+      console.error(`Candidate not found: ${opts.candidateId}`);
+      process.exit(1);
+      return;
+    }
+
+    // PRI-442 Stage 4: admission gate check — refuse non-admitted candidates
+    // to prevent CLI from bypassing the production admission gate.
+    const admissionBlock = checkAdmissionGate(candidate);
+    if (admissionBlock) {
+      const result = {
+        candidateId: opts.candidateId,
+        status: 'refused',
+        admissionDecision: admissionBlock.decision,
+        reason: admissionBlock.reason,
+        nextAction: admissionBlock.nextAction,
+      };
+      if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.error(`Admission gate refused candidate ${opts.candidateId}: ${admissionBlock.decision}`);
+        console.error(`  Reason:      ${admissionBlock.reason}`);
+        console.error(`  Next Action: ${admissionBlock.nextAction}`);
       }
+      process.exit(1);
+      return;
+    }
+
+    if (opts.dryRun) {
       const artifact = await stateManager.getArtifact(candidate.artifactId);
       if (!artifact) {
         console.error(`Artifact not found for candidate: ${opts.candidateId}`);
@@ -564,7 +598,6 @@ export async function handleCandidateIntake(opts: CandidateIntakeOptions): Promi
     const entry = await service.intake(opts.candidateId);
 
     // Check if already consumed before this call
-    const candidate = await stateManager.getCandidate(opts.candidateId);
     if (candidate?.status === 'consumed') {
       const infoMessage = `Candidate ${opts.candidateId} was already consumed. Ledger entry: ${entry.id}`;
       if (opts.json) {
@@ -724,6 +757,30 @@ export async function handleCandidateRepair(opts: CandidateRepairOptions): Promi
       process.exit(1);
     }
 
+    // PRI-442 Stage 4: admission gate check — even for consumed candidates,
+    // re-verify admission before re-intaking to prevent bypassing the gate.
+    // A consumed candidate that would fail the gate indicates data corruption
+    // or a prior bypass; refuse and surface the reason.
+    const admissionBlock = checkAdmissionGate(candidate);
+    if (admissionBlock) {
+      const result = {
+        candidateId: opts.candidateId,
+        status: 'refused',
+        admissionDecision: admissionBlock.decision,
+        reason: admissionBlock.reason,
+        nextAction: admissionBlock.nextAction,
+      };
+      if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.error(`Admission gate refused candidate ${opts.candidateId}: ${admissionBlock.decision}`);
+        console.error(`  Reason:      ${admissionBlock.reason}`);
+        console.error(`  Next Action: ${admissionBlock.nextAction}`);
+      }
+      process.exit(1);
+      return;
+    }
+
     const ledgerAdapter = new PrincipleTreeLedgerAdapter({ stateDir: path.join(workspaceDir, '.state') });
     const service = new CandidateIntakeService({ stateManager, ledgerAdapter });
 
@@ -931,6 +988,7 @@ export async function handleCandidateInternalizationBackfill(opts: CandidateBack
         continue;
       }
       const seed = buildDreamerSeedFromCandidate(candidate, { route: decision.route, ready: decision.ready, sourcePainId });
+      // eslint-disable-next-line no-restricted-syntax -- 'in' required for discriminated union narrowing (BridgeTaskSeed | BridgeDecision)
       if ('decision' in seed) {
         output.deferred++;
         const decisionResult = seed as { decision: string; reason?: string; taskId?: string };
@@ -998,6 +1056,15 @@ export async function handleCandidateInternalizationBackfill(opts: CandidateBack
         continue;
       }
 
+      // PRI-442 Stage 4: admission gate check — refuse non-admitted pending
+      // candidates to prevent backfill from bypassing the admission gate.
+      const admissionBlock = checkAdmissionGate(candidate);
+      if (admissionBlock) {
+        output.intakeFailed++;
+        output.results.push({ candidateId, route: 'unknown', status: 'intake_failed', reason: `Admission gate refused: ${admissionBlock.reason}`, statusBefore: 'pending', statusAfter: 'pending', intakeDecision: 'skipped', seedDecision: 'skipped', nextAction: admissionBlock.nextAction });
+        continue;
+      }
+
       const recommendation = resolveCandidateRecommendation(candidate, stateManager, candidateId);
       const decision = decideInternalizationRoute(recommendation as Parameters<typeof decideInternalizationRoute>[0]);
 
@@ -1010,6 +1077,7 @@ export async function handleCandidateInternalizationBackfill(opts: CandidateBack
         continue;
       }
       const seed = buildDreamerSeedFromCandidate(candidate, { route: decision.route, ready: decision.ready, sourcePainId });
+      // eslint-disable-next-line no-restricted-syntax -- 'in' required for discriminated union narrowing (BridgeTaskSeed | BridgeDecision)
       if ('decision' in seed) {
         output.deferred++;
         const decisionResult = seed as { decision: string; reason?: string; taskId?: string };

package/src/commands/console.ts

@@ -72,6 +72,20 @@ export async function handleConsole(opts: ConsoleOptions = {}): Promise<void> {
     return;
   }
 
+  // EP-06 regression guard (PR #1169): verify web UI bundle exists before launch.
+  // Without dist/web/index.html the server returns 404 "Run npm run build:ui first".
+  const webIndex = path.join(consoleDir, 'dist', 'web', 'index.html');
+  if (!fs.existsSync(webIndex)) {
+    const msg = `Console web UI not found at ${webIndex}. The console bundle is corrupted. Re-run installer.`;
+    if (opts.json) {
+      console.log(JSON.stringify({ success: false, reason: msg, nextAction: 'npx create-principles-disciple' }));
+    } else {
+      console.error(msg);
+    }
+    process.exit(1);
+    return;
+  }
+
   const port = opts.port || '3100';
   const host = '127.0.0.1';
   const args = [serverEntry, '--workspace', workspaceDir, '--port', port, '--host', host];
@@ -305,6 +319,32 @@ export async function handleConsoleOpen(opts: ConsoleOpenOptions = {}): Promise<
     return;
   }
 
+  // EP-06 regression guard (PR #1169): verify web UI bundle exists before launch.
+  // Without dist/web/index.html the server returns 404 "Run npm run build:ui first"
+  // — a fatal first-impression bug for new users.
+  const webIndex = path.join(consoleDir, 'dist', 'web', 'index.html');
+  if (!fs.existsSync(webIndex)) {
+    const result: ConsoleLaunchResult = {
+      status: 'failed',
+      url: '',
+      port: 0,
+      host: '127.0.0.1',
+      workspaceDir,
+      reused: false,
+      browserOpened: false,
+      reason: 'console_web_ui_missing',
+      nextAction: `Re-run installer: npx create-principles-disciple (expected ${webIndex})`,
+    };
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.error(`error: ${result.reason}`);
+      console.error(`next:   ${result.nextAction}`);
+    }
+    process.exit(1);
+    return;
+  }
+
   // 4) Read auth token for health probes (PD_CONSOLE_TOKEN)
   const token = opts.token ?? process.env.PD_CONSOLE_TOKEN;
 

package/src/commands/demo-story-a.ts

@@ -183,8 +183,10 @@ export async function handleDemoStoryA(opts: DemoStoryAOptions): Promise<void> {
     }
 
     if (result.status !== 'passed') {
-      console.error('');
-      console.error(`FAIL: status=${result.status}`);
+      if (!opts.json) {
+        console.error('');
+        console.error(`FAIL: status=${result.status}`);
+      }
       process.exitCode = 1;
     }
   } finally {