@principles/pd-cli 1.129.0 → 1.131.0

package/src/commands/runtime-internalization-queue.ts

@@ -11,7 +11,6 @@ import * as path from 'path';
 import { createInternalizationQueueReadModel } from '@principles/core/runtime-v2';
 import type { InternalizationQueueSnapshot } from '@principles/core/runtime-v2';
 import { resolveWorkspaceDir } from '../resolve-workspace.js';
-import { loadEffectiveFeatureFlags } from '../services/feature-flag-loader.js';
 import { loadPdConfig, computeFlagsFromLoadResult } from '../services/pd-config-loader.js';
 
 interface QueueOptions {
@@ -95,29 +94,25 @@ function formatTextOutput(snap: InternalizationQueueSnapshot, workspaceDir: stri
 export async function handleRuntimeInternalizationQueue(opts: QueueOptions): Promise<void> {
   const workspaceDir = opts.workspace ? path.resolve(opts.workspace) : resolveWorkspaceDir();
 
-  const featureFlags = loadEffectiveFeatureFlags(workspaceDir);
-  const enabledChannels = new Set(
-    Object.values(featureFlags.flags)
-      .filter(f => f.enabled)
-      .map(f => f.id),
-  );
+  // Single canonical config load — replaces split-brain legacy + canonical reads (PRI-460).
+  const pdConfigResult = loadPdConfig(workspaceDir);
+  if (!pdConfigResult.ok) {
+    const configWarning = JSON.stringify({
+      level: 'warning',
+      source: 'pd_config',
+      errors: pdConfigResult.errors.map(e => ({ reason: e.reason, nextAction: e.nextAction })),
+    });
+    process.stderr.write(`${configWarning}\n`);
+  }
+  const pdFlags = computeFlagsFromLoadResult(pdConfigResult);
+  const enabledChannels = new Set(pdFlags.enabledChannels);
+  const autoConsumerEnabled = pdFlags.flags.internalization_auto_consumer?.enabled ?? false;
+
   const { readModel, close } = await createInternalizationQueueReadModel({ workspaceDir, enabledChannels });
 
   try {
     const snapshot = await readModel.getSnapshot();
 
-    const pdConfigResult = loadPdConfig(workspaceDir);
-    if (!pdConfigResult.ok) {
-      const configWarning = JSON.stringify({
-        level: 'warning',
-        source: 'pd_config',
-        errors: pdConfigResult.errors.map(e => ({ reason: e.reason, nextAction: e.nextAction })),
-      });
-      process.stderr.write(`${configWarning}\n`);
-    }
-    const pdFlags = computeFlagsFromLoadResult(pdConfigResult);
-    const autoConsumerEnabled = pdFlags.flags.internalization_auto_consumer?.enabled ?? false;
-
     if (opts.json) {
       const output: Record<string, unknown> = { ...snapshot };
 

package/src/index.ts

@@ -53,6 +53,7 @@ import { handleRuntimeFeaturesStatus } from './commands/runtime-features.js';
 import { handleConfigDoctor } from './commands/config-doctor.js';
 import { registerMvpCommands } from './commands/mvp-smoke.js';
 import { registerRulecodeCommand } from './commands/rulecode.js';
+import { registerIntentCommand } from './commands/intent.js';
 
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
@@ -971,6 +972,11 @@ registerMvpCommands(program);
 
 registerRulecodeCommand(program);
 
+// ─── Intent Engineering (PRI-466) ───────────────────────────────────────────
+// Owner-authored INTENT.md management: init (create), show (read-only summary).
+
+registerIntentCommand(program);
+
 const consoleCmd = program
   .command('console')
   .description('Start the pd-console web UI for principle review (default: fallback launcher)')

package/src/services/__tests__/runtime-adapter-resolver.test.ts

@@ -62,9 +62,11 @@ vi.mock('@principles/core/principle-tree-ledger', () => ({
   loadLedger: vi.fn().mockReturnValue({ tree: { principles: {} } }),
 }));
 
-const mockLoadEffectiveFeatureFlags = vi.fn();
-vi.mock('../feature-flag-loader.js', () => ({
-  loadEffectiveFeatureFlags: mockLoadEffectiveFeatureFlags,
+const mockLoadPdConfig = vi.fn();
+const mockComputeFlagsFromLoadResult = vi.fn();
+vi.mock('../pd-config-loader.js', () => ({
+  loadPdConfig: mockLoadPdConfig,
+  computeFlagsFromLoadResult: mockComputeFlagsFromLoadResult,
 }));
 
 const mockResolveRuntimeFromPdConfig = vi.fn();
@@ -136,8 +138,10 @@ describe('resolveRuntimeAdapterFromConfig (PRI-431)', () => {
       // no-op: valid config
     });
     // Default: feature flags have l2_dreamer disabled
-    mockLoadEffectiveFeatureFlags.mockReturnValue({
+    mockLoadPdConfig.mockReturnValue({ ok: true, effective: {}, source: 'defaults' });
+    mockComputeFlagsFromLoadResult.mockReturnValue({
       flags: {},
+      enabledChannels: [],
       warnings: [],
     });
   });
@@ -288,8 +292,9 @@ describe('resolveRuntimeAdapterFromConfig (PRI-431)', () => {
     it('returns L2AgentLoopAdapter when runnerKind=dreamer + l2ArtifactReader + l2StateDir + flag enabled', () => {
       const config = makeValidPiAiConfig();
       mockResolveRuntimeFromPdConfig.mockReturnValue(makeResolvedConfig(config));
-      mockLoadEffectiveFeatureFlags.mockReturnValue({
-        flags: { l2_dreamer: { enabled: true } },
+      mockComputeFlagsFromLoadResult.mockReturnValue({
+        flags: { l2_dreamer: { id: 'l2_dreamer', enabled: true, category: 'quiet' } },
+        enabledChannels: [],
         warnings: [],
       });
       const fakeArtifactReader = { readArtifact: vi.fn() };
@@ -310,8 +315,9 @@ describe('resolveRuntimeAdapterFromConfig (PRI-431)', () => {
     it('falls back to PiAiRuntimeAdapter when l2_dreamer flag is disabled', () => {
       const config = makeValidPiAiConfig();
       mockResolveRuntimeFromPdConfig.mockReturnValue(makeResolvedConfig(config));
-      mockLoadEffectiveFeatureFlags.mockReturnValue({
-        flags: { l2_dreamer: { enabled: false } },
+      mockComputeFlagsFromLoadResult.mockReturnValue({
+        flags: { l2_dreamer: { id: 'l2_dreamer', enabled: false, category: 'quiet' } },
+        enabledChannels: [],
         warnings: [],
       });
 
@@ -330,8 +336,9 @@ describe('resolveRuntimeAdapterFromConfig (PRI-431)', () => {
     it('falls back to PiAiRuntimeAdapter when l2ArtifactReader is missing', () => {
       const config = makeValidPiAiConfig();
       mockResolveRuntimeFromPdConfig.mockReturnValue(makeResolvedConfig(config));
-      mockLoadEffectiveFeatureFlags.mockReturnValue({
-        flags: { l2_dreamer: { enabled: true } },
+      mockComputeFlagsFromLoadResult.mockReturnValue({
+        flags: { l2_dreamer: { id: 'l2_dreamer', enabled: true, category: 'quiet' } },
+        enabledChannels: [],
         warnings: [],
       });
 
@@ -349,8 +356,9 @@ describe('resolveRuntimeAdapterFromConfig (PRI-431)', () => {
     it('falls back to PiAiRuntimeAdapter when runnerKind is not dreamer', () => {
       const config = makeValidPiAiConfig();
       mockResolveRuntimeFromPdConfig.mockReturnValue(makeResolvedConfig(config));
-      mockLoadEffectiveFeatureFlags.mockReturnValue({
-        flags: { l2_dreamer: { enabled: true } },
+      mockComputeFlagsFromLoadResult.mockReturnValue({
+        flags: { l2_dreamer: { id: 'l2_dreamer', enabled: true, category: 'quiet' } },
+        enabledChannels: [],
         warnings: [],
       });
 

package/src/services/runtime-adapter-resolver.ts

@@ -13,7 +13,7 @@
  * - CLI-gate concerns (process.exit, telemetry, help text) stay at call sites.
  *   This resolver throws structured `ConfigResolutionError` that handlers translate.
  * - Lives in pd-cli/services (NOT core) because it constructs adapters and reads
- *   CLI feature flags via `loadEffectiveFeatureFlags`, which is a pd-cli service.
+ *   PD config via `loadPdConfig` + `computeFlagsFromLoadResult`, which are pd-cli services.
  *
  * ERR refs:
  * - ERR-001 (no any): all types explicit
@@ -34,7 +34,7 @@ import {
 } from '@principles/core/runtime-v2';
 import type { PDRuntimeAdapter, PdL2ArtifactReader, RuntimeConfig, RuntimeConfigResult } from '@principles/core/runtime-v2';
 import { loadLedger } from '@principles/core/principle-tree-ledger';
-import { loadEffectiveFeatureFlags } from './feature-flag-loader.js';
+import { loadPdConfig, computeFlagsFromLoadResult } from './pd-config-loader.js';
 import { resolveRuntimeFromPdConfig } from './resolve-runtime-from-pd-config.js';
 import type { ResolvedRuntimeFromPdConfig } from './resolve-runtime-from-pd-config.js';
 
@@ -255,7 +255,7 @@ export function resolveRuntimeAdapterFromConfig(opts: ResolveAdapterOptions): PD
     // dreamer runner, route through the L2 multi-turn agent loop adapter.
     // Other runners (philosopher/scribe/...) stay on L1.
     if (opts.runnerKind === 'dreamer' && opts.l2ArtifactReader && opts.l2StateDir) {
-      const effectiveFlags = loadEffectiveFeatureFlags(opts.workspaceDir);
+      const effectiveFlags = computeFlagsFromLoadResult(loadPdConfig(opts.workspaceDir));
       const l2FlagDef = Object.hasOwn(effectiveFlags.flags, 'l2_dreamer')
         ? effectiveFlags.flags.l2_dreamer
         : undefined;

package/tests/commands/intent.test.ts

@@ -0,0 +1,321 @@
+/**
+ * PRI-466: pd intent — handler-level tests.
+ *
+ * Tests real handler behavior using temporary workspaces with .pd/config.yaml
+ * to control the intent_engineering flag. No mocks on resolveWorkspaceDir or
+ * loadPdConfig — full integration through the real code paths.
+ *
+ * ERR refs:
+ *   - ERR-002: all degraded paths include reason + nextAction
+ *   - ERR-009: missing file / flag-off surfaced explicitly
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import * as yaml from 'js-yaml';
+import { handleIntentInit, handleIntentShow } from '../../src/commands/intent.js';
+
+let workspaceDir: string;
+let tmpDir: string;
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-intent-cli-test-'));
+  workspaceDir = path.join(tmpDir, 'workspace');
+  fs.mkdirSync(workspaceDir, { recursive: true });
+  fs.mkdirSync(path.join(workspaceDir, '.pd'), { recursive: true });
+});
+
+afterEach(() => {
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+function writeConfig(intentEnabled: boolean): void {
+  const config = {
+    version: 1,
+    features: {
+      intent_engineering: { category: 'quiet', enabled: intentEnabled },
+    },
+    runtimeProfiles: {
+      'openclaw.default': { type: 'openclaw', source: 'default' },
+    },
+    internalAgents: {
+      defaultRuntime: 'openclaw.default',
+      agents: {
+        diagnostician: { enabled: true, runtimeProfile: 'openclaw.default' },
+        dreamer: { enabled: true },
+        scribe: { enabled: true },
+      },
+    },
+    ui: { diagnostics: { mode: 'simple' } },
+  };
+  fs.writeFileSync(
+    path.join(workspaceDir, '.pd', 'config.yaml'),
+    yaml.dump(config),
+    'utf8',
+  );
+}
+
+function getIntentPath(): string {
+  return path.join(workspaceDir, '.principles', 'INTENT.md');
+}
+
+const VALID_INTENT = `# INTENT.md
+
+## 1. Why
+
+This project validates pain from repeatedly correcting Agents.
+
+## 2. Desired Outcome
+
+A new user understands PD within five minutes.
+
+## 3. Non-negotiables
+
+- Do not make PD a heavy Agent platform.
+- Do not increase Owner attention burden.
+
+## 4. Stop / Escalation
+
+If a change expands PD into orchestration, stop and ask Owner.
+
+## 5. Current Strategic Focus
+
+Validate the smallest loop: Pain to Principle to Delta.
+`;
+
+// ── handleIntentInit ─────────────────────────────────────────────────────────
+
+describe('handleIntentInit', () => {
+  it('creates INTENT.md from template with --confirm', async () => {
+    await handleIntentInit({ workspace: workspaceDir, confirm: true, json: false });
+
+    const intentPath = getIntentPath();
+    expect(fs.existsSync(intentPath)).toBe(true);
+    const content = fs.readFileSync(intentPath, 'utf8');
+    expect(content).toContain('# INTENT.md');
+    expect(content).toContain('## 1. Why');
+    expect(content).toContain('## 5. Current Strategic Focus');
+  });
+
+  it('defaults to dry-run (does not write) when no --confirm', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+    await handleIntentInit({ workspace: workspaceDir, json: true });
+
+    expect(logSpy).toHaveBeenCalled();
+    const jsonOutput = JSON.parse(logSpy.mock.calls[0][0] as string);
+    expect(jsonOutput.status).toBe('dry_run');
+    expect(jsonOutput.path).toContain('INTENT.md');
+    expect(jsonOutput.reason).toBe('dry_run');
+    expect(jsonOutput.nextAction).toContain('--confirm');
+
+    // File must NOT be created
+    expect(fs.existsSync(getIntentPath())).toBe(false);
+
+    logSpy.mockRestore();
+  });
+
+  it('dry-run with --dry-run flag produces same dry-run output', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+    await handleIntentInit({ workspace: workspaceDir, dryRun: true, json: true });
+
+    const jsonOutput = JSON.parse(logSpy.mock.calls[0][0] as string);
+    expect(jsonOutput.status).toBe('dry_run');
+
+    expect(fs.existsSync(getIntentPath())).toBe(false);
+    logSpy.mockRestore();
+  });
+
+  it('rejects --dry-run and --confirm together (CLI Gate rule 4)', async () => {
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined as never);
+    await handleIntentInit({ workspace: workspaceDir, dryRun: true, confirm: true, json: true });
+
+    expect(exitSpy).not.toHaveBeenCalled();
+    expect(process.exitCode).toBe(1);
+    // File must NOT be created
+    expect(fs.existsSync(getIntentPath())).toBe(false);
+
+    process.exitCode = undefined;
+    exitSpy.mockRestore();
+  });
+
+  it('skips when file exists and --force is not set', async () => {
+    // Pre-create the file
+    fs.mkdirSync(path.dirname(getIntentPath()), { recursive: true });
+    fs.writeFileSync(getIntentPath(), 'existing content', 'utf8');
+
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined as never);
+    await handleIntentInit({ workspace: workspaceDir, force: false, confirm: true, json: false });
+    expect(exitSpy).not.toHaveBeenCalled();
+    expect(process.exitCode).toBe(1);
+
+    // File should NOT be overwritten
+    const content = fs.readFileSync(getIntentPath(), 'utf8');
+    expect(content).toBe('existing content');
+
+    process.exitCode = undefined;
+    exitSpy.mockRestore();
+  });
+
+  it('overwrites when --force and --confirm are set', async () => {
+    fs.mkdirSync(path.dirname(getIntentPath()), { recursive: true });
+    fs.writeFileSync(getIntentPath(), 'existing content', 'utf8');
+
+    await handleIntentInit({ workspace: workspaceDir, force: true, confirm: true, json: false });
+
+    const content = fs.readFileSync(getIntentPath(), 'utf8');
+    expect(content).toContain('# INTENT.md');
+    expect(content).not.toContain('existing content');
+  });
+
+  it('outputs JSON when --json is set with --confirm', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+    await handleIntentInit({ workspace: workspaceDir, confirm: true, json: true });
+
+    expect(logSpy).toHaveBeenCalled();
+    const jsonOutput = JSON.parse(logSpy.mock.calls[0][0] as string);
+    expect(jsonOutput.status).toBe('ok');
+    expect(jsonOutput.path).toContain('INTENT.md');
+    expect(jsonOutput.overwritten).toBe(false);
+
+    logSpy.mockRestore();
+  });
+
+  it('creates .principles directory if it does not exist', async () => {
+    await handleIntentInit({ workspace: workspaceDir, confirm: true, json: false });
+
+    const dir = path.join(workspaceDir, '.principles');
+    expect(fs.existsSync(dir)).toBe(true);
+    expect(fs.existsSync(getIntentPath())).toBe(true);
+  });
+
+  it('emits structured read_error JSON when workspace path is invalid (CLI Gate rule 6)', async () => {
+    // resolveWorkspaceDir throws on paths with null bytes or other invalid chars.
+    // The error must be caught and emitted as a structured IntentInitOutput,
+    // not an uncaught stack trace.
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+    process.exitCode = undefined;
+    await handleIntentInit({ workspace: 'invalid\0path', confirm: true, json: true });
+
+    expect(process.exitCode).toBe(1);
+    const jsonOutput = JSON.parse(logSpy.mock.calls[0][0] as string) as Record<string, unknown>;
+    expect(jsonOutput.status).toBe('read_error');
+    expect(jsonOutput.reason).toBeDefined();
+    expect(jsonOutput.nextAction).toBeDefined();
+    // Must NOT include the ad-hoc `ok` field that the old code emitted
+    expect(jsonOutput.ok).toBeUndefined();
+
+    process.exitCode = undefined;
+    logSpy.mockRestore();
+  });
+});
+
+// ── handleIntentShow ─────────────────────────────────────────────────────────
+
+describe('handleIntentShow', () => {
+  it('returns flag_disabled when intent_engineering is off', async () => {
+    writeConfig(false);
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+
+    await handleIntentShow({ workspace: workspaceDir, json: true });
+
+    const jsonOutput = JSON.parse(logSpy.mock.calls[0][0] as string);
+    expect(jsonOutput.status).toBe('flag_disabled');
+    expect(jsonOutput.flagEnabled).toBe(false);
+    expect(jsonOutput.reason).toBe('flag_disabled');
+    expect(jsonOutput.nextAction).toBeDefined();
+
+    logSpy.mockRestore();
+  });
+
+  it('returns not_found when INTENT.md does not exist', async () => {
+    writeConfig(true);
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+
+    await handleIntentShow({ workspace: workspaceDir, json: true });
+
+    const jsonOutput = JSON.parse(logSpy.mock.calls[0][0] as string);
+    expect(jsonOutput.status).toBe('not_found');
+    expect(jsonOutput.found).toBe(false);
+    expect(jsonOutput.nextAction).toContain('pd intent init');
+
+    logSpy.mockRestore();
+  });
+
+  it('returns ok with sections and hash for valid INTENT.md', async () => {
+    writeConfig(true);
+    fs.mkdirSync(path.dirname(getIntentPath()), { recursive: true });
+    fs.writeFileSync(getIntentPath(), VALID_INTENT, 'utf8');
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+
+    await handleIntentShow({ workspace: workspaceDir, json: true });
+
+    const jsonOutput = JSON.parse(logSpy.mock.calls[0][0] as string);
+    expect(jsonOutput.status).toBe('ok');
+    expect(jsonOutput.found).toBe(true);
+    expect(jsonOutput.flagEnabled).toBe(true);
+    expect(jsonOutput.contentHash).toMatch(/^sha256:/);
+    expect(jsonOutput.lastEditedAt).toBeDefined();
+    expect(jsonOutput.sections).toBeDefined();
+    expect(jsonOutput.sections.why).toContain('correcting Agents');
+    expect(jsonOutput.warnings).toEqual([]);
+
+    logSpy.mockRestore();
+  });
+
+  it('returns oversized for file > 32KB', async () => {
+    writeConfig(true);
+    fs.mkdirSync(path.dirname(getIntentPath()), { recursive: true });
+    const big = '# INTENT.md\n\n## 1. Why\n\n' + 'x'.repeat(33 * 1024) + '\n';
+    fs.writeFileSync(getIntentPath(), big, 'utf8');
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+
+    await handleIntentShow({ workspace: workspaceDir, json: true });
+
+    const jsonOutput = JSON.parse(logSpy.mock.calls[0][0] as string);
+    expect(jsonOutput.status).toBe('oversized');
+    expect(jsonOutput.found).toBe(true);
+    expect(jsonOutput.nextAction).toContain('bytes');
+
+    logSpy.mockRestore();
+  });
+
+  it('emits warnings for partial INTENT.md', async () => {
+    writeConfig(true);
+    fs.mkdirSync(path.dirname(getIntentPath()), { recursive: true });
+    fs.writeFileSync(getIntentPath(), '# INTENT.md\n\n## 1. Why\n\nJust the why section.\n', 'utf8');
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+
+    await handleIntentShow({ workspace: workspaceDir, json: true });
+
+    const jsonOutput = JSON.parse(logSpy.mock.calls[0][0] as string);
+    expect(jsonOutput.status).toBe('ok');
+    expect(jsonOutput.warnings.length).toBe(4);
+    expect(jsonOutput.warnings.every((w: { code: string }) => w.code === 'missing_section')).toBe(true);
+
+    logSpy.mockRestore();
+  });
+
+  it('outputs text when --json is not set', async () => {
+    writeConfig(true);
+    fs.mkdirSync(path.dirname(getIntentPath()), { recursive: true });
+    fs.writeFileSync(getIntentPath(), VALID_INTENT, 'utf8');
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+
+    await handleIntentShow({ workspace: workspaceDir, json: false });
+
+    const textOutput = logSpy.mock.calls[0][0] as string;
+    expect(textOutput).toContain('INTENT.md');
+    expect(textOutput).toContain('Content hash:');
+    expect(textOutput).toContain('Last edited:');
+    expect(textOutput).toContain('## 1. Why');
+
+    logSpy.mockRestore();
+  });
+});

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({