@principles/pd-cli 1.145.0 → 1.145.2

package/src/commands/pain-list.ts

@@ -0,0 +1,203 @@
+/**
+ * pd pain list command — PRI-640 (Governance Signal Host Attribution v0.1)
+ *
+ * Read-only: lists canonical pain_events rows from trajectory.db with their
+ * host attribution. `--host` filters by openclaw / codex / unknown.
+ *
+ * Usage:
+ *   pd pain list [--workspace <path>] [--limit N] [--host openclaw|codex|unknown] [--json]
+ *
+ * Host semantics (SPEC §6/§12): host_kind is observability metadata only.
+ * NULL (legacy / manual / unprovable) is reported as `unknown` — never guessed.
+ * On a pre-PRI-640 database without the host_kind column every row reports
+ * `unknown` and a `host_kind_column_missing` warning is emitted (rc-9).
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { resolveWorkspaceDir } from '../resolve-workspace.js';
+
+export type PainListHostFilter = 'openclaw' | 'codex' | 'unknown';
+
+export interface PainListOptions {
+  workspace?: string;
+  limit?: number;
+  host?: string;
+  json?: boolean;
+}
+
+export interface PainListEntry {
+  /** Canonical pain identity; `row:<id>` when the legacy row has none. */
+  painId: string;
+  source: string;
+  /** 'openclaw' | 'codex' | 'unknown' — unknown covers NULL/unprovable. */
+  host: PainListHostFilter | 'unknown';
+  score: number;
+  severity: string | null;
+  createdAt: string;
+  runtimeTaskId: string | null;
+}
+
+export interface PainListResult {
+  count: number;
+  pains: PainListEntry[];
+  workspace: string;
+  hostFilter: PainListHostFilter | null;
+  warnings: string[];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function ownField(row: unknown, key: string): unknown {
+  return isRecord(row) && Object.hasOwn(row, key) ? row[key] : undefined;
+}
+
+/** Runtime Contract #1/#4: validate each DB row; skip malformed rows loudly. */
+function toPainEntry(row: unknown): PainListEntry | null {
+  const id = ownField(row, 'id');
+  const source = ownField(row, 'source');
+  const score = ownField(row, 'score');
+  const createdAt = ownField(row, 'created_at');
+  if (typeof id !== 'number' || typeof source !== 'string' || typeof score !== 'number' || typeof createdAt !== 'string') {
+    return null;
+  }
+  const canonicalPainId = ownField(row, 'canonical_pain_id');
+  const hostKind = ownField(row, 'host_kind');
+  const severity = ownField(row, 'severity');
+  const runtimeTaskId = ownField(row, 'runtime_task_id');
+  const host: PainListEntry['host'] =
+    hostKind === 'openclaw' || hostKind === 'codex' ? hostKind : 'unknown';
+  return {
+    painId: typeof canonicalPainId === 'string' && canonicalPainId.length > 0 ? canonicalPainId : `row:${id}`,
+    source,
+    host,
+    score,
+    severity: typeof severity === 'string' ? severity : null,
+    createdAt,
+    runtimeTaskId: typeof runtimeTaskId === 'string' && runtimeTaskId.length > 0 ? runtimeTaskId : null,
+  };
+}
+
+export async function listPains(dbPath: string, options: { limit?: number; host?: PainListHostFilter } = {}): Promise<PainListResult> {
+  const Database = (await import('better-sqlite3')).default;
+  const db = new Database(dbPath, { readonly: true });
+  try {
+    const warnings: string[] = [];
+    const columns: unknown[] = db.prepare('PRAGMA table_info(pain_events)').all();
+    const hasHostKindColumn = columns.some((row) => ownField(row, 'name') === 'host_kind');
+    if (!hasHostKindColumn) {
+      warnings.push('host_kind_column_missing');
+    }
+
+    const params: (string | number)[] = [];
+    let query = 'SELECT id, source, score, severity, created_at, canonical_pain_id, runtime_task_id';
+    query += hasHostKindColumn ? ', host_kind' : ", NULL AS host_kind";
+    query += ' FROM pain_events WHERE 1=1';
+    if (options.host === 'unknown') {
+      query += hasHostKindColumn ? ' AND host_kind IS NULL' : '';
+    } else if (options.host === 'openclaw' || options.host === 'codex') {
+      if (!hasHostKindColumn) {
+        return { count: 0, pains: [], workspace: path.dirname(path.dirname(dbPath)), hostFilter: options.host, warnings };
+      }
+      query += ' AND host_kind = ?';
+      params.push(options.host);
+    }
+    query += ' ORDER BY created_at DESC, id DESC';
+    const limit = options.limit ?? 20;
+    query += ' LIMIT ?';
+    params.push(limit);
+
+    const rawRows: unknown[] = db.prepare(query).all(...params);
+    const skipped = rawRows.length - rawRows.map(toPainEntry).filter((entry) => entry !== null).length;
+    if (skipped > 0) {
+      warnings.push(`malformed_rows_skipped:${skipped}`);
+    }
+    const pains = rawRows
+      .map(toPainEntry)
+      .filter((entry): entry is PainListEntry => entry !== null);
+    return {
+      count: pains.length,
+      pains,
+      workspace: path.dirname(path.dirname(dbPath)),
+      hostFilter: options.host ?? null,
+      warnings,
+    };
+  } finally {
+    db.close();
+  }
+}
+
+function printHuman(result: PainListResult): void {
+  const filterNote = result.hostFilter ? ` (host: ${result.hostFilter})` : '';
+  console.log(`Pain events — ${result.count} shown${filterNote}`);
+  console.log('─'.repeat(96));
+  for (const pain of result.pains) {
+    const painId = pain.painId.length > 40 ? `${pain.painId.slice(0, 37)}...` : pain.painId;
+    console.log(`  ${pain.createdAt}  host=${pain.host.padEnd(8)} score=${String(pain.score).padEnd(3)} ${pain.severity ?? '-'.padEnd(6)} ${pain.source}`);
+    console.log(`    id: ${painId}${pain.runtimeTaskId ? ` | task: ${pain.runtimeTaskId}` : ''}`);
+  }
+  console.log('─'.repeat(96));
+  for (const warning of result.warnings) {
+    console.error(`WARN: ${warning}`);
+  }
+  if (result.warnings.includes('host_kind_column_missing')) {
+    console.error('Next: run `pd runtime init --workspace <dir>` (or restart the OpenClaw plugin) to migrate this workspace schema.');
+  }
+}
+
+export async function handlePainList(opts: PainListOptions): Promise<void> {
+  const { workspace, limit: rawLimit, host: rawHost, json } = opts;
+
+  if (rawHost !== undefined && rawHost !== 'openclaw' && rawHost !== 'codex' && rawHost !== 'unknown') {
+    const message = `invalid host filter: expected openclaw | codex | unknown, got ${rawHost}`;
+    if (json) {
+      console.log(JSON.stringify({ status: 'failed', reason: 'invalid_host_filter', message, nextAction: 'Pass --host openclaw, --host codex, or --host unknown.' }));
+    } else {
+      console.error('Error: ' + message);
+      console.error('Next: Pass --host openclaw, --host codex, or --host unknown.');
+    }
+    process.exit(1);
+    return; // guard: test stubs of process.exit continue execution (cli-2-exit-stops)
+  }
+  const hostFilter: PainListHostFilter | undefined = rawHost;
+
+  let effectiveLimit = 20;
+  if (rawLimit !== undefined) {
+    if (!Number.isInteger(rawLimit) || rawLimit < 1 || rawLimit > 10000) {
+      const message = `invalid limit: limit must be an integer between 1 and 10000, got ${rawLimit}`;
+      if (json) {
+        console.log(JSON.stringify({ status: 'failed', reason: 'invalid_limit', message, nextAction: 'Pass --limit with a valid integer (1-10000).' }));
+      } else {
+        console.error('Error: ' + message);
+        console.error('Next: Pass --limit with a valid integer (1-10000).');
+      }
+      process.exit(1);
+      return; // guard: test stubs of process.exit continue execution (cli-2-exit-stops)
+    }
+    effectiveLimit = rawLimit;
+  }
+
+  const workspaceDir = resolveWorkspaceDir(workspace);
+  const dbPath = path.join(workspaceDir, '.state', 'trajectory.db');
+  if (!fs.existsSync(dbPath)) {
+    const message = `trajectory database not found at ${dbPath}`;
+    if (json) {
+      console.log(JSON.stringify({ status: 'failed', reason: 'trajectory_db_not_found', message, nextAction: 'Initialize the PD workspace first (pd runtime init), or pass --workspace pointing at an initialized workspace.' }));
+    } else {
+      console.error('Error: ' + message);
+      console.error('Next: Initialize the PD workspace first (pd runtime init), or pass --workspace pointing at an initialized workspace.');
+    }
+    process.exit(1);
+    return; // guard: test stubs of process.exit continue execution (cli-2-exit-stops)
+  }
+
+  const result = await listPains(dbPath, { limit: effectiveLimit, ...(hostFilter ? { host: hostFilter } : {}) });
+
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  printHuman(result);
+}

package/src/commands/pain-retry.ts

@@ -24,7 +24,6 @@ import {
   DiagRouterRunner,
   DefaultDiagRootCauseValidator,
   DefaultDiagDistillerValidator,
-  DisabledDiagnosticianRunner,
   type DiagnosticianRunnerLike,
   TestDoubleRuntimeAdapter,
   OpenClawCliRuntimeAdapter,
@@ -33,8 +32,8 @@ import {
   isRuntimeConfigError,
   CandidateIntakeService,
   run as diagnoseRun,
-  isFeatureEnabled,
   SPLIT_PIPELINE_TOTAL_TIMEOUT_MS,
+  resolveDiagnosticianCapability,
   PrincipleTreeLedgerAdapter,
   SqliteDeadLetterStore,
   PainSignalBridge,
@@ -44,7 +43,7 @@ import {
 } from '@principles/core/runtime-v2';
 import type { PDRuntimeAdapter, RuntimeConfig, OutputLanguage } from '@principles/core/runtime-v2';
 import type { Command } from 'commander';
-import { loadPdConfig, computeFlagsFromLoadResult } from '../services/pd-config-loader.js';
+import { loadPdConfig } from '../services/pd-config-loader.js';
 import { resolveRuntimeFromPdConfig } from '../services/resolve-runtime-from-pd-config.js';
 import { createHash } from 'node:crypto';
 /** Layer 0 content-hash (design §6.1); injected so diag writers can attach predecessorSummary hashes. */
@@ -226,6 +225,9 @@ function refuseExit(opts: PainRetryOptions, payload: { status?: string; painId:
     }));
   } else {
     console.error(`error: ${payload.message ?? payload.reason}`);
+    // PRI-638: the reason must be visible in text mode too — an Owner kill
+    // switch (capability_disabled) must not read like a runtime fault.
+    console.error(`reason: ${payload.reason}`);
     console.error(`nextAction: ${payload.nextAction}`);
   }
   process.exit(1);
@@ -245,6 +247,28 @@ export async function handlePainRetry(opts: PainRetryOptions): Promise<void> {
 
   const { taskId } = resolution;
 
+  // PRI-638: the capability gate comes BEFORE runtime resolution. Previously an
+  // Owner-disabled Diagnostician surfaced here as `missing_runtime` ("no
+  // .pd/config.yaml runtime binding found"), which told the Owner their config
+  // was broken when they had deliberately switched the agent off. This reads the
+  // same canonical authority (`internalAgents.agents.diagnostician.enabled`) the
+  // runtime factory uses — the CLI owns no kill switch of its own.
+  const capability = resolveDiagnosticianCapability(
+    (() => {
+      const loaded = loadPdConfig(workspaceDir);
+      return loaded.ok ? loaded.effective : loaded.defaults;
+    })(),
+  );
+  if (!capability.available) {
+    return refuseExit(opts, {
+      painId: opts.painId,
+      taskId,
+      reason: capability.reason,
+      message: capability.message,
+      nextAction: capability.nextAction,
+    });
+  }
+
   // Step 2: Look up task and validate
   const stateManager = new RuntimeStateManager({ workspaceDir });
 
@@ -522,17 +546,18 @@ export async function handlePainRetry(opts: PainRetryOptions): Promise<void> {
     const outputLangResult = readOutputLanguageFromWorkspace(workspaceDir);
     const outputLanguage: OutputLanguage | undefined = outputLangResult.outputLanguage;
 
-    // Check if split pipeline is enabled — 3 serial LLM calls need more time
-    const configLoadResult = loadPdConfig(workspaceDir);
-    const featureFlags = computeFlagsFromLoadResult(configLoadResult);
-    const isSplitPipeline = isFeatureEnabled(featureFlags, 'diagnostician_split_pipeline');
-    const pipelineTimeoutMs = isSplitPipeline ? SPLIT_PIPELINE_TOTAL_TIMEOUT_MS : 300_000;
+    // PRI-638: implementation selection is gone. The split pipeline is the only
+    // Diagnostician implementation, so it always runs with its documented
+    // 3-stage budget; `diagnostician_split_pipeline` no longer selects a runner
+    // nor disables capability (the capability gate above owns that).
+    const pipelineTimeoutMs = SPLIT_PIPELINE_TOTAL_TIMEOUT_MS;
     // BUG-1 (PRI-442): extract effectiveConfig so ADR-0019 LLM rate-limit
     // degradation (isDegradationEnabled in base-peer-runner) can read the
     // diagnostician_llm_degradation feature flag. Without this, the runners
     // receive no effectiveConfig and degradation silently never fires.
     // CR-1 (CodeRabbit P2, rc-9): warn when config load failed so the
     // fallback to defaults is observable — no silent degradation.
+    const configLoadResult = loadPdConfig(workspaceDir);
     if (!configLoadResult.ok) {
       const errSummary = configLoadResult.errors
         .map((e) => `${e.path}: ${e.reason}`)
@@ -543,34 +568,29 @@ export async function handlePainRetry(opts: PainRetryOptions): Promise<void> {
     }
     const effectiveConfig = configLoadResult.ok ? configLoadResult.effective : configLoadResult.defaults;
 
-    let runner: DiagnosticianRunnerLike;
-    if (isSplitPipeline) {
-      const resolvedKind = typeof runtimeAdapter.kind === 'function' ? runtimeAdapter.kind() : runtimeKind;
-      const perStageTimeoutMs = pipelineTimeoutMs / 3;
-      const rootCauseRunner = new DiagRootCauseRunner(
-        { stateManager, runtimeAdapter, eventEmitter, artifactStore: stateManager.piArtifactStore, validator: new DefaultDiagRootCauseValidator(), contextAssembler, contentHashFn },
-        { owner: 'pd-cli-pain-retry', runtimeKind: resolvedKind, outputLanguage, timeoutMs: perStageTimeoutMs, effectiveConfig },
-      );
-      const distillerRunner = new DiagDistillerRunner(
-        { stateManager, runtimeAdapter, eventEmitter, artifactStore: stateManager.piArtifactStore, validator: new DefaultDiagDistillerValidator(), contentHashFn },
-        { owner: 'pd-cli-pain-retry', runtimeKind: resolvedKind, outputLanguage, timeoutMs: perStageTimeoutMs, effectiveConfig },
-      );
-      const routerRunner = new DiagRouterRunner(
-        { stateManager, runtimeAdapter, eventEmitter, artifactStore: stateManager.piArtifactStore, committer, contentHashFn },
-        { owner: 'pd-cli-pain-retry', runtimeKind: resolvedKind, outputLanguage, timeoutMs: perStageTimeoutMs, effectiveConfig },
-      );
-
-      runner = new SplitDiagnosticianRunner({
-        rootCauseRunner,
-        distillerRunner,
-        routerRunner,
-        stateManager,
-        committer,
-        perStageTimeoutMs,
-      });
-    } else {
-      runner = new DisabledDiagnosticianRunner();
-    }
+    const resolvedKind = typeof runtimeAdapter.kind === 'function' ? runtimeAdapter.kind() : runtimeKind;
+    const perStageTimeoutMs = pipelineTimeoutMs / 3;
+    const rootCauseRunner = new DiagRootCauseRunner(
+      { stateManager, runtimeAdapter, eventEmitter, artifactStore: stateManager.piArtifactStore, validator: new DefaultDiagRootCauseValidator(), contextAssembler, contentHashFn },
+      { owner: 'pd-cli-pain-retry', runtimeKind: resolvedKind, outputLanguage, timeoutMs: perStageTimeoutMs, effectiveConfig },
+    );
+    const distillerRunner = new DiagDistillerRunner(
+      { stateManager, runtimeAdapter, eventEmitter, artifactStore: stateManager.piArtifactStore, validator: new DefaultDiagDistillerValidator(), contentHashFn },
+      { owner: 'pd-cli-pain-retry', runtimeKind: resolvedKind, outputLanguage, timeoutMs: perStageTimeoutMs, effectiveConfig },
+    );
+    const routerRunner = new DiagRouterRunner(
+      { stateManager, runtimeAdapter, eventEmitter, artifactStore: stateManager.piArtifactStore, committer, contentHashFn },
+      { owner: 'pd-cli-pain-retry', runtimeKind: resolvedKind, outputLanguage, timeoutMs: perStageTimeoutMs, effectiveConfig },
+    );
+
+    const runner: DiagnosticianRunnerLike = new SplitDiagnosticianRunner({
+      rootCauseRunner,
+      distillerRunner,
+      routerRunner,
+      stateManager,
+      committer,
+      perStageTimeoutMs,
+    });
 
     // ── Dead letter replay branch ──────────────────────────────────────────
     // When task was null but a dead letter was found, replay the pain signal

package/src/commands/runtime-init.ts

@@ -95,12 +95,23 @@ const DB_NAMES = {
  */
 function buildConfigYaml(workspaceDir: string): string {
   const config = getDefaultPdConfig();
+  // PRI-637: `pd runtime init` is PD machinery writing a bootstrap snapshot, so
+  // every flag entry records `source: 'system'` — an ORIGIN HINT, NOT proof that
+  // the value lacks Owner intent (direct .pd/config.yaml editing is a supported
+  // path; an Owner may later pin behavior on top of this entry). Labels are
+  // metadata only; effective values are unchanged. If a flag graduates, system-
+  // origin entries are cleanup CANDIDATES that still require explicit Owner
+  // confirmation before removal.
+  const features: Record<string, unknown> = {};
+  for (const [id, entry] of Object.entries(config.features)) {
+    features[id] = { category: entry.category, enabled: entry.enabled, source: 'system' };
+  }
   const yamlObj: Record<string, unknown> = {
     version: config.version,
     workspace: {
       default: workspaceDir,
     },
-    features: config.features,
+    features,
     runtimeProfiles: config.runtimeProfiles,
     internalAgents: config.internalAgents,
     ui: config.ui,

package/src/index.ts

@@ -10,6 +10,7 @@ import { Command } from 'commander';
 import { handlePainRecord } from './commands/pain-record.js';
 import { registerPainRetryCommand } from './commands/pain-retry.js';
 import { handlePainEvidence } from './commands/pain-evidence.js';
+import { handlePainList } from './commands/pain-list.js';
 import { handleSamplesList } from './commands/samples-list.js';
 import { handleSamplesReview } from './commands/samples-review.js';
 import { handleEvolutionTasksList } from './commands/evolution-tasks-list.js';
@@ -130,6 +131,17 @@ painCmd
 
 registerPainRetryCommand(painCmd);
 
+painCmd
+  .command('list')
+  .description('List canonical pain events with host attribution (PRI-640)')
+  .option('-w, --workspace <path>', 'Workspace directory')
+  .option('-l, --limit <number>', 'Max entries to show (default: 20)', parseInt)
+  .option('--host <kind>', 'Filter by host: openclaw | codex | unknown')
+  .option('--json', 'Output raw JSON')
+  .action(async (opts) => {
+    await handlePainList(opts);
+  });
+
 painCmd
   .command('evidence')
   .description('Show recent TRIGGER_DECISION log entries — pain admission gate decisions only (PEAT-B2)')

package/tests/bdd/cli-contract.steps.ts

@@ -133,6 +133,9 @@ vi.mock('@principles/core/runtime-v2', () => {
     OpenClawCliRuntimeAdapter: vi.fn().mockImplementation(function () { return {}; }),
     PiAiRuntimeAdapter: vi.fn().mockImplementation(function () { return {}; }),
     SPLIT_PIPELINE_TOTAL_TIMEOUT_MS: 300000,
+    // PRI-638: capability gate — available by default so the BDD scenarios
+    // exercise the pre-existing success/failure JSON contracts unchanged.
+    resolveDiagnosticianCapability: vi.fn(() => ({ available: true })),
     PDRuntimeError: class PDRuntimeError extends Error {
       constructor(public category: string, message: string) {
         super(message);

package/tests/commands/diagnose.test.ts

@@ -108,6 +108,8 @@ vi.mock('@principles/core/runtime-v2', () => {
     OpenClawCliRuntimeAdapter: vi.fn().mockImplementation(function () { return {}; }),
     PiAiRuntimeAdapter: vi.fn().mockImplementation(function () { return {}; }),
     SPLIT_PIPELINE_TOTAL_TIMEOUT_MS: 300000,
+    // PRI-638: capability gate — available by default; disabled cases override this.
+    resolveDiagnosticianCapability: vi.fn((): { available: boolean; reason?: string; message?: string; nextAction?: string } => ({ available: true })),
     PDRuntimeError: class PDRuntimeError extends Error {
       constructor(public category: string, message: string) {
         super(message);
@@ -1714,3 +1716,83 @@ describe('BUG-2 (PRI-442): sourcePainId resolution for dreamer seed', () => {
     exitSpy.mockRestore();
   });
 });
+
+// ── PRI-638: unified capability-disabled semantics ───────────────────────────
+//
+// The CLI owns no kill switch of its own: it reads the canonical authority
+// (internalAgents.agents.diagnostician.enabled) through the same resolver the
+// runtime factory uses. Owner-disabled must come out as a structured
+// `capability_disabled` result — never as missing_runtime / config failure —
+// with no adapter constructed and no provider contacted.
+
+describe('PRI-638: pd diagnose run when Diagnostician capability is disabled', () => {
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    const runtimeV2 = await import('@principles/core/runtime-v2');
+    vi.mocked(runtimeV2.resolveDiagnosticianCapability).mockReturnValue({
+      available: false,
+      reason: 'capability_disabled',
+      message: "Agent 'diagnostician' is disabled",
+      nextAction: "Enable agent 'diagnostician' in .pd/config.yaml internalAgents.agents.diagnostician.enabled",
+    });
+  });
+
+  afterEach(async () => {
+    const runtimeV2 = await import('@principles/core/runtime-v2');
+    vi.mocked(runtimeV2.resolveDiagnosticianCapability).mockReset();
+  });
+
+  it('DIAG-638-01: --json emits a structured capability_disabled result and exits 1', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handleDiagnoseRun({
+      taskId: 'diag_task-1',
+      workspace: '/tmp/fake-workspace',
+      runtime: 'test-double',
+      json: true,
+    } as DiagnoseRunOptions);
+
+    const jsonLine = logSpy.mock.calls
+      .map((c) => String(c[0]))
+      .find((line) => line.trim().startsWith('{'));
+    expect(jsonLine).toBeDefined();
+    const parsed = JSON.parse(jsonLine as string);
+    expect(parsed.reason).toBe('capability_disabled');
+    expect(parsed.nextAction).toContain('internalAgents.agents.diagnostician.enabled');
+    expect(parsed.message).toContain('disabled');
+
+    // Kill switch fires before any runtime machinery: no adapter, no runner.
+    const runtimeV2 = await import('@principles/core/runtime-v2');
+    expect(runtimeV2.TestDoubleRuntimeAdapter).not.toHaveBeenCalled();
+    expect(runtimeV2.SplitDiagnosticianRunner).not.toHaveBeenCalled();
+    expect(exitSpy).toHaveBeenCalledWith(1);
+
+    logSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  it('DIAG-638-02: human-readable output names the reason and the recovery action', async () => {
+    const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handleDiagnoseRun({
+      taskId: 'diag_task-1',
+      workspace: '/tmp/fake-workspace',
+      runtime: 'test-double',
+      json: false,
+    } as DiagnoseRunOptions);
+
+    const out = errSpy.mock.calls.map((c) => String(c[0])).join('\n');
+    expect(out).toContain('diagnostician');
+    expect(out).toContain('capability_disabled');
+    expect(out).toContain('internalAgents.agents.diagnostician.enabled');
+
+    const runtimeV2b = await import('@principles/core/runtime-v2');
+    expect(runtimeV2b.TestDoubleRuntimeAdapter).not.toHaveBeenCalled();
+    expect(exitSpy).toHaveBeenCalledWith(1);
+
+    errSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+});