@principles/pd-cli 1.82.0 → 1.84.0

package/src/commands/runtime-uat.ts

@@ -17,6 +17,12 @@ import { execFileSync } from 'child_process';
 import { fileURLToPath } from 'node:url';
 import * as path from 'path';
 import * as fs from 'fs';
+import {
+  guardUatWorkspace,
+  formatGuardRefusal,
+  type GuardResult,
+  type GuardRefusal,
+} from '../utils/production-workspace-guard.js';
 
 // ── Types ────────────────────────────────────────────────────────────────────
 
@@ -25,6 +31,7 @@ interface UatOptions {
   count?: number;
   minSuccessRate?: number;
   json?: boolean;
+  allowProductionWorkspaceForUat?: boolean;
 }
 
 interface PainRecordResult {
@@ -73,6 +80,8 @@ export function parseUatArgs(argv: string[]): UatOptions {
     } else if (argv[i] === '--min-success-rate') {
       const rate = parseFloat(argv[++i] ?? '1.0');
       args.minSuccessRate = isNaN(rate) ? 1.0 : rate;
+    } else if (argv[i] === '--allow-production-workspace-for-uat') {
+      args.allowProductionWorkspaceForUat = true;
     }
   }
   return args;
@@ -153,8 +162,6 @@ interface IterationConfig {
 export function runUatIteration(config: IterationConfig): PainRecordResult {
   const { iteration, reason, workspace, timeoutMs = 300_000 } = config;
   const iterStart = Date.now();
-
-  // eslint-disable-next-line @typescript-eslint/init-declarations
   let recordOutput: string;
   try {
     recordOutput = pd(['pain', 'record', '--reason', reason, '--score', '85', '--source', 'manual', '--json'], workspace, timeoutMs);
@@ -173,7 +180,6 @@ export function runUatIteration(config: IterationConfig): PainRecordResult {
   }
 
   const wallTimeMs = Date.now() - iterStart;
-  // eslint-disable-next-line @typescript-eslint/init-declarations
   let parsed: Record<string, unknown>;
   try {
     parsed = parseJsonOutput(recordOutput) as Record<string, unknown>;
@@ -190,7 +196,6 @@ export function runUatIteration(config: IterationConfig): PainRecordResult {
     };
   }
 
-  // eslint-disable-next-line @typescript-eslint/init-declarations
   let auditStatus: string;
   try {
     const auditOut = pd(['candidate', 'audit', '--json'], workspace, 30_000);
@@ -276,6 +281,37 @@ export async function handleRuntimeUat(opts: UatOptions): Promise<void> {
   if (!workspace) {
     console.error('Error: --workspace <path> is required');
     process.exit(1);
+    return;
+  }
+
+  // PRI-334: Guard against writing to production workspace
+  const guardResult: GuardResult = guardUatWorkspace(workspace, 'pd runtime uat');
+
+  if (guardResult.refused && !opts.allowProductionWorkspaceForUat) {
+    // Fail loud with structured reason and nextAction (EP-03/EP-04)
+    const refused: GuardRefusal = guardResult;
+    const refusalOutput = formatGuardRefusal(
+      refused,
+      'pd runtime uat',
+      !!opts.json
+    );
+
+    if (opts.json) {
+      console.log(refusalOutput);
+    } else {
+      console.error(refusalOutput);
+    }
+
+    process.exit(1);
+    return;
+  }
+
+  if (guardResult.refused && opts.allowProductionWorkspaceForUat) {
+    // Escape hatch used: warn but allow
+    console.error('[pd-cli] WARNING: --allow-production-workspace-for-uat is set.');
+    console.error('  Test/synthetic data will be written to your production workspace.');
+    console.error('  This is not recommended and may pollute your real PD state.');
+    console.error('');
   }
 
   console.error(`[${new Date().toISOString()}] Runtime V2 Chain UAT — workspace: ${workspace}, count: ${count}`);
@@ -284,6 +320,7 @@ export async function handleRuntimeUat(opts: UatOptions): Promise<void> {
   if (!process.env.MINIMAX_CN_API_KEY) {
     console.error('Error: MINIMAX_CN_API_KEY environment variable not set');
     process.exit(1);
+    return;
   }
 
   const results: PainRecordResult[] = [];
@@ -332,6 +369,7 @@ export async function handleRuntimeUat(opts: UatOptions): Promise<void> {
     console.error(`FAIL: successRate=${summary.successRate} (threshold: ${minSuccessRate}) ` +
       `ledger=${summary.ledgerConsistencyOk} candidates=${summary.allHaveCandidates} ledger=${summary.allHaveLedger}`);
     process.exit(1);
+    return;
   }
 
   console.error('');

package/src/config-reader.ts

@@ -0,0 +1,122 @@
+/**
+ * Config reader for pd-cli — reads outputLanguage from .pd/config.yaml.
+ *
+ * This is an I/O boundary module (pd-cli is the I/O layer).
+ * Uses core's `resolveOutputLanguage` for validation and degradation.
+ *
+ * ERR entries:
+ * - ERR-001: No `as` bypasses on untrusted parsed YAML — use isRecord type guard
+ * - ERR-002: Graceful degradation includes reason + nextAction
+ * - ERR-009: Malformed values fail loud with structured warning
+ * - ERR-013: Object.hasOwn() for untrusted keys
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import yaml from 'js-yaml';
+import { resolveOutputLanguage, DEFAULT_OUTPUT_LANGUAGE } from '@principles/core/runtime-v2';
+import type { ResolvedOutputLanguage } from '@principles/core/runtime-v2';
+
+/**
+ * Type guard: checks that a value is a non-null plain object (Record<string, unknown>).
+ * Per ERR-001: use type guards instead of `as` casts at trust boundaries.
+ */
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Build a structured degradation warning for config read errors.
+ * Per ERR-002/ERR-009: every degraded path must include reason + nextAction.
+ */
+function configDegradationWarning(
+  reason: 'read_error' | 'yaml_parse_error' | 'invalid_config_root' | 'invalid_principles_structure',
+  detail: string,
+): string {
+  const reasons: Record<typeof reason, { msg: string; action: string }> = {
+    read_error: {
+      msg: `Failed to read .pd/config.yaml: ${detail}`,
+      action: 'Check file permissions and ensure .pd/config.yaml is readable',
+    },
+    yaml_parse_error: {
+      msg: `Failed to parse .pd/config.yaml: ${detail}`,
+      action: 'Fix YAML syntax errors in .pd/config.yaml',
+    },
+    invalid_config_root: {
+      msg: `.pd/config.yaml root is not an object: ${detail}`,
+      action: 'Ensure .pd/config.yaml has a valid YAML mapping at the top level',
+    },
+    invalid_principles_structure: {
+      msg: `.pd/config.yaml principles field is not an object: ${detail}`,
+      action: 'Ensure principles field in .pd/config.yaml is a YAML mapping (e.g. principles: { outputLanguage: zh-CN })',
+    },
+  };
+  const entry = reasons[reason];
+  return `${entry.msg}. Falling back to default: ${DEFAULT_OUTPUT_LANGUAGE}. nextAction: ${entry.action}`;
+}
+
+/**
+ * Read principles.outputLanguage from workspace .pd/config.yaml.
+ *
+ * Returns ResolvedOutputLanguage with:
+ * - outputLanguage: the effective language to use
+ * - degradationWarning: present if config was malformed or unreadable (ERR-002/ERR-009)
+ *
+ * Distinguishes between "not configured" (legitimate default, no warning)
+ * and "config broken" (degraded with reason + nextAction).
+ */
+export function readOutputLanguageFromWorkspace(workspaceDir: string): ResolvedOutputLanguage {
+  const configPath = path.join(workspaceDir, '.pd', 'config.yaml');
+
+  if (!fs.existsSync(configPath)) {
+    // No config file → legitimate default, no warning
+    return resolveOutputLanguage(undefined);
+  }
+
+  let raw: string;
+  try {
+    raw = fs.readFileSync(configPath, 'utf8');
+  } catch (err) {
+    return {
+      outputLanguage: DEFAULT_OUTPUT_LANGUAGE,
+      degradationWarning: configDegradationWarning('read_error', String(err)),
+    };
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = yaml.load(raw, { schema: yaml.JSON_SCHEMA });
+  } catch (err) {
+    return {
+      outputLanguage: DEFAULT_OUTPUT_LANGUAGE,
+      degradationWarning: configDegradationWarning('yaml_parse_error', String(err)),
+    };
+  }
+
+  if (!isRecord(parsed)) {
+    return {
+      outputLanguage: DEFAULT_OUTPUT_LANGUAGE,
+      degradationWarning: configDegradationWarning('invalid_config_root', typeof parsed),
+    };
+  }
+
+  if (!Object.hasOwn(parsed, 'principles')) {
+    // No principles section → legitimate default, no warning
+    return resolveOutputLanguage(undefined);
+  }
+
+  const principlesRaw = parsed.principles;
+  if (!isRecord(principlesRaw)) {
+    return {
+      outputLanguage: DEFAULT_OUTPUT_LANGUAGE,
+      degradationWarning: configDegradationWarning('invalid_principles_structure', typeof principlesRaw),
+    };
+  }
+
+  if (!Object.hasOwn(principlesRaw, 'outputLanguage')) {
+    // No outputLanguage key → legitimate default, no warning
+    return resolveOutputLanguage(undefined);
+  }
+
+  return resolveOutputLanguage(principlesRaw.outputLanguage);
+}

package/src/index.ts

@@ -475,12 +475,14 @@ runtimeCmd
   .option('--count <n>', 'Number of iterations (default: 5, max: 50)', parseInt)
   .option('--min-success-rate <rate>', 'Minimum success rate threshold (default: 1.0)', parseFloat)
   .option('--json', 'Output machine-readable JSON summary')
+  .option('--allow-production-workspace-for-uat', 'DANGEROUS: Allow UAT to write to production workspace (NOT RECOMMENDED)')
   .action(async (opts) => {
     await handleRuntimeUat({
       workspace: opts.workspace,
       count: opts.count,
       minSuccessRate: opts.minSuccessRate,
       json: opts.json,
+      allowProductionWorkspaceForUat: opts.allowProductionWorkspaceForUat,
     });
   });
 

package/src/utils/production-workspace-guard.test.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect } from 'vitest';
+import * as path from 'path';
+import * as os from 'os';
+import {
+  isProductionWorkspace,
+  guardUatWorkspace,
+  getSafeUatWorkspacePath,
+  formatGuardRefusal,
+  type GuardRefusal,
+} from './production-workspace-guard.js';
+
+const PRODUCTION_PATHS = [
+  'D:\\.openclaw\\workspace',
+  'C:\\.openclaw\\workspace',
+  'C:\\Users\\Administrator\\.openclaw\\workspace',
+  path.join(os.homedir(), '.openclaw', 'workspace'),
+];
+
+const SAFE_PATHS = [
+  'D:\\.openclaw\\workspace-test',
+  'D:\\.openclaw\\workspace-backup',
+  path.join(os.tmpdir(), 'pd-uat-workspace'),
+  path.join(os.tmpdir(), 'pd-test-any'),
+  'C:\\completely-unrelated\\work',
+];
+
+describe('isProductionWorkspace', () => {
+  it.each(PRODUCTION_PATHS)('detects production: %s', (prodPath) => {
+    expect(isProductionWorkspace(path.resolve(prodPath))).toBe(true);
+  });
+  it.each(SAFE_PATHS)('allows safe: %s', (safePath) => {
+    expect(isProductionWorkspace(path.resolve(safePath))).toBe(false);
+  });
+  it('detects descendant', () => {
+    expect(isProductionWorkspace(path.resolve('D:\\.openclaw\\workspace\\sub\\child'))).toBe(true);
+  });
+  it('rejects sibling workspace-test (ERR-030)', () => {
+    expect(isProductionWorkspace(path.resolve('D:\\.openclaw\\workspace-test'))).toBe(false);
+  });
+  it('rejects sibling workspace-backup (ERR-030)', () => {
+    expect(isProductionWorkspace(path.resolve('D:\\.openclaw\\workspace-backup'))).toBe(false);
+  });
+});
+
+describe('guardUatWorkspace', () => {
+  describe('refused', () => {
+    it.each(PRODUCTION_PATHS)('refuses production: %s', (prodPath) => {
+      const r = guardUatWorkspace(prodPath, 'test');
+      expect(r.refused).toBe(true);
+      if (r.refused) {
+        expect(r.reason).toContain('UAT/runtime test commands are not allowed');
+        expect(r.nextAction).toContain('temporary workspace');
+      }
+    });
+    it('refuses descendant', () => {
+      expect(guardUatWorkspace('D:\\.openclaw\\workspace\\subdir', 'test').refused).toBe(true);
+    });
+  });
+  describe('allowed', () => {
+    it.each(SAFE_PATHS)('allows safe: %s', (safePath) => {
+      const r = guardUatWorkspace(safePath, 'test');
+      expect(r.refused).toBe(false);
+    });
+    it.each(['D:\\.openclaw\\workspace-test', 'D:\\.openclaw\\workspace-backup'])(
+      'allows sibling: %s (ERR-030)', (p) => {
+        expect(guardUatWorkspace(p, 'test').refused).toBe(false);
+      });
+  });
+});
+
+describe('JSON output (EP-04)', () => {
+  it('outputs single object with reason and nextAction', () => {
+    const r = guardUatWorkspace('D:\\.openclaw\\workspace', 'test');
+    const json = formatGuardRefusal(r as GuardRefusal, 'test', true);
+    const parsed = JSON.parse(json);
+    expect(parsed).toMatchObject({
+      status: 'refused', reason: expect.any(String), nextAction: expect.any(String),
+      workspace: expect.any(String), isProduction: true,
+    });
+    expect(Array.isArray(parsed)).toBe(false);
+  });
+  it('no console prefixes in JSON', () => {
+    const r = guardUatWorkspace('D:\\.openclaw\\workspace', 'test');
+    const json = formatGuardRefusal(r as GuardRefusal, 'test', true);
+    expect(json).not.toContain('[pd-cli]');
+    expect(json).not.toContain('ERROR:');
+    expect(json.trim().startsWith('{')).toBe(true);
+  });
+});
+
+describe('text output (EP-03)', () => {
+  it('includes reason and nextAction', () => {
+    const r = guardUatWorkspace('D:\\.openclaw\\workspace', 'test');
+    const text = formatGuardRefusal(r as GuardRefusal, 'test', false);
+    expect(text).toContain('Reason:');
+    expect(text).toContain('Next Action:');
+  });
+});
+
+describe('getSafeUatWorkspacePath', () => {
+  it('returns deterministic temp path', () => {
+    const p1 = getSafeUatWorkspacePath();
+    const p2 = getSafeUatWorkspacePath();
+    expect(p1).toBe(p2);
+    expect(p1).toContain(os.tmpdir());
+    expect(p1).toContain('pd-uat-workspace');
+  });
+});

package/src/utils/production-workspace-guard.ts

@@ -0,0 +1,219 @@
+/**
+ * Production Workspace Guard
+ *
+ * Prevents UAT/runtime test commands from writing to production workspaces.
+ *
+ * Production workspaces are:
+ * - D:\.openclaw\workspace
+ * - C:\Users\Administrator\.openclaw\workspace
+ * - And the default workspace resolved by OpenClaw configuration
+ *
+ * This module follows ERR-030 (path prefix matching must use segment boundaries)
+ * and EP-03/EP-04 (fail loud with structured reason and nextAction).
+ */
+
+import * as path from 'path';
+import * as os from 'os';
+import { existsSync } from 'fs';
+
+// ── Production workspace paths ─────────────────────────────────────────────────
+
+/**
+ * List of production workspace paths that should be protected from UAT/test writes.
+ * These are the default paths where PD is typically installed and used for real work.
+ */
+const PRODUCTION_WORKSPACE_PATHS = [
+  // Windows default
+  path.resolve('D:\\.openclaw\\workspace'),
+  path.resolve('C:\\.openclaw\\workspace'),
+  path.resolve('C:\\Users\\Administrator\\.openclaw\\workspace'),
+  path.resolve('C:\\Users\\Admin\\.openclaw\\workspace'),
+  // Unix-like defaults
+  path.resolve(path.join(os.homedir(), '.openclaw', 'workspace')),
+  // macOS-specific
+  path.resolve(path.join(os.homedir(), '.openclaw', 'workspace')),
+];
+
+// ── Resolution helpers ───────────────────────────────────────────────────────
+
+/**
+ * Resolve the workspace path from environment variable or current directory.
+ */
+export function resolveWorkspacePath(inputPath?: string): string {
+  if (!inputPath) {
+    // Default to current directory
+    return path.resolve(process.cwd());
+  }
+  return path.resolve(inputPath);
+}
+
+/**
+ * Check if a path is a production workspace.
+ *
+ * This follows ERR-030: path matching must use segment boundaries (path.sep)
+ * to avoid false positives on sibling directories like "workspace-backup".
+ *
+ * @param resolvedPath - The absolute, normalized workspace path to check
+ * @returns true if the path is a production workspace
+ */
+export function isProductionWorkspace(resolvedPath: string): boolean {
+  const normalized = resolvedPath.toLowerCase();
+
+  for (const prodPath of PRODUCTION_WORKSPACE_PATHS) {
+    const normalizedProd = prodPath.toLowerCase();
+
+    // Exact match
+    if (normalized === normalizedProd) {
+      return true;
+    }
+
+    // Descendant match: must have path separator after prefix
+    // ERR-030: "startsWith" without separator matches sibling directories
+    if (normalized.startsWith(normalizedProd + path.sep)) {
+      return true;
+    }
+
+    // Handle Windows path variations
+    // D:\.openclaw\workspace should not match D:\.openclaw\workspace-backup
+    // Use case-insensitive comparison (already normalized)
+    if (path.sep === '\\') {
+      // Windows: check both forward and backslash
+      if (normalized.startsWith(normalizedProd + '/')) {
+        return true;
+      }
+      if (normalized.startsWith(normalizedProd.replace(/\\/g, '/') + '/')) {
+        return true;
+      }
+      if (normalized.startsWith(normalizedProd.replace(/\\/g, '/') + '\\')) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+// ── Guard logic ──────────────────────────────────────────────────────────────
+
+/**
+ * Guard result for UAT/test commands attempting to write to production workspace.
+ */
+export interface GuardRefusal {
+  refused: true;
+  reason: string;
+  nextAction: string;
+  workspace: string;
+  isProduction: true;
+}
+
+/**
+ * Guard result allowing the operation.
+ */
+export interface GuardAllowed {
+  refused: false;
+  workspace: string;
+  isProduction: false;
+}
+
+export type GuardResult = GuardRefusal | GuardAllowed;
+
+/**
+ * Check if a workspace is protected from UAT/test writes.
+ *
+ * This is the main guard function for UAT/runtime test commands.
+ * It returns a structured result following EP-03/EP-04 requirements.
+ *
+ * @param inputPath - The workspace path to check (optional, resolves to cwd if not provided)
+ * @param commandContext - Context string for the error message (e.g., "pd runtime uat")
+ * @returns GuardResult indicating if the operation is allowed or refused
+ */
+export function guardUatWorkspace(
+  inputPath: string | undefined,
+  _commandContext: string
+): GuardResult {
+  const resolved = resolveWorkspacePath(inputPath);
+
+  // PRI-334: Guard check should happen BEFORE file existence check
+  // This prevents production workspace writes even if directory doesn't exist yet
+  if (isProductionWorkspace(resolved)) {
+    return {
+      refused: true,
+      workspace: resolved,
+      isProduction: true,
+      reason: `UAT/runtime test commands are not allowed to write to the production workspace (${resolved}). This prevents test/synthetic data from polluting your real PD state.`,
+      nextAction: `Use a temporary workspace for testing (recommended: ${os.tmpdir()}/pd-uat-workspace) or explicitly confirm you understand the risk by using --allow-production-workspace-for-uat (not recommended).`,
+    };
+  }
+
+  if (!existsSync(resolved)) {
+    // Non-existent workspace is safe to use (will be created)
+    return {
+      refused: false,
+      workspace: resolved,
+      isProduction: false,
+    };
+  }
+
+  return {
+    refused: false,
+    workspace: resolved,
+    isProduction: false,
+  };
+}
+
+/**
+ * Get a safe UAT workspace path in the system temp directory.
+ *
+ * This follows the safe execution path requirement from PRI-334.
+ */
+export function getSafeUatWorkspacePath(): string {
+  const tempDir = os.tmpdir();
+  // Create a unique but deterministic path for UAT workspaces
+  const uatWorkspace = path.join(tempDir, 'pd-uat-workspace');
+  return uatWorkspace;
+}
+
+/**
+ * Check if --allow-production-workspace-for-uat flag is set.
+ *
+ * This is the escape hatch for cases where the operator explicitly wants to run UAT on production.
+ * The flag must be very explicit in both name and output (as required by PRI-334).
+ */
+export function isProductionWorkspaceAllowed(): boolean {
+  // Check if the flag was parsed and passed through opts
+  // This will be called from command handlers after Commander parses flags
+  return false; // Placeholder; actual check depends on Commander opts
+}
+
+/**
+ * Format guard refusal for console output.
+ *
+ * Follows EP-03/EP-04: structured reason + nextAction.
+ */
+export function formatGuardRefusal(refusal: GuardRefusal, commandContext: string, jsonMode = false): string {
+  if (jsonMode) {
+    // JSON mode: output exactly one JSON object with reason and nextAction
+    return JSON.stringify(
+      {
+        status: 'refused',
+        reason: refusal.reason,
+        nextAction: refusal.nextAction,
+        workspace: refusal.workspace,
+        isProduction: refusal.isProduction,
+      },
+      null,
+      2
+    );
+  }
+
+  // Text mode: human-readable structured output
+  return [
+    `[pd-cli] ERROR: ${commandContext} - workspace guard triggered`,
+    '',
+    `Reason: ${refusal.reason}`,
+    `Next Action: ${refusal.nextAction}`,
+    `Workspace: ${refusal.workspace}`,
+    '',
+    'This guard prevents UAT/runtime test data from polluting your production workspace.',
+  ].join('\n');
+}

package/tests/commands/candidate-audit-repair.test.ts

@@ -93,6 +93,7 @@ vi.mock('@principles/core/runtime-v2', () => ({
   RuntimeStateManager: MockRuntimeStateManager,
   loadLedger: mockLoadLedger,
   getLedgerFilePathPublic: mockGetLedgerFilePath,
+  resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
 }));
 
 vi.mock('../../src/principle-tree-ledger-adapter.js', () => ({

package/tests/commands/candidate-intake.test.ts

@@ -70,6 +70,7 @@ vi.mock('@principles/core/runtime-v2', () => ({
   CandidateIntakeService: MockCandidateIntakeService,
   CandidateIntakeError: MockCandidateIntakeError,
   RuntimeStateManager: MockRuntimeStateManager,
+  resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
 }));
 
 vi.mock('../../src/principle-tree-ledger-adapter.js', () => ({

package/tests/commands/candidate-internalization-backfill.test.ts

@@ -89,6 +89,7 @@ vi.mock('@principles/core/runtime-v2', async (importOriginal) => {
       warnings: input.warnings ?? [],
     })),
     remediationAction: vi.fn((input: unknown) => input),
+    resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
   };
 });
 

package/tests/commands/candidate-internalize.test.ts

@@ -27,6 +27,7 @@ vi.mock('@principles/core/runtime-v2', async (importOriginal) => {
     ...original,
     RuntimeStateManager: MockRuntimeStateManager,
     decideInternalizationRoute: vi.fn(),
+    resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
   };
 });
 

package/tests/commands/candidate-route.test.ts

@@ -31,6 +31,7 @@ const { mockStateManager, MockRuntimeStateManager } = vi.hoisted(() => {
 vi.mock('@principles/core/runtime-v2', () => ({
   RuntimeStateManager: MockRuntimeStateManager,
   decideInternalizationRoute: vi.fn(),
+  resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
 }));
 
 vi.mock('../../src/resolve-workspace.js', () => ({

package/tests/commands/diagnose.test.ts

@@ -78,6 +78,7 @@ vi.mock('@principles/core/runtime-v2', () => {
       agentId: 'main',
     }),
     isRuntimeConfigError: vi.fn().mockReturnValue(false),
+    resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
     run: vi.fn().mockResolvedValue({
       status: 'succeeded',
       taskId: 'test-task-1',
@@ -101,6 +102,10 @@ vi.mock('../../src/principle-tree-ledger-adapter.js', () => ({
   PrincipleTreeLedgerAdapter: MockPrincipleTreeLedgerAdapter,
 }));
 
+vi.mock('../../src/config-reader.js', () => ({
+  readOutputLanguageFromWorkspace: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
+}));
+
 import { handleDiagnoseRun, type DiagnoseRunOptions } from '../../src/commands/diagnose.js';
 
 const SUCCEEDED_RESULT = {

package/tests/commands/health.test.ts

@@ -38,6 +38,7 @@ vi.mock('@principles/core/runtime-v2', () => ({
   }),
   auditCandidateLedgerConsistency: mockAuditCandidateLedgerConsistency,
   getLedgerFilePathPublic: vi.fn().mockReturnValue('/fake/workspace/.state/principle_training_state.json'),
+  resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
 }));
 
 vi.mock('../../src/resolve-workspace.js', () => ({

package/tests/commands/pain-record.test.ts

@@ -34,6 +34,7 @@ vi.mock('@principles/core/runtime-v2', () => ({
     agentId: 'main',
   }),
   isRuntimeConfigError: vi.fn().mockReturnValue(false),
+  resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
 }));
 
 import { handlePainRecord } from '../../src/commands/pain-record.js';

package/tests/commands/pain-retry.test.ts

@@ -103,6 +103,7 @@ vi.mock('@principles/core/runtime-v2', () => {
     CandidateIntakeService: MockCandidateIntakeService,
     resolveRuntimeConfig: mockResolveRuntimeConfig,
     isRuntimeConfigError: vi.fn().mockReturnValue(false),
+    resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
     run: mockRun,
     status: vi.fn(),
   };
@@ -112,6 +113,10 @@ vi.mock('../../src/principle-tree-ledger-adapter.js', () => ({
   PrincipleTreeLedgerAdapter: MockPrincipleTreeLedgerAdapter,
 }));
 
+vi.mock('../../src/config-reader.js', () => ({
+  readOutputLanguageFromWorkspace: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
+}));
+
 import { handlePainRetry } from '../../src/commands/pain-retry.js';
 
 // ── Test Data ──────────────────────────────────────────────────────────────────

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

@@ -20,6 +20,7 @@ vi.mock('@principles/core/runtime-v2', async (importOriginal) => {
         },
       };
     }),
+    resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
   };
 });