@principles/pd-cli 1.81.0 → 1.83.0

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

@@ -122,6 +122,11 @@ vi.mock('@principles/core/runtime-v2', () => ({
   }),
   isRuntimeConfigError: vi.fn().mockReturnValue(false),
   validateRuntimeConfig: vi.fn(),
+  resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
+}));
+
+vi.mock('../../src/config-reader.js', () => ({
+  readOutputLanguageFromWorkspace: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
 }));
 
 import { handleRuntimeInternalizationRunOnce } from '../../src/commands/runtime-internalization-run-once.js';
@@ -535,7 +540,7 @@ describe('handleRuntimeInternalizationRunOnce', () => {
     expect(text).toContain('resultRef: philosopher://run-phil-002');
   });
 
-  it('successful dreamer + --enqueue-next returns successorTaskId', async () => {
+  it('auto-enqueue: successful dreamer returns successor info by default', async () => {
     mockWakeOnce.mockResolvedValue({
       decision: 'would_lease',
       taskId: 'task-dreamer-enq-001',
@@ -564,11 +569,11 @@ describe('handleRuntimeInternalizationRunOnce', () => {
 
     const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
     expect(output.enqueueDecision).toBe('successor_created');
-    expect(output.successorTaskId).toBe('task-phil-enq-001');
+    expect(output.successorTaskIds![0]).toBe('task-phil-enq-001');
     expect(output.successorKind).toBe('philosopher');
   });
 
-  it('repeated --enqueue-next returns existing successorTaskId', async () => {
+  it('auto-enqueue: repeated run returns existing successorTaskId', async () => {
     mockWakeOnce.mockResolvedValue({
       decision: 'would_lease',
       taskId: 'task-dreamer-enq-002',
@@ -597,11 +602,11 @@ describe('handleRuntimeInternalizationRunOnce', () => {
 
     const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
     expect(output.enqueueDecision).toBe('successor_exists');
-    expect(output.successorTaskId).toBe('task-phil-enq-002');
+    expect(output.successorTaskIds![0]).toBe('task-phil-enq-002');
     expect(output.successorKind).toBe('philosopher');
   });
 
-  it('--enqueue-next with no_successor does not set successorTaskId', async () => {
+  it('auto-enqueue: no_successor does not set successor info', async () => {
     mockWakeOnce.mockResolvedValue({
       decision: 'would_lease',
       taskId: 'task-dreamer-enq-003',
@@ -629,10 +634,10 @@ describe('handleRuntimeInternalizationRunOnce', () => {
 
     const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
     expect(output.enqueueDecision).toBe('no_successor');
-    expect(output.successorTaskId).toBeUndefined();
+    expect(output.successorTaskIds).toEqual([]);
   });
 
-  it('--enqueue-next with failed run does not call commitNextTaskProposal', async () => {
+  it('auto-enqueue: failed run does not call commitNextTaskProposal', async () => {
     mockWakeOnce.mockResolvedValue({
       decision: 'would_lease',
       taskId: 'task-dreamer-enq-004',
@@ -652,7 +657,7 @@ describe('handleRuntimeInternalizationRunOnce', () => {
     expect(mockCommitNextTaskProposal).not.toHaveBeenCalled();
   });
 
-  it('--enqueue-next without --allow-test-double still blocked', async () => {
+  it('auto-enqueue without --allow-test-double still blocked', async () => {
     await handleRuntimeInternalizationRunOnce({ workspace: WS, runner: 'dreamer', runtime: 'test-double', enqueueNext: true });
 
     expect(process.exitCode).toBe(1);
@@ -880,7 +885,7 @@ describe('handleRuntimeInternalizationRunOnce', () => {
     expect(output.runnerResult.status).toBe('succeeded');
   });
 
-  it('--runner scribe --enqueue-next creates artificer successor', async () => {
+  it('auto-enqueue: --runner scribe creates artificer successor', async () => {
     mockWakeOnce.mockResolvedValue({
       decision: 'would_lease',
       taskId: 'task-scribe-enq-001',
@@ -916,7 +921,7 @@ describe('handleRuntimeInternalizationRunOnce', () => {
 
     const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
     expect(output.enqueueDecision).toBe('successor_created');
-    expect(output.successorTaskId).toBe('task-artificer-enq-001');
+    expect(output.successorTaskIds![0]).toBe('task-artificer-enq-001');
     expect(output.successorKind).toBe('artificer');
   });
 
@@ -979,7 +984,7 @@ describe('handleRuntimeInternalizationRunOnce', () => {
     expect(output.runnerResult.status).toBe('succeeded');
   });
 
-  it('--runner artificer --enqueue-next returns successor decision', async () => {
+  it('auto-enqueue: --runner artificer returns successor decision', async () => {
     mockWakeOnce.mockResolvedValue({
       decision: 'would_lease',
       taskId: 'task-artificer-enq-001',
@@ -1022,7 +1027,7 @@ describe('handleRuntimeInternalizationRunOnce', () => {
 
     const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
     expect(output.enqueueDecision).toBe('successor_created');
-    expect(output.successorTaskId).toBe('task-evaluator-enq-001');
+    expect(output.successorTaskIds![0]).toBe('task-evaluator-enq-001');
     expect(output.successorKind).toBe('evaluator');
   });
 
@@ -1112,7 +1117,7 @@ describe('handleRuntimeInternalizationRunOnce', () => {
     expect(output.runnerResult.status).toBe('succeeded');
   });
 
-  it('--runner evaluator --enqueue-next returns successor decision', async () => {
+  it('auto-enqueue: --runner evaluator returns successor decision', async () => {
     mockWakeOnce.mockResolvedValue({
       decision: 'would_lease',
       taskId: 'task-evaluator-enq-001',
@@ -1155,7 +1160,7 @@ describe('handleRuntimeInternalizationRunOnce', () => {
 
     const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
     expect(output.enqueueDecision).toBe('successor_created');
-    expect(output.successorTaskId).toBe('task-rollout-reviewer-enq-001');
+    expect(output.successorTaskIds![0]).toBe('task-rollout-reviewer-enq-001');
     expect(output.successorKind).toBe('rollout_reviewer');
   });
 
@@ -1208,7 +1213,7 @@ describe('handleRuntimeInternalizationRunOnce', () => {
     expect(output.runnerResult.status).toBe('succeeded');
   });
 
-  it('--runner rollout_reviewer --enqueue-next returns no_successor for prompt channel', async () => {
+  it('auto-enqueue: --runner rollout_reviewer returns no_successor for prompt channel', async () => {
     mockWakeOnce.mockResolvedValue({
       decision: 'would_lease',
       taskId: 'task-rollout-reviewer-enq-001',
@@ -1315,4 +1320,276 @@ describe('handleRuntimeInternalizationRunOnce', () => {
     expect(output.nextAction).toBeTruthy();
     expect(process.exitCode).toBe(1);
   });
+
+  // === Default enqueue successor tests ===
+
+  it('default behavior (no --no-enqueue-next) auto-enqueues successor on runner success', async () => {
+    mockWakeOnce.mockResolvedValue({
+      decision: 'would_lease',
+      taskId: 'task-dreamer-auto-001',
+      taskKind: 'dreamer',
+    });
+
+    mockRun.mockResolvedValue({
+      status: 'succeeded',
+      taskId: 'task-dreamer-auto-001',
+      runId: 'run-auto-001',
+      artifactId: 'pi-art-auto-001',
+      resultRef: 'dreamer://run-auto-001',
+      contextHash: 'ctx-auto',
+      output: { valid: true, taskId: 'task-dreamer-auto-001', candidates: VALID_DREAMER_CANDIDATES, contextRefs: [], generatedAt: new Date().toISOString() },
+      attemptCount: 1,
+    });
+
+    mockCommitNextTaskProposal.mockResolvedValue({
+      decision: 'successor_created',
+      sourceTaskId: 'task-dreamer-auto-001',
+      successorTaskId: 'task-phil-auto-001',
+      successorKind: 'philosopher',
+    });
+
+    // No enqueueNext specified — default should auto-enqueue
+    await handleRuntimeInternalizationRunOnce({ workspace: WS, runner: 'dreamer', runtime: 'test-double', allowTestDouble: true, json: true });
+
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(output.successorEnqueueAttempted).toBe(true);
+    expect(output.successorTasksCreated).toBe(1);
+    expect(output.successorTaskIds).toContain('task-phil-auto-001');
+    expect(output.enqueueDecision).toBe('successor_created');
+    expect(output.successorKind).toBe('philosopher');
+    expect(mockCommitNextTaskProposal).toHaveBeenCalledWith('task-dreamer-auto-001');
+  });
+
+  it('--no-enqueue-next (enqueueNext: false) skips successor enqueue', async () => {
+    mockWakeOnce.mockResolvedValue({
+      decision: 'would_lease',
+      taskId: 'task-dreamer-skip-001',
+      taskKind: 'dreamer',
+    });
+
+    mockRun.mockResolvedValue({
+      status: 'succeeded',
+      taskId: 'task-dreamer-skip-001',
+      runId: 'run-skip-001',
+      artifactId: 'pi-art-skip-001',
+      resultRef: 'dreamer://run-skip-001',
+      contextHash: 'ctx-skip',
+      output: { valid: true, taskId: 'task-dreamer-skip-001', candidates: VALID_DREAMER_CANDIDATES, contextRefs: [], generatedAt: new Date().toISOString() },
+      attemptCount: 1,
+    });
+
+    await handleRuntimeInternalizationRunOnce({ workspace: WS, runner: 'dreamer', runtime: 'test-double', allowTestDouble: true, enqueueNext: false, json: true });
+
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(output.successorEnqueueAttempted).toBe(false);
+    expect(output.nextAction).toContain('--no-enqueue-next');
+    expect(mockCommitNextTaskProposal).not.toHaveBeenCalled();
+  });
+
+  it('successor enqueue failure outputs partial_success with reason and nextAction', async () => {
+    mockWakeOnce.mockResolvedValue({
+      decision: 'would_lease',
+      taskId: 'task-dreamer-fail-001',
+      taskKind: 'dreamer',
+    });
+
+    mockRun.mockResolvedValue({
+      status: 'succeeded',
+      taskId: 'task-dreamer-fail-001',
+      runId: 'run-fail-001',
+      artifactId: 'pi-art-fail-001',
+      resultRef: 'dreamer://run-fail-001',
+      contextHash: 'ctx-fail',
+      output: { valid: true, taskId: 'task-dreamer-fail-001', candidates: VALID_DREAMER_CANDIDATES, contextRefs: [], generatedAt: new Date().toISOString() },
+      attemptCount: 1,
+    });
+
+    mockCommitNextTaskProposal.mockRejectedValue(new Error('database locked'));
+
+    await handleRuntimeInternalizationRunOnce({ workspace: WS, runner: 'dreamer', runtime: 'test-double', allowTestDouble: true, json: true });
+
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(output.decision).toBe('partial_success');
+    expect(output.successorEnqueueAttempted).toBe(true);
+    expect(output.enqueueDecision).toBe('enqueue_failed');
+    expect(output.enqueueReason).toContain('database locked');
+    expect(output.nextAction).toContain('enqueue-successors');
+    expect(output.successorTasksCreated).toBe(0);
+    expect(output.successorTaskIds).toEqual([]);
+  });
+
+  it('runner failure never enqueues successor (default behavior)', async () => {
+    mockWakeOnce.mockResolvedValue({
+      decision: 'would_lease',
+      taskId: 'task-dreamer-nofail-001',
+      taskKind: 'dreamer',
+    });
+
+    mockRun.mockResolvedValue({
+      status: 'failed',
+      taskId: 'task-dreamer-nofail-001',
+      errorCategory: 'execution_failed',
+      failureReason: 'Runtime unavailable',
+      attemptCount: 1,
+    });
+
+    // Default behavior (no --no-enqueue-next)
+    await handleRuntimeInternalizationRunOnce({ workspace: WS, runner: 'dreamer', runtime: 'test-double', allowTestDouble: true, json: true });
+
+    expect(mockCommitNextTaskProposal).not.toHaveBeenCalled();
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(output.successorEnqueueAttempted).toBeUndefined();
+  });
+
+  it('JSON output is single parseable JSON with successor fields', async () => {
+    mockWakeOnce.mockResolvedValue({
+      decision: 'would_lease',
+      taskId: 'task-dreamer-json-001',
+      taskKind: 'dreamer',
+    });
+
+    mockRun.mockResolvedValue({
+      status: 'succeeded',
+      taskId: 'task-dreamer-json-001',
+      runId: 'run-json-001',
+      artifactId: 'pi-art-json-001',
+      resultRef: 'dreamer://run-json-001',
+      contextHash: 'ctx-json',
+      output: { valid: true, taskId: 'task-dreamer-json-001', candidates: VALID_DREAMER_CANDIDATES, contextRefs: [], generatedAt: new Date().toISOString() },
+      attemptCount: 1,
+    });
+
+    mockCommitNextTaskProposal.mockResolvedValue({
+      decision: 'successor_created',
+      sourceTaskId: 'task-dreamer-json-001',
+      successorTaskId: 'task-phil-json-001',
+      successorKind: 'philosopher',
+    });
+
+    await handleRuntimeInternalizationRunOnce({ workspace: WS, runner: 'dreamer', runtime: 'test-double', allowTestDouble: true, json: true });
+
+    const rawOutput = consoleLogSpy.mock.calls[0][0];
+    // Must be single parseable JSON
+    const output = JSON.parse(rawOutput);
+    expect(output).toHaveProperty('successorEnqueueAttempted');
+    expect(output).toHaveProperty('successorTasksCreated');
+    expect(output).toHaveProperty('successorTaskIds');
+    // nextAction may be undefined when successor is successfully created
+    // but must be present on partial_success / no_successor / skipped
+  });
+
+  it('text output for auto-enqueue shows successor info', async () => {
+    mockWakeOnce.mockResolvedValue({
+      decision: 'would_lease',
+      taskId: 'task-dreamer-text-001',
+      taskKind: 'dreamer',
+    });
+
+    mockRun.mockResolvedValue({
+      status: 'succeeded',
+      taskId: 'task-dreamer-text-001',
+      runId: 'run-text-001',
+      artifactId: 'pi-art-text-001',
+      resultRef: 'dreamer://run-text-001',
+      contextHash: 'ctx-text',
+      output: { valid: true, taskId: 'task-dreamer-text-001', candidates: VALID_DREAMER_CANDIDATES, contextRefs: [], generatedAt: new Date().toISOString() },
+      attemptCount: 1,
+    });
+
+    mockCommitNextTaskProposal.mockResolvedValue({
+      decision: 'successor_created',
+      sourceTaskId: 'task-dreamer-text-001',
+      successorTaskId: 'task-phil-text-001',
+      successorKind: 'philosopher',
+    });
+
+    await handleRuntimeInternalizationRunOnce({ workspace: WS, runner: 'dreamer', runtime: 'test-double', allowTestDouble: true, json: false });
+
+    const text = consoleLogSpy.mock.calls.map((c: string[]) => c[0]).join('\n');
+    expect(text).toContain('successor: task-phil-text-001');
+    expect(text).toContain('enqueue_attempted: true');
+    expect(text).toContain('successors_created: 1');
+  });
+});
+
+// === Commander parser-level tests for --no-enqueue-next ===
+// These tests verify that Commander correctly maps --no-enqueue-next to opts.enqueueNext.
+// They exercise the real Commander parsing path, NOT the handler directly.
+// See ERR-063: previous code used opts.noEnqueueNext (always undefined) instead of opts.enqueueNext.
+
+describe('Commander --no-enqueue-next parser wiring', () => {
+  function buildRunOnceCommand(capturedOpts: Record<string, unknown>) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { Command } = require('commander') as typeof import('commander');
+    const program = new Command();
+    program.exitOverride(); // prevent process.exit during tests
+
+    const internalizationCmd = program.command('internalization');
+    internalizationCmd
+      .command('run-once')
+      .description('Wake-and-run: lease the next PI task and execute it')
+      .option('-w, --workspace <path>', 'Workspace directory')
+      .option('--runner <kind>', 'Runner kind', 'dreamer')
+      .option('--runtime <kind>', 'Runtime adapter kind', 'config')
+      .option('--allow-test-double', 'Acknowledge test-double runtime')
+      .option('--no-enqueue-next', 'Skip successor enqueue after successful runner')
+      .option('--timeout-ms <ms>', 'Runner timeout', parseInt)
+      .option('--json', 'Output raw JSON')
+      .action(async (opts) => {
+        Object.assign(capturedOpts, opts);
+      });
+
+    return program;
+  }
+
+  it('with --no-enqueue-next, Commander sets enqueueNext=false', async () => {
+    const captured: Record<string, unknown> = {};
+    const program = buildRunOnceCommand(captured);
+
+    await program.parseAsync([
+      'node', 'pd', 'internalization', 'run-once',
+      '--no-enqueue-next',
+      '--workspace', '/tmp/test',
+      '--runtime', 'test-double',
+      '--allow-test-double',
+      '--json',
+    ]);
+
+    expect(captured).toHaveProperty('enqueueNext', false);
+    expect(captured).not.toHaveProperty('noEnqueueNext');
+  });
+
+  it('without --no-enqueue-next, Commander sets enqueueNext=true (default)', async () => {
+    const captured: Record<string, unknown> = {};
+    const program = buildRunOnceCommand(captured);
+
+    await program.parseAsync([
+      'node', 'pd', 'internalization', 'run-once',
+      '--workspace', '/tmp/test',
+      '--runtime', 'test-double',
+      '--allow-test-double',
+      '--json',
+    ]);
+
+    expect(captured).toHaveProperty('enqueueNext', true);
+  });
+
+  it('opts has no noEnqueueNext property regardless of flag presence', async () => {
+    const capturedWith: Record<string, unknown> = {};
+    const programWith = buildRunOnceCommand(capturedWith);
+    await programWith.parseAsync([
+      'node', 'pd', 'internalization', 'run-once',
+      '--no-enqueue-next', '--workspace', '/tmp/test',
+    ]);
+
+    const capturedWithout: Record<string, unknown> = {};
+    const programWithout = buildRunOnceCommand(capturedWithout);
+    await programWithout.parseAsync([
+      'node', 'pd', 'internalization', 'run-once',
+      '--workspace', '/tmp/test',
+    ]);
+
+    expect(capturedWith).not.toHaveProperty('noEnqueueNext');
+    expect(capturedWithout).not.toHaveProperty('noEnqueueNext');
+  });
 });

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

@@ -21,6 +21,7 @@ vi.mock('@principles/core/runtime-v2', () => ({
   InternalizationOrchestrator: vi.fn().mockImplementation(function () {
     return { wakeOnce: mockWakeOnce };
   }),
+  resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
 }));
 
 import { handleRuntimeInternalizationWakeOnce } from '../../src/commands/runtime-internalization-wake-once.js';

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

@@ -87,6 +87,7 @@ vi.mock('@principles/core/runtime-v2', () => ({
   listPruningReviews: mockListPruningReviews,
   buildMaskedPrincipleSet: mockBuildMaskedPrincipleSet,
   removeOrphanReferencesFromLedger: mockRemoveOrphanReferencesFromLedger,
+  resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
 }));
 
 import { handlePruningReport, handlePruningExplain, handlePruningReview, handlePruningRollback, handlePruningOrphans } from '../../src/commands/runtime-pruning.js';

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

@@ -28,6 +28,7 @@ vi.mock('@principles/core/runtime-v2', () => ({
     warnings: input.warnings ?? [],
   })),
   remediationAction: vi.fn((input) => input),
+  resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
 }));
 
 import { handleRuntimeRecoverySweep } from '../../src/commands/runtime-recovery.js';

package/tests/commands/runtime.test.ts

@@ -32,6 +32,7 @@ vi.mock('@principles/core/runtime-v2', () => ({
     agentId: 'main',
   }),
   isRuntimeConfigError: vi.fn().mockReturnValue(false),
+  resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
   PDRuntimeError: class PDRuntimeError extends Error {
     constructor(public category: string, message: string) {
       super(message);

package/tests/commands/trace.test.ts

@@ -14,6 +14,7 @@ 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', () => ({

package/tests/config-reader.test.ts

@@ -0,0 +1,142 @@
+/**
+ * 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(),
+}));
+
+vi.mock('js-yaml', () => ({
+  default: {
+    load: vi.fn(),
+    JSON_SCHEMA: 'JSON_SCHEMA',
+  },
+}));
+
+import * as fs from 'fs';
+import 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');
+  });
+});