@xcompiler/cli 0.2.2

package/dist/runtime/runtime.d.ts

@@ -0,0 +1,1217 @@
+import { z } from 'zod';
+
+declare const XCOMPILER_VERSION = "0.2.2";
+declare const XCOMPILER_PLUGIN_API_VERSION = 1;
+
+/** Supported target languages for generated projects. */
+declare const LANGUAGES: readonly ["python", "typescript"];
+type Language = (typeof LANGUAGES)[number];
+/** Plan intent: greenfield generation, incremental work, or isolated self-bootstrap. */
+declare const PLAN_INTENTS: readonly ["greenfield", "feature", "refactor", "self"];
+type PlanIntent = (typeof PLAN_INTENTS)[number];
+declare const ROLES: readonly ["Planner", "Architect", "Coder", "Tester", "Debugger"];
+type Role = (typeof ROLES)[number];
+interface StepSubtask {
+    id: string;
+    title: string;
+    description: string;
+    acceptance?: string;
+    outputs?: string[];
+    subTasks?: StepSubtask[];
+}
+declare const StepSchema: z.ZodObject<{
+    id: z.ZodString;
+    iterationId: z.ZodDefault<z.ZodString>;
+    phase: z.ZodEnum<{
+        REQUIREMENT_ANALYSIS: "REQUIREMENT_ANALYSIS";
+        HIGH_LEVEL_DESIGN: "HIGH_LEVEL_DESIGN";
+        DETAILED_DESIGN: "DETAILED_DESIGN";
+        CODE: "CODE";
+        UNIT_TEST: "UNIT_TEST";
+        INTEGRATION_TEST: "INTEGRATION_TEST";
+        MODULE_TEST: "MODULE_TEST";
+        FUNCTIONAL_TEST: "FUNCTIONAL_TEST";
+        DEBUG: "DEBUG";
+    }>;
+    title: z.ZodString;
+    description: z.ZodString;
+    systemPrompt: z.ZodString;
+    role: z.ZodEnum<{
+        Planner: "Planner";
+        Architect: "Architect";
+        Coder: "Coder";
+        Tester: "Tester";
+        Debugger: "Debugger";
+    }>;
+    tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    inputs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    outputs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    subTasks: z.ZodOptional<z.ZodArray<z.ZodType<StepSubtask, unknown, z.core.$ZodTypeInternals<StepSubtask, unknown>>>>;
+    dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    acceptance: z.ZodString;
+    status: z.ZodDefault<z.ZodEnum<{
+        PENDING: "PENDING";
+        RUNNING: "RUNNING";
+        DONE: "DONE";
+        FAILED: "FAILED";
+        SKIPPED: "SKIPPED";
+    }>>;
+    retries: z.ZodDefault<z.ZodNumber>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type Step = z.infer<typeof StepSchema>;
+declare const PlanSchema: z.ZodPipe<z.ZodObject<{
+    version: z.ZodLiteral<"1">;
+    language: z.ZodDefault<z.ZodEnum<{
+        python: "python";
+        typescript: "typescript";
+    }>>;
+    intent: z.ZodDefault<z.ZodEnum<{
+        greenfield: "greenfield";
+        feature: "feature";
+        refactor: "refactor";
+        self: "self";
+    }>>;
+    projectType: z.ZodDefault<z.ZodEnum<{
+        application: "application";
+        library: "library";
+        mixed: "mixed";
+    }>>;
+    requirementDigest: z.ZodString;
+    complexityAssessment: z.ZodOptional<z.ZodObject<{
+        level: z.ZodEnum<{
+            simple: "simple";
+            moderate: "moderate";
+            complex: "complex";
+        }>;
+        rationale: z.ZodString;
+        splitRecommended: z.ZodDefault<z.ZodBoolean>;
+        userForcedPhaseSplit: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    implementationPhases: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        objective: z.ZodString;
+        status: z.ZodDefault<z.ZodEnum<{
+            current: "current";
+            planned: "planned";
+            deferred: "deferred";
+        }>>;
+        scope: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        deliverables: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        verificationGate: z.ZodOptional<z.ZodObject<{
+            summary: z.ZodString;
+            checks: z.ZodArray<z.ZodString>;
+            failurePolicy: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    architectureModules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        responsibility: z.ZodString;
+        sourcePaths: z.ZodArray<z.ZodString>;
+        testPaths: z.ZodArray<z.ZodString>;
+        dependencies: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    globalPrompt: z.ZodDefault<z.ZodString>;
+    baselineSummary: z.ZodDefault<z.ZodString>;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    pythonRequirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    userAddenda: z.ZodDefault<z.ZodString>;
+    createdAt: z.ZodString;
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        iterationId: z.ZodDefault<z.ZodString>;
+        phase: z.ZodEnum<{
+            REQUIREMENT_ANALYSIS: "REQUIREMENT_ANALYSIS";
+            HIGH_LEVEL_DESIGN: "HIGH_LEVEL_DESIGN";
+            DETAILED_DESIGN: "DETAILED_DESIGN";
+            CODE: "CODE";
+            UNIT_TEST: "UNIT_TEST";
+            INTEGRATION_TEST: "INTEGRATION_TEST";
+            MODULE_TEST: "MODULE_TEST";
+            FUNCTIONAL_TEST: "FUNCTIONAL_TEST";
+            DEBUG: "DEBUG";
+        }>;
+        title: z.ZodString;
+        description: z.ZodString;
+        systemPrompt: z.ZodString;
+        role: z.ZodEnum<{
+            Planner: "Planner";
+            Architect: "Architect";
+            Coder: "Coder";
+            Tester: "Tester";
+            Debugger: "Debugger";
+        }>;
+        tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        inputs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        outputs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        subTasks: z.ZodOptional<z.ZodArray<z.ZodType<StepSubtask, unknown, z.core.$ZodTypeInternals<StepSubtask, unknown>>>>;
+        dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        acceptance: z.ZodString;
+        status: z.ZodDefault<z.ZodEnum<{
+            PENDING: "PENDING";
+            RUNNING: "RUNNING";
+            DONE: "DONE";
+            FAILED: "FAILED";
+            SKIPPED: "SKIPPED";
+        }>>;
+        retries: z.ZodDefault<z.ZodNumber>;
+        maxRetries: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodTransform<{
+    dependencies: string[];
+    version: "1";
+    language: "python" | "typescript";
+    intent: "greenfield" | "feature" | "refactor" | "self";
+    projectType: "application" | "library" | "mixed";
+    requirementDigest: string;
+    globalPrompt: string;
+    baselineSummary: string;
+    userAddenda: string;
+    createdAt: string;
+    steps: {
+        id: string;
+        iterationId: string;
+        phase: "REQUIREMENT_ANALYSIS" | "HIGH_LEVEL_DESIGN" | "DETAILED_DESIGN" | "CODE" | "UNIT_TEST" | "INTEGRATION_TEST" | "MODULE_TEST" | "FUNCTIONAL_TEST" | "DEBUG";
+        title: string;
+        description: string;
+        systemPrompt: string;
+        role: "Planner" | "Architect" | "Coder" | "Tester" | "Debugger";
+        tools: string[];
+        inputs: string[];
+        outputs: string[];
+        dependsOn: string[];
+        acceptance: string;
+        status: "PENDING" | "RUNNING" | "DONE" | "FAILED" | "SKIPPED";
+        retries: number;
+        maxRetries: number;
+        subTasks?: StepSubtask[] | undefined;
+    }[];
+    complexityAssessment?: {
+        level: "simple" | "moderate" | "complex";
+        rationale: string;
+        splitRecommended: boolean;
+        userForcedPhaseSplit: boolean;
+    } | undefined;
+    implementationPhases?: {
+        id: string;
+        title: string;
+        objective: string;
+        status: "current" | "planned" | "deferred";
+        scope: string[];
+        deliverables: string[];
+        dependsOn: string[];
+        verificationGate?: {
+            summary: string;
+            checks: string[];
+            failurePolicy: string;
+        } | undefined;
+    }[] | undefined;
+    architectureModules?: {
+        id: string;
+        name: string;
+        responsibility: string;
+        sourcePaths: string[];
+        testPaths: string[];
+        dependencies: string[];
+    }[] | undefined;
+}, {
+    version: "1";
+    language: "python" | "typescript";
+    intent: "greenfield" | "feature" | "refactor" | "self";
+    projectType: "application" | "library" | "mixed";
+    requirementDigest: string;
+    globalPrompt: string;
+    baselineSummary: string;
+    userAddenda: string;
+    createdAt: string;
+    steps: {
+        id: string;
+        iterationId: string;
+        phase: "REQUIREMENT_ANALYSIS" | "HIGH_LEVEL_DESIGN" | "DETAILED_DESIGN" | "CODE" | "UNIT_TEST" | "INTEGRATION_TEST" | "MODULE_TEST" | "FUNCTIONAL_TEST" | "DEBUG";
+        title: string;
+        description: string;
+        systemPrompt: string;
+        role: "Planner" | "Architect" | "Coder" | "Tester" | "Debugger";
+        tools: string[];
+        inputs: string[];
+        outputs: string[];
+        dependsOn: string[];
+        acceptance: string;
+        status: "PENDING" | "RUNNING" | "DONE" | "FAILED" | "SKIPPED";
+        retries: number;
+        maxRetries: number;
+        subTasks?: StepSubtask[] | undefined;
+    }[];
+    complexityAssessment?: {
+        level: "simple" | "moderate" | "complex";
+        rationale: string;
+        splitRecommended: boolean;
+        userForcedPhaseSplit: boolean;
+    } | undefined;
+    implementationPhases?: {
+        id: string;
+        title: string;
+        objective: string;
+        status: "current" | "planned" | "deferred";
+        scope: string[];
+        deliverables: string[];
+        dependsOn: string[];
+        verificationGate?: {
+            summary: string;
+            checks: string[];
+            failurePolicy: string;
+        } | undefined;
+    }[] | undefined;
+    architectureModules?: {
+        id: string;
+        name: string;
+        responsibility: string;
+        sourcePaths: string[];
+        testPaths: string[];
+        dependencies: string[];
+    }[] | undefined;
+    dependencies?: string[] | undefined;
+    pythonRequirements?: string[] | undefined;
+}>>;
+type Plan = z.infer<typeof PlanSchema>;
+
+type ChatRole = 'system' | 'user' | 'assistant';
+interface ChatMessage {
+    role: ChatRole;
+    content: string;
+}
+interface ChatOptions {
+    temperature?: number;
+    maxTokens?: number;
+    /** Force JSON-only response if provider supports it. */
+    responseFormat?: 'text' | 'json';
+    /**
+     * 流式 token 回调。设置后 provider 会以增量方式推送 token；
+     * provider 仍会聚合并返回完整文本作为最终结果。
+     */
+    onToken?: (chunk: string) => void;
+    /**
+     * 流式模式下的“可提前结束”判定。用于兼容一些 provider：
+     * 输出内容本身已经完整，但既不及时发送 [DONE]，也不主动断开连接。
+     * 返回 true 后 provider 应尽快结束本次流读取并返回当前 aggregate。
+     */
+    streamStopWhen?: (text: string) => boolean;
+    /**
+     * 可选验证钩子：provider 返回后调用。抛异常会被 FallbackClient
+     * 视为该 provider 失败，并切换到下一个。适用于：JSON 退化、
+     * 空输出、model token loop 等“表面成功但语义不可用”场景。
+     */
+    validate?: (text: string) => void;
+    /**
+     * 调用者可传入回调，与 LLM 输出一同拿到实际产出该响应的 provider 名。
+     * 主要用于追溯：在 FallbackClient 中服务于响应的是链中某一个后选 provider，
+     * 调用者（如 Executor）需要在审计 / Markdown 记录中为响应打上正确的“via 哪个模型”标签。
+     */
+    onProvider?: (name: string) => void;
+    /**
+     * 每次开始尝试候选 provider 时触发。用于 CLI 在等待首个 token 前显示
+     * 当前 provider 与模型；fallback 切换时会再次触发。
+     */
+    onProviderStart?: (name: string, model: string) => void;
+}
+interface LLMClient {
+    readonly name: string;
+    chat(messages: ChatMessage[], options?: ChatOptions): Promise<string>;
+}
+
+/**
+ * AuditLogger 把开发流水线中的所有交互/执行动作记录到两份产物：
+ *
+ *  - `docs/process_log.md` —— 人类可读的过程记录，用于交付时汇总。
+ *  - `.xcompiler/audit.jsonl`   —— 机器可读的逐行 JSON，便于后续分析与回放。
+ *
+ * 设计原则：
+ *  - 追加写入，永不删除。
+ *  - 失败时不影响主流程（写盘异常仅打印 warning）。
+ *  - 每条事件都带 ts / kind / payload。
+ */
+type AuditKind = 'session.start' | 'session.end' | 'user.input' | 'user.decision' | 'llm.request' | 'llm.response' | 'llm.error' | 'llm.score' | 'fs.write' | 'plan.persist' | 'topic.persist' | 'phase.start' | 'phase.end' | 'tool.call' | 'tool.result' | 'sandbox.exec' | 'executor.turn' | 'planner.thought' | 'conftest.autogen' | 'issue.record' | 'issue.route' | 'issue.resolve' | 'note';
+interface AuditLoggerOptions {
+    /** workspace 根目录（绝对路径） */
+    root: string;
+    /** 命令名，例如 `xcompiler_build` / `xcompiler_run` */
+    command: string;
+    /** markdown 文件相对路径，默认 docs/process_log.md */
+    mdRelPath?: string;
+    /** jsonl 文件相对路径，默认 .xcompiler/audit.jsonl */
+    jsonlRelPath?: string;
+    /** full=完整内容；redacted=保留内容但遮蔽凭据（默认）；metadata=仅保留长度与摘要。 */
+    contentMode?: AuditContentMode;
+}
+type AuditContentMode = 'full' | 'redacted' | 'metadata';
+declare class AuditLogger {
+    private readonly mdAbs;
+    private readonly jsonlAbs;
+    private readonly command;
+    private readonly contentMode;
+    private startTs;
+    /** 串行化 markdown 追加，防止并发 appendFile 交错。 */
+    private mdQueue;
+    constructor(opts: AuditLoggerOptions);
+    start(meta?: Record<string, unknown>): Promise<void>;
+    end(summary?: Record<string, unknown>): Promise<void>;
+    /** 通用事件，jsonl + 简短 markdown 一行。 */
+    event(kind: AuditKind, message: string, data?: Record<string, unknown>): Promise<void>;
+    /** 用户输入 / 决策。会把内容以引用块写入 markdown。 */
+    userInput(label: string, content: string): Promise<void>;
+    userDecision(label: string, value: string): Promise<void>;
+    /** LLM 请求/响应：完整 prompt 与回包写入 markdown 折叠块。 */
+    llmRequest(role: string, model: string, messages: unknown, options?: unknown): Promise<void>;
+    llmResponse(role: string, model: string, content: string, meta?: Record<string, unknown>): Promise<void>;
+    llmError(role: string, model: string, err: unknown): Promise<void>;
+    /**
+     * 记录一轮 Executor 思考：thoughts 文本、计划调用的 actions、是否完成。
+     * 写入 jsonl + markdown 折叠块，交付时可作为"AI 思考过程完整记录"。
+     */
+    executorTurn(stepId: string, role: string, round: number, payload: {
+        thoughts?: string;
+        actions?: unknown[];
+        done?: boolean;
+        raw?: string;
+        provider?: string;
+    }): Promise<void>;
+    /** 记录 Planner 的思考阶段，比如 clarify / decompose 原始输出。 */
+    plannerThought(stage: string, content: string, meta?: Record<string, unknown> & {
+        provider?: string;
+    }): Promise<void>;
+    private ensureFiles;
+    private appendMd;
+    private appendJsonl;
+}
+
+declare const CLARIFICATION_CATEGORIES: readonly ["functionality", "data", "acceptance", "boundary", "quality", "extensibility"];
+type ClarificationCategory = (typeof CLARIFICATION_CATEGORIES)[number];
+declare const CLARIFICATION_OPTION_LABELS: readonly ["A", "B", "C", "D", "E"];
+type ClarificationOptionLabel = (typeof CLARIFICATION_OPTION_LABELS)[number];
+interface ClarifyOption {
+    label: ClarificationOptionLabel;
+    answer: string;
+}
+interface ClarifyQuestion {
+    id: string;
+    category: ClarificationCategory;
+    question: string;
+    why: string;
+    options: ClarifyOption[];
+}
+interface PlannerInput {
+    rawRequirement: string;
+    clarifications: Array<{
+        question: string;
+        answer: string;
+        category?: ClarificationCategory;
+        why?: string;
+        options?: ClarifyOption[];
+    }>;
+    /** 用户在澄清问答后补充的自定义需求（可为空）。 */
+    userAddenda?: string;
+    /** 增量开发时，现有工程基线摘要（文档 / 计划 / 源码树）。 */
+    baselineContext?: string;
+    /** 计划意图：greenfield / feature / refactor / self。 */
+    intent?: PlanIntent;
+}
+
+declare class Workspace {
+    readonly root: string;
+    constructor(root: string);
+    abs(...p: string[]): string;
+    ensure(dir: string): Promise<void>;
+    writeFile(rel: string, content: string): Promise<void>;
+    readFile(rel: string): Promise<string>;
+    exists(rel: string): Promise<boolean>;
+    remove(rel: string): Promise<void>;
+}
+
+interface ExecResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+    durationMs: number;
+}
+interface ExecExtra {
+    cwd?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+}
+/** 沙盒统一接口。任意 phase / tool 都通过此接口与运行时交互。 */
+interface Sandbox {
+    /** 实现标识，便于审计与日志区分。 */
+    readonly kind: 'subprocess' | 'docker';
+    /**
+     * 构建/复用环境。
+     *  - Python：`pip install -r requirements.txt` + venv。
+     *  - TypeScript：`npm install`（依据 package.json）。
+     * manifestFile 为依赖清单在 workspace 内的相对路径；不存在则跳过安装。
+     * 返回是否真正重建。
+     */
+    build(manifestFile?: string): Promise<{
+        rebuilt: boolean;
+        reason: string;
+    }>;
+    /** 执行任意命令；cmd 视实现可能是宿主路径或容器内路径。 */
+    exec(cmd: string, argv: string[], extra?: ExecExtra): Promise<ExecResult>;
+    /**
+     * 运行工程入口程序。
+     *  - Python：`python <args>`（自动选用 venv 内解释器）。
+     *  - TypeScript：`npx tsx <args>`。
+     */
+    runProgram(args: string[], extra?: ExecExtra): Promise<ExecResult>;
+    /**
+     * 运行测试套件。
+     *  - Python：`python -m pytest <args>`。
+     *  - TypeScript：`npm test`（Vitest）。
+     */
+    runTests(args?: string[], extra?: ExecExtra): Promise<ExecResult>;
+    /**
+     * 安装额外依赖（不写入依赖清单）。
+     *  - Python：`pip install <packages>`。
+     *  - TypeScript：`npm install <packages>`。
+     */
+    installDeps(packages: string[]): Promise<ExecResult>;
+}
+
+type ToolPermissionOperation = 'shell_command' | 'file_write' | 'file_delete' | 'install_dependency' | 'config_change' | 'git_operation' | 'network_access' | 'test_command' | 'build_command' | 'external_read' | 'external_write';
+interface ToolPermissionRequest {
+    id?: string;
+    operationType: ToolPermissionOperation;
+    target: string;
+    reason: string;
+    risk: string;
+    scope: string;
+    skippable: boolean;
+    denyBehavior: string;
+    stepId?: string;
+    tool?: string;
+    metadata?: Record<string, unknown>;
+}
+interface ToolPermissionDecision {
+    approved: boolean;
+    reason?: string;
+}
+type ToolPermissionRequester = (request: ToolPermissionRequest) => Promise<ToolPermissionDecision>;
+interface ToolExecutionEvent {
+    status: 'started' | 'completed';
+    stepId: string;
+    tool: string;
+    target?: string;
+    args?: Record<string, unknown>;
+    ok?: boolean;
+    summary?: string;
+    error?: string;
+    changedFiles?: string[];
+    patch?: string;
+}
+type ToolExecutionReporter = (event: ToolExecutionEvent) => void | Promise<void>;
+/** 工具调用的统一上下文。 */
+interface ToolContext {
+    ws: Workspace;
+    sandbox: Sandbox;
+    audit?: AuditLogger;
+    /** 当前 Step 的 outputs 白名单（写操作必须落在白名单内）。 */
+    allowedWrites: string[];
+    /** 当前 Step 的 id（仅用于审计）。 */
+    stepId: string;
+    /** 目标语言（决定依赖清单文件等）。默认 python。 */
+    language?: Language;
+    /** 当前 Step 的 write_file / append_file 单次 content 字节预算。 */
+    writeChunkBytes?: number;
+    /** Optional protocol/UI permission hook for sensitive tool operations. */
+    requestPermission?: ToolPermissionRequester;
+    /** Optional protocol/UI event hook for tool calls and file changes. */
+    onToolEvent?: ToolExecutionReporter;
+}
+/** 单次工具调用的结果统一结构。 */
+interface ToolResult<T = unknown> {
+    ok: boolean;
+    data?: T;
+    error?: string;
+    /** 用于摘要展示。 */
+    summary?: string;
+}
+interface Tool<A = unknown, R = unknown> {
+    readonly name: string;
+    readonly description: string;
+    /** 简要 JSON Schema 描述参数（仅用于 prompt，不强校验）。 */
+    readonly argsSchema: Record<string, unknown>;
+    run(args: A, ctx: ToolContext): Promise<ToolResult<R>>;
+}
+
+/**
+ * Skill：把一组原子工具组合为面向 LLM 的"高阶能力"。
+ *
+ * 在 M3 阶段 Skill 是一层"语义包装"——执行器仍然按 step.tools 中的工具名调用具体 Tool，
+ * 但 Step 可以声明 `tools: ["skill:patcher"]`，Skill Registry 会展开为底层工具集合，
+ * 并把 Skill 的 `prompt` 注入 system prompt，提示 LLM 该如何组合这些工具。
+ */
+interface Skill {
+    /** 形如 `patcher` / `tester` / `dep_resolver`。 */
+    readonly name: string;
+    /** 注入到 system prompt 的简短指引（中文一句话）。 */
+    readonly prompt: string;
+    /** 该 Skill 暴露给 LLM 的底层工具名集合。 */
+    readonly tools: string[];
+}
+
+interface EngineRunSummary {
+    totalSteps: number;
+    executedSteps: number;
+    failedStepId?: string;
+    failureLog?: string;
+    failureReason?: string;
+}
+interface StepAttemptOutcome {
+    ok: boolean;
+    failureLog: string;
+    reason?: string;
+}
+/**
+ * XCompiler 的公共生命周期 Hook。
+ *
+ * Context 对象会按顺序传给所有 handler；插件可以原位补充或调整字段，但不得替换
+ * workspace / audit 等核心服务。涉及文件写入时仍必须通过 Tool 与 EditGuard。
+ */
+interface HookContextMap {
+    'compile.start': {
+        workspace: string;
+        intent: PlanIntent;
+        topicMode: boolean;
+    };
+    'compile.afterClarify': {
+        rawRequirement: string;
+        questions: ClarifyQuestion[];
+        clarifications: PlannerInput['clarifications'];
+        userAddenda: string;
+    };
+    'compile.beforeDecompose': {
+        input: PlannerInput;
+    };
+    'compile.afterPlan': {
+        plan: Plan;
+    };
+    'compile.finish': {
+        plan: Plan;
+        planPath: string;
+    };
+    'run.before': {
+        plan: Plan;
+    };
+    'run.after': {
+        plan: Plan;
+        result: EngineRunSummary;
+    };
+    'run.error': {
+        plan: Plan;
+        error: unknown;
+    };
+    'step.before': {
+        plan: Plan;
+        step: Step;
+    };
+    'step.after': {
+        plan: Plan;
+        step: Step;
+        ok: boolean;
+    };
+    'step.error': {
+        plan: Plan;
+        step: Step;
+        error: unknown;
+    };
+    'step.attempt.before': {
+        plan: Plan;
+        step: Step;
+        role: Role;
+        debug: boolean;
+        retry: number;
+    };
+    'step.attempt.after': {
+        plan: Plan;
+        step: Step;
+        role: Role;
+        debug: boolean;
+        retry: number;
+        outcome: StepAttemptOutcome;
+    };
+    'tool.before': {
+        stepId: string;
+        tool: string;
+        args: unknown;
+        context: ToolContext;
+    };
+    'tool.after': {
+        stepId: string;
+        tool: string;
+        args: unknown;
+        context: ToolContext;
+        result: ToolResult;
+    };
+    'tool.error': {
+        stepId: string;
+        tool: string;
+        args: unknown;
+        context: ToolContext;
+        error: unknown;
+    };
+    'llm.before': {
+        role: string;
+        model: string;
+        messages: ChatMessage[];
+        options?: ChatOptions;
+    };
+    'llm.after': {
+        role: string;
+        model: string;
+        messages: ChatMessage[];
+        response: string;
+        durationMs: number;
+    };
+    'llm.error': {
+        role: string;
+        model: string;
+        messages: ChatMessage[];
+        error: unknown;
+        durationMs: number;
+    };
+}
+type HookName = keyof HookContextMap;
+type HookHandler<K extends HookName> = (context: HookContextMap[K]) => void | Promise<void>;
+interface HookRegistrationOptions {
+    /** 数值越大越先执行；相同优先级保持插件及注册顺序。 */
+    priority?: number;
+}
+interface PluginApi {
+    /** 当前 XCompiler 核心版本。 */
+    readonly xcompilerVersion: string;
+    /** 当前插件 API 主版本；仅同一主版本兼容。 */
+    readonly pluginApiVersion: number;
+    on<K extends HookName>(hook: K, handler: HookHandler<K>, options?: HookRegistrationOptions): () => void;
+    registerTool(tool: Tool): void;
+    registerSkill(skill: Skill): void;
+}
+/** 可序列化的插件清单；后续 registry / marketplace 不需要加载插件代码即可读取。 */
+interface XCompilerPluginManifest {
+    /** 全局唯一且稳定的插件 ID，例如 `company.policy-checker`。 */
+    id: string;
+    /** 插件自身版本，必须是完整 SemVer。 */
+    version: string;
+    /** 插件编译时面向的 XCompiler Plugin API 主版本。 */
+    apiVersion: number;
+    /** 插件可运行的最低 XCompiler 核心版本；必填完整 SemVer。 */
+    minXCompilerVersion: string;
+    /** 以下字段用于插件目录展示，不参与运行时兼容判定。 */
+    displayName?: string;
+    description?: string;
+    license?: string;
+    homepage?: string;
+    keywords?: string[];
+}
+type PluginCompatibilityCode = 'compatible' | 'invalid-runtime-version' | 'invalid-id' | 'invalid-plugin-version' | 'invalid-min-xcompiler-version' | 'api-version-mismatch' | 'xcompiler-version-too-old';
+interface PluginCompatibilityReport {
+    compatible: boolean;
+    code: PluginCompatibilityCode;
+    pluginId: string;
+    pluginVersion: string;
+    xcompilerVersion: string;
+    pluginApiVersion: number;
+    message?: string;
+}
+interface XCompilerPlugin {
+    manifest: XCompilerPluginManifest;
+    /** 默认 continue：记录错误但不拖垮核心流程。 */
+    failureMode?: 'continue' | 'fail';
+    setup(api: PluginApi): void | Promise<void>;
+}
+interface PluginHostOptions {
+    plugins?: XCompilerPlugin[];
+    /** 强制所有插件错误中断主流程，适合 CI / 合规插件。 */
+    strict?: boolean;
+    audit?: AuditLogger;
+    /** 嵌入式宿主可显式传入版本；一般应使用内置默认值。 */
+    xcompilerVersion?: string;
+    pluginApiVersion?: number;
+}
+interface PluginExtensionTarget {
+    tools: {
+        get(name: string): Tool | undefined;
+        register(tool: Tool): void;
+    };
+    skills: {
+        get(name: string): Skill | undefined;
+        register(skill: Skill): void;
+    };
+}
+
+type RuntimeLogLevel = 'success' | 'warning' | 'error' | 'info' | 'dim' | 'accent' | 'raw';
+
+interface RuntimeLogEvent {
+    type: 'log';
+    level: RuntimeLogLevel;
+    message: string;
+}
+interface RuntimeResultEvent {
+    type: 'result';
+    command: 'build' | 'run';
+    status: string;
+    data?: Record<string, unknown>;
+}
+interface RuntimeProgressEvent {
+    type: 'progress';
+    status: 'start' | 'succeed' | 'fail';
+    message: string;
+}
+interface RuntimeToolCallEvent {
+    type: 'tool_call';
+    status: ToolExecutionEvent['status'];
+    stepId: string;
+    tool: string;
+    target?: string;
+    ok?: boolean;
+    summary?: string;
+    error?: string;
+}
+interface RuntimeFileChangedEvent {
+    type: 'file_changed';
+    stepId: string;
+    tool: string;
+    path: string;
+}
+interface RuntimePatchProposedEvent {
+    type: 'patch_proposed';
+    stepId: string;
+    tool: string;
+    patch: string;
+}
+interface RuntimePermissionEvent {
+    type: 'permission';
+    status: 'requested' | 'approved' | 'denied';
+    request: ToolPermissionRequest;
+}
+type RuntimeEvent = RuntimeLogEvent | RuntimeProgressEvent | RuntimeResultEvent | RuntimeToolCallEvent | RuntimeFileChangedEvent | RuntimePatchProposedEvent | RuntimePermissionEvent;
+interface RuntimeProgress {
+    succeed(message: string): void | Promise<void>;
+    fail(message: string): void | Promise<void>;
+    stop?(): void | Promise<void>;
+}
+interface RuntimeSelectChoice<T extends string = string> {
+    name: string;
+    value: T;
+}
+interface RuntimeInteraction {
+    input(args: {
+        message: string;
+    }): Promise<string>;
+    confirm(args: {
+        message: string;
+        default?: boolean;
+    }): Promise<boolean>;
+    editor(args: {
+        message: string;
+        default?: string;
+        postfix?: string;
+    }): Promise<string>;
+    select<T extends string>(args: {
+        message: string;
+        choices: RuntimeSelectChoice<T>[];
+    }): Promise<T>;
+    readMultiline(args: {
+        message: string;
+    }): Promise<string>;
+    pauseStdin?(): void;
+}
+interface RuntimeIO {
+    emit(event: RuntimeEvent): void | Promise<void>;
+    progress(message: string, opts?: {
+        animate?: boolean;
+    }): RuntimeProgress;
+    interaction?: RuntimeInteraction;
+    requestPermission?: ToolPermissionRequester;
+}
+declare const silentRuntimeIO: RuntimeIO;
+
+interface CompileOptions {
+    workspace: string;
+    configPath?: string;
+    inputFile?: string;
+    /**
+     * 已澄清的 topic.md 直接输入：跳过 intake / clarify / Addenda / Gate 1，把该文件
+     * 内容当作冻结后的项目选题书，直接进入 decompose。常用于：
+     *   - 用户上次已澄清并保留了 topic.md，重新跑 decompose 不想再问一遍
+     *   - 离线编辑了 topic.md 想直接拿来出 plan.json
+     * 与 --input 互斥；同时给则 --topic 优先并打印警告。
+     */
+    topicFile?: string;
+    outputFile?: string;
+    intent?: PlanIntent;
+    baselinePlanFile?: string;
+    yes?: boolean;
+    force?: boolean;
+    /** Optional XXX.xc project file to create/update with config, plan, and progress. */
+    projectFilePath?: string;
+    /** Project-file history command label; defaults to build. */
+    projectCommand?: string;
+    /** 程序化插件入口；动态插件加载将在后续版本基于它实现。 */
+    plugins?: XCompilerPlugin[];
+    pluginStrict?: boolean;
+    /** Runtime event and interaction adapter. CLI supplies a terminal implementation; SDKs may stay silent. */
+    io?: RuntimeIO;
+}
+/** CLI 可映射为退出码、程序化调用方可捕获并安全收尾的编译终止。 */
+declare class CompileExitError extends Error {
+    readonly exitCode: number;
+    constructor(exitCode: number, message: string);
+}
+declare function runCompile(opts: CompileOptions): Promise<{
+    planPath?: string;
+}>;
+
+/**
+ * 每个 LLM provider 的运行时评分（默认 1.0）。
+ *
+ * 设计动机：
+ *  - 配置允许给一个角色挂多个 provider；运行时按评分降序选择当前"最可信"的。
+ *  - 评分会随成功/失败动态调整：失败 -0.5 直到 0（=禁用）；成功 +0.1 直到 cap=10。
+ *  - preflight 检测到 ollama 服务器上**模型不存在**会直接把评分置 0。
+ *  - 持久化到 config 同目录的 sidecar 文件 `llm_scores.yaml`，避免改写用户的 config.yaml
+ *    （会丢注释）。配置里 `llm.scores` 段作为 sidecar 缺失时的初值。
+ */
+declare class ScoreStore {
+    private readonly audit?;
+    static readonly DEFAULT = 1;
+    static readonly MIN = 0;
+    static readonly MAX = 10;
+    static readonly DECAY = 0.5;
+    static readonly BOOST = 0.1;
+    private readonly scores;
+    private dirty;
+    private writeQueue;
+    private readonly sidecarPath;
+    constructor(configPath: string, initial?: Record<string, number>, audit?: AuditLogger | undefined);
+    /** 异步加载 sidecar 文件；失败/不存在不抛错，使用 ctor 提供的初值。 */
+    load(): Promise<void>;
+    get(name: string): number;
+    /** 主动设置评分（如 preflight 把不存在的模型置 0）。 */
+    set(name: string, value: number, reason?: string): void;
+    decay(name: string, reason: string): void;
+    boost(name: string, reason: string): void;
+    /** 全量快照（用于测试与 audit 输出）。 */
+    snapshot(): Record<string, number>;
+    /** 等待待写入完成（CLI 退出前调用，确保评分已落盘）。 */
+    flush(): Promise<void>;
+    private scheduleSave;
+    private persist;
+}
+
+/** 插件注册、扩展能力合并与生命周期 Hook 调度中心。 */
+declare class PluginHost {
+    private readonly plugins;
+    private readonly strict;
+    private readonly xcompilerVersion;
+    private readonly pluginApiVersion;
+    private readonly hooks;
+    private readonly contributedTools;
+    private readonly contributedSkills;
+    private audit?;
+    private initialized;
+    private registrationOrder;
+    constructor(options?: PluginHostOptions);
+    get size(): number;
+    /** 返回只读清单快照，供诊断、插件目录和未来 registry 使用。 */
+    get manifests(): readonly XCompilerPluginManifest[];
+    setAudit(audit: AuditLogger): void;
+    initialize(): Promise<void>;
+    /** 把插件贡献的 Tool / Skill 合并到 Engine 的默认注册表；禁止静默覆盖核心能力。 */
+    applyExtensions(target: PluginExtensionTarget): void;
+    emit<K extends HookName>(hook: K, context: HookContextMap[K]): Promise<void>;
+    /** 在不绕过原 Tool / EditGuard 的前提下增加 before / after / error Hook。 */
+    wrapTool<A, R>(tool: Tool<A, R>): Tool<A, R>;
+    /** 包装完整 LLM 调用；response 可由 after Hook 做结构化后处理。 */
+    wrapLLM(client: LLMClient, role: string): LLMClient;
+    private createApi;
+    private handleFailure;
+}
+
+interface ProjectAuditCheck {
+    name: string;
+    severity: 'error' | 'warn' | 'info';
+    ok: boolean;
+    summary: string;
+    detail?: string;
+}
+interface ProjectAuditResult {
+    ok: boolean;
+    warnings: number;
+    errors: number;
+    checks: ProjectAuditCheck[];
+    scope?: 'project' | 'iteration';
+    iterationId?: string;
+}
+
+interface EngineResult {
+    totalSteps: number;
+    executedSteps: number;
+    failedStepId?: string;
+    /** 失败 Step 的最终详细日志（reason + tool calls + 健康度）。 */
+    failureLog?: string;
+    failureReason?: string;
+}
+
+interface ExecuteOptions {
+    planPath: string;
+    workspace: string;
+    configPath?: string;
+    dryRun?: boolean;
+    fromStepId?: string;
+    onlyPhase?: string;
+    resetStatus?: boolean;
+    force?: boolean;
+    /** Optional XXX.xc project file to keep in sync with execution progress. */
+    projectFilePath?: string;
+    /** Project-file history command label; defaults to run. */
+    projectCommand?: string;
+    /** Whether to append a history row when execution starts; defaults to true. */
+    recordProjectHistory?: boolean;
+    /** @deprecated Runtime never mutates the host process. CLI adapters translate ExecuteResult to exit codes. */
+    setProcessExitCode?: boolean;
+    /** 程序化插件入口；CLI 文件加载器后续基于该入口实现。 */
+    plugins?: XCompilerPlugin[];
+    pluginStrict?: boolean;
+    /** Runtime event and interaction adapter. CLI supplies terminal rendering; SDKs may stay silent. */
+    io?: RuntimeIO;
+    /** Allow human terminal progress from lower-level engines. Defaults to true for CLI compatibility. */
+    terminalOutput?: boolean;
+}
+interface ExecuteResult {
+    status: 'ok' | 'failed' | 'error' | 'dry-run';
+    engine?: EngineResult;
+    audit?: ProjectAuditResult;
+    message?: string;
+    exitCode?: number;
+}
+declare function runExecute(opts: ExecuteOptions): Promise<ExecuteResult>;
+
+interface WorkspaceOptions {
+    output?: string;
+    workspace?: string;
+    baseDir?: string;
+    name?: string;
+}
+declare function defaultProjectName(now?: Date): string;
+declare function resolveCompileWorkspace(opts: WorkspaceOptions): Promise<string>;
+declare function resolveEvolveWorkspace(opts: WorkspaceOptions, cwd?: string): Promise<string>;
+
+type RuntimeBuildCommandOptions = Omit<CompileOptions, 'workspace'> & WorkspaceOptions;
+interface RuntimeBuildCommandResult {
+    workspace: string;
+    planPath?: string;
+}
+declare function runBuildCommand(opts: RuntimeBuildCommandOptions): Promise<RuntimeBuildCommandResult>;
+type RuntimeEvolveCommandOptions = Omit<CompileOptions, 'workspace' | 'outputFile' | 'projectCommand'> & WorkspaceOptions & {
+    planOut?: string;
+    cwd?: string;
+};
+interface RuntimeEvolveCommandResult {
+    workspace: string;
+    planPath?: string;
+    execution?: ExecuteResult;
+}
+declare function runEvolveCommand(opts: RuntimeEvolveCommandOptions): Promise<RuntimeEvolveCommandResult>;
+type RuntimeRunCommandOptions = Omit<ExecuteOptions, 'planPath' | 'workspace' | 'projectCommand'> & {
+    planArg?: string;
+    output?: string;
+    workspace?: string;
+    cwd?: string;
+};
+declare function runRunCommand(opts: RuntimeRunCommandOptions): Promise<ExecuteResult>;
+type RuntimeLoadCommandOptions = Omit<ExecuteOptions, 'planPath' | 'workspace' | 'projectFilePath' | 'projectCommand'> & {
+    projectFile: string;
+};
+declare function runLoadCommand(opts: RuntimeLoadCommandOptions): Promise<ExecuteResult>;
+type RuntimeAppendCommandOptions = Omit<CompileOptions, 'workspace' | 'baselinePlanFile' | 'outputFile' | 'projectFilePath' | 'projectCommand'> & {
+    projectFile: string;
+    planOut?: string;
+};
+interface RuntimeAppendCommandResult {
+    workspace: string;
+    planPath?: string;
+    execution?: ExecuteResult;
+}
+declare function runAppendCommand(opts: RuntimeAppendCommandOptions): Promise<RuntimeAppendCommandResult>;
+
+interface BootstrapOptions {
+    repository?: string;
+    configPath?: string;
+    inputFile?: string;
+    topicFile?: string;
+    yes?: boolean;
+    force?: boolean;
+    promote?: boolean;
+    cleanup?: boolean;
+    worktree?: string;
+    /** Opt into the experimental Docker qualification runner. */
+    dockerQualification?: boolean;
+    io?: RuntimeIO;
+}
+interface BootstrapCheck {
+    name: string;
+    command: string;
+    required: boolean;
+    ok: boolean;
+    exitCode: number;
+    durationMs: number;
+    detail: string;
+}
+interface BootstrapWorkspace {
+    repository: string;
+    worktree: string;
+    branch: string;
+    baseCommit: string;
+    runId: string;
+}
+interface BootstrapResult extends BootstrapWorkspace {
+    status: 'cancelled' | 'compile-failed' | 'execution-failed' | 'qualification-failed' | 'qualified' | 'promoted';
+    candidateCommit?: string;
+    reportPath: string;
+    checks: BootstrapCheck[];
+    changedFiles: string[];
+}
+/**
+ * Generation-based self-bootstrap: the loaded XCompiler process (N) edits a linked worktree
+ * containing candidate N+1. The host checkout is never used as the execution workspace.
+ */
+declare function runBootstrap(opts: BootstrapOptions): Promise<BootstrapResult>;
+
+type CheckLevel = 'ok' | 'warn' | 'fail';
+interface CheckItem {
+    level: CheckLevel;
+    message: string;
+}
+interface CheckSection {
+    title: string;
+    items: CheckItem[];
+}
+interface DoctorReport {
+    sections: CheckSection[];
+    fails: number;
+    warns: number;
+}
+interface DoctorOptions {
+    configPath?: string;
+    /** Probe timeout for LLM endpoints (ms). Default 3000. */
+    probeTimeoutMs?: number;
+    /** Skip outbound network probes (used by tests). */
+    skipNetwork?: boolean;
+    /** Override score lookup (defaults to config.llm.scores). */
+    scoreStore?: ScoreStore;
+}
+/**
+ * Run the full environment check. Always returns a report — does not throw.
+ * Fatal config-load errors are recorded as a single fail item under [config].
+ */
+declare function runDoctor(opts?: DoctorOptions): Promise<DoctorReport>;
+
+interface RuntimeDoctorOptions extends DoctorOptions {
+    /** Exit non-zero on warnings as well as failures. */
+    strict?: boolean;
+}
+interface RuntimeDoctorResult {
+    report: DoctorReport;
+    exitCode: number;
+}
+declare function runDoctorCommand(opts?: RuntimeDoctorOptions): Promise<RuntimeDoctorResult>;
+
+interface LsOptions {
+    workspace: string;
+    /** Maximum depth for recursively finding plan.json files. Defaults to 4. */
+    maxDepth?: number;
+}
+interface PlanSummary {
+    total: number;
+    done: number;
+    failed: number;
+    pending: number;
+    running: number;
+    skipped: number;
+}
+interface LsPlanEntry {
+    path: string;
+    relativePath: string;
+    language?: string;
+    summary?: PlanSummary;
+    requirementDigestLine?: string;
+    error?: string;
+}
+interface LsResult {
+    root: string;
+    plans: LsPlanEntry[];
+}
+declare function runLsCommand(opts: LsOptions): Promise<LsResult>;
+interface ShowOptions {
+    workspace: string;
+    stepId: string;
+    planPath?: string;
+    /** Number of recent matching audit jsonl events. Defaults to 10. */
+    auditTail?: number;
+}
+interface ShowOutputStatus {
+    path: string;
+    exists: boolean;
+}
+interface AuditLine {
+    ts: string;
+    kind: string;
+    msg?: string;
+}
+interface ShowResult {
+    root: string;
+    planPath: string;
+    stepId: string;
+    step?: Step;
+    outputs: ShowOutputStatus[];
+    auditEvents: AuditLine[];
+    exitCode: number;
+}
+declare function runShowCommand(opts: ShowOptions): Promise<ShowResult>;
+declare function summarizePlan(plan: Plan): PlanSummary;
+declare function findPlans(root: string, maxDepth: number): Promise<string[]>;
+declare function readAuditFor(file: string, stepId: string, tail: number): Promise<AuditLine[]>;
+type InspectStep = Step;
+
+interface PluginRuntimeVersion {
+    xcompilerVersion?: string;
+    pluginApiVersion?: number;
+}
+/** 在加载插件代码前可独立调用的 manifest 兼容性检查。 */
+declare function checkPluginCompatibility(manifest: XCompilerPluginManifest, runtime?: PluginRuntimeVersion): PluginCompatibilityReport;
+
+/** 无 Commander 副作用的程序化运行入口，供宿主应用和插件加载器使用。 */
+
+interface XCompilerRuntimeOptions {
+    io?: RuntimeIO;
+}
+declare class XCompilerRuntime {
+    private readonly defaults;
+    constructor(defaults?: XCompilerRuntimeOptions);
+    build(opts: CompileOptions): ReturnType<typeof runCompile>;
+    run(opts: ExecuteOptions): ReturnType<typeof runExecute>;
+    buildCommand(opts: RuntimeBuildCommandOptions): ReturnType<typeof runBuildCommand>;
+    evolveCommand(opts: RuntimeEvolveCommandOptions): ReturnType<typeof runEvolveCommand>;
+    runCommand(opts: RuntimeRunCommandOptions): ReturnType<typeof runRunCommand>;
+    loadCommand(opts: RuntimeLoadCommandOptions): ReturnType<typeof runLoadCommand>;
+    appendCommand(opts: RuntimeAppendCommandOptions): ReturnType<typeof runAppendCommand>;
+    bootstrap(opts: BootstrapOptions): ReturnType<typeof runBootstrap>;
+    doctor(opts?: RuntimeDoctorOptions): ReturnType<typeof runDoctorCommand>;
+    ls(opts: LsOptions): ReturnType<typeof runLsCommand>;
+    show(opts: ShowOptions): ReturnType<typeof runShowCommand>;
+    private withDefaults;
+}
+
+export { type AuditLine, type BootstrapOptions, type BootstrapResult, type CheckLevel, CompileExitError, type CompileOptions, type DoctorOptions, type DoctorReport, type ExecuteOptions, type ExecuteResult, type InspectStep, type LsOptions, type LsPlanEntry, type LsResult, type PlanSummary, type PluginCompatibilityReport, PluginHost, type PluginHostOptions, type RuntimeAppendCommandOptions, type RuntimeAppendCommandResult, type RuntimeBuildCommandOptions, type RuntimeBuildCommandResult, type RuntimeDoctorOptions, type RuntimeDoctorResult, type RuntimeEvent, type RuntimeEvolveCommandOptions, type RuntimeEvolveCommandResult, type RuntimeFileChangedEvent, type RuntimeIO, type RuntimeInteraction, type RuntimeLoadCommandOptions, type RuntimeLogEvent, type RuntimeLogLevel, type RuntimePatchProposedEvent, type RuntimePermissionEvent, type RuntimeProgress, type RuntimeProgressEvent, type RuntimeResultEvent, type RuntimeRunCommandOptions, type RuntimeSelectChoice, type RuntimeToolCallEvent, type ShowOptions, type ShowOutputStatus, type ShowResult, type ToolExecutionEvent, type ToolExecutionReporter, type ToolPermissionDecision, type ToolPermissionOperation, type ToolPermissionRequest, type ToolPermissionRequester, type WorkspaceOptions, XCOMPILER_PLUGIN_API_VERSION, XCOMPILER_VERSION, type XCompilerPlugin, type XCompilerPluginManifest, XCompilerRuntime, type XCompilerRuntimeOptions, checkPluginCompatibility, defaultProjectName, findPlans, readAuditFor, resolveCompileWorkspace, resolveEvolveWorkspace, runAppendCommand, runBootstrap, runBuildCommand, runCompile, runDoctor, runDoctorCommand, runEvolveCommand, runExecute, runLoadCommand, runLsCommand, runRunCommand, runShowCommand, silentRuntimeIO, summarizePlan };