@principles/pd-cli 1.128.2 → 1.130.0

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

@@ -46,22 +46,17 @@ vi.mock('@principles/core/runtime-v2', () => ({
   resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
 }));
 
-vi.mock('../../src/services/feature-flag-loader.js', () => ({
-  loadEffectiveFeatureFlags: vi.fn().mockReturnValue({
-    source: 'defaults',
-    configPath: '/fake/workspace/.pd/feature-flags.yaml',
-    flags: {
-      prompt: { id: 'prompt', category: 'core', enabled: true, since: '2026-05-24' },
-      code_tool_hook: { id: 'code_tool_hook', category: 'core', enabled: true, since: '2026-05-24' },
-      defer_archive: { id: 'defer_archive', category: 'core', enabled: true, since: '2026-05-24' },
-      gfi: { id: 'gfi', category: 'quiet', enabled: true, since: '2026-05-24' },
-    },
-    warnings: [],
-  }),
+const { mockLoadPdConfig, mockComputeFlagsFromLoadResult } = vi.hoisted(() => ({
+  mockLoadPdConfig: vi.fn(),
+  mockComputeFlagsFromLoadResult: vi.fn(),
+}));
+
+vi.mock('../../src/services/pd-config-loader.js', () => ({
+  loadPdConfig: mockLoadPdConfig,
+  computeFlagsFromLoadResult: mockComputeFlagsFromLoadResult,
 }));
 
 import { runCanaryChecks } from '../../src/commands/runtime-canary.js';
-import { loadEffectiveFeatureFlags } from '../../src/services/feature-flag-loader.js';
 
 const WS = '/fake/workspace';
 
@@ -126,6 +121,26 @@ describe('runCanaryChecks', () => {
     mockAuditConsistency.mockResolvedValue({ status: 'ok', consumedCount: 0, orphanCandidateCount: 0, missingLedgerCount: 0 });
     mockBuildGfiSnapshot.mockReturnValue(healthyGfiSnapshot());
     mockClassifyGfiHealth.mockReturnValue({ status: 'healthy', reason: '0 active, 0 stale sessions', staleGfiDegradedThreshold: 40 });
+    // Default: GFI enabled, no warnings (canonical config loader)
+    mockLoadPdConfig.mockReturnValue({
+      ok: true,
+      effective: {},
+      source: 'defaults',
+      configPath: `${WS}/.pd/config.yaml`,
+      warnings: [],
+      legacyFilesDetected: [],
+      legacyFileNextActions: [],
+    });
+    mockComputeFlagsFromLoadResult.mockReturnValue({
+      flags: {
+        prompt: { id: 'prompt', category: 'core', enabled: true },
+        code_tool_hook: { id: 'code_tool_hook', category: 'core', enabled: true },
+        defer_archive: { id: 'defer_archive', category: 'core', enabled: true },
+        gfi: { id: 'gfi', category: 'quiet', enabled: true },
+      },
+      enabledChannels: ['prompt', 'code_tool_hook', 'defer_archive'],
+      warnings: [],
+    });
   });
 
   it('returns healthy when all checks are healthy', async () => {
@@ -275,12 +290,11 @@ describe('runCanaryChecks', () => {
 
   describe('GFI config warning degraded status', () => {
     it('returns healthy when GFI disabled with no warnings', async () => {
-      vi.mocked(loadEffectiveFeatureFlags).mockReturnValue({
-        source: 'defaults',
-        configPath: `${WS}/.pd/feature-flags.yaml`,
+      mockComputeFlagsFromLoadResult.mockReturnValue({
         flags: {
-          gfi: { id: 'gfi', category: 'quiet', enabled: false, since: '2026-05-24' },
+          gfi: { id: 'gfi', category: 'quiet', enabled: false },
         },
+        enabledChannels: [],
         warnings: [],
       });
 
@@ -292,13 +306,12 @@ describe('runCanaryChecks', () => {
     });
 
     it('returns degraded when GFI disabled but config has warnings (malformed YAML)', async () => {
-      vi.mocked(loadEffectiveFeatureFlags).mockReturnValue({
-        source: 'defaults',
-        configPath: `${WS}/.pd/feature-flags.yaml`,
+      mockComputeFlagsFromLoadResult.mockReturnValue({
         flags: {
-          gfi: { id: 'gfi', category: 'quiet', enabled: false, since: '2026-05-24' },
+          gfi: { id: 'gfi', category: 'quiet', enabled: false },
         },
-        warnings: ['feature-flags.yaml: YAML parse error, using defaults'],
+        enabledChannels: [],
+        warnings: ['.pd/config.yaml: YAML parse error, using defaults'],
       });
 
       const result = await runCanaryChecks(WS);
@@ -307,16 +320,15 @@ describe('runCanaryChecks', () => {
       expect(gfiCheck?.status).toBe('degraded');
       expect(gfiCheck?.summary).toContain('warnings');
       expect(gfiCheck?.details).toBeDefined();
-      expect(result.recommendedNextActions.some(a => a.includes('feature-flags.yaml'))).toBe(true);
+      expect(result.recommendedNextActions.some(a => a.includes('config.yaml'))).toBe(true);
     });
 
     it('returns degraded when GFI disabled but config has malformed override warning', async () => {
-      vi.mocked(loadEffectiveFeatureFlags).mockReturnValue({
-        source: 'workspace_file',
-        configPath: `${WS}/.pd/feature-flags.yaml`,
+      mockComputeFlagsFromLoadResult.mockReturnValue({
         flags: {
-          gfi: { id: 'gfi', category: 'quiet', enabled: false, since: '2026-05-24' },
+          gfi: { id: 'gfi', category: 'quiet', enabled: false },
         },
+        enabledChannels: [],
         warnings: ["flag 'gfi': malformed override kept default (enabled must be boolean)"],
       });
 
@@ -324,16 +336,15 @@ describe('runCanaryChecks', () => {
       const gfiCheck = result.checks.find(c => c.name === 'gfi_snapshot');
 
       expect(gfiCheck?.status).toBe('degraded');
-      expect(result.recommendedNextActions.some(a => a.includes('feature-flags.yaml') || a.includes('pd runtime features'))).toBe(true);
+      expect(result.recommendedNextActions.some(a => a.includes('config.yaml') || a.includes('pd runtime features'))).toBe(true);
     });
 
     it('runs GFI snapshot when flag enabled with no warnings', async () => {
-      vi.mocked(loadEffectiveFeatureFlags).mockReturnValue({
-        source: 'workspace_file',
-        configPath: `${WS}/.pd/feature-flags.yaml`,
+      mockComputeFlagsFromLoadResult.mockReturnValue({
         flags: {
-          gfi: { id: 'gfi', category: 'quiet', enabled: true, since: '2026-05-24' },
+          gfi: { id: 'gfi', category: 'quiet', enabled: true },
         },
+        enabledChannels: [],
         warnings: [],
       });
 
@@ -346,12 +357,11 @@ describe('runCanaryChecks', () => {
     });
 
     it('recommends session lifecycle review for GFI session issues (not config)', async () => {
-      vi.mocked(loadEffectiveFeatureFlags).mockReturnValue({
-        source: 'defaults',
-        configPath: `${WS}/.pd/feature-flags.yaml`,
+      mockComputeFlagsFromLoadResult.mockReturnValue({
         flags: {
-          gfi: { id: 'gfi', category: 'quiet', enabled: true, since: '2026-05-24' },
+          gfi: { id: 'gfi', category: 'quiet', enabled: true },
         },
+        enabledChannels: [],
         warnings: [],
       });
       mockClassifyGfiHealth.mockReturnValue({

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

@@ -24,27 +24,14 @@ vi.mock('@principles/core/runtime-v2', () => ({
   resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
 }));
 
-vi.mock('../../src/services/feature-flag-loader.js', () => ({
-  loadEffectiveFeatureFlags: vi.fn().mockReturnValue({
-    flags: {
-      prompt: { id: 'prompt', enabled: true, category: 'core' },
-      code_tool_hook: { id: 'code_tool_hook', enabled: true, category: 'core' },
-      defer_archive: { id: 'defer_archive', enabled: true, category: 'core' },
-    },
-    source: 'defaults',
-    configPath: '/fake/workspace/.pd/feature-flags.yaml',
-    warnings: [],
-  }),
-}));
-
 const { mockLoadPdConfig, mockComputeFlagsFromLoadResult } = vi.hoisted(() => ({
-  mockLoadPdConfig: vi.fn().mockReturnValue({ config: {}, source: 'defaults' }),
+  mockLoadPdConfig: vi.fn().mockReturnValue({ ok: true, effective: {}, source: 'defaults' }),
   mockComputeFlagsFromLoadResult: vi.fn().mockReturnValue({
     flags: {
       internalization_auto_consumer: { id: 'internalization_auto_consumer', enabled: true, category: 'quiet' },
     },
-    source: 'defaults',
-    errors: [],
+    enabledChannels: ['prompt', 'code_tool_hook', 'defer_archive'],
+    warnings: [],
   }),
 }));
 
@@ -89,8 +76,8 @@ describe('handleRuntimeInternalizationQueue', () => {
       flags: {
         internalization_auto_consumer: { id: 'internalization_auto_consumer', enabled: true, category: 'quiet' },
       },
-      source: 'defaults',
-      errors: [],
+      enabledChannels: ['prompt', 'code_tool_hook', 'defer_archive'],
+      warnings: [],
     });
   });
 
@@ -308,8 +295,8 @@ describe('handleRuntimeInternalizationQueue', () => {
       flags: {
         internalization_auto_consumer: { id: 'internalization_auto_consumer', enabled: true, category: 'quiet' },
       },
-      source: 'config',
-      errors: [],
+      enabledChannels: ['prompt', 'code_tool_hook', 'defer_archive'],
+      warnings: [],
     });
 
     await handleRuntimeInternalizationQueue({ workspace: WS, json: true });
@@ -332,8 +319,8 @@ describe('handleRuntimeInternalizationQueue', () => {
       flags: {
         internalization_auto_consumer: { id: 'internalization_auto_consumer', enabled: false, category: 'quiet' },
       },
-      source: 'config',
-      errors: [],
+      enabledChannels: ['prompt', 'code_tool_hook', 'defer_archive'],
+      warnings: [],
     });
 
     await handleRuntimeInternalizationQueue({ workspace: WS, json: true });
@@ -379,8 +366,8 @@ describe('handleRuntimeInternalizationQueue', () => {
       flags: {
         internalization_auto_consumer: { id: 'internalization_auto_consumer', enabled: false, category: 'quiet' },
       },
-      source: 'config',
-      errors: [],
+      enabledChannels: ['prompt', 'code_tool_hook', 'defer_archive'],
+      warnings: [],
     });
 
     await handleRuntimeInternalizationQueue({ workspace: WS, json: false });

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

@@ -41,14 +41,22 @@ vi.mock('../../src/services/resolve-runtime-from-pd-config.js', () => ({
   resolveRuntimeFromPdConfig: mockResolveRuntimeFromPdConfig,
 }));
 
-// PRI-431: Mock feature-flag-loader so the shared resolver's L2 dreamer sub-branch
-// doesn't call the real loadEffectiveFeatureFlags (which needs computeEffectiveFlags
-// from @principles/core/runtime-v2 — not included in the mock above).
-vi.mock('../../src/services/feature-flag-loader.js', () => ({
-  loadEffectiveFeatureFlags: vi.fn().mockReturnValue({
+// PRI-460: Mock pd-config-loader so the shared resolver's L2 dreamer sub-branch
+// doesn't call the real loadPdConfig (which needs fs access).
+vi.mock('../../src/services/pd-config-loader.js', () => ({
+  loadPdConfig: vi.fn().mockReturnValue({
+    ok: true,
+    effective: {},
+    source: 'defaults',
+    configPath: '/fake/workspace/.pd/config.yaml',
+    warnings: [],
+    legacyFilesDetected: [],
+    legacyFileNextActions: [],
+  }),
+  computeFlagsFromLoadResult: vi.fn().mockReturnValue({
     flags: {},
+    enabledChannels: [],
     warnings: [],
-    configPath: '/fake/workspace/.pd/feature-flags.yaml',
   }),
 }));
 

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

@@ -52,6 +52,18 @@ function writeConfig(workspaceDir: string, content: object): void {
   );
 }
 
+/** Type guard: narrows `unknown` to `Record<string, unknown>` without `as`. */
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function requireRecord(value: unknown, label: string): Record<string, unknown> {
+  if (!isRecord(value)) {
+    throw new Error(`${label} is not a record`);
+  }
+  return value;
+}
+
 /** Config with both artificer+evaluator enabled, pi-ai profile, API key env set. */
 function makeCapabilityOnConfig(workspaceDir: string): object {
   return {
@@ -90,17 +102,19 @@ function makeCapabilityOnConfig(workspaceDir: string): object {
 
 /** Config with artificer disabled (capability must be OFF). */
 function makeArtificerDisabledConfig(workspaceDir: string): object {
-  const cfg = makeCapabilityOnConfig(workspaceDir) as Record<string, unknown>;
-  const internalAgents = cfg.internalAgents as { agents: Record<string, { enabled: boolean; runtimeProfile?: string }> };
-  internalAgents.agents.artificer = { enabled: false };
+  const cfg = makeCapabilityOnConfig(workspaceDir);
+  const internalAgents = requireRecord(Reflect.get(cfg, 'internalAgents'), 'internalAgents');
+  const agents = requireRecord(Reflect.get(internalAgents, 'agents'), 'internalAgents.agents');
+  Reflect.set(agents, 'artificer', { enabled: false });
   return cfg;
 }
 
 /** Config with evaluator disabled (capability must be OFF). */
 function makeEvaluatorDisabledConfig(workspaceDir: string): object {
-  const cfg = makeCapabilityOnConfig(workspaceDir) as Record<string, unknown>;
-  const internalAgents = cfg.internalAgents as { agents: Record<string, { enabled: boolean; runtimeProfile?: string }> };
-  internalAgents.agents.evaluator = { enabled: false };
+  const cfg = makeCapabilityOnConfig(workspaceDir);
+  const internalAgents = requireRecord(Reflect.get(cfg, 'internalAgents'), 'internalAgents');
+  const agents = requireRecord(Reflect.get(internalAgents, 'agents'), 'internalAgents.agents');
+  Reflect.set(agents, 'evaluator', { enabled: false });
   return cfg;
 }
 
@@ -158,10 +172,11 @@ describe('runRuleHost production-wiring (PRI-429) — deterministic, no LLM', ()
   }
 
   /** Extract the single JSON object written to stdout. Fails if not exactly one write. */
-  function parseJsonOutput(): unknown {
+  function parseJsonOutput(): Record<string, unknown> {
     expect(stdoutSpy).toHaveBeenCalledTimes(1);
     const raw = stdoutSpy.mock.calls[0][0] as string;
-    return JSON.parse(raw);
+    const parsed: unknown = JSON.parse(raw);
+    return requireRecord(parsed, 'stdout JSON');
   }
 
   // ── Capability ON: both agents enabled, API key set ──────────────────────
@@ -178,14 +193,11 @@ describe('runRuleHost production-wiring (PRI-429) — deterministic, no LLM', ()
     });
 
     const output = parseJsonOutput();
-    expect(typeof output).toBe('object');
-    expect(output).not.toBeNull();
-    const obj = output as { status: string; codeRuleCapability?: { enabled: boolean; disabledReason?: string }; capabilityStatus?: string };
-    expect(obj.status).toBe('dry_run');
-    expect(obj.codeRuleCapability).toBeDefined();
-    expect(obj.codeRuleCapability?.enabled).toBe(true);
-    expect(obj.codeRuleCapability?.disabledReason).toBeUndefined();
-    expect(obj.capabilityStatus).toContain('ON');
+    const codeRuleCapability = requireRecord(output.codeRuleCapability, 'codeRuleCapability');
+    expect(output.status).toBe('dry_run');
+    expect(codeRuleCapability.enabled).toBe(true);
+    expect(codeRuleCapability.disabledReason).toBeUndefined();
+    expect(String(output.capabilityStatus)).toContain('ON');
     // exitCode must NOT be set for dry_run success
     expect(process.exitCode).toBeUndefined();
   });
@@ -203,16 +215,13 @@ describe('runRuleHost production-wiring (PRI-429) — deterministic, no LLM', ()
     await handleRunRuleHost({ workspace, painId: 'pain-flag-default', dryRun: true, json: true });
 
     const output = parseJsonOutput();
-    // PRI-435 (CodeRabbit P3): narrow unknown before property access
-    expect(typeof output).toBe('object');
-    expect(output).not.toBeNull();
-    const obj = output as { status: string; codeRuleCapability?: { enabled: boolean; disabledReason?: string }; capabilityStatus?: string };
-    expect(obj.status).toBe('dry_run');
+    const codeRuleCapability = requireRecord(output.codeRuleCapability, 'codeRuleCapability');
+    expect(output.status).toBe('dry_run');
     // PRI-435: code_rule_capability is now a core flag — defaults ON even when omitted from config.
     // It cannot be disabled by config. The capability is ON when artificer+evaluator are configured.
-    expect(obj.codeRuleCapability).toEqual(expect.objectContaining({ enabled: true }));
-    expect(obj.codeRuleCapability?.disabledReason).toBeUndefined();
-    expect(String(obj.capabilityStatus)).toContain('ON');
+    expect(codeRuleCapability).toEqual(expect.objectContaining({ enabled: true }));
+    expect(codeRuleCapability.disabledReason).toBeUndefined();
+    expect(String(output.capabilityStatus)).toContain('ON');
   });
 
   it('PRI-435: explicit emergency disable via code_rule_capability.enabled=false is observable', async () => {
@@ -229,16 +238,13 @@ describe('runRuleHost production-wiring (PRI-429) — deterministic, no LLM', ()
     await handleRunRuleHost({ workspace, painId: 'pain-emergency-disable', dryRun: true, json: true });
 
     const output = parseJsonOutput();
-    // PRI-435 (CodeRabbit P3): narrow unknown before property access
-    expect(typeof output).toBe('object');
-    expect(output).not.toBeNull();
-    const obj = output as { status: string; codeRuleCapability?: { enabled: boolean; disabledReason?: string }; capabilityStatus?: string };
-    expect(obj.status).toBe('dry_run');
+    const codeRuleCapability = requireRecord(output.codeRuleCapability, 'codeRuleCapability');
+    expect(output.status).toBe('dry_run');
     // PRI-435: Emergency disable via code_rule_capability.enabled=false is preserved.
     // The capability is OFF with a structured reason.
-    expect(obj.codeRuleCapability).toEqual(expect.objectContaining({ enabled: false }));
-    expect(String(obj.codeRuleCapability?.disabledReason)).toContain('feature flag');
-    expect(String(obj.capabilityStatus)).toContain('OFF');
+    expect(codeRuleCapability).toEqual(expect.objectContaining({ enabled: false }));
+    expect(String(codeRuleCapability.disabledReason)).toContain('feature flag');
+    expect(String(output.capabilityStatus)).toContain('OFF');
   });
 
   it('reports the resolved runtime profile for every executed agent', async () => {
@@ -271,10 +277,17 @@ describe('runRuleHost production-wiring (PRI-429) — deterministic, no LLM', ()
 
     await handleRunRuleHost({ workspace, painId: 'pain-disabled-philosopher', confirm: true, json: true });
 
+    // PRI-461: readiness gate catches disabled required agents BEFORE adapter
+    // construction, returning status='refused' with a structured reason instead
+    // of the old opaque 'agent_runtime_resolution_failed' error.
     const output = parseJsonOutput();
-    expect(output.status).toBe('failed');
-    expect(output.reason).toBe('agent_runtime_resolution_failed');
-    expect(String(output.message)).toContain('philosopher');
+    expect(isRecord(output)).toBe(true);
+    if (!isRecord(output)) {
+      throw new Error('output is not a record');
+    }
+    expect(output.status).toBe('refused');
+    expect(String(output.reason)).toContain('philosopher');
+    expect(typeof output.nextAction).toBe('string');
     expect(process.exitCode).toBe(1);
     expect(fs.existsSync(path.join(workspace, '.state', 'runtime-v2.sqlite'))).toBe(false);
   });
@@ -308,10 +321,10 @@ describe('runRuleHost production-wiring (PRI-429) — deterministic, no LLM', ()
     });
 
     const output = parseJsonOutput();
-    const obj = output as { status: string; codeRuleCapability: { enabled: boolean; disabledReason?: string } };
-    expect(obj.status).toBe('dry_run');
-    expect(obj.codeRuleCapability.enabled).toBe(false);
-    expect(obj.codeRuleCapability.disabledReason).toContain('artificer');
+    const codeRuleCapability = requireRecord(output.codeRuleCapability, 'codeRuleCapability');
+    expect(output.status).toBe('dry_run');
+    expect(codeRuleCapability.enabled).toBe(false);
+    expect(String(codeRuleCapability.disabledReason)).toContain('artificer');
   });
 
   // ── Capability OFF: evaluator disabled ───────────────────────────────────
@@ -328,10 +341,10 @@ describe('runRuleHost production-wiring (PRI-429) — deterministic, no LLM', ()
     });
 
     const output = parseJsonOutput();
-    const obj = output as { status: string; codeRuleCapability: { enabled: boolean; disabledReason?: string } };
-    expect(obj.status).toBe('dry_run');
-    expect(obj.codeRuleCapability.enabled).toBe(false);
-    expect(obj.codeRuleCapability.disabledReason).toContain('evaluator');
+    const codeRuleCapability = requireRecord(output.codeRuleCapability, 'codeRuleCapability');
+    expect(output.status).toBe('dry_run');
+    expect(codeRuleCapability.enabled).toBe(false);
+    expect(String(codeRuleCapability.disabledReason)).toContain('evaluator');
   });
 
   // ── Capability OFF: API key not set ──────────────────────────────────────
@@ -393,10 +406,11 @@ describe('runRuleHost production-wiring (PRI-429) — deterministic, no LLM', ()
     });
 
     const output = parseJsonOutput();
-    const obj = output as { status: string; codeRuleCapability: { enabled: boolean; disabledReason?: string } };
-    expect(obj.status).toBe('dry_run');
-    expect(obj.codeRuleCapability.enabled).toBe(false);
-    expect(obj.codeRuleCapability.disabledReason).toContain('apiKeyEnv');
+    const codeRuleCapability = requireRecord(output.codeRuleCapability, 'codeRuleCapability');
+    expect(output.status).toBe('dry_run');
+    expect(codeRuleCapability.enabled).toBe(false);
+    expect(String(codeRuleCapability.disabledReason)).toContain('TEST_RULEHOST_ARTIFICER_KEY');
+    expect(String(codeRuleCapability.disabledReason)).toContain('not set');
   });
 
   // ── CLI gate: mutual exclusivity ─────────────────────────────────────────
@@ -414,10 +428,9 @@ describe('runRuleHost production-wiring (PRI-429) — deterministic, no LLM', ()
     });
 
     const output = parseJsonOutput();
-    const obj = output as { status: string; reason: string; nextAction: string };
-    expect(obj.status).toBe('failed');
-    expect(obj.reason).toContain('mutually exclusive');
-    expect(obj.nextAction).toBeTruthy();
+    expect(output.status).toBe('failed');
+    expect(String(output.reason)).toContain('mutually exclusive');
+    expect(output.nextAction).toBeTruthy();
     expect(process.exitCode).toBe(1);
   });
 
@@ -435,10 +448,9 @@ describe('runRuleHost production-wiring (PRI-429) — deterministic, no LLM', ()
     });
 
     const output = parseJsonOutput();
-    const obj = output as { status: string; reason: string; nextAction: string };
-    expect(obj.status).toBe('failed');
-    expect(obj.reason).toContain('painId');
-    expect(obj.nextAction).toBeTruthy();
+    expect(output.status).toBe('failed');
+    expect(String(output.reason)).toContain('painId');
+    expect(output.nextAction).toBeTruthy();
     expect(process.exitCode).toBe(1);
   });
 
@@ -480,8 +492,7 @@ describe('runRuleHost production-wiring (PRI-429) — deterministic, no LLM', ()
     });
 
     const output = parseJsonOutput();
-    const obj = output as { status: string };
-    expect(obj.status).toBe('dry_run');
+    expect(output.status).toBe('dry_run');
     // Must NOT set exitCode for dry_run
     expect(process.exitCode).toBeUndefined();
   });
@@ -501,10 +512,9 @@ describe('runRuleHost production-wiring (PRI-429) — deterministic, no LLM', ()
     });
 
     const output = parseJsonOutput();
-    const obj = output as { status: string; reason: string; nextAction: string };
-    expect(obj.status).toBe('failed');
-    expect(obj.reason).toContain('unsupported channel');
-    expect(obj.nextAction).toBeTruthy();
+    expect(output.status).toBe('failed');
+    expect(String(output.reason)).toContain('unsupported channel');
+    expect(output.nextAction).toBeTruthy();
     expect(process.exitCode).toBe(1);
   });
 });

package/dist/services/feature-flag-loader.d.ts

@@ -1,6 +0,0 @@
-import type { EffectiveFeatureFlags } from '@principles/core/runtime-v2';
-export declare const FEATURE_FLAGS_CONFIG_FILENAME = "feature-flags.yaml";
-export declare const FEATURE_FLAGS_CONFIG_DIR = ".pd";
-export declare function getFeatureFlagsConfigPath(workspaceDir: string): string;
-export declare function loadEffectiveFeatureFlags(workspaceDir: string): EffectiveFeatureFlags;
-//# sourceMappingURL=feature-flag-loader.d.ts.map

package/dist/services/feature-flag-loader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"feature-flag-loader.d.ts","sourceRoot":"","sources":["../../src/services/feature-flag-loader.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAEzE,eAAO,MAAM,6BAA6B,uBAAuB,CAAC;AAClE,eAAO,MAAM,wBAAwB,QAAQ,CAAC;AAQ9C,wBAAgB,yBAAyB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED,wBAAgB,yBAAyB,CAAC,YAAY,EAAE,MAAM,GAAG,qBAAqB,CAkDrF"}

package/dist/services/feature-flag-loader.js

@@ -1,53 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs';
-import * as yaml from 'js-yaml';
-import { computeEffectiveFlags, DEFAULT_FEATURE_FLAGS, } from '@principles/core/runtime-v2';
-export const FEATURE_FLAGS_CONFIG_FILENAME = 'feature-flags.yaml';
-export const FEATURE_FLAGS_CONFIG_DIR = '.pd';
-const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
-function isRecord(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-export function getFeatureFlagsConfigPath(workspaceDir) {
-    return path.join(workspaceDir, FEATURE_FLAGS_CONFIG_DIR, FEATURE_FLAGS_CONFIG_FILENAME);
-}
-export function loadEffectiveFeatureFlags(workspaceDir) {
-    const configPath = getFeatureFlagsConfigPath(workspaceDir);
-    if (!fs.existsSync(configPath)) {
-        return computeEffectiveFlags({}, DEFAULT_FEATURE_FLAGS, configPath);
-    }
-    const raw = fs.readFileSync(configPath, 'utf8');
-    let parsed;
-    try {
-        parsed = yaml.load(raw, { schema: yaml.JSON_SCHEMA });
-    }
-    catch {
-        return {
-            ...computeEffectiveFlags({}, DEFAULT_FEATURE_FLAGS, configPath),
-            warnings: ['feature-flags.yaml: YAML parse error, using defaults'],
-        };
-    }
-    if (parsed === null || parsed === undefined || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        return {
-            ...computeEffectiveFlags({}, DEFAULT_FEATURE_FLAGS, configPath),
-            warnings: ['feature-flags.yaml: expected a mapping, using defaults'],
-        };
-    }
-    const parsedRecord = Object.create(null);
-    const warnings = [];
-    for (const key of Object.keys(parsed)) {
-        if (DANGEROUS_KEYS.has(key)) {
-            warnings.push(`feature-flags.yaml: dangerous key '${key}' rejected`);
-            continue;
-        }
-        if (Object.hasOwn(parsed, key) && isRecord(parsed)) {
-            parsedRecord[key] = parsed[key];
-        }
-    }
-    const result = computeEffectiveFlags(parsedRecord, DEFAULT_FEATURE_FLAGS, configPath);
-    if (warnings.length > 0) {
-        result.warnings = [...warnings, ...result.warnings];
-    }
-    return result;
-}
-//# sourceMappingURL=feature-flag-loader.js.map

package/dist/services/feature-flag-loader.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"feature-flag-loader.js","sourceRoot":"","sources":["../../src/services/feature-flag-loader.ts"],"names":[],"mappings":"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"}

package/src/services/feature-flag-loader.ts

@@ -1,73 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs';
-import * as yaml from 'js-yaml';
-import {
-  computeEffectiveFlags,
-  DEFAULT_FEATURE_FLAGS,
-} from '@principles/core/runtime-v2';
-import type { EffectiveFeatureFlags } from '@principles/core/runtime-v2';
-
-export const FEATURE_FLAGS_CONFIG_FILENAME = 'feature-flags.yaml';
-export const FEATURE_FLAGS_CONFIG_DIR = '.pd';
-
-const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-
-export function getFeatureFlagsConfigPath(workspaceDir: string): string {
-  return path.join(workspaceDir, FEATURE_FLAGS_CONFIG_DIR, FEATURE_FLAGS_CONFIG_FILENAME);
-}
-
-export function loadEffectiveFeatureFlags(workspaceDir: string): EffectiveFeatureFlags {
-  const configPath = getFeatureFlagsConfigPath(workspaceDir);
-
-  if (!fs.existsSync(configPath)) {
-    return computeEffectiveFlags({}, DEFAULT_FEATURE_FLAGS, configPath);
-  }
-
-  const raw = fs.readFileSync(configPath, 'utf8');
-
-   
-  let parsed: unknown;
-  try {
-    parsed = yaml.load(raw, { schema: yaml.JSON_SCHEMA });
-  } catch {
-    return {
-      ...computeEffectiveFlags({}, DEFAULT_FEATURE_FLAGS, configPath),
-      warnings: ['feature-flags.yaml: YAML parse error, using defaults'],
-    };
-  }
-
-  if (parsed === null || parsed === undefined || typeof parsed !== 'object' || Array.isArray(parsed)) {
-    return {
-      ...computeEffectiveFlags({}, DEFAULT_FEATURE_FLAGS, configPath),
-      warnings: ['feature-flags.yaml: expected a mapping, using defaults'],
-    };
-  }
-
-  const parsedRecord: Record<string, unknown> = Object.create(null);
-  const warnings: string[] = [];
-  for (const key of Object.keys(parsed)) {
-    if (DANGEROUS_KEYS.has(key)) {
-      warnings.push(`feature-flags.yaml: dangerous key '${key}' rejected`);
-      continue;
-    }
-    if (Object.hasOwn(parsed, key) && isRecord(parsed)) {
-      parsedRecord[key] = parsed[key];
-    }
-  }
-
-  const result = computeEffectiveFlags(
-    parsedRecord,
-    DEFAULT_FEATURE_FLAGS,
-    configPath,
-  );
-
-  if (warnings.length > 0) {
-    result.warnings = [...warnings, ...result.warnings];
-  }
-
-  return result;
-}