@principles/pd-cli 1.152.12 → 1.152.14

package/tests/commands/telemetry.test.ts

@@ -1,190 +0,0 @@
-/**
- * pd telemetry — behavior tests (PRI-597/598 acceptance at the CLI surface).
- *
- * Covers: JSON purity (cli-1), dry-run default + --confirm (cli-4),
- * enable/disable/reset consent transitions against a temp HOME, status
- * never exposing the secret, preview showing the exact payload with the
- * "Preview only. Nothing was sent." banner.
- */
-
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import {
-  handleTelemetryMutation,
-  handleTelemetryPreview,
-  handleTelemetryStatus,
-} from '../../src/commands/telemetry.js';
-import { getProductTelemetryStatePath, readProductTelemetryControlState } from '@principles/host-runtime';
-
-// Toggleable workspace-resolution failure for the preview fail-loud test.
-// Defaults to delegating to the real resolver so other tests are unaffected.
-const wsMock = vi.hoisted(() => ({ shouldThrow: false }));
-vi.mock('../../src/resolve-workspace.js', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('../../src/resolve-workspace.js')>();
-  return {
-    ...actual,
-    resolveWorkspaceDir: (...args: Parameters<typeof actual.resolveWorkspaceDir>) => {
-      if (wsMock.shouldThrow) {
-        throw new Error('No workspace directory configured.');
-      }
-      return actual.resolveWorkspaceDir(...args);
-    },
-  };
-});
-
-let tmpHome: string;
-let tmpWorkspace: string;
-let originalUserprofile: string | undefined;
-let originalHome: string | undefined;
-let stdoutSpy: ReturnType<typeof vi.spyOn>;
-
-function capturedOutput(): { text: string; json: Record<string, unknown> } {
-  expect(stdoutSpy).toHaveBeenCalled();
-  const text = stdoutSpy.mock.calls[0][0] as string;
-  return { text, json: JSON.parse(text) };
-}
-
-beforeEach(() => {
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-tel-cli-home-'));
-  tmpWorkspace = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-tel-cli-ws-'));
-  // os.homedir() reads USERPROFILE on Windows and HOME on POSIX — set both so
-  // the machine-scope consent store is isolated on every CI runner.
-  originalUserprofile = process.env.USERPROFILE;
-  originalHome = process.env.HOME;
-  process.env.USERPROFILE = tmpHome;
-  process.env.HOME = tmpHome;
-  stdoutSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-});
-
-afterEach(() => {
-  stdoutSpy.mockRestore();
-  if (originalUserprofile === undefined) {
-    delete process.env.USERPROFILE;
-  } else {
-    process.env.USERPROFILE = originalUserprofile;
-  }
-  if (originalHome === undefined) {
-    delete process.env.HOME;
-  } else {
-    process.env.HOME = originalHome;
-  }
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-  fs.rmSync(tmpWorkspace, { recursive: true, force: true });
-});
-
-describe('pd telemetry status', () => {
-  it('--json outputs exactly one parseable JSON object with consent gates and no secret', async () => {
-    await handleTelemetryMutation('enable', { confirm: true, json: true, workspace: tmpWorkspace });
-    stdoutSpy.mockClear();
-    await handleTelemetryStatus({ json: true, workspace: tmpWorkspace });
-    const { text, json } = capturedOutput();
-    expect(stdoutSpy).toHaveBeenCalledTimes(1);
-    expect(json.status).toBe('ok');
-    expect(json.command).toBe('telemetry:status');
-    expect(json.consent).toBe('granted');
-    expect(json.canExport).toBe(false); // flag off + repo-checkout suppression in tests — expected
-    const stateRead = readProductTelemetryControlState(tmpHome);
-    const secret = stateRead.ok ? stateRead.state.telemetrySecret : undefined;
-    expect(secret).toMatch(/^[0-9a-f]{64}$/);
-    expect(text).not.toContain(secret as string);
-    expect(JSON.stringify(json)).not.toContain(secret as string);
-    expect(json.blockers).toEqual(expect.arrayContaining(['feature_flag_disabled']));
-  });
-
-  it('works with no resolvable workspace passed explicitly (machine-scope status)', async () => {
-    // No --workspace: resolution falls back to discovery; machine-scope
-    // fields must render regardless of what discovery finds on this machine.
-    await handleTelemetryStatus({ json: true });
-    const { json } = capturedOutput();
-    expect(json.status).toBe('ok');
-    expect(json.command).toBe('telemetry:status');
-    expect(json.consent).toBe('unset');
-    expect(json.hasSecret).toBe(false);
-    expect(json.flagEnabled).toBeDefined();
-  });
-});
-
-describe('pd telemetry enable/disable/reset (cli-4 dry-run default)', () => {
-  it('enable without --confirm is a dry-run: nothing written', async () => {
-    await handleTelemetryMutation('enable', { json: true });
-    const { json } = capturedOutput();
-    expect(json.applied).toBe(false);
-    expect(json.dryRun).toBe(true);
-    expect(fs.existsSync(getProductTelemetryStatePath(tmpHome))).toBe(false);
-  });
-
-  it('enable --confirm writes granted consent with a secret', async () => {
-    await handleTelemetryMutation('enable', { confirm: true, json: true });
-    const { json } = capturedOutput();
-    expect(json.applied).toBe(true);
-    expect(json.consent).toBe('granted');
-    const state = readProductTelemetryControlState(tmpHome);
-    expect(state.ok && state.state.consent).toBe('granted');
-    expect(state.ok && state.state.telemetrySecret).toMatch(/^[0-9a-f]{64}$/);
-  });
-
-  it('--dry-run and --confirm together are rejected (cli-4 mutex)', async () => {
-    await handleTelemetryMutation('enable', { dryRun: true, confirm: true, json: true });
-    const { json } = capturedOutput();
-    expect(json.ok).toBe(false);
-    expect(process.exitCode).toBe(1);
-    process.exitCode = 0;
-  });
-
-  it('disable --confirm deletes identity and preserves the denied choice', async () => {
-    await handleTelemetryMutation('enable', { confirm: true, json: true, workspace: tmpWorkspace });
-    await handleTelemetryMutation('disable', { confirm: true, json: true });
-    const state = readProductTelemetryControlState(tmpHome);
-    expect(state.ok && state.state.consent).toBe('denied');
-    expect(state.ok && state.state.telemetrySecret).toBeUndefined();
-  });
-
-  it('reset --confirm rotates the secret while consent stays granted', async () => {
-    await handleTelemetryMutation('enable', { confirm: true, json: true, workspace: tmpWorkspace });
-    const before = readProductTelemetryControlState(tmpHome);
-    const secretBefore = before.ok ? before.state.telemetrySecret : undefined;
-    await handleTelemetryMutation('reset', { confirm: true, json: true });
-    const after = readProductTelemetryControlState(tmpHome);
-    expect(after.ok && after.state.consent).toBe('granted');
-    expect(after.ok && after.state.telemetrySecret).not.toBe(secretBefore);
-  });
-});
-
-describe('pd telemetry preview', () => {
-  it('shows the exact snapshot with the never-sent banner and zero network activity', async () => {
-    await handleTelemetryMutation('enable', { confirm: true, json: true, workspace: tmpWorkspace });
-    stdoutSpy.mockClear();
-    await handleTelemetryPreview({ json: true, workspace: tmpWorkspace });
-    const { text, json } = capturedOutput();
-    expect(json.banner).toBe('Preview only. Nothing was sent.');
-    expect(text).toContain('Preview only. Nothing was sent.');
-    const snapshot = json.snapshot as Record<string, unknown>;
-    expect(snapshot.schemaVersion).toBe('1');
-    expect(snapshot.milestones).toBeDefined();
-    // Conservative booleans for an empty workspace fixture.
-    const milestones = snapshot.milestones as Record<string, unknown>;
-    expect(milestones.initialized).toBe(false);
-    expect(milestones.painObserved).toBe(false);
-    // The stored secret never appears in the preview output.
-    const state = readProductTelemetryControlState(tmpHome);
-    const secret = state.ok ? state.state.telemetrySecret : undefined;
-    expect(text).not.toContain(secret ?? 'no-secret');
-  });
-
-  it('fails loud with nextAction when workspace resolution throws', async () => {
-    wsMock.shouldThrow = true;
-    try {
-      await handleTelemetryPreview({ json: true });
-      const { json } = capturedOutput();
-      expect(json.ok).toBe(false);
-      expect(json.reason).toContain('workspace_unresolvable');
-      expect(json.nextAction).toBeDefined();
-      expect(process.exitCode).toBe(1);
-      process.exitCode = 0;
-    } finally {
-      wsMock.shouldThrow = false;
-    }
-  });
-});

