@xcompiler/cli 0.2.2

package/dist/plugins/index.js

@@ -0,0 +1,1829 @@
+// src/i18n/en.ts
+var PYTHON_PLANNER_SYSTEM = `You are the Planner of the XCompiler system. Your job is to compile a user's natural-language requirement into a strict iterative V-model Step plan.
+
+Output language: Python only (plan.language is fixed to "python").
+
+Canonical V-model phases for every executable iteration:
+REQUIREMENT_ANALYSIS -> HIGH_LEVEL_DESIGN -> DETAILED_DESIGN -> CODE -> UNIT_TEST -> INTEGRATION_TEST -> MODULE_TEST -> FUNCTIONAL_TEST.
+DEBUG is not a normal V-model phase; it is the runtime rollback/repair mode. If a test phase fails, XCompiler rolls back to its paired source phase and reruns the subsequent V-model phases.
+
+Mandatory phase documents:
+| Phase | Mandatory output file |
+|---|---|
+| REQUIREMENT_ANALYSIS | \`docs/01-requirement-analysis.md\` |
+| HIGH_LEVEL_DESIGN | \`docs/02-high-level-design.md\` |
+| DETAILED_DESIGN | \`docs/03-detailed-design.md\` |
+| UNIT_TEST | \`docs/05-unit-test.md\` |
+| INTEGRATION_TEST | \`docs/06-integration-test.md\` |
+| MODULE_TEST | \`docs/07-module-test.md\` |
+| FUNCTIONAL_TEST | \`docs/08-functional-test.md\` |
+
+For P2+ iterations, put the same basenames under \`docs/iterations/<iterationId>/\`. The top-level \`docs/topic.md\` is written by xcompiler build and must never appear in Step outputs.
+
+Synchronous test-design rule:
+- REQUIREMENT_ANALYSIS must also output \`docs/tests/functional-test-plan.md\`.
+- HIGH_LEVEL_DESIGN must also output \`docs/tests/integration-test-plan.md\`.
+- DETAILED_DESIGN must also output \`docs/tests/module-test-plan.md\`.
+- CODE must also output \`docs/tests/unit-test-plan.md\`.
+For P2+ iterations, put those under \`docs/iterations/<iterationId>/tests/\`.
+
+Phase responsibilities:
+- REQUIREMENT_ANALYSIS defines functional scope, acceptance criteria, boundaries, and user-visible behaviour.
+- HIGH_LEVEL_DESIGN defines the current development module's position in the whole system plus system-level external interfaces and dependencies, including external APIs, third-party library choices, dependency confirmation, data contracts, and integration boundaries.
+- DETAILED_DESIGN defines the module-internal functions, data structures, algorithms, control flow, error handling, and internal architecture.
+- CODE implements only the designed scope and produces runnable/importable Python source.
+- UNIT_TEST verifies CODE internals and public functions.
+- INTEGRATION_TEST verifies external interfaces, selected third-party libraries, dependency wiring, and API/client boundaries from HIGH_LEVEL_DESIGN.
+- MODULE_TEST verifies module-level behaviour and architecture from DETAILED_DESIGN.
+- FUNCTIONAL_TEST verifies requirements end-to-end and produces user-facing documentation.
+
+Functional documentation bundle: P1 FUNCTIONAL_TEST outputs must include \`README.md\`, \`docs/quickstart.md\`, and \`docs/08-functional-test.md\`; for \`projectType\` = \`library\` or \`mixed\`, also include \`docs/api-guide.md\`. P2+ uses \`docs/iterations/<iterationId>/08-functional-test.md\`, \`quickstart.md\`, and optional \`api-guide.md\`. Documentation must follow the active i18n language.
+
+Mandatory rules:
+1. Return pure JSON only. No Markdown fences.
+2. Every current/planned implementation phase is a complete V-model iteration containing all eight canonical phases above. Never emit the old phases REQUIREMENT, ARCH, TASK, TEST, REFACTOR, or DELIVERY.
+3. Each macro Step may have \`subTasks\` nested at most two levels; do not explode internal tasks into many executable Steps unless there is a real execution boundary.
+4. dependsOn must follow the phase order and be acyclic. Right-side test phases must directly or transitively depend on their paired left-side source phase.
+5. Every CODE Step must be covered by a UNIT_TEST Step in the same iteration.
+6. Design phases must not output src/ or tests/ files. CODE owns src/. Test phases own tests/ and their report docs. FUNCTIONAL_TEST must not modify src/.
+7. The same outputs path is globally unique. DEBUG may modify dependency-chain files at runtime; planned Steps should not duplicate outputs.
+8. id has the form S001, S002, ...; role is Planner / Architect / Coder / Tester / Debugger.
+9. Every Step needs a systemPrompt that pins scope, inputs, outputs, acceptance, forbidden actions, and the paired test-design obligation when applicable.
+10. projectType is inferred by the LLM after clarification: application, library, or mixed. There is no CLI project-type override.
+11. complexityAssessment is your plan-stage complexity assessment. simple => P1 only; moderate => at least P1+P2; complex => at least P1+P2+P3. If the user explicitly asks for phases/stages, set userForcedPhaseSplit=true and split.
+12. implementationPhases must include P1 current and any planned executable phases. Each phase has a verificationGate whose failurePolicy says to feed the failure log to Debugger, roll back to the paired V-model phase, and rerun subsequent phases.
+13. dependencies is a Python pip dependency list. Include \`pytest\`; use bare package names only; never list \`requirements.txt\` in Step outputs.
+14. Application/mixed projects need a directly executable Python entry point (\`src/main.py\` or package \`__main__.py\`) that reuses CODE modules. Library/mixed projects need a stable public API and \`docs/api-guide.md\`.
+15. Structured HIGH_LEVEL_DESIGN -> CODE -> MODULE_TEST contract: for non-trivial work, return \`architectureModules\` with each module's id, name, responsibility, sourcePaths, testPaths, and dependencies. CODE/MODULE_TEST Steps may cover multiple modules but must list module-level work in subTasks.
+
+Output JSON shape:
+{
+  "requirementDigest": "string",
+  "globalPrompt": "string",
+  "projectType": "application | library | mixed",
+  "complexityAssessment": { "level": "simple | moderate | complex", "rationale": "string", "splitRecommended": true, "userForcedPhaseSplit": false },
+  "implementationPhases": [
+    { "id": "P1", "title": "Core functionality", "objective": "string", "status": "current", "scope": ["..."], "deliverables": ["..."], "dependsOn": [], "verificationGate": { "summary": "string", "checks": ["run tests", "probe entrypoint/API", "verify functional docs"], "failurePolicy": "Feed failures to Debugger, roll back to the paired V-model phase, and rerun subsequent phases." } }
+  ],
+  "dependencies": ["pytest"],
+  "architectureModules": [
+    { "id": "M001", "name": "module name", "responsibility": "one clear responsibility", "sourcePaths": ["src/example.py"], "testPaths": ["tests/test_example.py"], "dependencies": [] }
+  ],
+  "steps": [
+    {
+      "id": "S001",
+      "iterationId": "P1",
+      "phase": "REQUIREMENT_ANALYSIS",
+      "title": "string",
+      "description": "string",
+      "systemPrompt": "Step-specific prompt: scope, inputs, outputs, acceptance, forbidden actions",
+      "role": "Planner",
+      "tools": ["write_file"],
+      "inputs": ["docs/topic.md"],
+      "outputs": ["docs/01-requirement-analysis.md", "docs/tests/functional-test-plan.md"],
+      "subTasks": [
+        { "id": "T1", "title": "string", "description": "string", "acceptance": "string", "outputs": ["docs/01-requirement-analysis.md"], "subTasks": [] }
+      ],
+      "dependsOn": [],
+      "acceptance": "string",
+      "maxRetries": 3
+    }
+  ]
+}`;
+var PYTHON_EXECUTOR_SYSTEM = `You are XCompiler's Step Executor. You may only interact with the system through JSON tool calls \u2014 no Markdown and no explanatory text.
+
+Every round you must return strict JSON:
+{
+  "thoughts": "<one sentence describing this round's intent>",
+  "actions": [ { "tool": "<tool name>", "args": { ... } }, ... ],
+  "done": true | false
+}
+
+Rules:
+1. Only call tools in the Step's authorised whitelist.
+2. File writes must land within the Step's writable allowlist (other paths are rejected); required outputs are the final artifacts that must exist for acceptance.
+   For FUNCTIONAL_TEST documentation outputs, write the complete declared bundle in the active i18n language: P1 paths such as \`README.md\`, \`docs/quickstart.md\`, \`docs/08-functional-test.md\`, and \`docs/api-guide.md\` when present, or the declared iteration-scoped equivalents under \`docs/iterations/<iterationId>/\`. Do not set done=true while any declared documentation output is missing.
+3. Generated code must follow the target language's best practice; modules importable, functions typed appropriately.
+   - [Import convention] When modules under src/ import each other, use "from <module> import \u2026" (sibling name).
+     **Never write "from src.<module> import \u2026".** If main.py needs to run from the project root, prepend
+     "sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))" before any import,
+     so that both "python src/main.py \u2026" and "python -m src.main \u2026" work.
+   - [Test convention] Files under tests/ also import targets via "from <module> import \u2026".
+     **XCompiler auto-generates tests/conftest.py to inject project-root and src/ into sys.path**,
+     so both pytest and "python tests/test_*.py" can resolve modules \u2014 test files
+     **must NOT** add their own sys.path.insert(...). If you create or edit conftest.py yourself,
+     keep the existing sys.path injection \u2014 do not delete it.
+   - [Self-contained tests] Tests **must NOT** open() a sample file that does not exist on disk
+     (e.g. "test.dbc", "sample.csv"). When a target function needs file input, do exactly one of:
+       (a) use pytest's tmp_path fixture inside the test, e.g. tmp_path.joinpath("x.dbc").write_text(...);
+       (b) use write_file to put a fixture under tests/fixtures/<name> \u2014 test/DEBUG phases have
+           write permission to tests/fixtures/ by default, sub-directories are auto-mkdir'd, and
+           **fixture paths do NOT need to be pre-declared in outputs**.
+     A test that references a file nobody created will trap the Debugger in an endless FileNotFoundError loop.
+   - [Fixture iteration] When a test runs but the target function raises "Invalid syntax / Parse error / Malformed",
+     the **fixture itself is malformed** (DBC/CSV/JSON/...), **not the implementation**.
+     read_file the fixture \u2192 write_file a minimal valid sample for that format \u2192 run_tests again.
+     Never edit the implementation, the assertion, or mock out the parser to "fix" a parse error \u2014 fix the fixture first.
+4. When all outputs files exist and self-check passes, set done = true with empty actions.
+5. Correct any error in the next round's actions; never overstep authority or invent tools.
+6. [Large-file chunked writes] write_file / append_file content must stay under the current Step's runtime chunk limit shown in the tool docs.
+   - For larger files: in the same actions array, first write_file the head (imports + top-level constants + first function/class),
+     then several append_file calls each adding one function/class block (preserving trailing newlines).
+   - For complex projects, prefer multiple cohesive modules/files and separate CODE/UNIT_TEST/INTEGRATION_TEST/MODULE_TEST/FUNCTIONAL_TEST Steps over one giant file.
+   - The concatenated result must be valid Python; never split inside a function body.
+   - For partial edits to existing files, use replace_in_file / apply_patch \u2014 do not overwrite the whole file repeatedly.`;
+var TYPESCRIPT_PLANNER_SYSTEM = `You are the Planner of the XCompiler system. Your job is to compile a user's natural-language requirement into a strict iterative V-model Step plan.
+
+Output language: TypeScript / Node.js only (plan.language is fixed to "typescript").
+
+Canonical V-model phases for every executable iteration:
+REQUIREMENT_ANALYSIS -> HIGH_LEVEL_DESIGN -> DETAILED_DESIGN -> CODE -> UNIT_TEST -> INTEGRATION_TEST -> MODULE_TEST -> FUNCTIONAL_TEST.
+DEBUG is runtime rollback/repair only. If a test phase fails, XCompiler rolls back to its paired source phase and reruns subsequent phases.
+
+Use the same phase documents and synchronous test-design rule as the Python planner:
+- REQUIREMENT_ANALYSIS: \`docs/01-requirement-analysis.md\` plus \`docs/tests/functional-test-plan.md\`.
+- HIGH_LEVEL_DESIGN: \`docs/02-high-level-design.md\` plus \`docs/tests/integration-test-plan.md\`.
+- DETAILED_DESIGN: \`docs/03-detailed-design.md\` plus \`docs/tests/module-test-plan.md\`.
+- CODE: implementation outputs plus \`docs/tests/unit-test-plan.md\`.
+- UNIT_TEST: \`docs/05-unit-test.md\`.
+- INTEGRATION_TEST: \`docs/06-integration-test.md\`.
+- MODULE_TEST: \`docs/07-module-test.md\`.
+- FUNCTIONAL_TEST: \`docs/08-functional-test.md\`, \`README.md\`, \`docs/quickstart.md\`, and \`docs/api-guide.md\` for library/mixed projects.
+For P2+ iterations, put phase docs under \`docs/iterations/<iterationId>/\` and test plans under \`docs/iterations/<iterationId>/tests/\`.
+
+HIGH_LEVEL_DESIGN must place the current development module in the whole system and define system-level external interfaces and dependencies, including external APIs, third-party library choices, dependency confirmation, package.json scripts, package dependencies/devDependencies, tsconfig, data contracts, and integration boundaries.
+DETAILED_DESIGN must define module-internal functions, types, data structures, algorithms, control flow, error handling, and internal architecture.
+
+Mandatory rules:
+1. Return pure JSON only. Never emit the old phases REQUIREMENT, ARCH, TASK, TEST, REFACTOR, or DELIVERY.
+2. Every current/planned implementation phase is a complete V-model iteration containing all eight canonical phases.
+3. Each macro Step may contain \`subTasks\` nested at most two levels.
+4. Every CODE Step must be covered by a UNIT_TEST Step in the same iteration; module testPaths from architectureModules must be produced by MODULE_TEST.
+5. Design phases must not output src/ or tests/ files. HIGH_LEVEL_DESIGN is the only phase that may output \`package.json\` / \`tsconfig.json\`.
+6. Exactly one HIGH_LEVEL_DESIGN Step must output \`package.json\` for greenfield TypeScript plans; ensure one HIGH_LEVEL_DESIGN Step output \`package.json\`. It must include scripts for \`build\`, \`test\`, and preferably \`lint\`.
+7. Local TypeScript source imports must use explicit \`.ts\` ESM specifiers. Configure \`allowImportingTsExtensions: true\` and use \`tsc --noEmit\`. Generated TypeScript must be compatible with Node native type stripping: avoid enums, namespaces, parameter properties, and transform-required syntax.
+8. dependencies is an advisory runtime npm package list; the authoritative manifest is \`package.json\` from HIGH_LEVEL_DESIGN. Do not invent package names.
+9. Application/mixed projects need \`src/main.ts\` with a directly runnable \`main()\`; library/mixed projects need \`src/index.ts\` or equivalent public API plus API guide.
+10. complexityAssessment and implementationPhases follow the same rules as Python: simple => P1, moderate => at least P1+P2, complex => at least P1+P2+P3, forced phase split => set userForcedPhaseSplit=true.
+11. verificationGate failurePolicy must say: Feed failures to Debugger, roll back to the paired V-model phase, and rerun subsequent phases.
+12. For non-trivial work, return architectureModules with sourcePaths and testPaths; CODE/MODULE_TEST Steps may cover multiple modules but must list module-level work in subTasks.
+
+Output JSON shape is identical to Python and must include \`"projectType": "application | library | mixed"\`, with TypeScript paths such as \`src/example.ts\` and \`tests/example.test.ts\`; the first Step phase must be \`REQUIREMENT_ANALYSIS\`, not \`REQUIREMENT\`. There is no CLI project-type override.`;
+var TYPESCRIPT_EXECUTOR_SYSTEM = `You are XCompiler's Step Executor. You may only interact with the system through JSON tool calls \u2014 no Markdown and no explanatory text.
+
+Every round you must return strict JSON:
+{
+  "thoughts": "<one sentence describing this round's intent>",
+  "actions": [ { "tool": "<tool name>", "args": { ... } }, ... ],
+  "done": true | false
+}
+
+Rules:
+1. Only call tools in the Step's authorised whitelist.
+2. File writes must land within the Step's writable allowlist (other paths are rejected); required outputs are the final artifacts that must exist for acceptance.
+   For FUNCTIONAL_TEST documentation outputs, write the complete declared bundle in the active i18n language: P1 paths such as \`README.md\`, \`docs/quickstart.md\`, \`docs/08-functional-test.md\`, and \`docs/api-guide.md\` when present, or the declared iteration-scoped equivalents under \`docs/iterations/<iterationId>/\`. Do not set done=true while any declared documentation output is missing.
+3. Generated code must follow TypeScript / Node.js best practice; modules importable, APIs typed, and runtime code directly runnable.
+   - [Import convention] Local source modules under src/ use ESM relative imports with explicit ".ts" specifiers, e.g. \`import { x } from "./util.ts";\`. Keep code compatible with Node's native TypeScript type stripping: use erasable type syntax only, and avoid enums, namespaces, parameter properties, or other transform-required TS features. Never use Python-style imports, \`from src.<module>\`, or sys.path hacks.
+   - [Test convention] Tests use Vitest: \`import { describe, it, expect } from "vitest";\`. Test files live under \`tests/**/*.test.ts\`.
+   - [Self-contained tests] Tests **must NOT** read a sample file that does not exist on disk. When a target function needs file input, either create the content inside the test or write fixtures under \`tests/fixtures/<name>\`.
+   - [Fixture iteration] When a test runs but the target function raises "Invalid syntax / Parse error / Malformed", the **fixture itself is malformed**. read_file the fixture \u2192 write_file a minimal valid sample \u2192 run_tests again. Never "fix" a parse error by weakening the implementation or the assertion.
+4. When all outputs files exist and self-check passes, set done = true with empty actions.
+5. Correct any error in the next round's actions; never overstep authority or invent tools.
+6. [Large-file chunked writes] write_file / append_file content must stay under the current Step's runtime chunk limit shown in the tool docs.
+   - For larger files: in the same actions array, first write_file the head (imports + top-level constants + first function/class), then several append_file calls each adding one function/class block.
+   - For complex projects, prefer multiple cohesive modules/files and separate CODE/UNIT_TEST/INTEGRATION_TEST/MODULE_TEST/FUNCTIONAL_TEST Steps over one giant file.
+   - The concatenated result must be valid TypeScript; never split inside a function body.
+   - For partial edits to existing files, use replace_in_file / apply_patch \u2014 do not overwrite the whole file repeatedly.
+7. package.json is the dependency manifest. Use add_dependency for npm packages; never write requirements.txt.
+8. run_program runs the project entry with \`npx tsx\`, run_tests runs Vitest via \`npm test\`, and the final delivery gate also verifies the direct Node entry command.`;
+var PLANNER_CLARIFY_SYSTEM = `You are the requirements analyst for XCompiler's V-model. Do not restate the topic; expose unresolved decisions that would change functional design, acceptance, or architecture boundaries.
+Return strict JSON only. Each question must be directly answerable by a product owner, cover one decision, and avoid vague catch-all or implementation-stack questions.`;
+function buildPlannerSystem(profile) {
+  return (profile.id === "typescript" ? TYPESCRIPT_PLANNER_SYSTEM : PYTHON_PLANNER_SYSTEM) + profile.plannerPromptOverride;
+}
+function buildExecutorSystem(profile) {
+  return (profile.id === "typescript" ? TYPESCRIPT_EXECUTOR_SYSTEM : PYTHON_EXECUTOR_SYSTEM) + profile.executorPromptOverride;
+}
+var messages = {
+  llm: {
+    coderDebuggerSameModel: (model, coderProvider, debuggerProvider) => `Model configuration advice: Coder (${coderProvider}) and Debugger (${debuggerProvider}) both use ${model}. Prefer different models so debugging provides an independent reasoning path.`,
+    invalidBaseUrl: (raw, fallback) => `[xcompiler] invalid base_url (${raw}); falling back to ${fallback}`,
+    providerValidationFailed: (role, model) => `[${role}] provider ${model} failed output validation; trying next`,
+    providerCallFailed: (role, model) => `[${role}] provider ${model} failed; trying next`,
+    scoreReadFailed: (p, message) => `failed to read ${p}: ${message}`,
+    scoreChanged: (provider, score, previous) => `score(${provider}) = ${score} (was ${previous})`,
+    scorePersistFailed: (message) => `failed to persist scores: ${message}`,
+    preflightOllamaReachable: (baseUrl, models) => `preflight: ollama ${baseUrl} reachable; found ${models} model(s)`,
+    preflightOllamaUnreachable: (baseUrl, message) => `preflight: ollama ${baseUrl} unreachable: ${message}`,
+    preflightAutoAdded: (providers, roles) => `preflight: auto-added ${providers} provider(s) for roles [${roles}]`,
+    scoreFileHeader: "# XCompiler LLM provider score snapshot (maintained automatically by ScoreStore; do not edit)",
+    scoreFileSemantics: "# Scores: default 1.0; failure -0.5 (floor 0=disabled); success +0.1 (cap 10)."
+  },
+  system: {
+    configEnvMissing: (names) => `[xcompiler] unset config environment variables were replaced with empty strings: ${names}`,
+    unhandledError: (message) => `Unhandled error: ${message}`,
+    unsupportedPypiOnlyNetwork: "network=pypi-only is rejected because Docker cannot enforce a PyPI-only allowlist by itself. Use network=off for isolation or network=download-only for explicitly unrestricted outbound downloads.",
+    dockerInsideContainerUnsupported: "XCompiler is running inside a container, so sandbox=docker is unsupported because Docker-outside-of-Docker can mis-map bind mounts and docker.sock permissions. Use agent.sandbox=subprocess, run XCompiler on the host, or set XC_IN_CONTAINER=0 only in a controlled environment.",
+    firejailUnsupported: "sandbox=firejail is not implemented; use subprocess or docker.",
+    smokeHeader: (baseUrl) => `Smoke test against ${baseUrl} (streaming)`,
+    smokeOk: (model, totalMs, firstTokenMs, chunks, preview) => `[OK total=${totalMs}ms first-token=${firstTokenMs}ms chunks=${chunks}] ${model} -> ${preview}`,
+    smokeFail: (model, message) => `[FAIL] ${model} -> ${message}`
+  },
+  plugins: {
+    invalidId: (id) => `Plugin ID "${id}" is invalid; use lowercase letters, digits, dots, hyphens, or underscores.`,
+    duplicateId: (id) => `Duplicate plugin ID: ${id}`,
+    invalidVersion: (plugin, version) => `Plugin ${plugin} has an invalid SemVer version: ${version}`,
+    invalidCoreVersion: (version) => `XCompiler core has an invalid SemVer version: ${version}`,
+    apiVersionMismatch: (plugin, actual, expected) => `Plugin ${plugin} targets Plugin API ${actual}; this XCompiler runtime requires API ${expected}.`,
+    invalidMinimumVersion: (plugin, version) => `Plugin ${plugin} has an invalid minimum XCompiler version: ${version}`,
+    coreVersionTooOld: (plugin, minimum, actual) => `Plugin ${plugin} requires XCompiler >= ${minimum}; current version is ${actual}.`,
+    loaded: (plugin, version) => `Plugin ${plugin}@${version} loaded.`,
+    extensionConflict: (plugin, kind, name) => `Plugin ${plugin} cannot replace existing ${kind} "${name}".`,
+    hookFailed: (plugin, stage, message) => `Plugin ${plugin} failed during ${stage}: ${message}`,
+    manifestReadFailed: (path2, message) => `Cannot read plugin manifest ${path2}: ${message}`,
+    moduleLoadFailed: (plugin, path2, message) => `Cannot load plugin ${plugin} from ${path2}: ${message}`,
+    exportInvalid: (plugin, exportName) => `Plugin ${plugin} export ${exportName} is not a valid XCompiler plugin`,
+    manifestMismatch: (plugin) => `Plugin ${plugin} runtime manifest does not match its preflight manifest`
+  },
+  audit: {
+    processLogTitle: "# XCompiler Development Process Log",
+    processLogPreamble: "> Generated by XCompiler. Records CLI sessions, user input, LLM interactions, and execution actions for delivery traceability.",
+    sessionStart: (ts, command) => `## \u25B6 Session ${ts} \u2014 \`${command}\``,
+    sessionEnd: (ts) => `### \u25C0 Session end ${ts}`,
+    eventSessionStart: (command) => `start ${command}`,
+    eventSessionEnd: (command) => `end ${command}`,
+    userInput: (label) => `#### \u{1F464} User input \u2014 ${label}`,
+    llmRequest: (role, model) => `\u{1F916} LLM Request \u2014 <code>${role}</code> via <code>${model}</code>`,
+    llmResponse: (role, model) => `\u{1F4E9} LLM Response \u2014 <code>${role}</code> via <code>${model}</code>`,
+    executorTurn: (stepId, round, role, provider, actions, done) => `\u{1F9E0} Executor turn \u2014 <code>${stepId}</code> round ${round} / role <code>${role}</code>${provider ? ` \xB7 via <code>${provider}</code>` : ""} (actions=${actions}, done=${done})`,
+    thoughtsLabel: "**thoughts:**",
+    actionsLabel: "**actions:**",
+    noThoughts: "(no thoughts)",
+    plannerThought: (stage, provider) => `\u{1F9E9} Planner thought \u2014 ${stage}${provider ? ` \xB7 via <code>${provider}</code>` : ""}`,
+    markdownAppendFailed: (message) => `[audit] markdown append failed: ${message}`,
+    jsonlAppendFailed: (message) => `[audit] jsonl append failed: ${message}`,
+    traceLine: (kind, message) => `[audit] ${kind} ${message}`,
+    autoFixedSrcImport: (p) => `auto-fixed src import in ${p}`,
+    wroteFile: (p) => `wrote ${p}`,
+    userDecision: (label, value) => `${label} \u2192 ${value}`,
+    eventLlmRequest: (role, model) => `${role} \u2192 ${model}`,
+    eventLlmResponse: (role, model) => `${role} \u2190 ${model}`,
+    eventLlmError: (role, model, message) => `${role} via ${model}: ${message}`,
+    eventExecutorTurn: (stepId, round, role, provider) => `${stepId} round=${round} role=${role}${provider ? ` via ${provider}` : ""}`,
+    eventPlannerThought: (stage, provider) => `Planner ${stage}${provider ? ` via ${provider}` : ""}`,
+    llmChatFailedThought: (message) => `LLM chat failed: ${message}`,
+    llmChatAborted: (stepId, round, chars, message) => `${stepId} round ${round} aborted after ${chars} chars: ${message}`,
+    toolDenied: (tool) => `denied tool ${tool}`,
+    toolCalled: (tool) => `called tool ${tool}`,
+    toolResult: (tool, ok, detail) => `tool ${tool} ${ok ? "succeeded" : "failed"}: ${detail}`,
+    documentArchived: (from, to) => `archived ${from} \u2192 ${to}`,
+    documentArchiveFailed: (p, message) => `failed to archive ${p}: ${message}`,
+    httpFetchSaved: (method, url, p, bytes) => `http_fetch ${method} ${url} \u2192 ${p} (${bytes} B)`,
+    httpFetchResponse: (method, url, status, bytes) => `http_fetch ${method} ${url} \u2192 ${status} (${bytes} B)`,
+    partialFailureHeader: (message) => `# LLM chat failed: ${message}`,
+    streamLength: (chars) => `# Stream length: ${chars} chars`
+  },
+  stream: {
+    resolvingModel: "resolving-model",
+    waiting: "waiting",
+    streaming: "streaming",
+    done: "done",
+    failed: "failed",
+    chars: (n) => `${n} chars`,
+    toolRunner: "local-tool",
+    toolExecution: (stepId, tool) => `${stepId} tool ${tool}`
+  },
+  sandboxLog: {
+    subprocessBuilt: (deps) => `subprocess sandbox built (${deps ? "with dependencies" : "empty"})`,
+    subprocessNodeBuilt: "Node subprocess sandbox built (npm install)",
+    dockerBuilt: (deps) => `Docker sandbox built (${deps ? "with dependencies" : "empty"})`,
+    dockerNodeBuilt: "Docker Node sandbox built (npm install)",
+    command: (runtime, command) => `${runtime} ${command}`
+  },
+  cli: {
+    rootDescription: "XCompiler \u2014 AI Software Factory CLI",
+    compileDescription: "Interactively compile a requirement into plan.json (with mandatory human gates)",
+    runDescription: "Execute a confirmed plan.json (supports phased runs: --phase / --from)",
+    loadDescription: "Load a XXX.xc project file and continue its current plan",
+    appendDescription: "Append a new requirement to an existing XXX.xc project through clarification and V-model execution",
+    lsDescription: "Scan workspace and list every plan.json status summary",
+    showDescription: "Print Step definition / status / outputs / recent audit",
+    optWorkspace: "workspace directory (alias of --output, defaults to current directory)",
+    optOutput: "project / workspace output directory (highest priority, alias of -w)",
+    optConfig: "path to config.yaml",
+    optInput: "read requirement from a file (non-interactive)",
+    optTopic: "reuse an already-clarified topic.md as input: skip intake / clarify / addenda / Gate 1 and go straight to decompose",
+    optPlanOut: "output path for plan.json (default <workspace>/plan.json)",
+    optBaseDir: "project root output directory (creates <name> subdir under it)",
+    optName: "project name (default xcompiler-<timestamp>)",
+    optYes: "skip human confirmation (only meaningful with -i / -t)",
+    optForce: "force regenerate: override workspace lock and ignore existing plan.json",
+    optDryRun: "print topology only, do not execute",
+    optFrom: "start from the given Step (earlier ones are skipped)",
+    optPhase: "execute only the given phase (REQUIREMENT_ANALYSIS/HIGH_LEVEL_DESIGN/DETAILED_DESIGN/CODE/UNIT_TEST/INTEGRATION_TEST/MODULE_TEST/FUNCTIONAL_TEST/DEBUG)",
+    optReset: "reset all Step status to PENDING",
+    optMaxDepth: "maximum recursion depth",
+    optTail: "number of recent audit entries",
+    optPlan: "plan.json path, default <workspace>/plan.json",
+    optLang: "UI / prompt language: EN | CN (ISO 3166-1 Alpha-2)",
+    optIntent: "plan intent: greenfield | feature | refactor | self",
+    optBaselinePlan: "existing baseline plan.json path (default <workspace>/plan.json)",
+    optProjectFile: "XXX.xc project file path (default <workspace>/<name>.xc)",
+    argPlan: "plan.json path (default = <workspace>/plan.json)",
+    argProjectFile: "XXX.xc project file",
+    argStepId: "Step ID, e.g. S001",
+    evolveDescription: "Generate and execute an incremental feature/refactor plan on top of an existing workspace",
+    bootstrapDescription: "Build and qualify the next XCompiler generation in an isolated Git worktree",
+    optRepository: "XCompiler Git repository to bootstrap (default current directory)",
+    optPromote: "fast-forward the current branch after every qualification gate passes",
+    optCleanup: "remove the isolated worktree after writing the report (branch is retained)",
+    optDockerQualification: "use the experimental Docker runner for candidate qualification",
+    invalidLocale: (value) => `Unsupported language "${value}"; use EN or CN.`,
+    invalidIntent: (value, allowed) => `Invalid intent "${value}"; expected one of: ${allowed}.`,
+    invalidPhase: (value, allowed) => `Invalid phase "${value}"; expected one of: ${allowed}.`,
+    invalidStepId: (value) => `Invalid Step ID "${value}"; expected S followed by at least three digits.`,
+    invalidNonNegativeInteger: (value) => `Expected a non-negative integer, received "${value}".`,
+    helpUsage: "Usage:",
+    helpArguments: "Arguments:",
+    helpOptions: "Options:",
+    helpCommands: "Commands:",
+    helpOption: "display help for command",
+    versionOption: "output the version number",
+    defaultValue: (value) => `(default: ${value})`
+  },
+  bootstrap: {
+    notGitRepository: (p) => `Not a Git repository: ${p}`,
+    dirtyRepository: (files) => `Self-bootstrap requires a clean host repository. Pending paths: ${files}`,
+    worktreeReady: (p, branch) => `Bootstrap worktree ready: ${p} (${branch})`,
+    compileStarted: "Compiling the self-bootstrap V-model plan\u2026",
+    compileFailed: (code, message) => `Self-bootstrap compilation failed (exit=${code}): ${message}`,
+    compileCancelled: "Self-bootstrap compilation was cancelled before a plan was confirmed.",
+    executeStarted: "Executing the candidate generation in the isolated worktree\u2026",
+    executeFailed: (status) => `Candidate execution did not complete successfully (${status}).`,
+    qualificationStarted: "Running deterministic bootstrap qualification gates\u2026",
+    qualificationDockerExperimental: "Docker qualification is experimental and has not completed environment validation.",
+    missingScript: (name) => `required package.json script is missing: ${name}`,
+    missingBin: "package.json does not declare a CLI bin entry",
+    checkPassed: (name, ms) => `${name} passed (${ms}ms)`,
+    checkFailed: (name, code) => `${name} failed (exit=${code})`,
+    reportWritten: (p) => `Bootstrap report written: ${p}`,
+    candidateReady: (branch) => `Candidate is qualified on ${branch}; promotion still requires explicit --promote.`,
+    promoted: (branch) => `Bootstrap candidate promoted by fast-forward merge: ${branch}`,
+    cleanupDone: (p) => `Bootstrap worktree removed: ${p}`,
+    promotionBlocked: "Promotion blocked because one or more qualification gates failed.",
+    hostHeadChanged: "host HEAD changed during bootstrap",
+    candidateDirty: (files) => `Candidate worktree changed outside a committed generation: ${files}`,
+    candidateStatusUnknown: "(unknown path)",
+    candidateMoved: (expected, actual) => `Candidate commit changed after qualification (expected ${expected}, got ${actual}).`,
+    candidateNotBasedOnBase: (candidate, base) => `Candidate ${candidate} is not descended from bootstrap base ${base}.`,
+    promotionVerificationFailed: (expected, actual) => `Promotion verification failed (expected HEAD ${expected}, got ${actual}).`,
+    reportTitle: "XCompiler Self-Bootstrap Report",
+    reportNone: "(none)",
+    reportNextQualified: (repository, candidateCommit) => `git -C "${repository}" merge --ff-only "${candidateCommit}"`,
+    reportNextPromoted: "Run the next self-bootstrap request with the promoted generation.",
+    reportNextFailed: "Inspect the candidate worktree and fix the failed gate before promotion.",
+    reportLabels: {
+      status: "Status",
+      repository: "Repository",
+      baseCommit: "Base commit",
+      candidateCommit: "Candidate commit",
+      branch: "Candidate branch",
+      worktree: "Worktree",
+      createdAt: "Created at",
+      checks: "Qualification checks",
+      changedFiles: "Changed files",
+      nextStep: "Next step"
+    }
+  },
+  compile: {
+    workspaceReady: (p) => `Workspace: ${p}`,
+    forceOverride: "--force: overriding workspace lock and regenerating plan.",
+    topicInputConflict: "--topic and --input were both supplied; --topic wins and --input is ignored.",
+    auditTopicInput: "topic.md (--topic)",
+    auditOriginalRequirement: "Original requirement (Intake)",
+    auditUserAddenda: "User addenda",
+    auditEditedTopic: "Edited topic.md",
+    auditTopicPersisted: (p) => `topic.md written: ${p}`,
+    auditDecomposeFailed: "planner.decompose failed",
+    lintIssue: (id, message) => ` - [${id}] ${message}`,
+    planPreviewTruncated: "\u2026 (truncated; see docs/plan.md)",
+    auditPlanPersisted: (p) => `plan.json written: ${p}`,
+    projectFileWritten: (p) => `project file updated: ${p}`,
+    nextCommand: (command) => `  Next: ${command}`,
+    topicEmptyExit: "--topic file is empty, aborting.",
+    topicLoaded: (p) => `topic loaded: ${p} (skipping intake / clarify / Gate 1)`,
+    requirementEmptyExit: "requirement is empty, aborting.",
+    requirementInputHint: "Please describe your requirement (multi-line, blank line to finish):",
+    spinClarify: "Planner is clarifying the requirement\u2026",
+    clarifySucceed: (n) => `clarification questions: ${n}`,
+    clarifyFail: "clarification failed",
+    clarifyChoiceHint: (range) => `Reply with ${range} to choose a shown option, or type a custom answer.`,
+    addendaConfirm: "Any extra requirements to append? (Will be sent to Planner together with the clarification and kept in plan.userAddenda)",
+    addendaEditorMsg: "Enter custom addenda (multi-line, Markdown allowed)",
+    auditClarifyAnswer: (qid, q) => `clarify answer ${qid}: ${q}`,
+    spinDecompose: "Planner is decomposing along the V-model\u2026",
+    decomposeFail: "Planner decomposition failed",
+    plannerInvalidPlan: "Planner could not produce a valid plan:",
+    plannerInvalidPlanHint1: "  Common cause: every LLM provider returned malformed/truncated JSON (e.g. token loop).",
+    plannerInvalidPlanHint2: "  Investigate: check llm.error / planner.thought entries in .xcompiler/audit.jsonl.",
+    decomposeSucceed: (n) => `generated ${n} Step(s)`,
+    schemaFail: "Plan schema validation failed:",
+    schemaInvalidSavedAt: (p) => `  full plan saved to: ${p}`,
+    lintFail: (n) => `Plan lint failed (${n}):`,
+    topicPreviewHeader: "\u2500\u2500\u2500 topic.md (preview) \u2500\u2500\u2500",
+    topicPreviewFooter: "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+    gate1Confirm: "Does the requirement match expectations?",
+    gate1ChoiceConfirm: "\u2705 confirm \u2014 proceed to plan generation",
+    gate1ChoiceEdit: "\u270F\uFE0F  edit    \u2014 open editor to modify",
+    gate1ChoiceCancel: "\u274C cancel  \u2014 abandon this session",
+    gate1AuditLabel: "Requirement Confirmation Gate (Gate 1)",
+    gate1Cancelled: "Cancelled, no files written.",
+    editTopicMsg: "Edit topic.md",
+    topicWritten: (p) => `topic written: ${p}`,
+    planWritten: (p) => `plan written: ${p}`,
+    planPreviewHeader: "\u2500\u2500\u2500 plan.md (preview) \u2500\u2500\u2500",
+    planPreviewFooter: "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+    gate2Confirm: "Confirm this plan? (Final confirmation \u2014 confirms write to plan.json)",
+    gate2AuditLabel: "Plan Confirmation Gate (Gate 2)",
+    gate2Rejected: "Not confirmed, abandoned. plan.json was not written.",
+    baselineLoaded: (kind, sources) => `loaded ${kind} baseline from: ${sources}`,
+    baselineMissing: (workspace) => `incremental mode requires an existing project baseline in ${workspace} (topic / docs / plan / src).`,
+    baselineLanguageOverride: (baseline, source, configured) => `incremental mode: using baseline language ${baseline} from ${source} instead of config language ${configured}.`,
+    topicTitle: "# Project Topic",
+    topicPreamble: "> This file is the project topic frozen after requirement clarification. All subsequent V-model decomposition and every phase output use this file as the sole requirement input.",
+    topicSecRequirement: "## Original requirement",
+    topicSecClarify: "## Clarification record",
+    topicSecAddenda: "## User addenda",
+    topicSecBaseline: "## Existing project baseline"
+  },
+  inspect: {
+    noPlanFound: "No plan.json found",
+    digestLabel: "digest:",
+    stepNotFound: (id) => `Step ${id} not found`,
+    secDescription: "\u2014 description \u2014",
+    secAcceptance: "\u2014 acceptance \u2014",
+    secSubtasks: "\u2014 subtasks \u2014",
+    secSystemPrompt: "\u2014 systemPrompt \u2014",
+    secOutputs: "\u2014 outputs \u2014",
+    secRecentAudit: (n) => `\u2014 recent audit (${n}) \u2014`,
+    planHeader: (p, language) => `${p} lang=${language}`,
+    planStatusSummary: (total, done, pending, failed, skipped, running) => `steps=${total} done=${done} pending=${pending} failed=${failed} skipped=${skipped} running=${running}`,
+    planReadFailed: (p, message) => `${p} \u2014 ${message}`,
+    stepHeader: (id, phase, title, status, retries, maxRetries) => `${id} ${phase} ${title} ${status} retries=${retries}/${maxRetries}`,
+    stepRoleTools: (role, tools) => `role=${role} tools=[${tools}]`,
+    stepDependsOn: (ids) => `dependsOn: ${ids}`,
+    outputStatus: (exists, p) => `${exists ? "\u2713" : "\u2717"} ${p}`,
+    auditEntry: (ts, kind, message) => `${ts} ${kind} ${message}`
+  },
+  execute: {
+    forceReset: "--force: resetting every Step to PENDING and overriding the workspace lock.",
+    manifestRecalibrated: (p) => `recalibrated ${p} (removed version pins / hallucinated names)`,
+    manifestSeeded: (p) => `seeded ${p} from plan.dependencies`,
+    auditPlanLoaded: (p) => `plan loaded: ${p}`,
+    planLoaded: (p) => `Plan loaded: ${p}`,
+    planSummary: (language, steps) => `  language=${language}, steps=${steps}`,
+    preflightModelMissing: (names) => `LLM preflight: missing models, disabled [${names}]`,
+    preflightAutoAdded: (n) => `LLM preflight: auto-injected ${n} provider(s) (from ollama /api/tags)`,
+    runInterrupted: (id, e, total) => `execution interrupted at ${id} (executed ${e}/${total})`,
+    runReasonLabel: "  reason: ",
+    runFailureLogHeader: "  --- failure log (tail, 40 lines) ---",
+    runAllDone: (e, total) => `Plan fully completed (${e}/${total})`,
+    projectAuditSummary: (errors, warnings) => `project audit: ${errors} error(s), ${warnings} warning(s)`,
+    projectMemoryRefreshFailed: (message) => `project memory refresh failed: ${message}`,
+    projectAuditCheck: (name, summary) => `[audit:${name}] ${summary}`,
+    auditDocPresent: (p) => `${p} present`,
+    auditDocMissing: (p) => `missing ${p}`,
+    auditDeliveryDocPresent: "delivery documentation present",
+    auditDeliveryDocMissing: "missing docs/08-functional-test.md",
+    auditTestFilesFound: (count) => `found ${count} concrete test file(s)`,
+    auditTestFilesMissing: "no concrete test files found under tests/",
+    auditEntrypointOk: (command) => `entrypoint ok: ${command}`,
+    auditEntrypointFailed: (command) => `entrypoint failed: ${command}`,
+    auditPackageJsonMissing: "missing package.json",
+    auditScriptMissing: (name) => `package.json has no ${name} script`,
+    auditCommandOk: (name) => `${name} ok`,
+    auditCommandFailed: (name, exitCode, timedOut) => `${name} failed (exit=${exitCode}${timedOut ? ", timeout" : ""})`
+  },
+  engine: {
+    spinSandboxBuild: (profile) => profile.id === "typescript" ? `building sandbox (npm install, ${profile.manifestFile})\u2026` : `building sandbox (pip install -r ${profile.manifestFile})\u2026`,
+    sandboxReady: (r) => `sandbox ready: ${r}`,
+    stepSkipDone: (id, phase) => `  \u21AA ${id} ${phase} already done, skipping`,
+    spinSandboxRebuild: (id, profile) => profile.id === "typescript" ? `Step ${id} wrote ${profile.manifestFile} \u2014 rebuilding npm sandbox\u2026` : `Step ${id} wrote ${profile.manifestFile} \u2014 rebuilding pip sandbox\u2026`,
+    sandboxStatus: (r) => `sandbox: ${r}`,
+    autoFixedSrcImports: (n, files) => `  \u26A0 auto-fixed sys.path bootstrap in ${n} entry file(s): ${files}`,
+    debugResumeNotice: (id, n) => `  \u21BB ${id} previous session ended FAILED (${n} attempts so far); first round of this run goes straight into Debugger mode.`,
+    spinDebugRetry: (id, attempt, budget, cap, reason) => `\u{1F6E0}  ${id} DEBUG retry ${attempt}/${budget} (cap=${cap}) \u2014 ${reason}`,
+    retryException: (a, b, msg) => `retry ${a}/${b} threw: ${msg}`,
+    fixSucceeded: (id, a) => `${id} fix succeeded (retry=${a})`,
+    retryHealthyButFailed: (a, before, b, tag, reason) => `retry ${a}/${before}\u2192${b} still failing but healthy (expand window) \xB7 ${tag} \xB7 ${reason}`,
+    retryLowQuality: (a, before, b, tag, reason) => `retry ${a}/${before}\u2192${b} low-quality output (shrink window) \xB7 ${tag} \xB7 ${reason}`,
+    retryStillFailed: (a, b, tag, reason) => `retry ${a}/${b} still failing \xB7 ${tag} \xB7 ${reason}`,
+    earlyAbortLowQuality: (id, n) => `  \u26A1 ${id} ${n} consecutive low-quality rounds \u2014 early-aborting DEBUG retries`,
+    stepFinalFailed: (id, phase, role) => `\u2716 Step ${id} (${phase} / ${role}) finally failed`,
+    finalAttemptsLine: (a, b, c, ea) => `  attempts=${a}  final_budget=${b}  cap=${c}` + (ea ? "  (early-abort: low-quality)" : ""),
+    finalMetricsLine: (h, p, r, tf, pr) => `  health=${h}  parseFail=${p}  repeat=${r}  toolFail=${tf}  progress=${pr}`,
+    reasonLabel: "reason: ",
+    failureLogHeader: "--- failure log (tail, max 80 lines) ---",
+    fixSuggestionsHeader: "--- fix suggestions (calibration) ---",
+    auditHint: (id) => `  audit: see .xcompiler/audit.jsonl and .xcompiler/llm-stream/${id}-*.txt for the raw stream`,
+    spinStepRunning: (id, phase, title) => `\u25B6 ${id} ${phase} ${title}`,
+    noFailureLog: "(no log captured)",
+    suggestionLine: (index, code, hint) => `  ${index}. [${code}] ${hint}`,
+    phaseStart: (id, phase, title) => `${id} ${phase} ${title}`,
+    phaseFailed: (id, debug, reason) => `${id} ${debug ? "DEBUG " : ""}FAILED \u2014 ${reason}`,
+    phaseDone: (id, rounds) => `${id} DONE (rounds=${rounds})`,
+    phaseException: (id, message) => `${id} FAILED (exception) \u2014 ${message}`,
+    archGateReason: (missing) => `HIGH_LEVEL_DESIGN gate: architecture contract missing ${missing} token(s)`,
+    archGateMissing: (tokens) => `missing module ids/paths: ${tokens}`,
+    archGateInstruction: (p) => `Update ${p} so every architectureModules item is traceable before CODE starts.`,
+    testGateReason: (exitCode, timedOut) => `Test gate: tests exit=${exitCode}${timedOut ? " (timeout)" : ""}`,
+    deliveryGateReason: (command, exitCode, timedOut) => `FUNCTIONAL_TEST gate: \`${command}\` exit=${exitCode}${timedOut ? " (timeout)" : ""}`,
+    missingPythonEntrypoint: "missing Python entrypoint: expected src/main.py or src/<package>/__main__.py",
+    missingTypeScriptEntrypoint: "missing TypeScript entrypoint: expected package.json start/bin or one of src/main.ts, src/index.ts, src/main.tsx",
+    invalidPythonEntrypointSource: (path2) => `invalid Python entrypoint source in ${path2}: expected a real CLI entry structure such as def main(...), argparse.ArgumentParser, or if __name__ == "__main__"; placeholder/import-only files are not runnable applications.`,
+    entrypointHelpOutputMissing: (command) => `entrypoint probe \`${command}\` exited 0 but produced no meaningful help/usage text; implement --help instead of relying on an empty script exit.`,
+    reasonLine: (reason) => `reason: ${reason}`,
+    roundsLine: (rounds) => `rounds: ${rounds}`,
+    commandLine: (command) => `command: ${command}`,
+    stdoutTailHeader: "--- stdout (tail) ---",
+    stderrTailHeader: "--- stderr (tail) ---",
+    testStdoutTailHeader: "--- test stdout (tail) ---",
+    testStderrTailHeader: "--- test stderr (tail) ---",
+    outputsMissing: (paths) => `outputs missing: ${paths}`,
+    metricsLine: (health, parseFail, repeat, toolFail, progress) => `metrics: health=${health} parseFail=${parseFail} repeat=${repeat} toolFail=${toolFail} progress=${progress}`,
+    metricsUnavailable: "metrics: (n/a)",
+    toolCallsHeader: "tool calls:",
+    toolCallLine: (tool, ok, detail) => `  - ${tool} ${ok ? "OK" : "FAIL"} ${detail}`,
+    projectMemoryRefreshFailed: (message) => `project memory refresh failed: ${message}`,
+    deliveryFixHints: (language) => language === "typescript" ? [
+      "Fix directions (priority order):",
+      "  1. For module resolution / ERR_MODULE_NOT_FOUND in TypeScript source, use relative ESM imports with explicit .ts specifiers.",
+      "  2. For --help / unknown option, main() must support --help and exit 0.",
+      "  3. For application exceptions, fix the implementation and keep the entrypoint thin."
+    ] : [
+      "Fix directions (priority order):",
+      "  1. For ModuleNotFoundError involving src, add the planner #19 sys.path bootstrap or remove the src. import prefix.",
+      '  2. main() must be a real CLI entrypoint: parse --help, call the project modules, print meaningful output, and use if __name__ == "__main__": main().',
+      "  3. For argparse errors, main() must support --help without other required arguments and exit 0.",
+      "  4. For business exceptions, fix the implementation and keep the entrypoint limited to parsing and dispatch."
+    ]
+  },
+  render: {
+    sectionGlobalPrompt: "## Global prompt (injected into every Step's system prompt)",
+    sectionDependencies: (manifestFile) => `## Dependencies (written to ${manifestFile})`,
+    sectionBaselineSummary: "## Existing project baseline",
+    labelSystemPrompt: "**System prompt (sole mandate):**"
+  },
+  prompts: {
+    plannerSystem: (p) => buildPlannerSystem(p),
+    plannerSelfMode: `SELF-BOOTSTRAP OVERRIDE (takes precedence over conflicting greenfield rules above):
+- The target is the existing XCompiler repository. Preserve its current package.json, tsconfig, bin entries, CLI entrypoints, module layout, public exports, and documentation unless the requirement explicitly changes them.
+- Do not create src/main.ts merely to satisfy a greenfield entrypoint convention. Reuse the entrypoints declared by the existing package.json.
+- Do not list package.json or tsconfig.json as HIGH_LEVEL_DESIGN outputs unless this change genuinely needs to modify them.
+- Every CODE/test output must be scoped to the requested delta. Never rebuild or replace the repository wholesale.
+- Treat the stable host binary as generation N and the worktree candidate as N+1; do not design in-process hot replacement.`,
+    plannerClarifySystem: PLANNER_CLARIFY_SYSTEM,
+    plannerClarify: (raw, opts = {}) => `The user's original requirement is:
+
+"""
+${raw}
+"""
+
+Generate ${opts.complex ? "8-10" : "7-10"} non-duplicate clarification questions about unresolved decisions whose answers materially affect implementation or acceptance. Never return an empty array; when the functional description is already detailed, ask for acceptance examples, failure behaviour, and explicit exclusions.
+
+Return ONLY a JSON array. Every item must be shaped exactly as:
+{"id":"Q1","category":"functionality|data|acceptance|boundary|quality|extensibility","question":"one concrete directly-answerable question","why":"what design or acceptance decision this answer affects","options":[{"label":"A","answer":"highest-priority feasible setting"},{"label":"B","answer":"second feasible setting"}]}
+
+Question mix (functionality first):
+- At least ${opts.complex ? "5" : "4"} function-focused questions categorized as functionality / data / acceptance, so functional questions remain the majority. Prioritize actors, core journeys, business rules and state transitions, inputs/outputs, failure behaviour, and verifiable acceptance examples.
+- At least one boundary question defining in-scope, explicitly out-of-scope, external-system ownership, or compatibility limits.
+- At least one quality question requesting measurable latency, throughput, volume, concurrency, accuracy, reliability, or security targets. Never ask only \u201CAny performance requirements?\u201D.
+- At least one extensibility question identifying the most likely future business capability, extension axis, or interface that must remain stable. Never ask only \u201CShould it be extensible?\u201D.
+- If the deliverable shape is unclear, include one boundary question asking whether this should be an API library/SDK/package, a runnable application/CLI/service, or a mixed deliverable with both.
+- Order by blocking impact: core functional/data decisions first, then scope and quality, then future evolution.
+- One primary decision per question. Include useful business choices/examples; do not join unrelated questions with \u201Cand/or\u201D.
+- For every question, generate 2-5 feasible answer options ordered by priority. The option count is not fixed: use 2 for binary choices, 3 for common defaults, and 4-5 only when there are genuinely distinct viable settings. Do not pad or force every question to exactly 3 options.
+- Label options sequentially from A through the last generated option, for example A-B, A-C, A-D, or A-E. A should be the recommended/default setting when one is apparent. Options must be concrete business/product settings, not vague placeholders.
+- Do not include \u201COther\u201D, \u201CCustom\u201D, or \u201CLet the user decide\u201D as an option. The CLI already allows the user to reply with one of the shown labels or enter a custom free-form answer.
+${opts.projectShapeAmbiguous ? "- Required for this topic: ask the API library vs runnable application vs mixed-deliverable boundary explicitly.\n" : ""}
+
+[Hard constraint] The implementation stack is already fixed by XCompiler config / the existing project baseline. Do not reopen language/runtime/package-manager decisions.
+**Do NOT** ask questions of these forms:
+  - "Which programming language / framework / runtime should this use?"
+  - "Which test framework / build tool / package manager?"
+  - "Which OS is the target platform?"
+${opts.intent && opts.intent !== "greenfield" ? `This is an incremental ${opts.intent} request against an existing project${opts.hasBaseline ? " with a separate baseline summary that will be provided during decomposition" : ""}. Ask ONLY delta questions; do not ask to rebuild the project from scratch.` : ""}The majority of questions must concern functional behaviour; performance, boundaries, and extensibility should eliminate ambiguities that affect this delivery.`,
+    plannerDecompose: (raw, qa, addenda, opts = {}) => `Original requirement:
+"""
+${raw}
+"""
+
+Clarification Q&A:
+${qa || "(none)"}
+
+${addenda ? `User addenda (must be strictly followed; takes priority over any vague parts of the original):
+"""
+${addenda}
+"""
+
+` : ""}${opts.intent && opts.intent !== "greenfield" ? `Incremental intent: ${opts.intent}
+
+Generate an incremental ${opts.intent} plan on top of the existing project. Reuse the current architecture, files, tests and dependencies where possible instead of rebootstrapping the whole project. Outside the requested change, preserve existing behaviour.
+
+Existing project baseline:
+"""
+${opts.baseline || "(missing baseline)"}
+"""
+
+` : ""}Planning depth rules:
+- Unless the request is explicitly tiny (single function / toy script / one-file utility), do not collapse the solution into one source file and one test.
+- If the requirement spans multiple concerns (domain logic, API/CLI surface, persistence, integration, orchestration, tests), reflect that with multiple architecture modules and Step.subTasks under CODE/MODULE_TEST macro Steps.
+- Assess project complexity in the plan and size implementationPhases from that assessment: simple => P1 current only; moderate => P1 current + at least P2 planned; complex => P1 current + at least P2/P3 planned. If the user explicitly requested phases/stages, use at least P1+P2 and set userForcedPhaseSplit=true. Every current/planned implementation phase must be represented by a full V-model cycle in steps, with Step.iterationId pointing to that phase.
+- Use HIGH_LEVEL_DESIGN/DETAILED_DESIGN steps to describe module boundaries, responsibilities, dependencies, and extension points that future incremental work can build on.
+- When baseline files already exist, prefer editing/extending those modules over creating shadow implementations with duplicate behaviour.
+
+Output a strict JSON plan per the system rules.`,
+    executorSystem: (p) => buildExecutorSystem(p),
+    executorDebugBlock: (reason, suggestions) => `
+
+You are now in DEBUG retry mode. Previous failure reason: ${reason}
+DEBUG may edit upstream source files and tests within the current allowedWrites. If the failure reveals a real implementation, contract, or downstream integration mismatch, fix that real defect; do not pass by weakening assertions, skipping tests, deleting failing cases, or merely accommodating an incorrect test. Begin with read_file / code_search to localise the issue, then make the smallest possible fix via apply_patch / replace_in_file / add_dependency, and finally run_tests to verify. If the failure log shows a network/API failure, do not stop at probing endpoints: use at most two consecutive http_fetch probes, reject 2xx responses with empty or unusable bodies, then patch the real integration and verify with run_program plus run_tests. Do not set done=true while the entrypoint still reports a network/API failure.` + (suggestions ? `
+
+${suggestions}` : ""),
+    executorGlobalBlock: (globalPrompt) => `
+
+## Project-wide constraints
+${globalPrompt}`,
+    executorStepBlock: (sp) => `
+
+## Current Step prompt (sole mission \u2014 do not drift across steps)
+${sp}`,
+    executorUserPromptOutro: "Now return the first round of JSON per the protocol.",
+    executorFeedbackHeader: "Tool results this round:",
+    executorFeedbackVerifyOk: "outputs verified. If you are done, set done=true and actions=[].",
+    executorFeedbackVerifyMissing: (paths) => `outputs still missing: ${paths}. Please continue.`
+  },
+  skills: {
+    patcher: "Use apply_patch / replace_in_file for small in-place edits to existing files; never overwrite a whole file.",
+    author: "Use write_file to create new files; prefer paths inside the current Step writable allowlist.",
+    tester: `Write and run pytest tests verifying function behaviour; on failure parse with analyze_error. [Self-contained fixtures] Tests **must NOT** open() a sample file that does not exist on disk (e.g. "test.dbc"); when the target function needs file input, either use pytest tmp_path to construct content inside the test, or use write_file to put a fixture under tests/fixtures/<name> \u2014 test/DEBUG phases already grant write permission to that directory, sub-dirs are auto-mkdir'd, and **fixture paths do NOT need to be pre-declared in outputs**. When generating tests, always emit every dependent resource so the Debugger does not loop on FileNotFoundError. [Fixture iteration] If a running test raises "Invalid syntax / Parse error / Malformed" from the target function, your fixture content does not match the format spec: read_file to inspect, write_file to rewrite a minimal valid sample, then run_tests. Never edit the implementation or assertions to "fix" a parse error.`,
+    dep_resolver: "On ModuleNotFoundError, use add_dependency to write the package back into requirements.txt and rebuild the sandbox.",
+    debugger: 'First run_tests / run_python to reproduce the error \u2192 analyze_error \u2192 patch / replace_in_file to fix \u2192 run_tests again. Make the smallest possible change each round. [Network/API failures] Locate the failing URL, try only a small number of replacement API probes, then patch the source and run_program to prove the entrypoint no longer emits API failure. [Important] If replace_in_file on the same file fails \u2265 2 times in a row, switch to read_file and then patch or rewrite within the current runtime chunk limit; stop guessing the find string. [No no-ops] replace_in_file find and replace must differ \u2014 if you only want to "verify" a snippet, use read_file; do not submit identical-string replacements.',
+    refactorer: "Refactors must preserve behaviour: run regression tests \u2192 modify \u2192 run regression tests again."
+  },
+  doctor: {
+    cliDescription: "check that config / LLM / sandbox / skills are ready",
+    optStrict: "treat warnings as failures (exit non-zero on any warn)",
+    header: "XCompiler environment check",
+    sectionConfig: "[config]",
+    sectionLLM: "[LLM]",
+    sectionSandbox: "[sandbox]",
+    sectionSkills: "[skills]",
+    summaryOk: "all checks passed.",
+    summaryWarn: (n) => `passed with ${n} warning(s).`,
+    summaryFail: (n) => `${n} failure(s) detected.`,
+    configLoadOk: (path2) => `config loaded: ${path2}`,
+    configLoadFail: (msg) => `failed to load config: ${msg}`,
+    configLocale: (locale) => `locale=${locale}`,
+    llmNoProviders: "no LLM providers defined in config.llm.providers",
+    llmProviderListed: (n) => `${n} provider(s) declared`,
+    ollamaUnreachable: (baseUrl, msg) => `ollama unreachable @ ${baseUrl} \u2014 ${msg}`,
+    ollamaReachable: (baseUrl, n) => `ollama reachable @ ${baseUrl} (${n} model(s))`,
+    ollamaModelMissing: (provider, model, baseUrl) => `provider "${provider}": model "${model}" NOT installed on ${baseUrl} (run \`ollama pull ${model}\`)`,
+    ollamaModelOk: (provider, model) => `provider "${provider}": model "${model}" available`,
+    openaiKeyMissing: (provider) => `provider "${provider}": api_key empty (set OPENAI_API_KEY or config.llm.providers.${provider}.api_key)`,
+    openaiReachable: (provider, baseUrl) => `provider "${provider}": OpenAI endpoint reachable @ ${baseUrl}`,
+    openaiUnreachable: (provider, baseUrl, msg) => `provider "${provider}": OpenAI endpoint unreachable @ ${baseUrl} \u2014 ${msg}`,
+    openaiModelListMissing: (provider, model) => `provider "${provider}": model "${model}" not in /models response (it may still work if your account has access)`,
+    providerScoreZero: (provider) => `provider "${provider}" disabled (score=0)`,
+    roleNoLiveProvider: (role) => `role "${role}" has no live provider (no candidate is reachable & enabled)`,
+    roleOk: (role, provider) => `role "${role}" \u2192 ${provider}`,
+    sandboxKind: (kind) => `sandbox=${kind}`,
+    sandboxNetworkPolicy: (policy, ports) => `network=${policy}` + (ports.length ? ` (expose_ports=[${ports.join(", ")}])` : ""),
+    sandboxFullNoPorts: "network=full but no expose_ports configured \u2014 host-side cannot reach container services. Add `agent.sandbox_limits.expose_ports: [<port>]` in config.yaml.",
+    sandboxNodeMissing: "node not found on PATH (required by TypeScript subprocess sandbox)",
+    sandboxNodeOk: (version) => `node OK (${version})`,
+    sandboxNpmMissing: "npm not found on PATH (required by TypeScript subprocess sandbox)",
+    sandboxNpmOk: (version) => `npm OK (${version})`,
+    sandboxNpxMissing: "npx not found on PATH (required by TypeScript subprocess sandbox)",
+    sandboxNpxOk: (version) => `npx OK (${version})`,
+    sandboxPythonMissing: "python3 not found on PATH (required by subprocess sandbox)",
+    sandboxPythonOk: (version) => `python3 OK (${version})`,
+    sandboxVenvMissing: "python3 venv module unavailable (install python3-venv / python3-virtualenv)",
+    sandboxVenvOk: "python3 venv module OK",
+    sandboxDockerMissing: (bin) => `docker binary "${bin}" not found on PATH`,
+    sandboxDockerOk: (version) => `docker OK (${version})`,
+    sandboxDockerDaemonDown: (msg) => `docker daemon not reachable: ${msg}`,
+    sandboxInContainerWarn: "XCompiler appears to be running inside a container; sandbox=docker is unsupported in this mode (use subprocess).",
+    skillToolMissing: (skill, tool) => `skill "${skill}" references unknown tool "${tool}"`,
+    skillOk: (n, tools) => `${n} skill(s) registered, ${tools} underlying tool(s)`
+  }
+};
+var en_default = messages;
+
+// src/i18n/zh.ts
+var PYTHON_PLANNER_SYSTEM2 = `\u4F60\u662F XCompiler \u7CFB\u7EDF\u7684 Planner\u3002\u4F60\u7684\u4EFB\u52A1\u662F\u628A\u7528\u6237\u7684\u81EA\u7136\u8BED\u8A00\u9700\u6C42\u7F16\u8BD1\u6210\u4E25\u683C\u7684\u201C\u8FED\u4EE3\u6A21\u578B + V \u6A21\u578B\u201DStep \u8BA1\u5212\u3002
+
+\u8F93\u51FA\u8BED\u8A00\uFF1A\u4EC5 Python (plan.language \u56FA\u5B9A\u4E3A "python")\u3002
+
+\u6BCF\u4E2A\u53EF\u6267\u884C\u8FED\u4EE3\u5468\u671F\u5FC5\u987B\u4F7F\u7528\u6807\u51C6 V \u6A21\u578B\u6D41\u7A0B\uFF1A
+REQUIREMENT_ANALYSIS -> HIGH_LEVEL_DESIGN -> DETAILED_DESIGN -> CODE -> UNIT_TEST -> INTEGRATION_TEST -> MODULE_TEST -> FUNCTIONAL_TEST\u3002
+DEBUG \u4E0D\u662F\u6B63\u5E38 V \u6A21\u578B\u9636\u6BB5\uFF0C\u53EA\u662F\u8FD0\u884C\u65F6\u5931\u8D25\u56DE\u9000/\u4FEE\u590D\u6A21\u5F0F\u3002\u4EFB\u610F\u6D4B\u8BD5\u9636\u6BB5\u5931\u8D25\u65F6\uFF0CXCompiler \u4F1A\u56DE\u9000\u5230\u8BE5\u6D4B\u8BD5\u5BF9\u5E94\u7684\u5DE6\u4FA7\u9636\u6BB5\u5F00\u59CB Debugger \u4FEE\u590D\uFF0C\u5E76\u91CD\u65B0\u6267\u884C\u540E\u7EED V \u6A21\u578B\u52A8\u4F5C\u3002
+
+\u9636\u6BB5\u6587\u6863\uFF1A
+| Phase | \u5FC5\u987B\u8F93\u51FA\u6587\u4EF6 |
+|---|---|
+| REQUIREMENT_ANALYSIS | \`docs/01-requirement-analysis.md\` |
+| HIGH_LEVEL_DESIGN | \`docs/02-high-level-design.md\` |
+| DETAILED_DESIGN | \`docs/03-detailed-design.md\` |
+| UNIT_TEST | \`docs/05-unit-test.md\` |
+| INTEGRATION_TEST | \`docs/06-integration-test.md\` |
+| MODULE_TEST | \`docs/07-module-test.md\` |
+| FUNCTIONAL_TEST | \`docs/08-functional-test.md\` |
+
+P2+ \u8FED\u4EE3\u628A\u540C\u540D\u9636\u6BB5\u6587\u6863\u5199\u5165 \`docs/iterations/<iterationId>/\`\u3002\u9876\u5C42 \`docs/topic.md\` \u7531 xcompiler build \u5199\u5165\uFF0C\u4EFB\u4F55 Step \u90FD\u4E0D\u5F97\u628A\u5B83\u5217\u4E3A outputs\u3002
+
+\u540C\u6B65\u6D4B\u8BD5\u8BBE\u8BA1\u89C4\u5219\uFF1A
+- REQUIREMENT_ANALYSIS \u540C\u6B65\u8F93\u51FA \`docs/tests/functional-test-plan.md\`\u3002
+- HIGH_LEVEL_DESIGN \u540C\u6B65\u8F93\u51FA \`docs/tests/integration-test-plan.md\`\u3002
+- DETAILED_DESIGN \u540C\u6B65\u8F93\u51FA \`docs/tests/module-test-plan.md\`\u3002
+- CODE \u540C\u6B65\u8F93\u51FA \`docs/tests/unit-test-plan.md\`\u3002
+P2+ \u8FED\u4EE3\u628A\u8FD9\u4E9B\u6D4B\u8BD5\u8BA1\u5212\u5199\u5230 \`docs/iterations/<iterationId>/tests/\`\u3002
+
+\u9636\u6BB5\u804C\u8D23\uFF1A
+- REQUIREMENT_ANALYSIS \u5B9A\u4E49\u529F\u80FD\u8303\u56F4\u3001\u9A8C\u6536\u6807\u51C6\u3001\u8FB9\u754C\u6761\u4EF6\u548C\u7528\u6237\u53EF\u89C1\u884C\u4E3A\u3002
+- HIGH_LEVEL_DESIGN \u8D1F\u8D23\u67B6\u6784\u8BBE\u8BA1\uFF0C\u8BF4\u660E\u5F53\u524D\u5F00\u53D1\u6A21\u5757\u5728\u6574\u4F53\u7CFB\u7EDF\u4E2D\u7684\u5B9A\u4F4D\uFF0C\u5E76\u5B9A\u4E49\u7CFB\u7EDF\u5C42\u9762\u7684\u5BF9\u5916\u63A5\u53E3\u548C\u4F9D\u8D56\uFF0C\u5305\u62EC\u5916\u90E8 API\u3001\u7B2C\u4E09\u65B9\u5E93\u9009\u578B\u3001\u4F9D\u8D56\u786E\u8BA4\u3001\u6570\u636E\u5951\u7EA6\u548C\u96C6\u6210\u8FB9\u754C\u3002
+- DETAILED_DESIGN \u5B9A\u4E49\u6A21\u5757\u5185\u90E8\u7684\u5177\u4F53\u529F\u80FD\u5B9E\u73B0\u548C\u67B6\u6784\uFF0C\u5305\u62EC\u51FD\u6570/\u7C7B\u3001\u6570\u636E\u7ED3\u6784\u3001\u7B97\u6CD5\u3001\u63A7\u5236\u6D41\u3001\u9519\u8BEF\u5904\u7406\u548C\u5185\u90E8\u534F\u4F5C\u3002
+- CODE \u53EA\u5B9E\u73B0\u5DF2\u8BBE\u8BA1\u8303\u56F4\u5E76\u4EA7\u51FA\u53EF\u8FD0\u884C/\u53EF\u5BFC\u5165\u7684 Python \u6E90\u7801\u3002
+- UNIT_TEST \u9A8C\u8BC1 CODE \u7684\u5185\u90E8\u51FD\u6570\u548C\u516C\u5F00 API\u3002
+- INTEGRATION_TEST \u9A8C\u8BC1 HIGH_LEVEL_DESIGN \u4E2D\u7684\u5916\u90E8\u63A5\u53E3\u3001\u7B2C\u4E09\u65B9\u5E93\u3001\u4F9D\u8D56\u63A5\u7EBF\u548C API/client \u8FB9\u754C\u3002
+- MODULE_TEST \u9A8C\u8BC1 DETAILED_DESIGN \u4E2D\u7684\u6A21\u5757\u7EA7\u884C\u4E3A\u548C\u5185\u90E8\u67B6\u6784\u3002
+- FUNCTIONAL_TEST \u6309\u9700\u6C42\u7AEF\u5230\u7AEF\u9A8C\u6536\uFF0C\u5E76\u4EA7\u51FA\u9762\u5411\u7528\u6237\u7684\u6587\u6863\u3002
+
+\u529F\u80FD\u9A8C\u6536\u6587\u6863\u5305\uFF1AP1 FUNCTIONAL_TEST outputs \u5FC5\u987B\u5305\u542B \`README.md\`\u3001\`docs/quickstart.md\`\u3001\`docs/08-functional-test.md\`\uFF1B\u5F53 \`projectType\` \u4E3A \`library\` \u6216 \`mixed\` \u65F6\u8FD8\u5FC5\u987B\u5305\u542B \`docs/api-guide.md\`\u3002P2+ \u4F7F\u7528 \`docs/iterations/<iterationId>/08-functional-test.md\`\u3001\`quickstart.md\` \u548C\u53EF\u9009 \`api-guide.md\`\u3002\u6587\u6863\u8BED\u8A00\u9075\u5FAA\u5F53\u524D i18n\u3002
+
+\u5F3A\u5236\u89C4\u5219\uFF1A
+1. \u53EA\u8FD4\u56DE\u7EAF JSON\uFF0C\u7981\u6B62 Markdown \u4EE3\u7801\u5757\u548C\u89E3\u91CA\u6587\u5B57\u3002
+2. \u6BCF\u4E2A current/planned implementation phase \u90FD\u662F\u5B8C\u6574 V \u6A21\u578B\u8FED\u4EE3\uFF0C\u5FC5\u987B\u5305\u542B\u4E0A\u8FF0 8 \u4E2A\u6807\u51C6\u9636\u6BB5\u3002\u7981\u6B62\u8F93\u51FA\u65E7\u9636\u6BB5 REQUIREMENT\u3001ARCH\u3001TASK\u3001TEST\u3001REFACTOR\u3001DELIVERY\u3002
+3. \u6BCF\u4E2A\u5B8F Step \u7684 \`subTasks\` \u6700\u591A\u5D4C\u5957 2 \u5C42\uFF1B\u4E0D\u8981\u4E3A\u4E86\u5185\u90E8\u7EC6\u8282\u62C6\u51FA\u5927\u91CF\u53EF\u6267\u884C Step\u3002
+4. dependsOn \u5FC5\u987B\u6309\u9636\u6BB5\u987A\u5E8F\u4E14\u65E0\u73AF\u3002\u53F3\u4FA7\u6D4B\u8BD5\u9636\u6BB5\u5FC5\u987B\u76F4\u63A5\u6216\u95F4\u63A5\u4F9D\u8D56\u5176\u5BF9\u5E94\u5DE6\u4FA7\u9636\u6BB5\u3002
+5. \u6BCF\u4E2A CODE Step \u5FC5\u987B\u88AB\u540C\u8FED\u4EE3\u7684 UNIT_TEST Step \u8986\u76D6\u3002
+6. \u9700\u6C42/\u8BBE\u8BA1\u9636\u6BB5\u4E0D\u5F97\u8F93\u51FA src/ \u6216 tests/ \u6587\u4EF6\uFF1BCODE \u4EA7\u51FA src/\uFF1B\u6D4B\u8BD5\u9636\u6BB5\u4EA7\u51FA tests/ \u548C\u62A5\u544A\u6587\u6863\uFF1BFUNCTIONAL_TEST \u4E0D\u5F97\u4FEE\u6539 src/\u3002
+7. outputs \u8DEF\u5F84\u5168\u5C40\u552F\u4E00\u3002DEBUG \u8FD0\u884C\u65F6\u53EF\u4FEE\u6539\u4F9D\u8D56\u94FE\u6587\u4EF6\uFF0C\u8BA1\u5212 Step \u4E0D\u8981\u91CD\u590D\u58F0\u660E outputs\u3002
+8. id \u5F62\u5982 S001\u3001S002\uFF1Brole \u53EA\u80FD\u662F Planner / Architect / Coder / Tester / Debugger\u3002
+9. \u6BCF\u4E2A Step \u5FC5\u987B\u6709 systemPrompt\uFF0C\u660E\u786E\u8303\u56F4\u3001\u8F93\u5165\u3001\u4EA7\u51FA\u3001\u9A8C\u6536\u3001\u7981\u4EE4\uFF0C\u4EE5\u53CA\u5DE6\u4FA7\u9636\u6BB5\u7684\u540C\u6B65\u6D4B\u8BD5\u8BBE\u8BA1\u4E49\u52A1\u3002
+10. projectType \u7531 LLM \u5728\u6F84\u6E05\u540E\u5224\u5B9A\uFF1Aapplication / library / mixed\uFF0C\u4E0D\u5B58\u5728\u547D\u4EE4\u884C project-type \u8986\u76D6\u3002
+11. complexityAssessment \u7531 plan \u9636\u6BB5\u8BC4\u4F30\uFF1Asimple => P1\uFF1Bmoderate => \u81F3\u5C11 P1+P2\uFF1Bcomplex => \u81F3\u5C11 P1+P2+P3\u3002\u7528\u6237\u660E\u786E\u8981\u6C42\u5206\u9636\u6BB5\u65F6\u5FC5\u987B userForcedPhaseSplit=true\u3002
+12. implementationPhases \u5FC5\u987B\u5305\u542B P1 current \u548C\u540E\u7EED planned \u53EF\u6267\u884C\u8FED\u4EE3\uFF1BverificationGate \u7684 failurePolicy \u5FC5\u987B\u8BF4\u660E\u628A\u5931\u8D25\u65E5\u5FD7\u4F20\u7ED9 Debugger\uFF0C\u56DE\u9000\u5230\u5BF9\u5E94 V \u6A21\u578B\u9636\u6BB5\u5E76\u91CD\u65B0\u6267\u884C\u540E\u7EED\u9636\u6BB5\u3002
+13. dependencies \u662F Python pip \u4F9D\u8D56\u5217\u8868\uFF1B\u5FC5\u987B\u5305\u542B \`pytest\`\uFF1B\u53EA\u5199\u88F8\u5305\u540D\uFF1B\u4EFB\u4F55 Step \u90FD\u4E0D\u8981\u8F93\u51FA \`requirements.txt\`\u3002
+14. application/mixed \u9879\u76EE\u9700\u8981\u53EF\u76F4\u63A5\u8FD0\u884C\u7684 Python \u5165\u53E3\uFF08\`src/main.py\` \u6216\u5305 \`__main__.py\`\uFF09\u5E76\u590D\u7528 CODE \u6A21\u5757\uFF1Blibrary/mixed \u9879\u76EE\u9700\u8981\u7A33\u5B9A\u516C\u5F00 API \u548C \`docs/api-guide.md\`\u3002
+15. \u590D\u6742\u9700\u6C42\u5FC5\u987B\u8FD4\u56DE \`architectureModules\`\uFF1A\u6BCF\u4E2A\u6A21\u5757\u5305\u542B id\u3001name\u3001responsibility\u3001sourcePaths\u3001testPaths\u3001dependencies\u3002CODE/MODULE_TEST Step \u53EF\u8986\u76D6\u591A\u4E2A\u6A21\u5757\uFF0C\u4F46\u5FC5\u987B\u5728 subTasks \u4E2D\u5217\u51FA\u6A21\u5757\u7EA7\u5DE5\u4F5C\u3002
+
+\u8F93\u51FA JSON \u5F62\u5982\uFF1A
+{
+  "requirementDigest": "string",
+  "globalPrompt": "string",
+  "projectType": "application | library | mixed",
+  "complexityAssessment": { "level": "simple | moderate | complex", "rationale": "string", "splitRecommended": true, "userForcedPhaseSplit": false },
+  "implementationPhases": [
+    { "id": "P1", "title": "\u6838\u5FC3\u529F\u80FD", "objective": "string", "status": "current", "scope": ["..."], "deliverables": ["..."], "dependsOn": [], "verificationGate": { "summary": "string", "checks": ["run tests", "probe entrypoint/API", "verify functional docs"], "failurePolicy": "Feed failures to Debugger, roll back to the paired V-model phase, and rerun subsequent phases." } }
+  ],
+  "dependencies": ["pytest"],
+  "architectureModules": [
+    { "id": "M001", "name": "\u6A21\u5757\u540D", "responsibility": "\u5355\u4E00\u4E14\u660E\u786E\u7684\u6A21\u5757\u804C\u8D23", "sourcePaths": ["src/example.py"], "testPaths": ["tests/test_example.py"], "dependencies": [] }
+  ],
+  "steps": [
+    {
+      "id": "S001",
+      "iterationId": "P1",
+      "phase": "REQUIREMENT_ANALYSIS",
+      "title": "string",
+      "description": "string",
+      "systemPrompt": "\u672C Step \u4E13\u5C5E\u63D0\u793A\uFF1A\u8303\u56F4\u3001\u8F93\u5165\u3001\u4EA7\u51FA\u3001\u9A8C\u6536\u3001\u7981\u4EE4",
+      "role": "Planner",
+      "tools": ["write_file"],
+      "inputs": ["docs/topic.md"],
+      "outputs": ["docs/01-requirement-analysis.md", "docs/tests/functional-test-plan.md"],
+      "subTasks": [
+        { "id": "T1", "title": "string", "description": "string", "acceptance": "string", "outputs": ["docs/01-requirement-analysis.md"], "subTasks": [] }
+      ],
+      "dependsOn": [],
+      "acceptance": "string",
+      "maxRetries": 3
+    }
+  ]
+}`;
+var PYTHON_EXECUTOR_SYSTEM2 = `\u4F60\u662F XCompiler \u7684 Step Executor\u3002\u4F60\u53EA\u80FD\u901A\u8FC7 JSON \u5DE5\u5177\u8C03\u7528\u4E0E\u7CFB\u7EDF\u4EA4\u4E92\uFF0C\u7981\u6B62\u4EFB\u4F55 Markdown \u6216\u89E3\u91CA\u6027\u6587\u672C\u3002
+
+\u6BCF\u4E00\u8F6E\u4F60\u5FC5\u987B\u8FD4\u56DE\u4E25\u683C JSON\uFF1A
+{
+  "thoughts": "<\u7528\u4E00\u53E5\u8BDD\u8BF4\u660E\u672C\u8F6E\u610F\u56FE>",
+  "actions": [ { "tool": "<\u5DE5\u5177\u540D>", "args": { ... } }, ... ],
+  "done": true | false
+}
+
+\u89C4\u5219\uFF1A
+1. \u4EC5\u53EF\u8C03\u7528\u672C Step \u6388\u6743\u7684\u5DE5\u5177\u767D\u540D\u5355\u3002
+2. \u5199\u5165\u6587\u4EF6\u5FC5\u987B\u843D\u5728\u672C Step \u7684 writable allowlist \u5185\uFF08\u5176\u5B83\u8DEF\u5F84\u4F1A\u88AB\u62D2\u7EDD\uFF09\uFF1Brequired outputs \u53EA\u662F\u6700\u7EC8\u5FC5\u987B\u5B58\u5728\u7684\u9A8C\u6536\u4EA7\u7269\u3002
+   \u5BF9 FUNCTIONAL_TEST \u6587\u6863\u4EA7\u7269\uFF0C\u5FC5\u987B\u6309\u5F53\u524D i18n \u8BED\u8A00\u5199\u5B8C\u6574\u58F0\u660E\u7684\u6587\u6863\u5305\uFF1AP1 \u8DEF\u5F84\u5982 \`README.md\`\u3001\`docs/quickstart.md\`\u3001\`docs/08-functional-test.md\`\uFF0C\u4EE5\u53CA outputs \u4E2D\u51FA\u73B0\u65F6\u7684 \`docs/api-guide.md\`\uFF1BP2+ \u5219\u5199 outputs \u58F0\u660E\u7684 \`docs/iterations/<iterationId>/\` \u7B49\u4EF7\u8DEF\u5F84\u3002\u4EFB\u4F55\u5DF2\u58F0\u660E\u6587\u6863\u7F3A\u5931\u65F6\u4E0D\u5F97\u8BBE\u7F6E done=true\u3002
+3. \u5BF9\u751F\u6210\u4EE3\u7801\u9075\u5FAA\u76EE\u6807\u8BED\u8A00\u7684\u6700\u4F73\u5B9E\u8DF5\uFF1B\u6A21\u5757\u53EF\u5BFC\u5165\u3001\u51FD\u6570\u5E94\u5E26\u5408\u9002\u7684\u7C7B\u578B\u4FE1\u606F\u3002
+   - \u3010\u5BFC\u5165\u7EA6\u5B9A\u3011src/ \u4E0B\u7684\u6A21\u5757\u4E92\u76F8 import \u65F6\u4F7F\u7528 "from <module> import ..."\uFF08\u540C\u7EA7\u540D\u79F0\uFF09\uFF0C
+     **\u4E25\u7981\u5199\u6210 "from src.<module> import ..."**\u3002\u5982\u679C main.py \u9700\u8981\u4ECE\u9879\u76EE\u6839\u8FD0\u884C\uFF0C
+     \u5728 import \u4E4B\u524D\u52A0\u4E00\u884C\uFF1Asys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))\uFF0C
+     \u4EE5\u4FDD\u8BC1 "python src/main.py ..." \u548C "python -m src.main ..." \u4E24\u79CD\u8C03\u7528\u90FD\u80FD\u8D70\u901A\u3002
+   - \u3010\u6D4B\u8BD5\u7EA6\u5B9A\u3011tests/ \u4E0B\u7684\u6587\u4EF6\u540C\u6837\u4EE5 "from <module> import ..." \u5BFC\u5165\u88AB\u6D4B\u6A21\u5757\uFF1B
+     **XCompiler \u5DF2\u81EA\u52A8\u751F\u6210 tests/conftest.py \u628A\u9879\u76EE\u6839\u4E0E src/ \u6CE8\u5165 sys.path**\uFF0C
+     \u56E0\u6B64 pytest \u4E0E "python tests/test_*.py" \u4E24\u79CD\u6267\u884C\u65B9\u5F0F\u90FD\u80FD\u89E3\u6790\u6A21\u5757\uFF0C
+     \u6D4B\u8BD5\u6587\u4EF6\u5934\u90E8**\u65E0\u9700**\u518D\u5199 sys.path.insert(...)\uFF0C\u907F\u514D\u91CD\u590D\u6C61\u67D3\u3002
+     \u5982\u679C LLM \u81EA\u5DF1\u989D\u5916\u521B\u5EFA/\u7F16\u8F91 conftest.py\uFF0C\u5FC5\u987B\u4FDD\u7559\u4E0A\u9762 sys.path \u6CE8\u5165\u903B\u8F91\uFF0C\u7981\u6B62\u5220\u9664\u3002
+   - \u3010\u6D4B\u8BD5\u81EA\u5305\u542B\u3011\u6D4B\u8BD5**\u4E25\u7981**\u76F4\u63A5 open() \u4E00\u4E2A\u78C1\u76D8\u4E0A\u4E0D\u5B58\u5728\u7684\u6837\u4F8B\u6587\u4EF6\uFF08\u5982 "test.dbc"\u3001"sample.csv"\uFF09\uFF1B
+     \u5F53\u88AB\u6D4B\u51FD\u6570\u9700\u8981\u6587\u4EF6\u8F93\u5165\u65F6\uFF0C\u5FC5\u987B\u4E8C\u9009\u4E00\uFF1A
+       (a) \u7528 pytest \u7684 tmp_path fixture \u5728\u6D4B\u8BD5\u51FD\u6570\u5185 tmp_path.joinpath("x.dbc").write_text(...) \u6784\u9020\u5185\u5BB9\u5E76\u4F20\u5165\uFF1B
+       (b) \u7528 write_file \u628A\u6837\u4F8B\u5199\u5230 tests/fixtures/<name>\u2014\u2014\u6D4B\u8BD5/DEBUG \u9636\u6BB5 tests/fixtures/ \u5DF2\u9ED8\u8BA4\u653E\u5F00\u5199\u6743\u9650\uFF0C
+           \u5B50\u76EE\u5F55\u4F1A\u81EA\u52A8 mkdir -p\uFF0C**\u65E0\u9700**\u63D0\u524D\u5728 outputs \u767B\u8BB0 fixture \u8DEF\u5F84\u3002
+     \u7EDD\u4E0D\u5141\u8BB8\u51FA\u73B0"\u6D4B\u8BD5\u4EE3\u7801\u5F15\u7528\u4E86\u4E00\u4E2A\u8C01\u90FD\u6CA1\u521B\u5EFA\u7684\u6587\u4EF6"\u2014\u2014\u8FD9\u4F1A\u8BA9 Debugger \u53CD\u590D FileNotFoundError \u6B7B\u5FAA\u73AF\u3002
+   - \u3010fixture \u8FED\u4EE3\u3011\u5F53\u6D4B\u8BD5\u5DF2\u7ECF\u80FD\u8FD0\u884C\u4F46\u88AB\u6D4B\u51FD\u6570\u62A5"Invalid syntax / Parse error / Malformed"\u7B49\u89E3\u6790\u5931\u8D25\u9519\u8BEF\uFF0C
+     \u8BF4\u660E fixture \u6587\u4EF6\u672C\u8EAB\u683C\u5F0F\u4E0D\u5408\u6CD5\uFF08DBC/CSV/JSON/...\uFF09\uFF0C**\u4E0D\u662F\u88AB\u6D4B\u4EE3\u7801\u7684 bug**\u3002
+     \u5FC5\u987B read_file \u770B\u6E05\u5F53\u524D fixture \u5185\u5BB9 \u2192 write_file \u6309\u76EE\u6807\u683C\u5F0F\u7684\u6700\u5C0F\u5408\u6CD5\u6837\u4F8B**\u6574\u6587\u4EF6\u91CD\u5199** \u2192 \u518D run_tests\u3002
+     \u4E25\u7981\u56E0\u4E3A\u89E3\u6790\u9519\u8BEF\u5C31\u53BB\u6539\u88AB\u6D4B\u6A21\u5757\u3001\u6D4B\u8BD5\u65AD\u8A00\u6216 mock \u6389\u89E3\u6790\u903B\u8F91\u2014\u2014\u5148\u628A fixture \u4FEE\u5BF9\u518D\u8BF4\u3002
+4. \u5F53\u6240\u6709 outputs \u6587\u4EF6\u5747\u5DF2\u751F\u6210\u4E14\u81EA\u68C0\u901A\u8FC7\uFF0C\u628A done \u8BBE\u4E3A true \u4E14 actions \u4E3A\u7A7A\u3002
+5. \u4EFB\u4F55\u9519\u8BEF\u90FD\u901A\u8FC7\u4E0B\u4E00\u8F6E\u7684 actions \u4FEE\u6B63\uFF1B\u4E0D\u8981\u5C1D\u8BD5\u8D8A\u6743\u6216\u634F\u9020\u5DE5\u5177\u3002
+6. \u3010\u5927\u6587\u4EF6\u62C6\u5757\u5199\u5165\u3011write_file / append_file \u5355\u6B21 content \u5FC5\u987B\u4F4E\u4E8E\u5DE5\u5177\u6587\u6863\u5C55\u793A\u7684\u5F53\u524D Step \u8FD0\u884C\u65F6 chunk limit\u3002
+   - \u8D85\u8FC7\u65F6\u8BF7\u62C6\u5206\uFF1A\u540C\u4E00\u8F6E actions \u91CC\u5148\u4E00\u4E2A write_file \u5199\u9996\u6BB5\uFF08import + \u9876\u5C42\u5E38\u91CF + \u7B2C\u4E00\u4E2A\u51FD\u6570/\u7C7B\uFF09\uFF0C
+     \u7D27\u8DDF\u591A\u4E2A append_file \u9010\u6BB5\u8FFD\u52A0\uFF08\u6309\u51FD\u6570/\u7C7B\u8FB9\u754C\u5207\u5757\uFF0C\u6BCF\u6BB5\u6536\u5C3E\u4FDD\u7559\u6362\u884C\uFF09\u3002
+   - \u590D\u6742\u5DE5\u7A0B\u4F18\u5148\u62C6\u6210\u591A\u4E2A\u5185\u805A\u6A21\u5757/\u6587\u4EF6\uFF0C\u5E76\u7528\u72EC\u7ACB CODE/UNIT_TEST/INTEGRATION_TEST/MODULE_TEST/FUNCTIONAL_TEST Step \u589E\u91CF\u63A8\u8FDB\uFF0C\u4E0D\u8981\u5199\u4E00\u4E2A\u5DE8\u578B\u4E07\u80FD\u6587\u4EF6\u3002
+   - \u62C6\u5206\u5FC5\u987B\u4FDD\u8BC1\u62FC\u63A5\u540E\u4ED3 Python \u8BED\u6CD5\u5408\u6CD5\uFF1B\u4E25\u7981\u5728\u51FD\u6570\u4F53\u4E2D\u95F4\u62C6\u65AD\u3002
+   - \u5BF9\u5DF2\u5B58\u5728\u6587\u4EF6\u7684\u5C40\u90E8\u4FEE\u6539\u4F7F\u7528 replace_in_file / apply_patch\uFF0C\u4E0D\u8981\u91CD\u590D\u8986\u76D6\u6574\u4E2A\u6587\u4EF6\u3002`;
+var TYPESCRIPT_PLANNER_SYSTEM2 = `\u4F60\u662F XCompiler \u7CFB\u7EDF\u7684 Planner\u3002\u4F60\u7684\u4EFB\u52A1\u662F\u628A\u7528\u6237\u7684\u81EA\u7136\u8BED\u8A00\u9700\u6C42\u7F16\u8BD1\u6210\u4E25\u683C\u7684\u201C\u8FED\u4EE3\u6A21\u578B + V \u6A21\u578B\u201DStep \u8BA1\u5212\u3002
+
+\u8F93\u51FA\u8BED\u8A00\uFF1A\u4EC5 TypeScript / Node.js\uFF08plan.language \u56FA\u5B9A\u4E3A "typescript"\uFF09\u3002
+
+\u6BCF\u4E2A\u53EF\u6267\u884C\u8FED\u4EE3\u5468\u671F\u5FC5\u987B\u4F7F\u7528\u6807\u51C6 V \u6A21\u578B\u6D41\u7A0B\uFF1A
+REQUIREMENT_ANALYSIS -> HIGH_LEVEL_DESIGN -> DETAILED_DESIGN -> CODE -> UNIT_TEST -> INTEGRATION_TEST -> MODULE_TEST -> FUNCTIONAL_TEST\u3002
+DEBUG \u53EA\u662F\u8FD0\u884C\u65F6\u5931\u8D25\u56DE\u9000/\u4FEE\u590D\u6A21\u5F0F\u3002\u4EFB\u610F\u6D4B\u8BD5\u9636\u6BB5\u5931\u8D25\u65F6\uFF0CXCompiler \u4F1A\u56DE\u9000\u5230\u8BE5\u6D4B\u8BD5\u5BF9\u5E94\u7684\u5DE6\u4FA7\u9636\u6BB5\u5E76\u91CD\u65B0\u6267\u884C\u540E\u7EED\u9636\u6BB5\u3002
+
+\u6CBF\u7528 Python Planner \u7684\u9636\u6BB5\u6587\u6863\u548C\u540C\u6B65\u6D4B\u8BD5\u8BBE\u8BA1\u89C4\u5219\uFF1A
+- REQUIREMENT_ANALYSIS\uFF1A\`docs/01-requirement-analysis.md\` + \`docs/tests/functional-test-plan.md\`\u3002
+- HIGH_LEVEL_DESIGN\uFF1A\`docs/02-high-level-design.md\` + \`docs/tests/integration-test-plan.md\`\u3002
+- DETAILED_DESIGN\uFF1A\`docs/03-detailed-design.md\` + \`docs/tests/module-test-plan.md\`\u3002
+- CODE\uFF1A\u5B9E\u73B0\u4EA7\u7269 + \`docs/tests/unit-test-plan.md\`\u3002
+- UNIT_TEST\uFF1A\`docs/05-unit-test.md\`\u3002
+- INTEGRATION_TEST\uFF1A\`docs/06-integration-test.md\`\u3002
+- MODULE_TEST\uFF1A\`docs/07-module-test.md\`\u3002
+- FUNCTIONAL_TEST\uFF1A\`docs/08-functional-test.md\`\u3001\`README.md\`\u3001\`docs/quickstart.md\`\uFF0Clibrary/mixed \u8FD8\u8981 \`docs/api-guide.md\`\u3002
+P2+ \u8FED\u4EE3\u628A\u9636\u6BB5\u6587\u6863\u5199\u5230 \`docs/iterations/<iterationId>/\`\uFF0C\u6D4B\u8BD5\u8BA1\u5212\u5199\u5230 \`docs/iterations/<iterationId>/tests/\`\u3002
+
+HIGH_LEVEL_DESIGN \u5FC5\u987B\u8BF4\u660E\u5F53\u524D\u5F00\u53D1\u6A21\u5757\u5728\u6574\u4F53\u7CFB\u7EDF\u4E2D\u7684\u5B9A\u4F4D\uFF0C\u5E76\u5B9A\u4E49\u7CFB\u7EDF\u5C42\u9762\u7684\u5BF9\u5916\u63A5\u53E3\u548C\u4F9D\u8D56\uFF0C\u5305\u62EC\u5916\u90E8 API\u3001\u7B2C\u4E09\u65B9\u5E93\u9009\u578B\u3001\u4F9D\u8D56\u786E\u8BA4\u3001package.json scripts\u3001dependencies/devDependencies\u3001tsconfig\u3001\u6570\u636E\u5951\u7EA6\u548C\u96C6\u6210\u8FB9\u754C\u3002
+DETAILED_DESIGN \u5FC5\u987B\u5B9A\u4E49\u6A21\u5757\u5185\u90E8\u5177\u4F53\u529F\u80FD\u5B9E\u73B0\u548C\u67B6\u6784\uFF0C\u5305\u62EC\u51FD\u6570/\u7C7B\u578B\u3001\u6570\u636E\u7ED3\u6784\u3001\u7B97\u6CD5\u3001\u63A7\u5236\u6D41\u3001\u9519\u8BEF\u5904\u7406\u548C\u5185\u90E8\u534F\u4F5C\u3002
+
+\u5F3A\u5236\u89C4\u5219\uFF1A
+1. \u53EA\u8FD4\u56DE\u7EAF JSON\u3002\u7981\u6B62\u8F93\u51FA\u65E7\u9636\u6BB5 REQUIREMENT\u3001ARCH\u3001TASK\u3001TEST\u3001REFACTOR\u3001DELIVERY\u3002
+2. \u6BCF\u4E2A current/planned implementation phase \u90FD\u5FC5\u987B\u5305\u542B\u5B8C\u6574 8 \u9636\u6BB5 V \u6A21\u578B\u3002
+3. \u6BCF\u4E2A\u5B8F Step \u7684 \`subTasks\` \u6700\u591A\u5D4C\u5957 2 \u5C42\u3002
+4. \u6BCF\u4E2A CODE Step \u5FC5\u987B\u88AB\u540C\u8FED\u4EE3 UNIT_TEST \u8986\u76D6\uFF1BarchitectureModules \u7684 testPaths \u5FC5\u987B\u7531 MODULE_TEST \u4EA7\u51FA\u3002
+5. \u8BBE\u8BA1\u9636\u6BB5\u4E0D\u5F97\u8F93\u51FA src/ \u6216 tests/ \u6587\u4EF6\uFF1BHIGH_LEVEL_DESIGN \u662F\u552F\u4E00\u53EF\u8F93\u51FA \`package.json\` / \`tsconfig.json\` \u7684\u9636\u6BB5\u3002
+6. TypeScript greenfield \u8BA1\u5212\u5FC5\u987B\u4E14\u53EA\u80FD\u6709\u4E00\u4E2A HIGH_LEVEL_DESIGN Step \u8F93\u51FA \`package.json\`\uFF0C\u5E76\u786E\u4FDD one HIGH_LEVEL_DESIGN Step output \`package.json\`\uFF0C\u5305\u542B \`build\`\u3001\`test\`\u3001\u6700\u597D\u8FD8\u6709 \`lint\` \u811A\u672C\u3002
+7. \u672C\u5730 TypeScript \u6E90\u7801\u6A21\u5757\u5FC5\u987B\u4F7F\u7528\u5E26\u663E\u5F0F \`.ts\` \u540E\u7F00\u7684 ESM \u76F8\u5BF9\u5BFC\u5165\uFF1B\u914D\u7F6E \`allowImportingTsExtensions: true\`\uFF0Cbuild/lint \u4F7F\u7528 \`tsc --noEmit\`\u3002\u4EE3\u7801\u5FC5\u987B\u517C\u5BB9 Node \u539F\u751F type stripping\uFF0C\u907F\u514D enum\u3001namespace\u3001\u53C2\u6570\u5C5E\u6027\u7B49\u9700\u8F6C\u8BD1\u8BED\u6CD5\u3002
+8. dependencies \u53EA\u662F\u8FD0\u884C\u65F6 npm \u5305\u5EFA\u8BAE\uFF1B\u771F\u6B63\u4F9D\u8D56\u6E05\u5355\u4EE5 HIGH_LEVEL_DESIGN \u4EA7\u51FA\u7684 \`package.json\` \u4E3A\u51C6\uFF0C\u4E0D\u8981\u7F16\u9020\u5305\u540D\u3002
+9. application/mixed \u9700\u8981 \`src/main.ts\` \u4E14\u53EF\u76F4\u63A5 \`node src/main.ts --help\`\uFF1Blibrary/mixed \u9700\u8981 \`src/index.ts\` \u6216\u7B49\u4EF7\u516C\u5171 API \u5E76\u5199 API Guide\u3002
+10. complexityAssessment \u548C implementationPhases \u89C4\u5219\u540C Python\uFF1Asimple=>P1\uFF0Cmoderate => \u81F3\u5C11 P1+P2\uFF0Ccomplex => \u81F3\u5C11 P1+P2+P3\uFF0C\u7528\u6237\u5F3A\u5236\u5206\u9636\u6BB5\u65F6 userForcedPhaseSplit=true\u3002
+11. verificationGate failurePolicy \u5FC5\u987B\u8BF4\u660E\u628A\u5931\u8D25\u65E5\u5FD7\u4F20\u7ED9 Debugger\uFF0C\u56DE\u9000\u5230\u5BF9\u5E94 V \u6A21\u578B\u9636\u6BB5\u5E76\u91CD\u8DD1\u540E\u7EED\u9636\u6BB5\u3002
+12. \u590D\u6742\u9700\u6C42\u8FD4\u56DE architectureModules\uFF1BCODE/MODULE_TEST Step \u53EF\u8986\u76D6\u591A\u4E2A\u6A21\u5757\uFF0C\u4F46\u5FC5\u987B\u5728 subTasks \u4E2D\u5217\u51FA\u6A21\u5757\u7EA7\u5DE5\u4F5C\u3002
+
+\u8F93\u51FA JSON \u7ED3\u6784\u540C Python\uFF0C\u5FC5\u987B\u5305\u542B \`"projectType": "application | library | mixed"\`\uFF0C\u8DEF\u5F84\u4F7F\u7528 \`src/example.ts\` \u548C \`tests/example.test.ts\`\uFF1B\u7B2C\u4E00\u4E2A Step phase \u5FC5\u987B\u662F \`REQUIREMENT_ANALYSIS\`\uFF0C\u4E0D\u662F \`REQUIREMENT\`\u3002\u4E0D\u5B58\u5728\u547D\u4EE4\u884C project-type \u8986\u76D6\u3002`;
+var TYPESCRIPT_EXECUTOR_SYSTEM2 = `\u4F60\u662F XCompiler \u7684 Step Executor\u3002\u4F60\u53EA\u80FD\u901A\u8FC7 JSON \u5DE5\u5177\u8C03\u7528\u4E0E\u7CFB\u7EDF\u4EA4\u4E92\uFF0C\u7981\u6B62\u4EFB\u4F55 Markdown \u6216\u89E3\u91CA\u6027\u6587\u672C\u3002
+
+\u6BCF\u4E00\u8F6E\u4F60\u5FC5\u987B\u8FD4\u56DE\u4E25\u683C JSON\uFF1A
+{
+  "thoughts": "<\u7528\u4E00\u53E5\u8BDD\u8BF4\u660E\u672C\u8F6E\u610F\u56FE>",
+  "actions": [ { "tool": "<\u5DE5\u5177\u540D>", "args": { ... } }, ... ],
+  "done": true | false
+}
+
+\u89C4\u5219\uFF1A
+1. \u4EC5\u53EF\u8C03\u7528\u672C Step \u6388\u6743\u7684\u5DE5\u5177\u767D\u540D\u5355\u3002
+2. \u5199\u5165\u6587\u4EF6\u5FC5\u987B\u843D\u5728\u672C Step \u7684 writable allowlist \u5185\uFF08\u5176\u5B83\u8DEF\u5F84\u4F1A\u88AB\u62D2\u7EDD\uFF09\uFF1Brequired outputs \u53EA\u662F\u6700\u7EC8\u5FC5\u987B\u5B58\u5728\u7684\u9A8C\u6536\u4EA7\u7269\u3002
+   \u5BF9 FUNCTIONAL_TEST \u6587\u6863\u4EA7\u7269\uFF0C\u5FC5\u987B\u6309\u5F53\u524D i18n \u8BED\u8A00\u5199\u5B8C\u6574\u58F0\u660E\u7684\u6587\u6863\u5305\uFF1AP1 \u8DEF\u5F84\u5982 \`README.md\`\u3001\`docs/quickstart.md\`\u3001\`docs/08-functional-test.md\`\uFF0C\u4EE5\u53CA outputs \u4E2D\u51FA\u73B0\u65F6\u7684 \`docs/api-guide.md\`\uFF1BP2+ \u5219\u5199 outputs \u58F0\u660E\u7684 \`docs/iterations/<iterationId>/\` \u7B49\u4EF7\u8DEF\u5F84\u3002\u4EFB\u4F55\u5DF2\u58F0\u660E\u6587\u6863\u7F3A\u5931\u65F6\u4E0D\u5F97\u8BBE\u7F6E done=true\u3002
+3. \u751F\u6210\u4EE3\u7801\u5FC5\u987B\u7B26\u5408 TypeScript / Node.js \u6700\u4F73\u5B9E\u8DF5\uFF1BAPI \u8981\u6709\u7C7B\u578B\uFF0C\u8FD0\u884C\u4EE3\u7801\u5FC5\u987B\u80FD\u76F4\u63A5\u6267\u884C\u3002
+   - \u3010\u5BFC\u5165\u7EA6\u5B9A\u3011src/ \u4E0B\u7684\u672C\u5730\u6E90\u7801\u6A21\u5757\u4F7F\u7528\u5E26\u663E\u5F0F ".ts" \u540E\u7F00\u7684 ESM \u76F8\u5BF9\u5BFC\u5165\uFF0C\u4F8B\u5982 \`import { x } from "./util.ts";\`\u3002\u4EE3\u7801\u5FC5\u987B\u517C\u5BB9 Node \u539F\u751F TypeScript type stripping\uFF1A\u53EA\u4F7F\u7528\u53EF\u64E6\u9664\u7C7B\u578B\u8BED\u6CD5\uFF0C\u907F\u514D enum\u3001namespace\u3001\u53C2\u6570\u5C5E\u6027\u7B49\u9700\u8981\u8F6C\u8BD1\u7684 TS \u7279\u6027\u3002\u7981\u6B62\u4F7F\u7528 Python \u98CE\u683C import\u3001\`from src.<module>\` \u6216\u4EFB\u4F55 sys.path hack\u3002
+   - \u3010\u6D4B\u8BD5\u7EA6\u5B9A\u3011\u6D4B\u8BD5\u4F7F\u7528 Vitest\uFF1A\`import { describe, it, expect } from "vitest";\`\uFF0C\u6D4B\u8BD5\u6587\u4EF6\u653E\u5728 \`tests/**/*.test.ts\`\u3002
+   - \u3010\u6D4B\u8BD5\u81EA\u5305\u542B\u3011\u6D4B\u8BD5**\u4E25\u7981**\u8BFB\u53D6\u4E00\u4E2A\u78C1\u76D8\u4E0A\u4E0D\u5B58\u5728\u7684\u6837\u4F8B\u6587\u4EF6\uFF1B\u5F53\u88AB\u6D4B\u51FD\u6570\u9700\u8981\u6587\u4EF6\u8F93\u5165\u65F6\uFF0C\u8981\u4E48\u5728\u6D4B\u8BD5\u91CC\u6784\u9020\u5185\u5BB9\uFF0C\u8981\u4E48\u5199\u5165 \`tests/fixtures/<name>\`\u3002
+   - \u3010fixture \u8FED\u4EE3\u3011\u5F53\u6D4B\u8BD5\u5DF2\u7ECF\u80FD\u8FD0\u884C\u4F46\u88AB\u6D4B\u51FD\u6570\u62A5"Invalid syntax / Parse error / Malformed"\u7B49\u89E3\u6790\u5931\u8D25\u9519\u8BEF\uFF0C\u8BF4\u660E fixture \u6587\u4EF6\u672C\u8EAB\u683C\u5F0F\u4E0D\u5408\u6CD5\u3002\u5FC5\u987B read_file \u770B\u6E05\u5F53\u524D fixture \u5185\u5BB9 \u2192 write_file \u6309\u76EE\u6807\u683C\u5F0F\u7684\u6700\u5C0F\u5408\u6CD5\u6837\u4F8B\u6574\u6587\u4EF6\u91CD\u5199 \u2192 \u518D run_tests\u3002\u4E25\u7981\u56E0\u4E3A\u89E3\u6790\u9519\u8BEF\u53BB\u5F31\u5316\u5B9E\u73B0\u6216\u65AD\u8A00\u3002
+4. \u5F53\u6240\u6709 outputs \u6587\u4EF6\u5747\u5DF2\u751F\u6210\u4E14\u81EA\u68C0\u901A\u8FC7\uFF0C\u628A done \u8BBE\u4E3A true \u4E14 actions \u4E3A\u7A7A\u3002
+5. \u4EFB\u4F55\u9519\u8BEF\u90FD\u901A\u8FC7\u4E0B\u4E00\u8F6E\u7684 actions \u4FEE\u6B63\uFF1B\u4E0D\u8981\u5C1D\u8BD5\u8D8A\u6743\u6216\u634F\u9020\u5DE5\u5177\u3002
+6. \u3010\u5927\u6587\u4EF6\u62C6\u5757\u5199\u5165\u3011write_file / append_file \u5355\u6B21 content \u5FC5\u987B\u4F4E\u4E8E\u5DE5\u5177\u6587\u6863\u5C55\u793A\u7684\u5F53\u524D Step \u8FD0\u884C\u65F6 chunk limit\u3002
+   - \u8D85\u8FC7\u65F6\u8BF7\u62C6\u5206\uFF1A\u540C\u4E00\u8F6E actions \u91CC\u5148\u4E00\u4E2A write_file \u5199\u9996\u6BB5\uFF08import + \u9876\u5C42\u5E38\u91CF + \u7B2C\u4E00\u4E2A\u51FD\u6570/\u7C7B\uFF09\uFF0C\u7D27\u8DDF\u591A\u4E2A append_file \u9010\u6BB5\u8FFD\u52A0\u3002
+   - \u590D\u6742\u5DE5\u7A0B\u4F18\u5148\u62C6\u6210\u591A\u4E2A\u5185\u805A\u6A21\u5757/\u6587\u4EF6\uFF0C\u5E76\u7528\u72EC\u7ACB CODE/UNIT_TEST/INTEGRATION_TEST/MODULE_TEST/FUNCTIONAL_TEST Step \u589E\u91CF\u63A8\u8FDB\uFF0C\u4E0D\u8981\u5199\u4E00\u4E2A\u5DE8\u578B\u4E07\u80FD\u6587\u4EF6\u3002
+   - \u62C6\u5206\u5FC5\u987B\u4FDD\u8BC1\u62FC\u63A5\u540E TypeScript \u8BED\u6CD5\u5408\u6CD5\uFF1B\u4E25\u7981\u5728\u51FD\u6570\u4F53\u4E2D\u95F4\u62C6\u65AD\u3002
+   - \u5BF9\u5DF2\u5B58\u5728\u6587\u4EF6\u7684\u5C40\u90E8\u4FEE\u6539\u4F7F\u7528 replace_in_file / apply_patch\uFF0C\u4E0D\u8981\u91CD\u590D\u8986\u76D6\u6574\u4E2A\u6587\u4EF6\u3002
+7. package.json \u662F\u4F9D\u8D56\u6E05\u5355\u3002\u65B0\u589E npm \u5305\u8981\u7528 add_dependency\uFF0C\u7981\u6B62\u53BB\u5199 requirements.txt\u3002
+8. run_program \u4F1A\u901A\u8FC7 \`npx tsx\` \u8FD0\u884C\u5165\u53E3\uFF0Crun_tests \u4F1A\u901A\u8FC7 \`npm test\` \u8DD1 Vitest\uFF0C\u6700\u7EC8\u4EA4\u4ED8\u95E8\u7981\u8FD8\u4F1A\u9A8C\u8BC1 direct Node \u5165\u53E3\u547D\u4EE4\u3002`;
+function buildPlannerSystem2(profile) {
+  return (profile.id === "typescript" ? TYPESCRIPT_PLANNER_SYSTEM2 : PYTHON_PLANNER_SYSTEM2) + profile.plannerPromptOverride;
+}
+function buildExecutorSystem2(profile) {
+  return (profile.id === "typescript" ? TYPESCRIPT_EXECUTOR_SYSTEM2 : PYTHON_EXECUTOR_SYSTEM2) + profile.executorPromptOverride;
+}
+var messages2 = {
+  llm: {
+    coderDebuggerSameModel: (model, coderProvider, debuggerProvider) => `\u6A21\u578B\u914D\u7F6E\u5EFA\u8BAE\uFF1ACoder\uFF08${coderProvider}\uFF09\u548C Debugger\uFF08${debuggerProvider}\uFF09\u5F53\u524D\u90FD\u4F7F\u7528 ${model}\u3002\u5EFA\u8BAE\u914D\u7F6E\u4E0D\u540C\u6A21\u578B\uFF0C\u8BA9\u8C03\u8BD5\u9636\u6BB5\u83B7\u5F97\u72EC\u7ACB\u7684\u63A8\u7406\u8DEF\u5F84\u3002`,
+    invalidBaseUrl: (raw, fallback) => `[xcompiler] base_url \u65E0\u6548\uFF08${raw}\uFF09\uFF0C\u56DE\u9000\u5230 ${fallback}`,
+    providerValidationFailed: (role, model) => `[${role}] provider ${model} \u8F93\u51FA\u9A8C\u8BC1\u5931\u8D25\uFF0C\u5207\u6362\u5230\u4E0B\u4E00\u4E2A`,
+    providerCallFailed: (role, model) => `[${role}] provider ${model} \u8C03\u7528\u5931\u8D25\uFF0C\u5207\u6362\u5230\u4E0B\u4E00\u4E2A`,
+    scoreReadFailed: (p, message) => `\u8BFB\u53D6 ${p} \u5931\u8D25\uFF1A${message}`,
+    scoreChanged: (provider, score, previous) => `\u8BC4\u5206\uFF08${provider}\uFF09=${score}\uFF08\u539F\u503C ${previous}\uFF09`,
+    scorePersistFailed: (message) => `\u6301\u4E45\u5316\u8BC4\u5206\u5931\u8D25\uFF1A${message}`,
+    preflightOllamaReachable: (baseUrl, models) => `\u9884\u68C0\uFF1AOllama ${baseUrl} \u53EF\u8FBE\uFF0C\u53D1\u73B0 ${models} \u4E2A\u6A21\u578B`,
+    preflightOllamaUnreachable: (baseUrl, message) => `\u9884\u68C0\uFF1AOllama ${baseUrl} \u4E0D\u53EF\u8FBE\uFF1A${message}`,
+    preflightAutoAdded: (providers, roles) => `\u9884\u68C0\uFF1A\u81EA\u52A8\u589E\u52A0 ${providers} \u4E2A provider\uFF0C\u8986\u76D6\u89D2\u8272 [${roles}]`,
+    scoreFileHeader: "# XCompiler LLM provider \u8BC4\u5206\u5FEB\u7167\uFF08\u7531 ScoreStore \u81EA\u52A8\u7EF4\u62A4\uFF0C\u8BF7\u52FF\u624B\u5DE5\u7F16\u8F91\uFF09",
+    scoreFileSemantics: "# \u8BC4\u5206\u8BED\u4E49\uFF1A\u9ED8\u8BA4 1.0\uFF1B\u5931\u8D25 -0.5\uFF08\u4E0B\u9650 0=\u7981\u7528\uFF09\uFF1B\u6210\u529F +0.1\uFF08\u4E0A\u9650 10\uFF09\u3002"
+  },
+  system: {
+    configEnvMissing: (names) => `[xcompiler] \u914D\u7F6E\u4E2D\u7684\u73AF\u5883\u53D8\u91CF\u672A\u8BBE\u7F6E\uFF0C\u5DF2\u66FF\u6362\u4E3A\u7A7A\u5B57\u7B26\u4E32\uFF1A${names}`,
+    unhandledError: (message) => `\u672A\u5904\u7406\u9519\u8BEF\uFF1A${message}`,
+    unsupportedPypiOnlyNetwork: "\u62D2\u7EDD network=pypi-only\uFF1ADocker \u672C\u8EAB\u65E0\u6CD5\u53EF\u9760\u6267\u884C\u201C\u4EC5 PyPI\u201D\u57DF\u540D\u767D\u540D\u5355\u3002\u9700\u8981\u9694\u79BB\u8BF7\u4F7F\u7528 network=off\uFF1B\u660E\u786E\u5141\u8BB8\u4EFB\u610F\u51FA\u7AD9\u4E0B\u8F7D\u65F6\u4F7F\u7528 network=download-only\u3002",
+    dockerInsideContainerUnsupported: "\u68C0\u6D4B\u5230 XCompiler \u8FD0\u884C\u5728\u5BB9\u5668\u5185\uFF0Csandbox=docker \u53EF\u80FD\u5BFC\u81F4 bind-mount \u8DEF\u5F84\u53CA docker.sock \u6743\u9650\u9519\u4F4D\uFF0C\u56E0\u6B64\u4E0D\u53D7\u652F\u6301\u3002\u8BF7\u4F7F\u7528 agent.sandbox=subprocess\u3001\u6539\u5728\u5BBF\u4E3B\u673A\u8FD0\u884C\uFF0C\u6216\u4EC5\u5728\u53D7\u63A7\u73AF\u5883\u8BBE\u7F6E XC_IN_CONTAINER=0\u3002",
+    firejailUnsupported: "\u5C1A\u672A\u5B9E\u73B0 sandbox=firejail\uFF0C\u8BF7\u4F7F\u7528 subprocess \u6216 docker\u3002",
+    smokeHeader: (baseUrl) => `\u6B63\u5728\u5BF9 ${baseUrl} \u6267\u884C\u6D41\u5F0F\u5192\u70DF\u6D4B\u8BD5`,
+    smokeOk: (model, totalMs, firstTokenMs, chunks, preview) => `[\u6210\u529F \u603B\u8017\u65F6=${totalMs}ms \u9996Token=${firstTokenMs}ms \u5206\u5757=${chunks}] ${model} -> ${preview}`,
+    smokeFail: (model, message) => `[\u5931\u8D25] ${model} -> ${message}`
+  },
+  plugins: {
+    invalidId: (id) => `\u63D2\u4EF6 ID\u201C${id}\u201D\u65E0\u6548\uFF1B\u4EC5\u5141\u8BB8\u5C0F\u5199\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u70B9\u3001\u8FDE\u5B57\u7B26\u6216\u4E0B\u5212\u7EBF\u3002`,
+    duplicateId: (id) => `\u63D2\u4EF6 ID \u91CD\u590D\uFF1A${id}`,
+    invalidVersion: (plugin, version) => `\u63D2\u4EF6 ${plugin} \u7684\u7248\u672C\u4E0D\u662F\u6709\u6548 SemVer\uFF1A${version}`,
+    invalidCoreVersion: (version) => `XCompiler \u6838\u5FC3\u7248\u672C\u4E0D\u662F\u6709\u6548 SemVer\uFF1A${version}`,
+    apiVersionMismatch: (plugin, actual, expected) => `\u63D2\u4EF6 ${plugin} \u9762\u5411 Plugin API ${actual}\uFF0C\u5F53\u524D XCompiler \u8FD0\u884C\u65F6\u8981\u6C42 API ${expected}\u3002`,
+    invalidMinimumVersion: (plugin, version) => `\u63D2\u4EF6 ${plugin} \u58F0\u660E\u7684\u6700\u4F4E XCompiler \u7248\u672C\u65E0\u6548\uFF1A${version}`,
+    coreVersionTooOld: (plugin, minimum, actual) => `\u63D2\u4EF6 ${plugin} \u8981\u6C42 XCompiler >= ${minimum}\uFF0C\u5F53\u524D\u7248\u672C\u4E3A ${actual}\u3002`,
+    loaded: (plugin, version) => `\u63D2\u4EF6 ${plugin}@${version} \u5DF2\u52A0\u8F7D\u3002`,
+    extensionConflict: (plugin, kind, name) => `\u63D2\u4EF6 ${plugin} \u4E0D\u80FD\u8986\u76D6\u5DF2\u6709 ${kind} \u201C${name}\u201D\u3002`,
+    hookFailed: (plugin, stage, message) => `\u63D2\u4EF6 ${plugin} \u5728 ${stage} \u9636\u6BB5\u6267\u884C\u5931\u8D25\uFF1A${message}`,
+    manifestReadFailed: (path2, message) => `\u65E0\u6CD5\u8BFB\u53D6\u63D2\u4EF6\u6E05\u5355 ${path2}\uFF1A${message}`,
+    moduleLoadFailed: (plugin, path2, message) => `\u65E0\u6CD5\u4ECE ${path2} \u52A0\u8F7D\u63D2\u4EF6 ${plugin}\uFF1A${message}`,
+    exportInvalid: (plugin, exportName) => `\u63D2\u4EF6 ${plugin} \u7684\u5BFC\u51FA ${exportName} \u4E0D\u662F\u6709\u6548 XCompiler \u63D2\u4EF6`,
+    manifestMismatch: (plugin) => `\u63D2\u4EF6 ${plugin} \u7684\u8FD0\u884C\u65F6\u6E05\u5355\u4E0E\u9884\u68C0\u6E05\u5355\u4E0D\u4E00\u81F4`
+  },
+  audit: {
+    processLogTitle: "# XCompiler \u5F00\u53D1\u8FC7\u7A0B\u8BB0\u5F55",
+    processLogPreamble: "> \u7531 XCompiler \u81EA\u52A8\u751F\u6210\uFF0C\u8BB0\u5F55 CLI \u4F1A\u8BDD\u3001\u7528\u6237\u8F93\u5165\u3001LLM \u4EA4\u4E92\u4E0E\u6267\u884C\u52A8\u4F5C\uFF0C\u7528\u4E8E\u4EA4\u4ED8\u8FFD\u8E2A\u3002",
+    sessionStart: (ts, command) => `## \u25B6 \u4F1A\u8BDD ${ts} \u2014 \`${command}\``,
+    sessionEnd: (ts) => `### \u25C0 \u4F1A\u8BDD\u7ED3\u675F ${ts}`,
+    eventSessionStart: (command) => `\u542F\u52A8 ${command}`,
+    eventSessionEnd: (command) => `\u7ED3\u675F ${command}`,
+    userInput: (label) => `#### \u{1F464} \u7528\u6237\u8F93\u5165 \u2014 ${label}`,
+    llmRequest: (role, model) => `\u{1F916} LLM \u8BF7\u6C42 \u2014 <code>${role}</code> \u4F7F\u7528 <code>${model}</code>`,
+    llmResponse: (role, model) => `\u{1F4E9} LLM \u54CD\u5E94 \u2014 <code>${role}</code> \u4F7F\u7528 <code>${model}</code>`,
+    executorTurn: (stepId, round, role, provider, actions, done) => `\u{1F9E0} \u6267\u884C\u8F6E\u6B21 \u2014 <code>${stepId}</code> \u7B2C ${round} \u8F6E / \u89D2\u8272 <code>${role}</code>${provider ? ` \xB7 \u4F7F\u7528 <code>${provider}</code>` : ""}\uFF08actions=${actions}, done=${done}\uFF09`,
+    thoughtsLabel: "**\u601D\u8003\uFF1A**",
+    actionsLabel: "**\u52A8\u4F5C\uFF1A**",
+    noThoughts: "\uFF08\u65E0\u601D\u8003\u5185\u5BB9\uFF09",
+    plannerThought: (stage, provider) => `\u{1F9E9} Planner \u601D\u8003 \u2014 ${stage}${provider ? ` \xB7 \u4F7F\u7528 <code>${provider}</code>` : ""}`,
+    markdownAppendFailed: (message) => `[audit] Markdown \u8FFD\u52A0\u5931\u8D25\uFF1A${message}`,
+    jsonlAppendFailed: (message) => `[audit] JSONL \u8FFD\u52A0\u5931\u8D25\uFF1A${message}`,
+    traceLine: (kind, message) => `[audit] ${kind} ${message}`,
+    autoFixedSrcImport: (p) => `\u5DF2\u81EA\u52A8\u4FEE\u590D ${p} \u4E2D\u7684 src import`,
+    wroteFile: (p) => `\u5DF2\u5199\u5165 ${p}`,
+    userDecision: (label, value) => `${label} \u2192 ${value}`,
+    eventLlmRequest: (role, model) => `${role} \u2192 ${model}`,
+    eventLlmResponse: (role, model) => `${role} \u2190 ${model}`,
+    eventLlmError: (role, model, message) => `${role} \u4F7F\u7528 ${model}\uFF1A${message}`,
+    eventExecutorTurn: (stepId, round, role, provider) => `${stepId} \u8F6E\u6B21=${round} \u89D2\u8272=${role}${provider ? ` \u4F7F\u7528 ${provider}` : ""}`,
+    eventPlannerThought: (stage, provider) => `Planner ${stage}${provider ? ` \u4F7F\u7528 ${provider}` : ""}`,
+    llmChatFailedThought: (message) => `LLM \u8C03\u7528\u5931\u8D25\uFF1A${message}`,
+    llmChatAborted: (stepId, round, chars, message) => `${stepId} \u7B2C ${round} \u8F6E\u5728\u6536\u5230 ${chars} \u5B57\u7B26\u540E\u4E2D\u6B62\uFF1A${message}`,
+    toolDenied: (tool) => `\u62D2\u7EDD\u8C03\u7528\u5DE5\u5177 ${tool}`,
+    toolCalled: (tool) => `\u8C03\u7528\u5DE5\u5177 ${tool}`,
+    toolResult: (tool, ok, detail) => `\u5DE5\u5177 ${tool}${ok ? "\u6267\u884C\u6210\u529F" : "\u6267\u884C\u5931\u8D25"}\uFF1A${detail}`,
+    documentArchived: (from, to) => `\u5DF2\u5F52\u6863 ${from} \u2192 ${to}`,
+    documentArchiveFailed: (p, message) => `\u5F52\u6863 ${p} \u5931\u8D25\uFF1A${message}`,
+    httpFetchSaved: (method, url, p, bytes) => `http_fetch ${method} ${url} \u2192 ${p}\uFF08${bytes} \u5B57\u8282\uFF09`,
+    httpFetchResponse: (method, url, status, bytes) => `http_fetch ${method} ${url} \u2192 ${status}\uFF08${bytes} \u5B57\u8282\uFF09`,
+    partialFailureHeader: (message) => `# LLM \u8C03\u7528\u5931\u8D25\uFF1A${message}`,
+    streamLength: (chars) => `# \u6D41\u5F0F\u54CD\u5E94\u957F\u5EA6\uFF1A${chars} \u5B57\u7B26`
+  },
+  stream: {
+    resolvingModel: "\u6B63\u5728\u89E3\u6790\u6A21\u578B",
+    waiting: "\u7B49\u5F85\u54CD\u5E94",
+    streaming: "\u6D41\u5F0F\u54CD\u5E94",
+    done: "\u5B8C\u6210",
+    failed: "\u5931\u8D25",
+    chars: (n) => `${n} \u5B57\u7B26`,
+    toolRunner: "\u672C\u5730\u5DE5\u5177",
+    toolExecution: (stepId, tool) => `${stepId} \u5DE5\u5177 ${tool}`
+  },
+  sandboxLog: {
+    subprocessBuilt: (deps) => `\u5B50\u8FDB\u7A0B\u6C99\u7BB1\u5DF2\u6784\u5EFA\uFF08${deps ? "\u542B\u4F9D\u8D56" : "\u7A7A\u73AF\u5883"}\uFF09`,
+    subprocessNodeBuilt: "Node \u5B50\u8FDB\u7A0B\u6C99\u7BB1\u5DF2\u6784\u5EFA\uFF08npm install\uFF09",
+    dockerBuilt: (deps) => `Docker \u6C99\u7BB1\u5DF2\u6784\u5EFA\uFF08${deps ? "\u542B\u4F9D\u8D56" : "\u7A7A\u73AF\u5883"}\uFF09`,
+    dockerNodeBuilt: "Docker Node \u6C99\u7BB1\u5DF2\u6784\u5EFA\uFF08npm install\uFF09",
+    command: (runtime, command) => `${runtime} ${command}`
+  },
+  cli: {
+    rootDescription: "XCompiler \u2014 AI Software Factory CLI",
+    compileDescription: "\u4EA4\u4E92\u5F0F\u7F16\u8BD1\u9700\u6C42\u4E3A plan.json\uFF08\u542B\u5F3A\u5236\u4EBA\u5DE5\u786E\u8BA4\uFF09",
+    runDescription: "\u6267\u884C\u5DF2\u786E\u8BA4\u7684 plan.json\uFF08\u652F\u6301\u5206\u9636\u6BB5\u8FD0\u884C\uFF1A--phase / --from\uFF09",
+    loadDescription: "\u52A0\u8F7D XXX.xc \u5DE5\u7A0B\u6587\u4EF6\u5E76\u7EE7\u7EED\u5F53\u524D plan",
+    appendDescription: "\u5728\u5DF2\u6709 XXX.xc \u5DE5\u7A0B\u57FA\u7840\u4E0A\u8FFD\u52A0\u65B0\u9700\u6C42\uFF0C\u5E76\u91CD\u65B0\u8D70\u6F84\u6E05\u4E0E V \u6A21\u578B\u6267\u884C",
+    lsDescription: "\u626B\u63CF workspace \u5217\u51FA\u6240\u6709 plan.json \u72B6\u6001\u6458\u8981",
+    showDescription: "\u6253\u5370 Step \u5B9A\u4E49 / \u72B6\u6001 / \u4EA7\u7269 / \u6700\u8FD1\u5BA1\u8BA1",
+    optWorkspace: "workspace \u76EE\u5F55\uFF08\u540C --output\uFF0C\u9ED8\u8BA4\u4E3A\u5F53\u524D\u76EE\u5F55\uFF09",
+    optOutput: "\u5DE5\u7A0B/workspace \u8F93\u51FA\u76EE\u5F55\uFF08\u4F18\u5148\u7EA7\u6700\u9AD8\uFF0C\u7B49\u4EF7\u4E8E -w\uFF09",
+    optConfig: "config.yaml \u8DEF\u5F84",
+    optInput: "\u4ECE\u9700\u6C42\u6587\u4EF6\u8BFB\u53D6\uFF08\u975E\u4EA4\u4E92\uFF09",
+    optTopic: "\u76F4\u63A5\u4F7F\u7528\u5DF2\u6F84\u6E05\u7684 topic.md \u4F5C\u4E3A\u8F93\u5165\uFF1A\u8DF3\u8FC7 intake / clarify / Addenda / Gate 1\uFF0C\u76F4\u63A5\u8FDB\u5165 decompose",
+    optPlanOut: "\u6307\u5B9A plan.json \u8F93\u51FA\u6587\u4EF6\uFF08\u9ED8\u8BA4 <workspace>/plan.json\uFF09",
+    optBaseDir: "\u9879\u76EE\u8F93\u51FA\u6839\u76EE\u5F55\uFF08\u5728\u5176\u4E0B\u521B\u5EFA <name> \u5B50\u76EE\u5F55\uFF09",
+    optName: "\u9879\u76EE\u540D\uFF08\u9ED8\u8BA4 xcompiler-<\u65F6\u95F4\u6233>\uFF09",
+    optYes: "\u8DF3\u8FC7\u4EBA\u5DE5\u786E\u8BA4\uFF08\u4EC5\u5728 -i / -t \u63D0\u4F9B\u65F6\u6709\u610F\u4E49\uFF09",
+    optForce: "\u5F3A\u5236\u91CD\u65B0\u751F\u6210\uFF1A\u8986\u5199 workspace \u9501\u3001\u5FFD\u7565\u65E7 plan.json",
+    optDryRun: "\u4EC5\u6253\u5370\u62D3\u6251\u987A\u5E8F\uFF0C\u4E0D\u6267\u884C",
+    optFrom: "\u4ECE\u6307\u5B9A Step \u5F00\u59CB\uFF08\u4E4B\u524D\u7684\u8DF3\u8FC7\uFF09",
+    optPhase: "\u4EC5\u6267\u884C\u6307\u5B9A phase\uFF08REQUIREMENT_ANALYSIS/HIGH_LEVEL_DESIGN/DETAILED_DESIGN/CODE/UNIT_TEST/INTEGRATION_TEST/MODULE_TEST/FUNCTIONAL_TEST/DEBUG\uFF09",
+    optReset: "\u91CD\u7F6E\u6240\u6709 Step \u72B6\u6001\u4E3A PENDING",
+    optMaxDepth: "\u9012\u5F52\u6700\u5927\u6DF1\u5EA6",
+    optTail: "\u6700\u8FD1\u5BA1\u8BA1\u6761\u6570",
+    optPlan: "plan.json \u8DEF\u5F84\uFF0C\u9ED8\u8BA4 <workspace>/plan.json",
+    optLang: "UI / \u63D0\u793A\u8BCD\u8BED\u8A00\uFF1AEN | CN\uFF08ISO 3166-1 Alpha-2\uFF09",
+    optIntent: "\u8BA1\u5212\u610F\u56FE\uFF1Agreenfield | feature | refactor | self",
+    optBaselinePlan: "\u5DF2\u6709\u57FA\u7EBF plan.json \u8DEF\u5F84\uFF08\u9ED8\u8BA4 <workspace>/plan.json\uFF09",
+    optProjectFile: "XXX.xc \u5DE5\u7A0B\u6587\u4EF6\u8DEF\u5F84\uFF08\u9ED8\u8BA4 <workspace>/<name>.xc\uFF09",
+    argPlan: "plan.json \u8DEF\u5F84\uFF08\u9ED8\u8BA4 = <workspace>/plan.json\uFF09",
+    argProjectFile: "XXX.xc \u5DE5\u7A0B\u6587\u4EF6",
+    argStepId: "Step ID\uFF0C\u5982 S001",
+    evolveDescription: "\u5728\u73B0\u6709 workspace \u57FA\u7840\u4E0A\u751F\u6210\u5E76\u6267\u884C\u589E\u91CF feature/refactor \u8BA1\u5212",
+    bootstrapDescription: "\u5728\u9694\u79BB Git worktree \u4E2D\u6784\u5EFA\u5E76\u9A8C\u8BC1\u4E0B\u4E00\u4EE3 XCompiler",
+    optRepository: "\u8981\u6267\u884C\u81EA\u4E3E\u7684 XCompiler Git \u4ED3\u5E93\uFF08\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55\uFF09",
+    optPromote: "\u5168\u90E8\u8D28\u91CF\u95E8\u901A\u8FC7\u540E\uFF0C\u5FEB\u8FDB\u5408\u5E76\u5230\u5F53\u524D\u5206\u652F",
+    optCleanup: "\u5199\u5165\u62A5\u544A\u540E\u5220\u9664\u9694\u79BB worktree\uFF08\u4FDD\u7559\u5019\u9009\u5206\u652F\uFF09",
+    optDockerQualification: "\u4F7F\u7528\u5C1A\u5904\u4E8E\u5B9E\u9A8C\u9636\u6BB5\u7684 Docker \u73AF\u5883\u6267\u884C\u5019\u9009\u8D28\u91CF\u95E8",
+    invalidLocale: (value) => `\u4E0D\u652F\u6301\u7684\u8BED\u8A00\u201C${value}\u201D\uFF0C\u8BF7\u4F7F\u7528 EN \u6216 CN\u3002`,
+    invalidIntent: (value, allowed) => `\u65E0\u6548 intent\u201C${value}\u201D\uFF0C\u53EF\u9009\u503C\uFF1A${allowed}\u3002`,
+    invalidPhase: (value, allowed) => `\u65E0\u6548\u9636\u6BB5\u201C${value}\u201D\uFF0C\u53EF\u9009\u503C\uFF1A${allowed}\u3002`,
+    invalidStepId: (value) => `\u65E0\u6548 Step ID\u201C${value}\u201D\uFF0C\u683C\u5F0F\u5E94\u4E3A S \u52A0\u81F3\u5C11\u4E09\u4F4D\u6570\u5B57\u3002`,
+    invalidNonNegativeInteger: (value) => `\u53C2\u6570\u5FC5\u987B\u662F\u975E\u8D1F\u6574\u6570\uFF0C\u5F53\u524D\u503C\u4E3A\u201C${value}\u201D\u3002`,
+    helpUsage: "\u7528\u6CD5\uFF1A",
+    helpArguments: "\u53C2\u6570\uFF1A",
+    helpOptions: "\u9009\u9879\uFF1A",
+    helpCommands: "\u547D\u4EE4\uFF1A",
+    helpOption: "\u663E\u793A\u547D\u4EE4\u5E2E\u52A9",
+    versionOption: "\u8F93\u51FA\u7248\u672C\u53F7",
+    defaultValue: (value) => `\uFF08\u9ED8\u8BA4\u503C\uFF1A${value}\uFF09`
+  },
+  bootstrap: {
+    notGitRepository: (p) => `\u4E0D\u662F Git \u4ED3\u5E93\uFF1A${p}`,
+    dirtyRepository: (files) => `\u529F\u80FD\u81EA\u4E3E\u8981\u6C42\u5BBF\u4E3B\u4ED3\u5E93\u4FDD\u6301\u5E72\u51C0\uFF0C\u5F85\u5904\u7406\u8DEF\u5F84\uFF1A${files}`,
+    worktreeReady: (p, branch) => `\u81EA\u4E3E worktree \u5DF2\u5C31\u7EEA\uFF1A${p}\uFF08${branch}\uFF09`,
+    compileStarted: "\u6B63\u5728\u7F16\u8BD1\u81EA\u4E3E V \u6A21\u578B\u8BA1\u5212\u2026",
+    compileFailed: (code, message) => `\u81EA\u4E3E\u8BA1\u5212\u7F16\u8BD1\u5931\u8D25\uFF08exit=${code}\uFF09\uFF1A${message}`,
+    compileCancelled: "\u81EA\u4E3E\u8BA1\u5212\u5C1A\u672A\u786E\u8BA4\uFF0C\u5DF2\u53D6\u6D88\u6267\u884C\u3002",
+    executeStarted: "\u6B63\u5728\u9694\u79BB worktree \u4E2D\u6267\u884C\u5019\u9009\u7248\u672C\u2026",
+    executeFailed: (status) => `\u5019\u9009\u7248\u672C\u6267\u884C\u672A\u6210\u529F\u5B8C\u6210\uFF08${status}\uFF09\u3002`,
+    qualificationStarted: "\u6B63\u5728\u6267\u884C\u786E\u5B9A\u6027\u81EA\u4E3E\u8D28\u91CF\u95E8\u2026",
+    qualificationDockerExperimental: "Docker \u8D28\u91CF\u95E8\u73AF\u5883\u5C1A\u672A\u5B8C\u6210\u9A8C\u8BC1\uFF0C\u672C\u6B21\u6309\u663E\u5F0F\u9009\u9879\u4EE5\u5B9E\u9A8C\u6A21\u5F0F\u6267\u884C\u3002",
+    missingScript: (name) => `package.json \u7F3A\u5C11\u5FC5\u9009\u811A\u672C\uFF1A${name}`,
+    missingBin: "package.json \u672A\u58F0\u660E CLI bin \u5165\u53E3",
+    checkPassed: (name, ms) => `${name} \u901A\u8FC7\uFF08${ms}ms\uFF09`,
+    checkFailed: (name, code) => `${name} \u5931\u8D25\uFF08exit=${code}\uFF09`,
+    reportWritten: (p) => `\u81EA\u4E3E\u62A5\u544A\u5DF2\u5199\u5165\uFF1A${p}`,
+    candidateReady: (branch) => `\u5019\u9009\u7248\u672C\u5DF2\u5728 ${branch} \u901A\u8FC7\u9A8C\u8BC1\uFF1B\u4ECD\u9700\u663E\u5F0F\u4F7F\u7528 --promote \u624D\u4F1A\u664B\u7EA7\u3002`,
+    promoted: (branch) => `\u5019\u9009\u7248\u672C\u5DF2\u901A\u8FC7\u5FEB\u8FDB\u5408\u5E76\u5B8C\u6210\u664B\u7EA7\uFF1A${branch}`,
+    cleanupDone: (p) => `\u81EA\u4E3E worktree \u5DF2\u5220\u9664\uFF1A${p}`,
+    promotionBlocked: "\u5B58\u5728\u672A\u901A\u8FC7\u7684\u8D28\u91CF\u95E8\uFF0C\u7981\u6B62\u664B\u7EA7\u5019\u9009\u7248\u672C\u3002",
+    hostHeadChanged: "\u81EA\u4E3E\u671F\u95F4\u5BBF\u4E3B HEAD \u5DF2\u53D8\u5316",
+    candidateDirty: (files) => `\u5019\u9009 worktree \u5B58\u5728\u672A\u63D0\u4EA4\u53D8\u66F4\uFF1A${files}`,
+    candidateStatusUnknown: "\uFF08\u672A\u77E5\u8DEF\u5F84\uFF09",
+    candidateMoved: (expected, actual) => `\u8D28\u91CF\u95E8\u4E4B\u540E\u5019\u9009\u63D0\u4EA4\u53D1\u751F\u6F02\u79FB\uFF08\u9884\u671F ${expected}\uFF0C\u5B9E\u9645 ${actual}\uFF09\u3002`,
+    candidateNotBasedOnBase: (candidate, base) => `\u5019\u9009\u63D0\u4EA4 ${candidate} \u4E0D\u662F\u81EA\u4E3E\u57FA\u7EBF ${base} \u7684\u540E\u4EE3\u3002`,
+    promotionVerificationFailed: (expected, actual) => `\u664B\u7EA7\u540E HEAD \u6821\u9A8C\u5931\u8D25\uFF08\u9884\u671F ${expected}\uFF0C\u5B9E\u9645 ${actual}\uFF09\u3002`,
+    reportTitle: "XCompiler \u529F\u80FD\u81EA\u4E3E\u62A5\u544A",
+    reportNone: "\uFF08\u65E0\uFF09",
+    reportNextQualified: (repository, candidateCommit) => `git -C "${repository}" merge --ff-only "${candidateCommit}"`,
+    reportNextPromoted: "\u4F7F\u7528\u5DF2\u664B\u7EA7\u7248\u672C\u6267\u884C\u4E0B\u4E00\u8F6E\u529F\u80FD\u81EA\u4E3E\u3002",
+    reportNextFailed: "\u68C0\u67E5\u5019\u9009 worktree\uFF0C\u4FEE\u590D\u5931\u8D25\u8D28\u91CF\u95E8\u540E\u518D\u664B\u7EA7\u3002",
+    reportLabels: {
+      status: "\u72B6\u6001",
+      repository: "\u4ED3\u5E93",
+      baseCommit: "\u57FA\u7EBF\u63D0\u4EA4",
+      candidateCommit: "\u5019\u9009\u63D0\u4EA4",
+      branch: "\u5019\u9009\u5206\u652F",
+      worktree: "\u9694\u79BB\u5DE5\u4F5C\u533A",
+      createdAt: "\u521B\u5EFA\u65F6\u95F4",
+      checks: "\u8D28\u91CF\u95E8",
+      changedFiles: "\u53D8\u66F4\u6587\u4EF6",
+      nextStep: "\u4E0B\u4E00\u6B65"
+    }
+  },
+  compile: {
+    workspaceReady: (p) => `\u5DE5\u4F5C\u533A\uFF1A${p}`,
+    forceOverride: "--force\uFF1A\u8986\u76D6\u5DE5\u4F5C\u533A\u9501\u5E76\u91CD\u65B0\u751F\u6210\u8BA1\u5212\u3002",
+    topicInputConflict: "\u540C\u65F6\u63D0\u4F9B\u4E86 --topic \u548C --input\uFF1B\u4F18\u5148\u4F7F\u7528 --topic\uFF0C\u5FFD\u7565 --input\u3002",
+    auditTopicInput: "topic.md\uFF08--topic\uFF09",
+    auditOriginalRequirement: "\u539F\u59CB\u9700\u6C42\uFF08Intake\uFF09",
+    auditUserAddenda: "\u7528\u6237\u8865\u5145\u9700\u6C42",
+    auditEditedTopic: "\u5DF2\u7F16\u8F91 topic.md",
+    auditTopicPersisted: (p) => `topic.md \u5DF2\u5199\u5165\uFF1A${p}`,
+    auditDecomposeFailed: "planner.decompose \u5931\u8D25",
+    lintIssue: (id, message) => ` - [${id}] ${message}`,
+    planPreviewTruncated: "\u2026\uFF08\u5DF2\u622A\u65AD\uFF0C\u5B8C\u6574\u5185\u5BB9\u89C1 docs/plan.md\uFF09",
+    auditPlanPersisted: (p) => `plan.json \u5DF2\u5199\u5165\uFF1A${p}`,
+    projectFileWritten: (p) => `\u5DE5\u7A0B\u6587\u4EF6\u5DF2\u66F4\u65B0\uFF1A${p}`,
+    nextCommand: (command) => `  \u4E0B\u4E00\u6B65\uFF1A${command}`,
+    topicEmptyExit: "--topic \u6587\u4EF6\u4E3A\u7A7A\uFF0C\u5DF2\u9000\u51FA\u3002",
+    topicLoaded: (p) => `\u5DF2\u52A0\u8F7D topic\uFF1A${p}\uFF08\u8DF3\u8FC7 intake / clarify / Gate 1\uFF09`,
+    requirementEmptyExit: "\u9700\u6C42\u4E3A\u7A7A\uFF0C\u5DF2\u9000\u51FA\u3002",
+    requirementInputHint: "\u8BF7\u63CF\u8FF0\u4F60\u7684\u9700\u6C42\uFF08\u591A\u884C\uFF0C\u8F93\u5165\u7A7A\u884C\u7ED3\u675F\uFF09:",
+    spinClarify: "Planner \u6B63\u5728\u6F84\u6E05\u9700\u6C42\u2026",
+    clarifySucceed: (n) => `\u6F84\u6E05\u95EE\u9898\uFF1A${n} \u6761`,
+    clarifyFail: "\u6F84\u6E05\u5931\u8D25",
+    clarifyChoiceHint: (range) => `\u8F93\u5165 ${range} \u9009\u62E9\u5DF2\u5C55\u793A\u9009\u9879\uFF0C\u6216\u76F4\u63A5\u8F93\u5165\u81EA\u5B9A\u4E49\u56DE\u7B54\u5185\u5BB9\u3002`,
+    addendaConfirm: "\u662F\u5426\u6709\u8865\u5145\u9700\u6C42\u8981\u8FFD\u52A0\uFF1F\uFF08\u4F1A\u8FDE\u540C\u6F84\u6E05\u4E00\u8D77\u53D1\u7ED9 Planner\uFF0C\u5E76\u4FDD\u7559\u5728 plan.userAddenda \u5B57\u6BB5\uFF09",
+    addendaEditorMsg: "\u8F93\u5165\u81EA\u5B9A\u4E49\u8865\u5145\u9700\u6C42\uFF08\u591A\u884C\u3001Markdown \u53EF\uFF09",
+    auditClarifyAnswer: (qid, q) => `\u6F84\u6E05\u56DE\u7B54 ${qid}: ${q}`,
+    spinDecompose: "Planner \u6B63\u5728\u6309 V \u6A21\u578B\u62C6\u89E3\u2026",
+    decomposeFail: "Planner \u62C6\u89E3\u5931\u8D25",
+    plannerInvalidPlan: "Planner \u65E0\u6CD5\u751F\u6210\u6709\u6548 plan\uFF1A",
+    plannerInvalidPlanHint1: "  \u5E38\u89C1\u539F\u56E0\uFF1A\u6240\u6709 LLM provider \u90FD\u8FD4\u56DE\u4E86\u975E\u6CD5/\u622A\u65AD JSON\uFF08\u5982 token loop\uFF09\u3002",
+    plannerInvalidPlanHint2: "  \u6392\u67E5\uFF1A\u68C0\u67E5 .xcompiler/audit.jsonl \u4E2D\u7684 llm.error / planner.thought \u539F\u6587\u3002",
+    decomposeSucceed: (n) => `\u5DF2\u751F\u6210 ${n} \u4E2A Step`,
+    schemaFail: "Plan schema \u6821\u9A8C\u5931\u8D25\uFF1A",
+    schemaInvalidSavedAt: (p) => `  \u5B8C\u6574 plan \u5DF2\u843D\u76D8\uFF1A${p}`,
+    lintFail: (n) => `Plan lint \u5931\u8D25\uFF08${n}\uFF09\uFF1A`,
+    topicPreviewHeader: "\u2500\u2500\u2500 topic.md (preview) \u2500\u2500\u2500",
+    topicPreviewFooter: "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+    gate1Confirm: "\u9700\u6C42\u662F\u5426\u7B26\u5408\u9884\u671F?",
+    gate1ChoiceConfirm: "\u2705 confirm \u2014 \u8FDB\u5165\u8BA1\u5212\u751F\u6210",
+    gate1ChoiceEdit: "\u270F\uFE0F  edit    \u2014 \u6253\u5F00\u7F16\u8F91\u5668\u4FEE\u6539",
+    gate1ChoiceCancel: "\u274C cancel  \u2014 \u653E\u5F03\u672C\u6B21\u4F1A\u8BDD",
+    gate1AuditLabel: "\u9700\u6C42\u786E\u8BA4\u95E8 (Gate 1)",
+    gate1Cancelled: "\u5DF2\u53D6\u6D88\uFF0C\u672A\u5199\u5165\u4EFB\u4F55\u6587\u4EF6\u3002",
+    editTopicMsg: "\u7F16\u8F91 topic.md",
+    topicWritten: (p) => `\u5DF2\u5199\u5165 ${p}`,
+    planWritten: (p) => `plan \u5DF2\u5199\u5165 ${p}`,
+    planPreviewHeader: "\u2500\u2500\u2500 plan.md (preview) \u2500\u2500\u2500",
+    planPreviewFooter: "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+    gate2Confirm: "\u662F\u5426\u786E\u8BA4\u8BE5\u8BA1\u5212? (\u6B64\u4E3A\u6700\u7EC8\u786E\u8BA4\uFF0C\u786E\u8BA4\u540E\u5C06\u5199\u5165 plan.json)",
+    gate2AuditLabel: "\u8BA1\u5212\u786E\u8BA4\u95E8 (Gate 2)",
+    gate2Rejected: "\u672A\u786E\u8BA4\uFF0C\u5DF2\u653E\u5F03\u3002plan.json \u672A\u5199\u5165\u3002",
+    baselineLoaded: (kind, sources) => `\u5DF2\u52A0\u8F7D ${kind} \u57FA\u7EBF\uFF1A${sources}`,
+    baselineMissing: (workspace) => `\u589E\u91CF\u6A21\u5F0F\u9700\u8981\u5728 ${workspace} \u4E2D\u627E\u5230\u5DF2\u6709\u5DE5\u7A0B\u57FA\u7EBF\uFF08topic / docs / plan / src\uFF09\u3002`,
+    baselineLanguageOverride: (baseline, source, configured) => `\u589E\u91CF\u6A21\u5F0F\u5C06\u6CBF\u7528\u57FA\u7EBF\u8BED\u8A00 ${baseline}\uFF08\u6765\u6E90\uFF1A${source}\uFF09\uFF0C\u800C\u4E0D\u662F\u914D\u7F6E\u4E2D\u7684 ${configured}\u3002`,
+    topicTitle: "# Project Topic (\u9879\u76EE\u9009\u9898)",
+    topicPreamble: "> \u672C\u6587\u4EF6\u662F\u9700\u6C42\u6F84\u6E05\u540E\u51BB\u7ED3\u7684\u9879\u76EE\u9009\u9898\uFF0C\u540E\u7EED V \u6A21\u578B\u62C6\u89E3\u4E0E\u6240\u6709\u9636\u6BB5\u4EA7\u51FA\u7686\u4EE5\u672C\u6587\u4EF6\u4E3A\u552F\u4E00\u9700\u6C42\u8F93\u5165\u3002",
+    topicSecRequirement: "## \u539F\u59CB\u9700\u6C42",
+    topicSecClarify: "## \u6F84\u6E05\u8BB0\u5F55",
+    topicSecAddenda: "## \u7528\u6237\u8865\u5145\u9700\u6C42 (Addenda)",
+    topicSecBaseline: "## \u73B0\u6709\u5DE5\u7A0B\u57FA\u7EBF"
+  },
+  inspect: {
+    noPlanFound: "\u672A\u627E\u5230\u4EFB\u4F55 plan.json",
+    digestLabel: "digest:",
+    stepNotFound: (id) => `Step ${id} \u672A\u627E\u5230`,
+    secDescription: "\u2014 description \u2014",
+    secAcceptance: "\u2014 acceptance \u2014",
+    secSubtasks: "\u2014 subtasks \u2014",
+    secSystemPrompt: "\u2014 systemPrompt \u2014",
+    secOutputs: "\u2014 outputs \u2014",
+    secRecentAudit: (n) => `\u2014 recent audit (${n}) \u2014`,
+    planHeader: (p, language) => `${p} \u8BED\u8A00=${language}`,
+    planStatusSummary: (total, done, pending, failed, skipped, running) => `\u6B65\u9AA4=${total} \u5B8C\u6210=${done} \u5F85\u6267\u884C=${pending} \u5931\u8D25=${failed} \u8DF3\u8FC7=${skipped} \u8FD0\u884C\u4E2D=${running}`,
+    planReadFailed: (p, message) => `${p} \u2014 ${message}`,
+    stepHeader: (id, phase, title, status, retries, maxRetries) => `${id} ${phase} ${title} ${status} \u91CD\u8BD5=${retries}/${maxRetries}`,
+    stepRoleTools: (role, tools) => `\u89D2\u8272=${role} \u5DE5\u5177=[${tools}]`,
+    stepDependsOn: (ids) => `\u4F9D\u8D56\uFF1A${ids}`,
+    outputStatus: (exists, p) => `${exists ? "\u2713" : "\u2717"} ${p}`,
+    auditEntry: (ts, kind, message) => `${ts} ${kind} ${message}`
+  },
+  execute: {
+    forceReset: "--force\uFF1A\u91CD\u7F6E\u6240\u6709 Step \u4E3A PENDING\uFF0C\u5E76\u8986\u76D6\u5DE5\u4F5C\u533A\u9501\u3002",
+    manifestRecalibrated: (p) => `\u5DF2\u91CD\u65B0\u6821\u51C6 ${p}\uFF08\u79FB\u9664\u7248\u672C\u9501\u548C\u5E7B\u89C9\u5305\u540D\uFF09`,
+    manifestSeeded: (p) => `\u5DF2\u6839\u636E plan.dependencies \u751F\u6210 ${p}`,
+    auditPlanLoaded: (p) => `\u5DF2\u52A0\u8F7D plan\uFF1A${p}`,
+    planLoaded: (p) => `\u5DF2\u52A0\u8F7D Plan\uFF1A${p}`,
+    planSummary: (language, steps) => `  \u8BED\u8A00=${language}\uFF0C\u6B65\u9AA4=${steps}`,
+    preflightModelMissing: (names) => `LLM preflight: \u6A21\u578B\u7F3A\u5931\uFF0C\u5DF2\u7981\u7528 [${names}]`,
+    preflightAutoAdded: (n) => `LLM preflight: \u81EA\u52A8\u6CE8\u5165 ${n} \u4E2A provider\uFF08\u6765\u81EA ollama /api/tags\uFF09`,
+    runInterrupted: (id, e, total) => `\u6267\u884C\u4E2D\u65AD\u4E8E ${id}\uFF08\u5DF2\u6267\u884C ${e}/${total}\uFF09`,
+    runReasonLabel: "  \u539F\u56E0: ",
+    runFailureLogHeader: "  --- \u8BE6\u7EC6\u5931\u8D25\u65E5\u5FD7\uFF08tail 40 \u884C\uFF09 ---",
+    runAllDone: (e, total) => `Plan \u5168\u90E8\u5B8C\u6210\uFF08${e}/${total}\uFF09`,
+    projectAuditSummary: (errors, warnings) => `\u9879\u76EE\u5BA1\u8BA1\uFF1A${errors} \u4E2A\u9519\u8BEF\uFF0C${warnings} \u4E2A\u8B66\u544A`,
+    projectMemoryRefreshFailed: (message) => `\u9879\u76EE\u8BB0\u5FC6\u5237\u65B0\u5931\u8D25\uFF1A${message}`,
+    projectAuditCheck: (name, summary) => `[\u5BA1\u8BA1:${name}] ${summary}`,
+    auditDocPresent: (p) => `${p} \u5B58\u5728`,
+    auditDocMissing: (p) => `\u7F3A\u5C11 ${p}`,
+    auditDeliveryDocPresent: "\u4EA4\u4ED8\u6587\u6863\u5B58\u5728",
+    auditDeliveryDocMissing: "\u7F3A\u5C11 docs/08-functional-test.md",
+    auditTestFilesFound: (count) => `\u53D1\u73B0 ${count} \u4E2A\u6709\u6548\u6D4B\u8BD5\u6587\u4EF6`,
+    auditTestFilesMissing: "tests/ \u4E0B\u6CA1\u6709\u6709\u6548\u6D4B\u8BD5\u6587\u4EF6",
+    auditEntrypointOk: (command) => `\u5165\u53E3\u9A8C\u8BC1\u901A\u8FC7\uFF1A${command}`,
+    auditEntrypointFailed: (command) => `\u5165\u53E3\u9A8C\u8BC1\u5931\u8D25\uFF1A${command}`,
+    auditPackageJsonMissing: "\u7F3A\u5C11 package.json",
+    auditScriptMissing: (name) => `package.json \u7F3A\u5C11 ${name} \u811A\u672C`,
+    auditCommandOk: (name) => `${name} \u901A\u8FC7`,
+    auditCommandFailed: (name, exitCode, timedOut) => `${name} \u5931\u8D25\uFF08exit=${exitCode}${timedOut ? "\uFF0C\u8D85\u65F6" : ""}\uFF09`
+  },
+  engine: {
+    spinSandboxBuild: (profile) => profile.id === "typescript" ? `\u6784\u5EFA\u6C99\u76D2\uFF08npm install\uFF0C${profile.manifestFile}\uFF09\u2026` : `\u6784\u5EFA\u6C99\u76D2\uFF08pip install -r ${profile.manifestFile}\uFF09\u2026`,
+    sandboxReady: (r) => `\u6C99\u76D2\u5C31\u7EEA\uFF1A${r}`,
+    stepSkipDone: (id, phase) => `  \u21AA ${id} ${phase} \u5DF2\u5B8C\u6210\uFF0C\u8DF3\u8FC7`,
+    spinSandboxRebuild: (id, profile) => profile.id === "typescript" ? `Step ${id} \u5199\u5165 ${profile.manifestFile}\uFF0C\u91CD\u5EFA npm \u6C99\u76D2\u2026` : `Step ${id} \u5199\u5165 ${profile.manifestFile}\uFF0C\u91CD\u5EFA pip \u6C99\u76D2\u2026`,
+    sandboxStatus: (r) => `\u6C99\u76D2\uFF1A${r}`,
+    autoFixedSrcImports: (n, files) => `  \u26A0 auto-fixed sys.path bootstrap in ${n} \u4E2A\u5165\u53E3\u6587\u4EF6\uFF1A${files}`,
+    debugResumeNotice: (id, n) => `  \u21BB ${id} \u68C0\u6D4B\u5230\u4E0A\u6B21\u4F1A\u8BDD\u4EE5 FAILED \u7ED3\u675F\uFF08\u5DF2\u7D2F\u79EF ${n} \u6B21\u5C1D\u8BD5\uFF09\uFF0C\u672C\u6B21\u9996\u8F6E\u76F4\u63A5\u8FDB\u5165 Debugger \u6A21\u5F0F\u3002`,
+    spinDebugRetry: (id, attempt, budget, cap, reason) => `\u{1F6E0}  ${id} DEBUG retry ${attempt}/${budget} (cap=${cap}) \u2014 ${reason}`,
+    retryException: (a, b, msg) => `retry ${a}/${b} \u629B\u51FA\u5F02\u5E38\uFF1A${msg}`,
+    fixSucceeded: (id, a) => `${id} \u4FEE\u590D\u6210\u529F (retry=${a})`,
+    retryHealthyButFailed: (a, before, b, tag, reason) => `retry ${a}/${before}\u2192${b} \u4ECD\u5931\u8D25\u4F46\u5065\u5EB7\uFF08\u6269\u7A97\uFF09 \xB7 ${tag} \xB7 ${reason}`,
+    retryLowQuality: (a, before, b, tag, reason) => `retry ${a}/${before}\u2192${b} \u4F4E\u8D28\u91CF\u8F93\u51FA\uFF08\u7F29\u7A97\uFF09 \xB7 ${tag} \xB7 ${reason}`,
+    retryStillFailed: (a, b, tag, reason) => `retry ${a}/${b} \u4ECD\u5931\u8D25 \xB7 ${tag} \xB7 ${reason}`,
+    earlyAbortLowQuality: (id, n) => `  \u26A1 ${id} \u68C0\u6D4B\u5230\u8FDE\u7EED ${n} \u6B21\u4F4E\u8D28\u91CF LLM \u8F93\u51FA\uFF08\u89E3\u6790\u5931\u8D25/\u91CD\u590D actions/\u65E0\u8FDB\u5C55\uFF09\uFF0C\u5FEB\u901F\u7EC8\u6B62 DEBUG \u91CD\u8BD5`,
+    stepFinalFailed: (id, phase, role) => `\u2716 Step ${id} (${phase} / ${role}) \u6700\u7EC8\u5931\u8D25`,
+    finalAttemptsLine: (a, b, c, ea) => `  attempts=${a}  final_budget=${b}  cap=${c}` + (ea ? "  (early-abort: low-quality)" : ""),
+    finalMetricsLine: (h, p, r, tf, pr) => `  health=${h}  parseFail=${p}  repeat=${r}  toolFail=${tf}  progress=${pr}`,
+    reasonLabel: "reason: ",
+    failureLogHeader: "--- failure log (tail, max 80 lines) ---",
+    fixSuggestionsHeader: "--- \u4FEE\u590D\u5EFA\u8BAE\uFF08calibration\uFF09 ---",
+    auditHint: (id) => `  \u5BA1\u8BA1: \u67E5\u770B .xcompiler/audit.jsonl \u4E0E .xcompiler/llm-stream/${id}-*.txt \u83B7\u53D6\u5B8C\u6574\u539F\u59CB\u6D41`,
+    spinStepRunning: (id, phase, title) => `\u25B6 ${id} ${phase} ${title}`,
+    noFailureLog: "\uFF08\u672A\u6355\u83B7\u65E5\u5FD7\uFF09",
+    suggestionLine: (index, code, hint) => `  ${index}. [${code}] ${hint}`,
+    phaseStart: (id, phase, title) => `${id} ${phase} ${title}`,
+    phaseFailed: (id, debug, reason) => `${id} ${debug ? "DEBUG " : ""}\u5931\u8D25 \u2014 ${reason}`,
+    phaseDone: (id, rounds) => `${id} \u5B8C\u6210\uFF08\u8F6E\u6B21=${rounds}\uFF09`,
+    phaseException: (id, message) => `${id} \u5F02\u5E38\u5931\u8D25 \u2014 ${message}`,
+    archGateReason: (missing) => `HIGH_LEVEL_DESIGN \u95E8\u7981\uFF1A\u67B6\u6784\u5951\u7EA6\u7F3A\u5C11 ${missing} \u4E2A\u6807\u8BB0`,
+    archGateMissing: (tokens) => `\u7F3A\u5931\u6A21\u5757 ID/\u8DEF\u5F84\uFF1A${tokens}`,
+    archGateInstruction: (p) => `\u8BF7\u66F4\u65B0 ${p}\uFF0C\u786E\u4FDD\u6BCF\u4E2A architectureModules \u9879\u5728\u8FDB\u5165 CODE \u524D\u5747\u53EF\u8FFD\u8E2A\u3002`,
+    testGateReason: (exitCode, timedOut) => `\u6D4B\u8BD5\u95E8\u7981\uFF1A\u6D4B\u8BD5\u9000\u51FA\u7801=${exitCode}${timedOut ? "\uFF08\u8D85\u65F6\uFF09" : ""}`,
+    deliveryGateReason: (command, exitCode, timedOut) => `FUNCTIONAL_TEST \u95E8\u7981\uFF1A\`${command}\` \u9000\u51FA\u7801=${exitCode}${timedOut ? "\uFF08\u8D85\u65F6\uFF09" : ""}`,
+    missingPythonEntrypoint: "\u7F3A\u5C11 Python \u5165\u53E3\uFF1A\u9700\u8981 src/main.py \u6216 src/<package>/__main__.py",
+    missingTypeScriptEntrypoint: "\u7F3A\u5C11 TypeScript \u5165\u53E3\uFF1A\u9700\u8981 package.json start/bin \u6216 src/main.ts\u3001src/index.ts\u3001src/main.tsx \u4E4B\u4E00",
+    invalidPythonEntrypointSource: (path2) => `Python \u5165\u53E3\u6E90\u7801\u65E0\u6548\uFF1A${path2} \u5FC5\u987B\u662F\u771F\u5B9E CLI \u5165\u53E3\uFF0C\u81F3\u5C11\u5305\u542B def main(...)\u3001argparse.ArgumentParser \u6216 if __name__ == "__main__" \u8FD9\u7C7B\u5165\u53E3\u7ED3\u6784\uFF1B\u4EC5 import/comment \u7684\u5360\u4F4D\u6587\u4EF6\u4E0D\u80FD\u7B97\u53EF\u8FD0\u884C\u5E94\u7528\u3002`,
+    entrypointHelpOutputMissing: (command) => `\u5165\u53E3\u63A2\u6D4B \`${command}\` \u867D\u7136\u9000\u51FA\u7801\u4E3A 0\uFF0C\u4F46\u6CA1\u6709\u8F93\u51FA\u6709\u610F\u4E49\u7684 help/usage \u6587\u672C\uFF1B\u5FC5\u987B\u5B9E\u73B0 --help\uFF0C\u4E0D\u80FD\u9760\u7A7A\u811A\u672C\u81EA\u7136\u9000\u51FA\u8FC7\u5173\u3002`,
+    reasonLine: (reason) => `\u539F\u56E0\uFF1A${reason}`,
+    roundsLine: (rounds) => `\u8F6E\u6B21\uFF1A${rounds}`,
+    commandLine: (command) => `\u547D\u4EE4\uFF1A${command}`,
+    stdoutTailHeader: "--- \u6807\u51C6\u8F93\u51FA\uFF08\u5C3E\u90E8\uFF09---",
+    stderrTailHeader: "--- \u6807\u51C6\u9519\u8BEF\uFF08\u5C3E\u90E8\uFF09---",
+    testStdoutTailHeader: "--- \u6D4B\u8BD5\u6807\u51C6\u8F93\u51FA\uFF08\u5C3E\u90E8\uFF09---",
+    testStderrTailHeader: "--- \u6D4B\u8BD5\u6807\u51C6\u9519\u8BEF\uFF08\u5C3E\u90E8\uFF09---",
+    outputsMissing: (paths) => `\u7F3A\u5931\u8F93\u51FA\uFF1A${paths}`,
+    metricsLine: (health, parseFail, repeat, toolFail, progress) => `\u6307\u6807\uFF1A\u5065\u5EB7\u5EA6=${health} \u89E3\u6790\u5931\u8D25=${parseFail} \u91CD\u590D=${repeat} \u5DE5\u5177\u5931\u8D25=${toolFail} \u8FDB\u5EA6=${progress}`,
+    metricsUnavailable: "\u6307\u6807\uFF1A\u65E0",
+    toolCallsHeader: "\u5DE5\u5177\u8C03\u7528\uFF1A",
+    toolCallLine: (tool, ok, detail) => `  - ${tool} ${ok ? "\u6210\u529F" : "\u5931\u8D25"} ${detail}`,
+    projectMemoryRefreshFailed: (message) => `\u9879\u76EE\u8BB0\u5FC6\u5237\u65B0\u5931\u8D25\uFF1A${message}`,
+    deliveryFixHints: (language) => language === "typescript" ? [
+      "\u4FEE\u590D\u65B9\u5411\uFF08\u6309\u4F18\u5148\u7EA7\uFF09\uFF1A",
+      "  1. \u82E5 TypeScript \u6E90\u7801\u51FA\u73B0\u6A21\u5757\u89E3\u6790\u6216 ERR_MODULE_NOT_FOUND\uFF0C\u4F7F\u7528\u5E26\u663E\u5F0F .ts \u540E\u7F00\u7684\u76F8\u5BF9 ESM import\u3002",
+      "  2. \u82E5\u4E3A --help \u6216\u672A\u77E5\u9009\u9879\uFF0Cmain() \u5FC5\u987B\u652F\u6301 --help \u5E76\u4EE5 0 \u9000\u51FA\u3002",
+      "  3. \u82E5\u4E3A\u5E94\u7528\u5F02\u5E38\uFF0C\u4FEE\u590D\u5B9E\u73B0\u5E76\u4FDD\u6301\u5165\u53E3\u8F7B\u91CF\u3002"
+    ] : [
+      "\u4FEE\u590D\u65B9\u5411\uFF08\u6309\u4F18\u5148\u7EA7\uFF09\uFF1A",
+      "  1. \u82E5\u4E3A src \u76F8\u5173 ModuleNotFoundError\uFF0C\u52A0\u5165 planner #19 \u7684 sys.path \u81EA\u4E3E\u6216\u79FB\u9664 import \u7684 src. \u524D\u7F00\u3002",
+      '  2. main() \u5FC5\u987B\u662F\u771F\u5B9E CLI \u5165\u53E3\uFF1A\u89E3\u6790 --help\u3001\u8C03\u7528\u9879\u76EE\u6A21\u5757\u3001\u6253\u5370\u6709\u610F\u4E49\u8F93\u51FA\uFF0C\u5E76\u7528 if __name__ == "__main__": main() \u542F\u52A8\u3002',
+      "  3. \u82E5\u4E3A argparse \u9519\u8BEF\uFF0Cmain() \u5FC5\u987B\u65E0\u9700\u5176\u4ED6\u5FC5\u586B\u53C2\u6570\u5373\u53EF\u652F\u6301 --help \u5E76\u4EE5 0 \u9000\u51FA\u3002",
+      "  4. \u82E5\u4E3A\u4E1A\u52A1\u5F02\u5E38\uFF0C\u4FEE\u590D\u5B9E\u73B0\uFF1B\u5165\u53E3\u53EA\u8D1F\u8D23\u53C2\u6570\u89E3\u6790\u4E0E\u8C03\u7528\u3002"
+    ]
+  },
+  render: {
+    sectionGlobalPrompt: "## Global prompt (\u6CE8\u5165\u6BCF\u4E2A Step \u7684 system prompt)",
+    sectionDependencies: (manifestFile) => `## Dependencies (\u5C06\u5199\u5165 ${manifestFile})`,
+    sectionBaselineSummary: "## \u73B0\u6709\u5DE5\u7A0B\u57FA\u7EBF",
+    labelSystemPrompt: "**System prompt (\u552F\u4E00\u4F7F\u547D):**"
+  },
+  prompts: {
+    plannerSystem: (p) => buildPlannerSystem2(p),
+    plannerSelfMode: `\u81EA\u4E3E\u6A21\u5F0F\u8986\u76D6\u89C4\u5219\uFF08\u4F18\u5148\u7EA7\u9AD8\u4E8E\u4E0A\u65B9\u4E0E\u4E4B\u51B2\u7A81\u7684 greenfield \u89C4\u5219\uFF09\uFF1A
+- \u76EE\u6807\u662F\u73B0\u6709 XCompiler \u4ED3\u5E93\u3002\u9664\u975E\u9700\u6C42\u660E\u786E\u8981\u6C42\u4FEE\u6539\uFF0C\u5426\u5219\u5FC5\u987B\u4FDD\u7559\u5F53\u524D package.json\u3001tsconfig\u3001bin\u3001CLI \u5165\u53E3\u3001\u6A21\u5757\u7ED3\u6784\u3001\u516C\u5171\u5BFC\u51FA\u548C\u8BBE\u8BA1\u6587\u6863\u3002
+- \u4E0D\u5F97\u4E3A\u4E86\u6EE1\u8DB3\u65B0\u5EFA\u5DE5\u7A0B\u5165\u53E3\u7EA6\u5B9A\u800C\u521B\u5EFA src/main.ts\uFF1B\u5FC5\u987B\u590D\u7528\u73B0\u6709 package.json \u58F0\u660E\u7684\u5165\u53E3\u3002
+- \u9664\u975E\u672C\u6B21\u53D8\u66F4\u786E\u5B9E\u9700\u8981\u4FEE\u6539\uFF0C\u5426\u5219 HIGH_LEVEL_DESIGN outputs \u4E0D\u5F97\u5305\u542B package.json \u6216 tsconfig.json\u3002
+- \u6BCF\u4E2A CODE/\u6D4B\u8BD5\u4EA7\u7269\u5FC5\u987B\u4E25\u683C\u9650\u5B9A\u5728\u672C\u6B21\u589E\u91CF\u8303\u56F4\uFF0C\u7981\u6B62\u6574\u4F53\u91CD\u5EFA\u6216\u66FF\u6362\u4ED3\u5E93\u3002
+- \u5C06\u7A33\u5B9A\u5BBF\u4E3B\u89C6\u4E3A N \u4EE3\u3001\u9694\u79BB worktree \u4E2D\u7684\u5019\u9009\u7248\u672C\u89C6\u4E3A N+1 \u4EE3\uFF1B\u7981\u6B62\u8BBE\u8BA1\u8FDB\u7A0B\u5185\u70ED\u66FF\u6362\u3002`,
+    plannerClarifySystem: `\u4F60\u662F XCompiler V \u6A21\u578B\u7684\u9700\u6C42\u5206\u6790\u5E08\u3002\u4F60\u7684\u804C\u8D23\u4E0D\u662F\u590D\u8FF0 topic\uFF0C\u800C\u662F\u53D1\u73B0\u4F1A\u6539\u53D8\u529F\u80FD\u8BBE\u8BA1\u3001\u9A8C\u6536\u7ED3\u679C\u6216\u67B6\u6784\u8FB9\u754C\u7684\u672A\u51B3\u4E8B\u9879\u3002
+\u53EA\u8FD4\u56DE\u4E25\u683C JSON\u3002\u95EE\u9898\u5FC5\u987B\u53EF\u7531\u4E1A\u52A1\u65B9\u76F4\u63A5\u4F5C\u7B54\u3001\u4E00\u6B21\u53EA\u786E\u8BA4\u4E00\u4E2A\u51B3\u7B56\uFF0C\u907F\u514D\u7A7A\u6CDB\u7684\u201C\u8FD8\u6709\u4EC0\u4E48\u8981\u6C42\u201D\u6216\u6280\u672F\u6808\u9009\u578B\u95EE\u9898\u3002`,
+    plannerClarify: (raw, opts = {}) => `\u7528\u6237\u7684\u539F\u59CB\u9700\u6C42\u5982\u4E0B\uFF1A
+
+"""
+${raw}
+"""
+
+\u8BF7\u9488\u5BF9 topic \u4E2D\u5C1A\u672A\u660E\u786E\u3001\u4E14\u7B54\u6848\u4F1A\u5B9E\u8D28\u6539\u53D8\u5B9E\u73B0\u6216\u9A8C\u6536\u7684\u4E8B\u9879\uFF0C\u751F\u6210${opts.complex ? "8-10" : "7-10"}\u4E2A\u4E92\u4E0D\u91CD\u590D\u7684\u6F84\u6E05\u95EE\u9898\u3002\u4E0D\u5F97\u8FD4\u56DE\u7A7A\u6570\u7EC4\uFF1B\u5982\u679C\u529F\u80FD\u63CF\u8FF0\u5DF2\u7ECF\u8F83\u5B8C\u6574\uFF0C\u5C31\u8FFD\u95EE\u9A8C\u6536\u793A\u4F8B\u3001\u5931\u8D25\u884C\u4E3A\u548C\u660E\u786E\u7684\u4E0D\u505A\u8303\u56F4\u3002
+
+\u4EC5\u8FD4\u56DE JSON \u6570\u7EC4\uFF0C\u6BCF\u9879\u4E25\u683C\u4E3A\uFF1A
+{"id":"Q1","category":"functionality|data|acceptance|boundary|quality|extensibility","question":"\u4E00\u4E2A\u53EF\u76F4\u63A5\u56DE\u7B54\u7684\u5177\u4F53\u95EE\u9898","why":"\u8BE5\u7B54\u6848\u4F1A\u5F71\u54CD\u4EC0\u4E48\u8BBE\u8BA1\u6216\u9A8C\u6536","options":[{"label":"A","answer":"\u6700\u9AD8\u4F18\u5148\u7EA7\u7684\u53EF\u884C\u8BBE\u5B9A"},{"label":"B","answer":"\u7B2C\u4E8C\u4E2A\u53EF\u884C\u8BBE\u5B9A"}]}
+
+\u95EE\u9898\u7EC4\u5408\u8981\u6C42\uFF08\u529F\u80FD\u4F18\u5148\uFF09\uFF1A
+- \u81F3\u5C11 ${opts.complex ? "5" : "4"} \u4E2A\u529F\u80FD\u6027\u95EE\u9898\uFF0Ccategory \u4F7F\u7528 functionality / data / acceptance\uFF0C\u786E\u4FDD\u529F\u80FD\u95EE\u9898\u5360\u591A\u6570\u3002\u4F18\u5148\u8D28\u8BE2\uFF1A\u76EE\u6807\u7528\u6237\u4E0E\u89D2\u8272\u3001\u6838\u5FC3\u4F7F\u7528\u6D41\u7A0B\u3001\u529F\u80FD\u89C4\u5219\u4E0E\u72B6\u6001\u53D8\u5316\u3001\u8F93\u5165\u8F93\u51FA\u3001\u5931\u8D25/\u5F02\u5E38\u884C\u4E3A\u3001\u53EF\u9A8C\u8BC1\u9A8C\u6536\u793A\u4F8B\u3002
+- \u81F3\u5C11 1 \u4E2A boundary\uFF1A\u660E\u786E\u672C\u671F\u5FC5\u987B\u505A\u3001\u660E\u786E\u4E0D\u505A\u3001\u5916\u90E8\u7CFB\u7EDF\u8D23\u4EFB\u8FB9\u754C\u6216\u517C\u5BB9\u8303\u56F4\u3002
+- \u81F3\u5C11 1 \u4E2A quality\uFF1A\u8BE2\u95EE\u53EF\u91CF\u5316\u7684\u6027\u80FD\u3001\u5BB9\u91CF\u3001\u5E76\u53D1\u3001\u65F6\u5EF6\u3001\u51C6\u786E\u6027\u3001\u53EF\u9760\u6027\u6216\u5B89\u5168\u6307\u6807\uFF1B\u4E0D\u8981\u53EA\u95EE\u201C\u6027\u80FD\u6709\u4EC0\u4E48\u8981\u6C42\u201D\u3002
+- \u81F3\u5C11 1 \u4E2A extensibility\uFF1A\u8BE2\u95EE\u6700\u53EF\u80FD\u65B0\u589E\u7684\u4E1A\u52A1\u80FD\u529B\u3001\u6269\u5C55\u7EF4\u5EA6\u6216\u9700\u8981\u7A33\u5B9A\u4FDD\u7559\u7684\u63A5\u53E3\uFF0C\u4E0D\u8981\u6CDB\u95EE\u201C\u662F\u5426\u9700\u8981\u6269\u5C55\u6027\u201D\u3002
+- \u5982\u679C\u4EA4\u4ED8\u5F62\u6001\u4E0D\u660E\u786E\uFF0C\u5FC5\u987B\u5305\u542B 1 \u4E2A boundary \u95EE\u9898\uFF0C\u786E\u8BA4\u672C\u9879\u76EE\u5E94\u662F API library/SDK/\u8F6F\u4EF6\u5305\u3001\u53EF\u8FD0\u884C\u5E94\u7528/CLI/\u670D\u52A1\uFF0C\u8FD8\u662F\u4E8C\u8005\u517C\u5177\u7684 mixed \u4EA4\u4ED8\u3002
+- \u6309\u963B\u585E\u7A0B\u5EA6\u6392\u5E8F\uFF1A\u5148\u95EE\u4F1A\u6539\u53D8\u6838\u5FC3\u529F\u80FD/\u6570\u636E\u6A21\u578B\u7684\u95EE\u9898\uFF0C\u518D\u95EE\u8303\u56F4\u4E0E\u8D28\u91CF\uFF0C\u6700\u540E\u95EE\u672A\u6765\u6269\u5C55\u3002
+- \u4E00\u9898\u53EA\u5305\u542B\u4E00\u4E2A\u4E3B\u8981\u51B3\u7B56\uFF0C\u7ED9\u51FA\u5FC5\u8981\u7684\u4E1A\u52A1\u9009\u9879\u6216\u793A\u4F8B\uFF0C\u7981\u6B62\u628A\u591A\u4E2A\u65E0\u5173\u95EE\u9898\u7528\u201C\u4EE5\u53CA/\u6216\u8005\u201D\u62FC\u6210\u4E00\u9898\u3002
+- \u6BCF\u4E2A\u95EE\u9898\u90FD\u5FC5\u987B\u9884\u751F\u6210 2-5 \u4E2A\u53EF\u884C\u56DE\u7B54\u8BBE\u5B9A\uFF0C\u6309\u4F18\u5148\u7EA7\u6392\u5E8F\u3002\u9009\u9879\u6570\u91CF\u4E0D\u662F\u56FA\u5B9A\u503C\uFF1A\u4E8C\u9009\u4E00\u573A\u666F\u7528 2 \u4E2A\uFF0C\u5E38\u89C1\u9ED8\u8BA4\u8BBE\u5B9A\u7528 3 \u4E2A\uFF0C\u53EA\u6709\u786E\u5B9E\u5B58\u5728 4-5 \u4E2A\u5F7C\u6B64\u4E0D\u540C\u7684\u53EF\u884C\u8BBE\u5B9A\u65F6\u624D\u751F\u6210 4-5 \u4E2A\uFF1B\u4E0D\u8981\u586B\u5145\u6216\u5F3A\u5236\u6BCF\u9898\u90FD\u662F 3 \u4E2A\u9009\u9879\u3002
+- \u9009\u9879\u4ECE A \u5F00\u59CB\u8FDE\u7EED\u6807\u53F7\uFF0C\u5230\u5B9E\u9645\u6700\u540E\u4E00\u4E2A\u9009\u9879\u7ED3\u675F\uFF0C\u4F8B\u5982 A-B\u3001A-C\u3001A-D \u6216 A-E\uFF1B\u5982\u679C\u80FD\u5224\u65AD\u63A8\u8350/\u9ED8\u8BA4\u65B9\u6848\uFF0CA \u5E94\u662F\u6700\u9AD8\u4F18\u5148\u7EA7\u65B9\u6848\u3002\u9009\u9879\u5FC5\u987B\u662F\u5177\u4F53\u4E1A\u52A1/\u4EA7\u54C1\u8BBE\u5B9A\uFF0C\u4E0D\u8981\u5199\u6210\u7A7A\u6CDB\u5360\u4F4D\u3002
+- \u4E0D\u8981\u628A\u201C\u5176\u4ED6 / \u81EA\u5B9A\u4E49 / \u7528\u6237\u51B3\u5B9A\u201D\u4F5C\u4E3A\u9009\u9879\uFF1BCLI \u5DF2\u652F\u6301\u7528\u6237\u8F93\u5165\u5DF2\u5C55\u793A\u7684\u9009\u9879\u5B57\u6BCD\u6216\u76F4\u63A5\u8F93\u5165\u81EA\u5B9A\u4E49\u56DE\u7B54\u5185\u5BB9\u3002
+${opts.projectShapeAmbiguous ? "- \u672C topic \u5FC5\u95EE\uFF1A\u660E\u786E\u786E\u8BA4 API library / \u53EF\u8FD0\u884C\u5E94\u7528 / mixed \u4EA4\u4ED8\u8FB9\u754C\u3002\n" : ""}
+
+\u3010\u786C\u7EA6\u675F\u3011\u5B9E\u73B0\u6280\u672F\u6808\u5DF2\u7ECF\u7531 XCompiler \u914D\u7F6E / \u73B0\u6709\u5DE5\u7A0B\u57FA\u7EBF\u56FA\u5B9A\uFF0C\u4E0D\u8981\u91CD\u65B0\u8BE2\u95EE\u8BED\u8A00\u3001\u8FD0\u884C\u65F6\u3001\u5305\u7BA1\u7406\u5668\u8FD9\u7C7B\u95EE\u9898\u3002
+**\u4E25\u7981**\u63D0\u51FA\u4EE5\u4E0B\u7C7B\u578B\u7684\u95EE\u9898\uFF1A
+  - "\u5E0C\u671B\u7528\u4EC0\u4E48\u7F16\u7A0B\u8BED\u8A00 / \u6846\u67B6 / \u8FD0\u884C\u65F6\u5B9E\u73B0\uFF1F"
+  - "\u9700\u8981\u54EA\u79CD\u6D4B\u8BD5\u6846\u67B6 / \u6784\u5EFA\u5DE5\u5177 / \u5305\u7BA1\u7406\u5668\uFF1F"
+  - "\u76EE\u6807\u5E73\u53F0\u662F\u54EA\u79CD\u64CD\u4F5C\u7CFB\u7EDF\uFF1F"
+${opts.intent && opts.intent !== "greenfield" ? `\u8FD9\u662F\u4E00\u6761\u9488\u5BF9\u73B0\u6709\u5DE5\u7A0B\u7684\u589E\u91CF ${opts.intent} \u8BF7\u6C42${opts.hasBaseline ? "\uFF1B\u5206\u89E3\u9636\u6BB5\u8FD8\u4F1A\u63D0\u4F9B\u4E00\u4EFD\u57FA\u7EBF\u6458\u8981" : ""}\u3002\u8BF7\u53EA\u95EE\u201C\u53D8\u66F4\u589E\u91CF\u201D\u76F8\u5173\u95EE\u9898\uFF0C\u4E0D\u8981\u628A\u9879\u76EE\u5F53\u6210\u4ECE\u96F6\u5F00\u59CB\u91CD\u505A\u3002` : ""}\u95EE\u9898\u4E3B\u4F53\u5FC5\u987B\u805A\u7126\u529F\u80FD\u884C\u4E3A\uFF1B\u6027\u80FD\u3001\u8FB9\u754C\u548C\u6269\u5C55\u6027\u7528\u4E8E\u6D88\u9664\u4F1A\u5F71\u54CD\u672C\u671F\u8BBE\u8BA1\u7684\u5173\u952E\u6B67\u4E49\u3002`,
+    plannerDecompose: (raw, qa, addenda, opts = {}) => `\u539F\u59CB\u9700\u6C42\uFF1A
+"""
+${raw}
+"""
+
+\u6F84\u6E05\u95EE\u7B54\uFF1A
+${qa || "\uFF08\u65E0\uFF09"}
+
+${addenda ? `\u7528\u6237\u8865\u5145\u9700\u6C42\uFF08\u9700\u4E25\u683C\u9075\u5B88\uFF0C\u4F18\u5148\u7EA7\u9AD8\u4E8E\u539F\u59CB\u63CF\u8FF0\u4E2D\u6A21\u7CCA\u7684\u90E8\u5206\uFF09\uFF1A
+"""
+${addenda}
+"""
+
+` : ""}${opts.intent && opts.intent !== "greenfield" ? `\u589E\u91CF\u610F\u56FE\uFF1A${opts.intent}
+
+\u8BF7\u5728\u73B0\u6709\u5DE5\u7A0B\u57FA\u7840\u4E0A\u751F\u6210\u4E00\u4EFD\u589E\u91CF ${opts.intent} \u8BA1\u5212\uFF0C\u4F18\u5148\u590D\u7528\u5F53\u524D\u67B6\u6784\u3001\u6587\u4EF6\u3001\u6D4B\u8BD5\u4E0E\u4F9D\u8D56\uFF0C\u800C\u4E0D\u662F\u628A\u6574\u4E2A\u9879\u76EE\u91CD\u65B0\u642D\u4E00\u904D\u3002\u9664\u672C\u6B21\u9700\u6C42\u6D89\u53CA\u7684\u8303\u56F4\u5916\uFF0C\u9ED8\u8BA4\u4FDD\u6301\u65E2\u6709\u884C\u4E3A\u4E0D\u53D8\u3002
+
+\u73B0\u6709\u5DE5\u7A0B\u57FA\u7EBF\uFF1A
+"""
+${opts.baseline || "\uFF08\u7F3A\u5C11\u57FA\u7EBF\u6458\u8981\uFF09"}
+"""
+
+` : ""}\u89C4\u5212\u6DF1\u5EA6\u7EA6\u675F\uFF1A
+- \u9664\u975E\u9700\u6C42\u660E\u786E\u53EA\u662F\u4E00\u4E2A\u5F88\u5C0F\u7684\u5355\u51FD\u6570 / \u5355\u811A\u672C / \u5C0F\u5DE5\u5177\uFF0C\u5426\u5219\u4E0D\u8981\u628A\u65B9\u6848\u538B\u7F29\u6210\u201C\u4E00\u4E2A\u6E90\u7801\u6587\u4EF6 + \u4E00\u4E2A\u6D4B\u8BD5\u6587\u4EF6\u201D\u7684\u6700\u5C0F\u5B9E\u73B0\u3002
+- \u5982\u679C\u9700\u6C42\u6A2A\u8DE8\u591A\u4E2A\u5173\u6CE8\u70B9\uFF08\u9886\u57DF\u903B\u8F91\u3001API/CLI \u63A5\u53E3\u3001\u6301\u4E45\u5316\u3001\u5916\u90E8\u96C6\u6210\u3001\u6D41\u7A0B\u7F16\u6392\u3001\u6D4B\u8BD5\uFF09\uFF0C\u5FC5\u987B\u5728\u8BA1\u5212\u91CC\u4F53\u73B0\u4E3A\u591A\u4E2A\u67B6\u6784\u6A21\u5757\uFF0C\u5E76\u5728 CODE/MODULE_TEST \u5B8F Step \u7684 subTasks \u4E0B\u5206\u89E3\u6A21\u5757\u7EA7\u5DE5\u4F5C\u3002
+- \u5728 plan \u4E2D\u8BC4\u4F30\u9879\u76EE\u590D\u6742\u5EA6\uFF0C\u5E76\u6309\u8BC4\u4F30\u7ED3\u679C\u786E\u5B9A implementationPhases \u6570\u91CF\uFF1Asimple => \u53EA\u6709 P1 current\uFF1Bmoderate => P1 current + \u81F3\u5C11 P2 planned\uFF1Bcomplex => P1 current + \u81F3\u5C11 P2/P3 planned\u3002\u82E5\u7528\u6237\u660E\u786E\u8981\u6C42\u5206\u9636\u6BB5/\u91CC\u7A0B\u7891\uFF0C\u81F3\u5C11\u4F7F\u7528 P1+P2\uFF0C\u5E76\u8BBE\u7F6E userForcedPhaseSplit=true\u3002\u6BCF\u4E2A current/planned implementation phase \u90FD\u5FC5\u987B\u5728 steps \u4E2D\u62E5\u6709\u4E00\u5957\u5B8C\u6574 V \u6A21\u578B\uFF0C\u5E76\u8BA9 Step.iterationId \u6307\u5411\u5BF9\u5E94 phase\u3002
+- \u8BF7\u901A\u8FC7 HIGH_LEVEL_DESIGN / DETAILED_DESIGN Step \u660E\u786E\u6A21\u5757\u8FB9\u754C\u3001\u804C\u8D23\u5212\u5206\u3001\u4F9D\u8D56\u548C\u540E\u7EED\u53EF\u6269\u5C55\u70B9\uFF0C\u8BA9\u540E\u7EED\u589E\u91CF\u5F00\u53D1\u53EF\u4EE5\u6301\u7EED\u8FFD\u52A0\uFF0C\u800C\u4E0D\u662F\u6BCF\u6B21\u91CD\u5199\u3002
+- \u5982\u679C\u57FA\u7EBF\u91CC\u5DF2\u7ECF\u5B58\u5728\u76F8\u5173\u6587\u4EF6\uFF0C\u4F18\u5148\u5728\u539F\u6A21\u5757\u4E0A\u6269\u5C55/\u91CD\u6784\uFF0C\u4E0D\u8981\u65B0\u9020\u4E00\u5957\u884C\u4E3A\u91CD\u590D\u7684\u5F71\u5B50\u5B9E\u73B0\u3002
+
+\u8BF7\u6309\u7CFB\u7EDF\u89C4\u5219\u8F93\u51FA\u4E25\u683C JSON \u8BA1\u5212\u3002`,
+    executorSystem: (p) => buildExecutorSystem2(p),
+    executorDebugBlock: (reason, suggestions) => `
+
+\u6B63\u5904\u4E8E DEBUG \u91CD\u8BD5\u6A21\u5F0F\u3002\u4E0A\u4E00\u8F6E\u5931\u8D25\u539F\u56E0: ${reason}
+DEBUG \u53EF\u4EE5\u4FEE\u6539\u5F53\u524D allowedWrites \u5185\u7684\u4E0A\u6E38\u6E90\u7801\u4E0E\u6D4B\u8BD5\u6587\u4EF6\uFF1B\u82E5\u5931\u8D25\u66B4\u9732\u7684\u662F\u5B9E\u73B0\u3001\u5951\u7EA6\u6216\u4E0B\u6E38\u8C03\u7528\u4E0D\u4E00\u81F4\uFF0C\u5FC5\u987B\u4FEE\u771F\u5B9E\u7F3A\u9677\uFF0C\u7981\u6B62\u901A\u8FC7\u524A\u5F31\u65AD\u8A00\u3001\u8DF3\u8FC7\u6D4B\u8BD5\u3001\u5220\u9664\u5931\u8D25\u7528\u4F8B\u6216\u53EA\u8FCE\u5408\u9519\u8BEF\u6D4B\u8BD5\u6765\u8FC7\u5173\u3002\u8BF7\u5305\u542B read_file/code_search \u5148\u5B9A\u4F4D\u95EE\u9898\uFF0C\u518D\u4EE5 apply_patch / replace_in_file / add_dependency \u4F5C\u6700\u5C0F\u4FEE\u6539\uFF0C\u6700\u540E run_tests \u9A8C\u8BC1\u3002\u5982\u679C\u5931\u8D25\u65E5\u5FD7\u663E\u793A\u7F51\u7EDC/API \u8C03\u7528\u5931\u8D25\uFF0C\u4E0D\u5141\u8BB8\u53EA\u505C\u7559\u5728\u63A2\u6D4B\u63A5\u53E3\uFF1A\u6700\u591A\u8FDE\u7EED\u6267\u884C 2 \u6B21 http_fetch \u63A2\u6D4B\uFF1BHTTP 2xx \u4F46 body \u4E3A\u7A7A\u6216\u683C\u5F0F\u4E0D\u53EF\u7528\u4E0D\u7B97\u53EF\u7528\u63A5\u53E3\uFF1B\u968F\u540E\u5FC5\u987B patch \u771F\u5B9E\u96C6\u6210\u4EE3\u7801\uFF0C\u5E76\u7528 run_program \u548C run_tests \u9A8C\u8BC1\u3002\u5165\u53E3\u4ECD\u8F93\u51FA\u7F51\u7EDC/API \u5931\u8D25\u65F6\u4E0D\u5F97 done=true\u3002` + (suggestions ? `
+
+${suggestions}` : ""),
+    executorGlobalBlock: (globalPrompt) => `
+
+## \u9879\u76EE\u5168\u5C40\u7EA6\u675F
+${globalPrompt}`,
+    executorStepBlock: (sp) => `
+
+## \u5F53\u524D Step \u4E13\u5C5E\u63D0\u793A (\u552F\u4E00\u4F7F\u547D\uFF0C\u7981\u6B62\u8DE8 Step \u53D1\u6563)
+${sp}`,
+    executorUserPromptOutro: "\u73B0\u5728\u6309\u534F\u8BAE\u8FD4\u56DE\u7B2C\u4E00\u8F6E JSON\u3002",
+    executorFeedbackHeader: "\u672C\u8F6E\u5DE5\u5177\u7ED3\u679C\uFF1A",
+    executorFeedbackVerifyOk: "outputs \u6821\u9A8C\u901A\u8FC7\u3002\u5982\u5DF2\u5B8C\u6210\uFF0C\u8BF7\u628A done \u8BBE\u4E3A true \u4E14 actions=[]\u3002",
+    executorFeedbackVerifyMissing: (paths) => `outputs \u4ECD\u7F3A\u5931\uFF1A${paths}\u3002\u8BF7\u7EE7\u7EED\u3002`
+  },
+  skills: {
+    patcher: "\u901A\u8FC7 apply_patch / replace_in_file \u5BF9\u5DF2\u6709\u6587\u4EF6\u505A\u5C0F\u6539\u52A8\uFF0C\u7981\u6B62\u6574\u6587\u4EF6\u8986\u76D6\u3002",
+    author: "\u901A\u8FC7 write_file \u521B\u5EFA\u65B0\u6587\u4EF6\uFF1B\u4F18\u5148\u653E\u5728\u5F53\u524D Step writable allowlist \u5185\u3002",
+    tester: '\u7F16\u5199\u5E76\u8FD0\u884C pytest \u6D4B\u8BD5\uFF0C\u9A8C\u8BC1\u51FD\u6570\u884C\u4E3A\uFF1B\u5931\u8D25\u65F6\u901A\u8FC7 analyze_error \u89E3\u6790\u3002\u3010fixture \u81EA\u5305\u542B\u3011\u6D4B\u8BD5**\u4E25\u7981**\u76F4\u63A5 open() \u78C1\u76D8\u4E0A\u4E0D\u5B58\u5728\u7684\u6837\u4F8B\u6587\u4EF6\uFF08\u5982 "test.dbc"\uFF09\uFF1B\u82E5\u88AB\u6D4B\u51FD\u6570\u9700\u8981\u6587\u4EF6\u8F93\u5165\uFF0C\u8BF7\u7528 pytest \u7684 tmp_path fixture \u5728\u6D4B\u8BD5\u91CC\u4E34\u65F6\u6784\u9020\u5185\u5BB9\uFF0C\u6216\u7528 write_file \u76F4\u63A5\u5199\u5230 tests/fixtures/<name>\u2014\u2014\u6D4B\u8BD5/DEBUG \u9636\u6BB5\u8BE5\u76EE\u5F55\u5DF2\u9ED8\u8BA4\u653E\u5F00\u5199\u6743\u9650\uFF0C\u5B50\u76EE\u5F55\u81EA\u52A8 mkdir -p\uFF0C**\u65E0\u9700**\u63D0\u524D\u628A fixture \u8DEF\u5F84\u767B\u8BB0\u5230 outputs\u3002\u751F\u6210\u6D4B\u8BD5\u65F6\u52A1\u5FC5\u540C\u65F6\u8F93\u51FA\u5168\u90E8\u4F9D\u8D56\u8D44\u6E90\uFF0C\u907F\u514D\u540E\u7EED Debugger \u56E0 FileNotFoundError \u53CD\u590D\u91CD\u8BD5\u3002\u3010fixture \u8FED\u4EE3\u3011\u82E5\u6D4B\u8BD5\u8FD0\u884C\u4E2D\u88AB\u6D4B\u51FD\u6570\u62A5"Invalid syntax / Parse error / Malformed"\u7B49\u89E3\u6790\u9519\u8BEF\uFF0C\u8BF4\u660E\u4F60\u5199\u51FA\u7684 fixture \u5185\u5BB9\u4E0D\u5408\u8BE5\u683C\u5F0F spec\uFF1Aread_file \u770B\u6E05\uFF0Cwrite_file \u6574\u6587\u4EF6\u91CD\u5199\u4E3A\u5408\u6CD5\u6837\u4F8B\uFF0C\u518D run_tests\uFF0C\u4E25\u7981\u53BB\u6539\u88AB\u6D4B\u6A21\u5757\u6216\u65AD\u8A00\u3002',
+    dep_resolver: "\u5F53\u51FA\u73B0 ModuleNotFoundError \u65F6\uFF0C\u7528 add_dependency \u5199\u56DE requirements.txt \u5E76\u91CD\u5EFA\u6C99\u76D2\u3002",
+    debugger: '\u5148 run_tests / run_python \u590D\u73B0\u9519\u8BEF \u2192 analyze_error \u2192 patch/replace_in_file \u4FEE\u590D \u2192 \u518D\u6B21 run_tests\u3002\u6BCF\u6B21\u53EA\u505A\u6700\u5C0F\u4FEE\u6539\u3002\u3010\u7F51\u7EDC/API \u5931\u8D25\u3011\u5B9A\u4F4D\u5931\u8D25 URL \u540E\uFF0C\u53EA\u5141\u8BB8\u5C11\u91CF\u63A2\u6D4B\u66FF\u4EE3 API\uFF0C\u968F\u540E\u5FC5\u987B patch \u6E90\u7801\u5E76\u7528 run_program \u8BC1\u660E\u5165\u53E3\u4E0D\u518D\u8F93\u51FA API \u5931\u8D25\u3002\u3010\u91CD\u8981\u3011\u540C\u4E00\u6587\u4EF6\u4E0A replace_in_file \u8FDE\u7EED\u5931\u8D25 2 \u6B21\u4EE5\u4E0A\u8BF7\u7ACB\u5373 read_file\uFF0C\u518D\u7528 patch \u6216\u5728\u5F53\u524D\u8FD0\u884C\u65F6 chunk limit \u5185\u6574\u6587\u4EF6\u91CD\u5199\uFF0C\u4E0D\u8981\u53CD\u590D\u731C\u6D4B find \u5B57\u7B26\u4E32\u3002\u3010\u7981\u6B62 no-op\u3011replace_in_file \u7684 find \u4E0E replace \u5FC5\u987B\u4E0D\u540C\u2014\u2014\u82E5\u4F60\u53EA\u662F\u60F3"\u786E\u8BA4"\u67D0\u6BB5\u4EE3\u7801\uFF0C\u8BF7\u7528 read_file\uFF0C\u4E0D\u8981\u63D0\u4EA4\u76F8\u540C\u5B57\u7B26\u4E32\u7684\u66FF\u6362\u3002',
+    refactorer: "\u91CD\u6784\u5FC5\u987B\u4FDD\u8BC1\u884C\u4E3A\u4E0D\u53D8\uFF1B\u5148\u8DD1\u56DE\u5F52\u6D4B\u8BD5 \u2192 \u4FEE\u6539 \u2192 \u518D\u8DD1\u56DE\u5F52\u6D4B\u8BD5\u3002"
+  },
+  doctor: {
+    cliDescription: "\u68C0\u67E5 config / LLM / sandbox / skills \u662F\u5426\u5C31\u7EEA",
+    optStrict: "\u628A warning \u4E5F\u89C6\u4E3A\u5931\u8D25\uFF08\u4EFB\u4E00 warn \u5373\u975E\u96F6\u9000\u51FA\uFF09",
+    header: "XCompiler \u542F\u52A8\u73AF\u5883\u81EA\u68C0",
+    sectionConfig: "[\u914D\u7F6E]",
+    sectionLLM: "[LLM]",
+    sectionSandbox: "[\u6C99\u76D2]",
+    sectionSkills: "[\u6280\u80FD]",
+    summaryOk: "\u5168\u90E8\u68C0\u67E5\u901A\u8FC7\u3002",
+    summaryWarn: (n) => `\u901A\u8FC7\uFF0C\u4F46\u6709 ${n} \u6761 warning\u3002`,
+    summaryFail: (n) => `\u68C0\u6D4B\u5230 ${n} \u9879\u5931\u8D25\u3002`,
+    configLoadOk: (path2) => `\u914D\u7F6E\u5DF2\u52A0\u8F7D\uFF1A${path2}`,
+    configLoadFail: (msg) => `\u914D\u7F6E\u52A0\u8F7D\u5931\u8D25\uFF1A${msg}`,
+    configLocale: (locale) => `locale=${locale}`,
+    llmNoProviders: "config.llm.providers \u4E3A\u7A7A\uFF0C\u672A\u58F0\u660E\u4EFB\u4F55 provider",
+    llmProviderListed: (n) => `\u5DF2\u58F0\u660E ${n} \u4E2A provider`,
+    ollamaUnreachable: (baseUrl, msg) => `ollama \u4E0D\u53EF\u8FBE @ ${baseUrl} \u2014\u2014 ${msg}`,
+    ollamaReachable: (baseUrl, n) => `ollama \u53EF\u8FBE @ ${baseUrl}\uFF08\u5171 ${n} \u4E2A\u6A21\u578B\uFF09`,
+    ollamaModelMissing: (provider, model, baseUrl) => `provider "${provider}"\uFF1A\u6A21\u578B "${model}" \u672A\u5B89\u88C5\u4E8E ${baseUrl}\uFF08\u8BF7\u6267\u884C \`ollama pull ${model}\`\uFF09`,
+    ollamaModelOk: (provider, model) => `provider "${provider}"\uFF1A\u6A21\u578B "${model}" \u53EF\u7528`,
+    openaiKeyMissing: (provider) => `provider "${provider}"\uFF1Aapi_key \u4E3A\u7A7A\uFF08\u8BF7\u8BBE\u7F6E OPENAI_API_KEY \u6216 config.llm.providers.${provider}.api_key\uFF09`,
+    openaiReachable: (provider, baseUrl) => `provider "${provider}"\uFF1AOpenAI \u7AEF\u70B9\u53EF\u8FBE @ ${baseUrl}`,
+    openaiUnreachable: (provider, baseUrl, msg) => `provider "${provider}"\uFF1AOpenAI \u7AEF\u70B9\u4E0D\u53EF\u8FBE @ ${baseUrl} \u2014\u2014 ${msg}`,
+    openaiModelListMissing: (provider, model) => `provider "${provider}"\uFF1A/models \u54CD\u5E94\u4E2D\u672A\u5217\u51FA "${model}"\uFF08\u82E5\u4F60\u7684\u8D26\u53F7\u6709\u8BBF\u95EE\u6743\u9650\u4ECD\u53EF\u6B63\u5E38\u8C03\u7528\uFF09`,
+    providerScoreZero: (provider) => `provider "${provider}" \u5DF2\u7981\u7528\uFF08score=0\uFF09`,
+    roleNoLiveProvider: (role) => `\u89D2\u8272 "${role}" \u6CA1\u6709\u53EF\u7528 provider\uFF08\u5019\u9009\u5217\u8868\u5168\u90E8\u4E0D\u53EF\u8FBE\u6216\u88AB\u7981\u7528\uFF09`,
+    roleOk: (role, provider) => `\u89D2\u8272 "${role}" \u2192 ${provider}`,
+    sandboxKind: (kind) => `sandbox=${kind}`,
+    sandboxNetworkPolicy: (policy, ports) => `network=${policy}` + (ports.length ? `\uFF08expose_ports=[${ports.join(", ")}]\uFF09` : ""),
+    sandboxFullNoPorts: "network=full \u4F46\u672A\u914D\u7F6E expose_ports\u2014\u5BBF\u4E3B\u4FA7\u65E0\u6CD5\u8BBF\u95EE\u5BB9\u5668\u5185\u670D\u52A1\u3002\u8BF7\u5728 config.yaml \u4E2D\u8BBE\u7F6E `agent.sandbox_limits.expose_ports: [<port>]`\u3002",
+    sandboxNodeMissing: "PATH \u4E0A\u627E\u4E0D\u5230 node\uFF08TypeScript subprocess \u6C99\u76D2\u5FC5\u9700\uFF09",
+    sandboxNodeOk: (version) => `node OK\uFF08${version}\uFF09`,
+    sandboxNpmMissing: "PATH \u4E0A\u627E\u4E0D\u5230 npm\uFF08TypeScript subprocess \u6C99\u76D2\u5FC5\u9700\uFF09",
+    sandboxNpmOk: (version) => `npm OK\uFF08${version}\uFF09`,
+    sandboxNpxMissing: "PATH \u4E0A\u627E\u4E0D\u5230 npx\uFF08TypeScript subprocess \u6C99\u76D2\u5FC5\u9700\uFF09",
+    sandboxNpxOk: (version) => `npx OK\uFF08${version}\uFF09`,
+    sandboxPythonMissing: "PATH \u4E0A\u627E\u4E0D\u5230 python3\uFF08subprocess \u6C99\u76D2\u5FC5\u9700\uFF09",
+    sandboxPythonOk: (version) => `python3 OK\uFF08${version}\uFF09`,
+    sandboxVenvMissing: "python3 venv \u6A21\u5757\u4E0D\u53EF\u7528\uFF08\u8BF7\u5B89\u88C5 python3-venv / python3-virtualenv\uFF09",
+    sandboxVenvOk: "python3 venv \u6A21\u5757 OK",
+    sandboxDockerMissing: (bin) => `PATH \u4E0A\u627E\u4E0D\u5230 docker \u4E8C\u8FDB\u5236 "${bin}"`,
+    sandboxDockerOk: (version) => `docker OK\uFF08${version}\uFF09`,
+    sandboxDockerDaemonDown: (msg) => `docker daemon \u4E0D\u53EF\u8FBE\uFF1A${msg}`,
+    sandboxInContainerWarn: "\u68C0\u6D4B\u5230 XCompiler \u8FD0\u884C\u5728\u5BB9\u5668\u5185\uFF0C\u6B64\u6A21\u5F0F\u4E0D\u652F\u6301 sandbox=docker\uFF08\u8BF7\u4F7F\u7528 subprocess\uFF09\u3002",
+    skillToolMissing: (skill, tool) => `skill "${skill}" \u5F15\u7528\u4E86\u672A\u6CE8\u518C\u7684\u5DE5\u5177 "${tool}"`,
+    skillOk: (n, tools) => `\u5DF2\u6CE8\u518C ${n} \u4E2A skill\uFF0C\u5BF9\u5E94 ${tools} \u4E2A\u5E95\u5C42\u5DE5\u5177`
+  }
+};
+var zh_default = messages2;
+
+// src/i18n/index.ts
+var TABLES = { en: en_default, zh: zh_default };
+var current = "en";
+function t() {
+  return TABLES[current];
+}
+
+// src/version.ts
+var XCOMPILER_VERSION = "0.2.2";
+var XCOMPILER_PLUGIN_API_VERSION = 1;
+
+// src/plugins/compatibility.ts
+function checkPluginCompatibility(manifest, runtime = {}) {
+  const candidate = manifest && typeof manifest === "object" ? manifest : {};
+  const xcompilerVersion = runtime.xcompilerVersion ?? XCOMPILER_VERSION;
+  const pluginApiVersion = runtime.pluginApiVersion ?? XCOMPILER_PLUGIN_API_VERSION;
+  const pluginId = typeof candidate.id === "string" ? candidate.id.trim() : "";
+  const pluginVersion = typeof candidate.version === "string" ? candidate.version : "";
+  const base = { pluginId, pluginVersion, xcompilerVersion, pluginApiVersion };
+  const reject = (code, message) => ({
+    ...base,
+    compatible: false,
+    code,
+    message
+  });
+  const current2 = parseSemVer(xcompilerVersion);
+  if (!current2) {
+    return reject("invalid-runtime-version", t().plugins.invalidCoreVersion(xcompilerVersion));
+  }
+  if (!/^[a-z0-9][a-z0-9._-]*$/u.test(pluginId)) {
+    return reject("invalid-id", t().plugins.invalidId(pluginId));
+  }
+  if (!parseSemVer(pluginVersion)) {
+    return reject("invalid-plugin-version", t().plugins.invalidVersion(pluginId, pluginVersion));
+  }
+  if (!Number.isInteger(candidate.apiVersion) || candidate.apiVersion !== pluginApiVersion) {
+    return reject(
+      "api-version-mismatch",
+      t().plugins.apiVersionMismatch(pluginId, candidate.apiVersion, pluginApiVersion)
+    );
+  }
+  const minimum = parseSemVer(candidate.minXCompilerVersion);
+  if (!minimum) {
+    return reject(
+      "invalid-min-xcompiler-version",
+      t().plugins.invalidMinimumVersion(pluginId, String(candidate.minXCompilerVersion ?? ""))
+    );
+  }
+  if (compareSemVer(current2, minimum) < 0) {
+    return reject(
+      "xcompiler-version-too-old",
+      t().plugins.coreVersionTooOld(pluginId, candidate.minXCompilerVersion, xcompilerVersion)
+    );
+  }
+  return { ...base, compatible: true, code: "compatible" };
+}
+function parseSemVer(value) {
+  const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.exec(value);
+  if (!match) return void 0;
+  const prereleaseParts = match[4]?.split(".") ?? [];
+  if (prereleaseParts.some((part) => /^0\d+$/u.test(part))) return void 0;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: prereleaseParts.map((part) => /^\d+$/.test(part) ? Number(part) : part)
+  };
+}
+function compareSemVer(a, b) {
+  for (const key of ["major", "minor", "patch"]) {
+    if (a[key] !== b[key]) return a[key] - b[key];
+  }
+  if (a.prerelease.length === 0 || b.prerelease.length === 0) {
+    return a.prerelease.length === b.prerelease.length ? 0 : a.prerelease.length === 0 ? 1 : -1;
+  }
+  const length = Math.max(a.prerelease.length, b.prerelease.length);
+  for (let index = 0; index < length; index++) {
+    const left = a.prerelease[index];
+    const right = b.prerelease[index];
+    if (left === void 0 || right === void 0) return left === void 0 ? -1 : 1;
+    if (left === right) continue;
+    if (typeof left === "number" && typeof right === "number") return left - right;
+    if (typeof left === "number") return -1;
+    if (typeof right === "number") return 1;
+    return left.localeCompare(right);
+  }
+  return 0;
+}
+
+// src/plugins/host.ts
+var PluginHost = class {
+  plugins;
+  strict;
+  xcompilerVersion;
+  pluginApiVersion;
+  hooks = /* @__PURE__ */ new Map();
+  contributedTools = [];
+  contributedSkills = [];
+  audit;
+  initialized = false;
+  registrationOrder = 0;
+  constructor(options = {}) {
+    this.plugins = (options.plugins ?? []).map(snapshotPlugin);
+    this.strict = options.strict ?? false;
+    this.xcompilerVersion = options.xcompilerVersion ?? XCOMPILER_VERSION;
+    this.pluginApiVersion = options.pluginApiVersion ?? XCOMPILER_PLUGIN_API_VERSION;
+    this.audit = options.audit;
+    assertPluginMetadata(this.plugins, this.xcompilerVersion, this.pluginApiVersion);
+  }
+  get size() {
+    return this.plugins.length;
+  }
+  /** 返回只读清单快照，供诊断、插件目录和未来 registry 使用。 */
+  get manifests() {
+    return this.plugins.map((plugin) => snapshotManifest(plugin.manifest));
+  }
+  setAudit(audit) {
+    this.audit = audit;
+  }
+  async initialize() {
+    if (this.initialized) return;
+    this.initialized = true;
+    for (const plugin of this.plugins) {
+      try {
+        await plugin.setup(this.createApi(plugin));
+        await this.audit?.event(
+          "note",
+          t().plugins.loaded(plugin.manifest.id, plugin.manifest.version),
+          {
+            messageId: "plugins.loaded",
+            pluginId: plugin.manifest.id,
+            pluginVersion: plugin.manifest.version,
+            minXCompilerVersion: plugin.manifest.minXCompilerVersion,
+            apiVersion: plugin.manifest.apiVersion
+          }
+        );
+      } catch (error) {
+        await this.handleFailure(plugin, "setup", error);
+      }
+    }
+  }
+  /** 把插件贡献的 Tool / Skill 合并到 Engine 的默认注册表；禁止静默覆盖核心能力。 */
+  applyExtensions(target) {
+    for (const { plugin, tool } of this.contributedTools) {
+      if (target.tools.get(tool.name)) {
+        throw new Error(t().plugins.extensionConflict(plugin.manifest.id, "tool", tool.name));
+      }
+      target.tools.register(tool);
+    }
+    for (const { plugin, skill } of this.contributedSkills) {
+      if (target.skills.get(skill.name)) {
+        throw new Error(t().plugins.extensionConflict(plugin.manifest.id, "skill", skill.name));
+      }
+      target.skills.register(skill);
+    }
+  }
+  async emit(hook, context) {
+    await this.initialize();
+    const handlers = [...this.hooks.get(hook) ?? []].sort((a, b) => b.priority - a.priority || a.order - b.order);
+    for (const registration of handlers) {
+      try {
+        await registration.handler(context);
+      } catch (error) {
+        await this.handleFailure(registration.plugin, hook, error);
+      }
+    }
+  }
+  /** 在不绕过原 Tool / EditGuard 的前提下增加 before / after / error Hook。 */
+  wrapTool(tool) {
+    return {
+      name: tool.name,
+      description: tool.description,
+      argsSchema: tool.argsSchema,
+      run: async (args, context) => {
+        const before = {
+          stepId: context.stepId,
+          tool: tool.name,
+          args,
+          context
+        };
+        await this.emit("tool.before", before);
+        try {
+          const result = await tool.run(before.args, context);
+          const after = {
+            ...before,
+            result
+          };
+          await this.emit("tool.after", after);
+          return after.result;
+        } catch (error) {
+          await this.emit("tool.error", { ...before, error });
+          throw error;
+        }
+      }
+    };
+  }
+  /** 包装完整 LLM 调用；response 可由 after Hook 做结构化后处理。 */
+  wrapLLM(client, role) {
+    return {
+      name: client.name,
+      chat: async (messages3, options) => {
+        const before = {
+          role,
+          model: client.name,
+          messages: [...messages3],
+          options: options ? { ...options } : void 0
+        };
+        await this.emit("llm.before", before);
+        const startedAt = Date.now();
+        try {
+          const response = await client.chat(before.messages, before.options);
+          const after = {
+            role,
+            model: client.name,
+            messages: before.messages,
+            response,
+            durationMs: Date.now() - startedAt
+          };
+          await this.emit("llm.after", after);
+          return after.response;
+        } catch (error) {
+          await this.emit("llm.error", {
+            role,
+            model: client.name,
+            messages: before.messages,
+            error,
+            durationMs: Date.now() - startedAt
+          });
+          throw error;
+        }
+      }
+    };
+  }
+  createApi(plugin) {
+    return {
+      xcompilerVersion: this.xcompilerVersion,
+      pluginApiVersion: this.pluginApiVersion,
+      on: (hook, handler, options = {}) => {
+        const registration = {
+          hook,
+          plugin,
+          handler: (context) => handler(context),
+          priority: options.priority ?? 0,
+          order: this.registrationOrder++
+        };
+        const list = this.hooks.get(hook) ?? [];
+        list.push(registration);
+        this.hooks.set(hook, list);
+        return () => {
+          const current2 = this.hooks.get(hook);
+          if (!current2) return;
+          const index = current2.indexOf(registration);
+          if (index >= 0) current2.splice(index, 1);
+        };
+      },
+      registerTool: (tool) => this.contributedTools.push({ plugin, tool }),
+      registerSkill: (skill) => this.contributedSkills.push({ plugin, skill })
+    };
+  }
+  async handleFailure(plugin, stage, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const rendered = t().plugins.hookFailed(plugin.manifest.id, stage, message);
+    await this.audit?.event("note", rendered, {
+      messageId: "plugins.hook_failed",
+      plugin: plugin.manifest.id,
+      stage,
+      error: message
+    });
+    if (this.strict || plugin.failureMode === "fail") throw error;
+    console.warn(rendered);
+  }
+};
+function assertPluginMetadata(plugins, xcompilerVersion, pluginApiVersion) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const plugin of plugins) {
+    const report = checkPluginCompatibility(plugin.manifest, { xcompilerVersion, pluginApiVersion });
+    if (!report.compatible) throw new Error(report.message);
+    if (seen.has(report.pluginId)) throw new Error(t().plugins.duplicateId(report.pluginId));
+    seen.add(report.pluginId);
+  }
+}
+function snapshotPlugin(plugin) {
+  return { ...plugin, manifest: snapshotManifest(plugin.manifest) };
+}
+function snapshotManifest(manifest) {
+  if (!manifest) return {};
+  return {
+    ...manifest,
+    keywords: manifest.keywords ? [...manifest.keywords] : void 0
+  };
+}
+
+// src/plugins/loader.ts
+import { readFile } from "fs/promises";
+import path from "path";
+import { pathToFileURL } from "url";
+async function loadPluginSources(options) {
+  const baseDir = path.resolve(options.baseDir ?? process.cwd());
+  const runtime = {
+    xcompilerVersion: options.xcompilerVersion ?? XCOMPILER_VERSION,
+    pluginApiVersion: options.pluginApiVersion ?? XCOMPILER_PLUGIN_API_VERSION
+  };
+  const preflight = [];
+  for (const source of options.sources) {
+    const manifestPath = path.resolve(baseDir, source.manifestPath);
+    const entryPath = path.resolve(baseDir, source.entryPath);
+    let manifest;
+    try {
+      manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+    } catch (error) {
+      const message = t().plugins.manifestReadFailed(manifestPath, errorMessage(error));
+      await auditRejected(options, "", "manifest-read", message, { manifestPath, entryPath });
+      throw new Error(message, { cause: error });
+    }
+    const report = checkPluginCompatibility(manifest, runtime);
+    if (!report.compatible) {
+      const message = report.message ?? report.code;
+      await auditRejected(options, report.pluginId, "compatibility", message, { manifestPath, entryPath });
+      throw new Error(message);
+    }
+    preflight.push({ source, manifest: snapshotManifest2(manifest), manifestPath, entryPath });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of preflight) {
+    if (seen.has(item.manifest.id)) {
+      const message = t().plugins.duplicateId(item.manifest.id);
+      await auditRejected(options, item.manifest.id, "duplicate-id", message, item);
+      throw new Error(message);
+    }
+    seen.add(item.manifest.id);
+  }
+  const plugins = [];
+  for (const item of preflight) {
+    const exportName = item.source.exportName ?? "default";
+    let loaded;
+    try {
+      loaded = await import(pathToFileURL(item.entryPath).href);
+    } catch (error) {
+      const message = t().plugins.moduleLoadFailed(item.manifest.id, item.entryPath, errorMessage(error));
+      await auditRejected(options, item.manifest.id, "module-load", message, item);
+      throw new Error(message, { cause: error });
+    }
+    const plugin = loaded[exportName];
+    if (!isPlugin(plugin)) {
+      const message = t().plugins.exportInvalid(item.manifest.id, exportName);
+      await auditRejected(options, item.manifest.id, "module-export", message, item);
+      throw new Error(message);
+    }
+    if (!sameRuntimeManifest(plugin.manifest, item.manifest)) {
+      const message = t().plugins.manifestMismatch(item.manifest.id);
+      await auditRejected(options, item.manifest.id, "manifest-mismatch", message, item);
+      throw new Error(message, { cause: new Error("plugin runtime manifest differs from preflight manifest") });
+    }
+    plugins.push({ ...plugin, manifest: snapshotManifest2(item.manifest) });
+  }
+  return plugins;
+}
+function isPlugin(value) {
+  return !!value && typeof value === "object" && typeof value.setup === "function" && !!value.manifest;
+}
+function sameRuntimeManifest(actual, expected) {
+  return actual.id === expected.id && actual.version === expected.version && actual.apiVersion === expected.apiVersion && actual.minXCompilerVersion === expected.minXCompilerVersion;
+}
+function snapshotManifest2(manifest) {
+  return { ...manifest, keywords: manifest.keywords ? [...manifest.keywords] : void 0 };
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function auditRejected(options, pluginId, stage, message, detail) {
+  await options.audit?.event("note", message, {
+    messageId: "plugins.load_rejected",
+    pluginId,
+    stage,
+    detail
+  });
+}
+export {
+  PluginHost,
+  XCOMPILER_PLUGIN_API_VERSION,
+  XCOMPILER_VERSION,
+  checkPluginCompatibility,
+  loadPluginSources
+};
+//# sourceMappingURL=index.js.map