package/tests/commands/trace.test.ts

@@ -1,316 +0,0 @@
-/**
- * pd runtime trace show command unit tests.
- *
- * Tests the trace command's external contract via mocked PainChainReadModel.
- * Tests pain-to-ledger chain tracing, latency reporting, consistency checks,
- * and failure classification output.
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import * as path from 'path';
-
-const mockTraceByPainId = vi.fn();
-const mockPainChainClose = vi.fn().mockResolvedValue(undefined);
-
-vi.mock('@principles/core/runtime-v2', () => ({
-  PainChainReadModel: vi.fn().mockImplementation(function () {
-    return { traceByPainId: mockTraceByPainId, close: mockPainChainClose };
-  }),
-  resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
-}));
-
-vi.mock('../../src/resolve-workspace.js', () => ({
-  resolveWorkspaceDir: vi.fn().mockReturnValue('/fake/workspace'),
-}));
-
-import { handleTraceShow } from '../../src/commands/trace.js';
-
-const WS = '/fake/workspace';
-
-function fullChainTrace() {
-  return {
-    painId: 'pain_001',
-    taskId: 'diagnosis_pain_001',
-    runId: 'run_001',
-    artifactId: 'art_001',
-    candidateIds: ['c1', 'c2'],
-    ledgerEntryIds: ['l1'],
-    status: 'succeeded',
-    latencyMs: {
-      painToTask: 100,
-      taskToRun: 200,
-      runToArtifact: 50,
-      artifactToCandidate: 30,
-      candidateToLedger: 20,
-    },
-    failureCategory: null,
-    checkedAt: '2026-05-03T12:00:00.000Z',
-    missingLinks: [],
-  };
-}
-
-function mockProcessExit() {
-  return vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
-}
-
-describe('handleTraceShow', () => {
-  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
-  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    process.exitCode = undefined;
-    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    consoleLogSpy.mockRestore();
-    consoleErrorSpy.mockRestore();
-  });
-
-  it('outputs full chain trace with all fields (--json)', async () => {
-    mockTraceByPainId.mockResolvedValue(fullChainTrace());
-
-    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: true });
-
-    expect(consoleLogSpy).toHaveBeenCalled();
-    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-    expect(jsonOutput.painId).toBe('pain_001');
-    expect(jsonOutput.taskId).toBe('diagnosis_pain_001');
-    expect(jsonOutput.runId).toBe('run_001');
-    expect(jsonOutput.artifactId).toBe('art_001');
-    expect(jsonOutput.candidateIds).toEqual(['c1', 'c2']);
-    expect(jsonOutput.ledgerEntryIds).toEqual(['l1']);
-    expect(jsonOutput.status).toBe('succeeded');
-    expect(jsonOutput.latencyMs).toBeDefined();
-  });
-
-  it('outputs readable text with latency breakdown', async () => {
-    mockTraceByPainId.mockResolvedValue(fullChainTrace());
-
-    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: false });
-
-    const allOutput = consoleLogSpy.mock.calls.map(c => c.join(' ')).join('\n');
-    expect(allOutput).toContain('Pain ID:       pain_001');
-    expect(allOutput).toContain('Task ID:       diagnosis_pain_001');
-    expect(allOutput).toContain('Status:        succeeded');
-    expect(allOutput).toContain('Run ID:        run_001');
-    expect(allOutput).toContain('Artifact ID:   art_001');
-    expect(allOutput).toContain('Candidate IDs:  c1, c2');
-    expect(allOutput).toContain('Ledger Entries: l1');
-    expect(allOutput).toContain('Checked at:    2026-05-03T12:00:00.000Z');
-    expect(allOutput).toContain('Latency:');
-    expect(allOutput).toContain('pain→task:          100ms');
-    expect(allOutput).toContain('task→run:           200ms');
-  });
-
-  it('outputs all latency segments in text mode', async () => {
-    mockTraceByPainId.mockResolvedValue(fullChainTrace());
-
-    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: false });
-
-    const allOutput = consoleLogSpy.mock.calls.map(c => c.join(' ')).join('\n');
-    expect(allOutput).toContain('run→artifact:       50ms');
-    expect(allOutput).toContain('artifact→candidate: 30ms');
-    expect(allOutput).toContain('candidate→ledger:   20ms');
-  });
-
-  it('outputs failure category in text mode when present', async () => {
-    mockTraceByPainId.mockResolvedValue({
-      ...fullChainTrace(),
-      status: 'failed',
-      failureCategory: 'runtime_timeout',
-    });
-
-    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: false });
-
-    const allOutput = consoleLogSpy.mock.calls.map(c => c.join(' ')).join('\n');
-    expect(allOutput).toContain('Failure:       runtime_timeout');
-  });
-
-  it('omits candidate/ledger lines when arrays are empty', async () => {
-    mockTraceByPainId.mockResolvedValue({
-      ...fullChainTrace(),
-      candidateIds: [],
-      ledgerEntryIds: [],
-    });
-
-    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: false });
-
-    const allOutput = consoleLogSpy.mock.calls.map(c => c.join(' ')).join('\n');
-    expect(allOutput).not.toContain('Candidate IDs:');
-    expect(allOutput).not.toContain('Ledger Entries:');
-  });
-
-  it('handles not_found status with exit code 1', async () => {
-    mockTraceByPainId.mockResolvedValue({
-      painId: 'pain_001',
-      taskId: 'diagnosis_pain_001',
-      status: 'not_found',
-      failureCategory: 'runtime_unavailable',
-      checkedAt: '2026-05-03T12:00:00.000Z',
-      missingLinks: ['task'],
-    });
-
-    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: false });
-
-    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('No task found'));
-    expect(process.exitCode).toBe(1);
-  });
-
-  it('handles not_found in text mode with derived taskId and workspace', async () => {
-    mockTraceByPainId.mockResolvedValue({
-      painId: 'pain_001',
-      taskId: 'diagnosis_pain_001',
-      status: 'not_found',
-      failureCategory: 'runtime_unavailable',
-      checkedAt: '2026-05-03T12:00:00.000Z',
-      missingLinks: ['task'],
-    });
-
-    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: false });
-
-    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('diagnosis_pain_001'));
-    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining(path.resolve(WS)));
-  });
-
-  it('handles error status with config_missing in JSON mode', async () => {
-    mockTraceByPainId.mockResolvedValue({
-      painId: 'pain_001',
-      taskId: 'diagnosis_pain_001',
-      status: 'error',
-      failureCategory: 'config_missing',
-      checkedAt: '2026-05-03T12:00:00.000Z',
-      missingLinks: ['state_manager_init'],
-    });
-
-    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: true });
-
-    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-    expect(jsonOutput.status).toBe('error');
-    expect(jsonOutput.failureCategory).toBe('config_missing');
-    expect(jsonOutput.message).toContain('Failed to initialize state manager');
-    expect(process.exitCode).toBe(1);
-  });
-
-  it('handles error status in text mode', async () => {
-    mockTraceByPainId.mockResolvedValue({
-      painId: 'pain_001',
-      taskId: 'diagnosis_pain_001',
-      status: 'error',
-      failureCategory: 'config_missing',
-      checkedAt: '2026-05-03T12:00:00.000Z',
-      missingLinks: ['state_manager_init'],
-    });
-
-    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: false });
-
-    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to open workspace'));
-    expect(process.exitCode).toBe(1);
-  });
-
-  it('reports missing links in text output', async () => {
-    mockTraceByPainId.mockResolvedValue({
-      ...fullChainTrace(),
-      status: 'degraded',
-      failureCategory: 'ledger_write_failed',
-      missingLinks: ['candidate:c1 consumed but missing from ledger'],
-    });
-
-    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: false });
-
-    const allOutput = consoleLogSpy.mock.calls.map(c => c.join(' ')).join('\n');
-    expect(allOutput).toContain('Missing links');
-    expect(allOutput).toContain('candidate:c1 consumed but missing from ledger');
-    expect(process.exitCode).toBe(1);
-  });
-
-  it('handles missing painId gracefully', async () => {
-    await handleTraceShow({ painId: '', workspace: WS, json: false });
-
-    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('--pain-id'));
-    expect(process.exitCode).toBe(1);
-  });
-
-  it('reports failed status with exit code 1', async () => {
-    mockTraceByPainId.mockResolvedValue({
-      ...fullChainTrace(),
-      status: 'failed',
-      failureCategory: 'runtime_timeout',
-    });
-
-    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: false });
-
-    expect(process.exitCode).toBe(1);
-  });
-
-  it('reports degraded status with exit code 1', async () => {
-    mockTraceByPainId.mockResolvedValue({
-      ...fullChainTrace(),
-      status: 'degraded',
-      failureCategory: 'candidate_missing',
-      missingLinks: ['No candidates generated for succeeded task'],
-    });
-
-    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: false });
-
-    expect(process.exitCode).toBe(1);
-  });
-
-  it('closes PainChainReadModel after use', async () => {
-    mockTraceByPainId.mockResolvedValue(fullChainTrace());
-
-    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: true });
-
-    expect(mockPainChainClose).toHaveBeenCalled();
-  });
-
-  it('closes PainChainReadModel even when traceByPainId throws', async () => {
-    mockTraceByPainId.mockRejectedValue(new Error('Database connection failed'));
-
-    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: true });
-
-    expect(mockPainChainClose).toHaveBeenCalled();
-  });
-
-  it('handles traceByPainId throwing an error', async () => {
-    mockTraceByPainId.mockRejectedValue(new Error('Database connection failed'));
-
-    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: true });
-
-    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-    expect(jsonOutput.status).toBe('error');
-    expect(jsonOutput.failureCategory).toBe('runtime_unavailable');
-    expect(jsonOutput.message).toContain('Database connection failed');
-    expect(process.exitCode).toBe(1);
-  });
-
-  it('outputs not_found in JSON format with correct fields', async () => {
-    mockTraceByPainId.mockResolvedValue({
-      painId: 'pain_001',
-      taskId: 'diagnosis_pain_001',
-      status: 'not_found',
-      failureCategory: 'runtime_unavailable',
-      checkedAt: '2026-05-03T12:00:00.000Z',
-      missingLinks: ['task'],
-    });
-
-    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: true });
-
-    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0]);
-    expect(jsonOutput.painId).toBe('pain_001');
-    expect(jsonOutput.taskId).toBe('diagnosis_pain_001');
-    expect(jsonOutput.status).toBe('not_found');
-    expect(jsonOutput.message).toContain('No task found');
-    expect(jsonOutput.workspace).toBe(path.resolve(WS));
-    expect(process.exitCode).toBe(1);
-  });
-
-  it('does not set exit code for succeeded status', async () => {
-    mockTraceByPainId.mockResolvedValue(fullChainTrace());
-
-    await handleTraceShow({ painId: 'pain_001', workspace: WS, json: true });
-
-    expect(process.exitCode).toBeUndefined();
-  });
-});

package/tests/config-reader.test.ts

@@ -1,143 +0,0 @@
-/**
- * Tests for config-reader — readOutputLanguageFromWorkspace (PRI-336).
- *
- * Validates:
- * - No config file → legitimate default, no warning
- * - No principles section → legitimate default, no warning
- * - No outputLanguage key → legitimate default, no warning
- * - Read error → degraded with read_error reason + nextAction (ERR-002/009)
- * - YAML parse error → degraded with yaml_parse_error reason + nextAction
- * - Invalid config root → degraded with invalid_config_root reason + nextAction
- * - Invalid principles structure → degraded with invalid_principles_structure reason + nextAction
- * - Valid outputLanguage → resolved value
- * - Invalid outputLanguage value → degraded with invalid value warning
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { readOutputLanguageFromWorkspace } from '../../src/config-reader.js';
-
-// Mock fs and yaml
-vi.mock('fs', () => ({
-  existsSync: vi.fn(),
-  readFileSync: vi.fn(),
-}));
-
-// Mock js-yaml with NAMED exports (matches `import * as yaml from 'js-yaml'`
-// in config-reader.ts). js-yaml 5.x removed the default export, so the mock
-// must provide `load` and `JSON_SCHEMA` as named members, not under `default`.
-vi.mock('js-yaml', () => ({
-  load: vi.fn(),
-  JSON_SCHEMA: 'JSON_SCHEMA',
-}));
-
-import * as fs from 'fs';
-import * as yaml from 'js-yaml';
-
-const mockExistsSync = vi.mocked(fs.existsSync);
-const mockReadFileSync = vi.mocked(fs.readFileSync);
-const mockYamlLoad = vi.mocked(yaml.load);
-
-beforeEach(() => {
-  vi.clearAllMocks();
-});
-
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-describe('readOutputLanguageFromWorkspace', () => {
-  it('returns default with no warning when config file does not exist', () => {
-    mockExistsSync.mockReturnValue(false);
-    const result = readOutputLanguageFromWorkspace('/workspace');
-    expect(result.outputLanguage).toBe('zh-CN');
-    expect(result.degradationWarning).toBeUndefined();
-  });
-
-  it('returns default with no warning when principles section is missing', () => {
-    mockExistsSync.mockReturnValue(true);
-    mockReadFileSync.mockReturnValue('version: 1\n');
-    mockYamlLoad.mockReturnValue({ version: 1 });
-    const result = readOutputLanguageFromWorkspace('/workspace');
-    expect(result.outputLanguage).toBe('zh-CN');
-    expect(result.degradationWarning).toBeUndefined();
-  });
-
-  it('returns default with no warning when outputLanguage key is missing', () => {
-    mockExistsSync.mockReturnValue(true);
-    mockReadFileSync.mockReturnValue('version: 1\nprinciples: {}\n');
-    mockYamlLoad.mockReturnValue({ version: 1, principles: {} });
-    const result = readOutputLanguageFromWorkspace('/workspace');
-    expect(result.outputLanguage).toBe('zh-CN');
-    expect(result.degradationWarning).toBeUndefined();
-  });
-
-  it('returns valid outputLanguage when configured', () => {
-    mockExistsSync.mockReturnValue(true);
-    mockReadFileSync.mockReturnValue('version: 1\nprinciples:\n  outputLanguage: en\n');
-    mockYamlLoad.mockReturnValue({ version: 1, principles: { outputLanguage: 'en' } });
-    const result = readOutputLanguageFromWorkspace('/workspace');
-    expect(result.outputLanguage).toBe('en');
-    expect(result.degradationWarning).toBeUndefined();
-  });
-
-  it('returns degraded with read_error when readFileSync throws', () => {
-    mockExistsSync.mockReturnValue(true);
-    mockReadFileSync.mockImplementation(() => { throw new Error('EACCES: permission denied'); });
-    const result = readOutputLanguageFromWorkspace('/workspace');
-    expect(result.outputLanguage).toBe('zh-CN');
-    expect(result.degradationWarning).toContain('Failed to read .pd/config.yaml');
-    expect(result.degradationWarning).toContain('nextAction');
-    expect(result.degradationWarning).toContain('Check file permissions');
-  });
-
-  it('returns degraded with yaml_parse_error when yaml.load throws', () => {
-    mockExistsSync.mockReturnValue(true);
-    mockReadFileSync.mockReturnValue('invalid: yaml: [broken');
-    mockYamlLoad.mockImplementation(() => { throw new Error('YAML syntax error'); });
-    const result = readOutputLanguageFromWorkspace('/workspace');
-    expect(result.outputLanguage).toBe('zh-CN');
-    expect(result.degradationWarning).toContain('Failed to parse .pd/config.yaml');
-    expect(result.degradationWarning).toContain('nextAction');
-    expect(result.degradationWarning).toContain('Fix YAML syntax');
-  });
-
-  it('returns degraded with invalid_config_root when parsed YAML is not an object', () => {
-    mockExistsSync.mockReturnValue(true);
-    mockReadFileSync.mockReturnValue('"just a string"');
-    mockYamlLoad.mockReturnValue('just a string');
-    const result = readOutputLanguageFromWorkspace('/workspace');
-    expect(result.outputLanguage).toBe('zh-CN');
-    expect(result.degradationWarning).toContain('root is not an object');
-    expect(result.degradationWarning).toContain('nextAction');
-  });
-
-  it('returns degraded with invalid_config_root when parsed YAML is an array', () => {
-    mockExistsSync.mockReturnValue(true);
-    mockReadFileSync.mockReturnValue('- item1\n- item2\n');
-    mockYamlLoad.mockReturnValue(['item1', 'item2']);
-    const result = readOutputLanguageFromWorkspace('/workspace');
-    expect(result.outputLanguage).toBe('zh-CN');
-    expect(result.degradationWarning).toContain('root is not an object');
-  });
-
-  it('returns degraded with invalid_principles_structure when principles is not an object', () => {
-    mockExistsSync.mockReturnValue(true);
-    mockReadFileSync.mockReturnValue('version: 1\nprinciples: "not an object"\n');
-    mockYamlLoad.mockReturnValue({ version: 1, principles: 'not an object' });
-    const result = readOutputLanguageFromWorkspace('/workspace');
-    expect(result.outputLanguage).toBe('zh-CN');
-    expect(result.degradationWarning).toContain('principles field is not an object');
-    expect(result.degradationWarning).toContain('nextAction');
-  });
-
-  it('returns degraded with invalid value warning when outputLanguage is invalid', () => {
-    mockExistsSync.mockReturnValue(true);
-    mockReadFileSync.mockReturnValue('version: 1\nprinciples:\n  outputLanguage: fr\n');
-    mockYamlLoad.mockReturnValue({ version: 1, principles: { outputLanguage: 'fr' } });
-    const result = readOutputLanguageFromWorkspace('/workspace');
-    expect(result.outputLanguage).toBe('zh-CN');
-    expect(result.degradationWarning).toContain('invalid');
-    expect(result.degradationWarning).toContain('fr');
-    expect(result.degradationWarning).toContain('nextAction');
-  });
-});