@kasenri/dsh-orbit 0.5.10 → 0.6.1

package/lib/session-state.js

@@ -15,6 +15,8 @@
 export const ORBIT_TOGGLE_COMMAND = 'orbit-toggle';
 /** The projection key carrying the per-Session enable state. */
 export const ORBIT_SESSION_KEY = 'orbitSession';
+/** Projection key carrying a bounded live/durable Orbit execution snapshot. */
+export const ORBIT_RUNTIME_KEY = 'orbitRuntime';
 /**
  * Parse one `/orbit-toggle` argument; `undefined` when it names neither state,
  * so a malformed toggle never flips the switch as a side effect.
@@ -58,7 +60,144 @@ function orbitSessionSchema() {
         },
     };
 }
-/** Register the per-Session enable projection on the session projection registry. */
+function finiteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function usageFrom(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const record = value;
+    const input = finiteNumber(record['input_tokens']);
+    const output = finiteNumber(record['output_tokens']);
+    const total = finiteNumber(record['total_tokens']);
+    if (input === undefined || output === undefined || total === undefined)
+        return undefined;
+    const cacheRead = finiteNumber(record['cache_read_tokens']);
+    const cacheWrite = finiteNumber(record['cache_write_tokens']);
+    const cost = finiteNumber(record['cost_usd']);
+    return {
+        input_tokens: input,
+        output_tokens: output,
+        total_tokens: total,
+        ...(cacheRead === undefined ? {} : { cache_read_tokens: cacheRead }),
+        ...(cacheWrite === undefined ? {} : { cache_write_tokens: cacheWrite }),
+        ...(cost === undefined ? {} : { cost_usd: cost }),
+    };
+}
+function orbitRuntimeSchema() {
+    return {
+        parse(value) {
+            if (value === null)
+                return null;
+            if (typeof value !== 'object' || Array.isArray(value))
+                throw new Error('orbitRuntime projection value must be an object or null');
+            const record = value;
+            const runId = typeof record['runId'] === 'string' ? record['runId'] : undefined;
+            const phase = typeof record['phase'] === 'string' ? record['phase'] : undefined;
+            const status = typeof record['status'] === 'string' ? record['status'] : undefined;
+            const updatedAt = typeof record['updatedAt'] === 'string' ? record['updatedAt'] : undefined;
+            const loopRaw = record['loop'];
+            const used = finiteNumber(loopRaw?.['used']);
+            const max = finiteNumber(loopRaw?.['max']);
+            if (!runId || !phase || !status || !updatedAt || used === undefined || max === undefined) {
+                throw new Error('orbitRuntime projection value is incomplete');
+            }
+            const allowedPhases = new Set(['PLAN', 'EXECUTE', 'EVALUATE', 'SUCCESS', 'NEEDS_USER', 'BUDGET_EXHAUSTED', 'STOPPED']);
+            const allowedStatuses = new Set(['running', 'success', 'stopped', 'needs_user', 'budget_exhausted']);
+            if (!allowedPhases.has(phase) || !allowedStatuses.has(status))
+                throw new Error('orbitRuntime projection value has invalid phase/status');
+            const currentRaw = record['currentStep'];
+            const currentId = typeof currentRaw?.['id'] === 'string' ? currentRaw['id'] : undefined;
+            const currentAttempt = finiteNumber(currentRaw?.['attempt']);
+            const currentMode = currentRaw?.['executionMode'] === 'MOA' ? 'MOA' : currentRaw?.['executionMode'] === 'SINGLE' ? 'SINGLE' : undefined;
+            const moaRaw = record['moa'];
+            let moa;
+            if (moaRaw) {
+                const moaPhase = typeof moaRaw['phase'] === 'string' ? moaRaw['phase'] : undefined;
+                const allowedMoa = new Set(['FANOUT', 'JUDGE', 'SELECTED', 'PROMOTING', 'PROMOTED', 'FAILED']);
+                if (!moaPhase || !allowedMoa.has(moaPhase))
+                    throw new Error('orbitRuntime MoA phase is invalid');
+                const candidatesRaw = Array.isArray(moaRaw['candidates']) ? moaRaw['candidates'] : [];
+                const candidates = candidatesRaw.flatMap((entry) => {
+                    if (entry === null || typeof entry !== 'object' || Array.isArray(entry))
+                        return [];
+                    const item = entry;
+                    const index = finiteNumber(item['index']);
+                    const provider = typeof item['provider'] === 'string' ? item['provider'] : undefined;
+                    const model = typeof item['model'] === 'string' ? item['model'] : undefined;
+                    const files = finiteNumber(item['files']);
+                    if (index === undefined || !provider || !model || typeof item['ok'] !== 'boolean' || files === undefined)
+                        return [];
+                    return [{ index, provider, model, ok: item['ok'], files, ...(usageFrom(item['usage']) ? { usage: usageFrom(item['usage']) } : {}) }];
+                });
+                moa = {
+                    phase: moaPhase,
+                    candidates,
+                    ...(typeof moaRaw['judgeModel'] === 'string' ? { judgeModel: moaRaw['judgeModel'] } : {}),
+                    ...(finiteNumber(moaRaw['winningCandidate']) === undefined ? {} : { winningCandidate: finiteNumber(moaRaw['winningCandidate']) }),
+                    ...(typeof moaRaw['winnerModel'] === 'string' ? { winnerModel: moaRaw['winnerModel'] } : {}),
+                    ...(usageFrom(moaRaw['totalUsage']) ? { totalUsage: usageFrom(moaRaw['totalUsage']) } : {}),
+                };
+            }
+            return {
+                runId,
+                phase: phase,
+                status: status,
+                loop: { used, max },
+                ...(currentId && currentAttempt !== undefined && currentMode ? { currentStep: { id: currentId, attempt: currentAttempt, executionMode: currentMode } } : {}),
+                ...(moa ? { moa } : {}),
+                updatedAt,
+            };
+        },
+    };
+}
+/** Build the bounded runtime view persisted into the owning Session. */
+export function orbitRuntimeFromState(state) {
+    const step = state.current_step === undefined ? undefined : state.plan.steps.find((candidate) => candidate.id === state.current_step?.id);
+    const moa = state.moa_step;
+    return {
+        runId: state.run_id,
+        phase: state.phase,
+        status: state.status,
+        loop: { used: state.loop.used, max: state.loop.max },
+        ...(state.current_step && step ? {
+            currentStep: {
+                id: state.current_step.id,
+                attempt: state.current_step.attempt,
+                executionMode: step.execution_mode === 'MOA' ? 'MOA' : 'SINGLE',
+            },
+        } : {}),
+        ...(moa ? {
+            moa: {
+                phase: moa.phase,
+                candidates: moa.candidates.slice(0, 4).map((candidate) => ({
+                    index: candidate.index,
+                    provider: candidate.provider,
+                    model: candidate.model,
+                    ok: candidate.ok,
+                    files: candidate.files.length,
+                    ...(candidate.usage ? { usage: candidate.usage } : {}),
+                })),
+                ...(state.moa_policy?.judge ? { judgeModel: `${state.moa_policy.judge.provider}/${state.moa_policy.judge.model}` } : {}),
+                ...(moa.winning_candidate === undefined ? {} : { winningCandidate: moa.winning_candidate }),
+                ...(moa.winner_model ? { winnerModel: moa.winner_model } : {}),
+                ...(moa.total_usage ? { totalUsage: moa.total_usage } : {}),
+            },
+        } : {}),
+        updatedAt: state.updated_at,
+    };
+}
+export function foldOrbitRuntime(state, event) {
+    if (event.type !== 'orbit/runtime')
+        return state;
+    try {
+        return orbitRuntimeSchema().parse(event.data);
+    }
+    catch {
+        return state;
+    }
+}
+/** Register the per-Session enable and runtime projections on the session projection registry. */
 export function installOrbitSessionProjection(ctx) {
     ctx.sessionProjections.register({
         key: ORBIT_SESSION_KEY,
@@ -71,6 +210,17 @@ export function installOrbitSessionProjection(ctx) {
         },
         stateVersion: 1,
     });
+    ctx.sessionProjections.register({
+        key: ORBIT_RUNTIME_KEY,
+        stateSchema: orbitRuntimeSchema(),
+        init: () => null,
+        apply: (state, event) => foldOrbitRuntime(state, event),
+        wire: {
+            viewSchema: orbitRuntimeSchema(),
+            view: (state) => state,
+        },
+        stateVersion: 1,
+    });
 }
 /** Whether the Session currently defaults ordinary messages into Orbit. */
 export function orbitEnabledOf(ctx, session) {

package/lib/state-store.js

@@ -23,8 +23,10 @@ function nowIso() {
 export class OrbitStateStore {
     stateDir;
     lockDepth = 0;
-    constructor(projectDir) {
+    onWrite;
+    constructor(projectDir, onWrite) {
         this.stateDir = join(projectDir, '.cx');
+        this.onWrite = onWrite;
     }
     get statePath() {
         return join(this.stateDir, 'state.json');
@@ -88,20 +90,25 @@ export class OrbitStateStore {
         return raw;
     }
     writeState(state) {
-        return this.transact(() => {
+        const next = this.transact(() => {
             const current = this.readRawState();
             const revision = Number(current?.['state_revision'] ?? 0) + 1;
-            const next = {
+            const updated = {
                 ...state,
                 schema_version: ORBIT_SCHEMA_VERSION,
                 state_revision: revision,
                 driver_ownership: driverOwnershipFor(state.phase, state.status),
                 updated_at: nowIso(),
             };
-            Object.assign(state, next);
-            this.writeJson(this.statePath, next);
-            return next;
+            Object.assign(state, updated);
+            this.writeJson(this.statePath, updated);
+            return updated;
         });
+        try {
+            this.onWrite?.(next);
+        }
+        catch { /* UI projection must never veto durable state. */ }
+        return next;
     }
     writeJson(filePath, value) {
         mkdirSync(dirname(filePath), { recursive: true, mode: 0o700 });

package/lib/supervisor.js

@@ -2,15 +2,17 @@ import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { buildEvidenceBundle, buildStepResult, formatStepResults, formatEvidenceBundle } from "./evidence.js";
 import { assertCommanderDecision, assertStrategyDecision, assertTimeoutDecision, assertWatchdogDecision, assertGuardWatchdogDecision, COMMANDER_FINAL_EVALUATE_SCHEMA, COMMANDER_PLAN_SCHEMA, COMMANDER_STEP_EVALUATE_SCHEMA, COMMANDER_STRATEGY_SCHEMA, WATCHDOG_GUARD_SCHEMA, WATCHDOG_RUNTIME_SCHEMA, WATCHDOG_STRATEGY_SCHEMA, WATCHDOG_TIMEOUT_SCHEMA, } from "./decisions.js";
-import { applyCommanderNeedsUser, applyCorrectionStep, applyExecutorCapabilityUnavailable, applyExecutorInterrupted, applyExecutorResume, applyExecutorSuccess, applyFinalAppend, applyFinalSuccess, applyPlan, applyStepPass, baseStepIdOf, beginStep, clearExecutorChild, clearGuardRecovery, correctionBlockCode, correctionDepthOf, createInitialState, enterBudgetExhausted, enterNeedsUser, ensureAutomaticLoopBudgetForPlan, markStrategyChallengeUsed, normalizePlan, openWatchdogAttempt, recordGuardRecovery, recordPlanFailure, recordWatchdogDecision, restoreEvaluationState, resumeFromNeedsUser, stopRun, upsertStepResult, normalizeCapabilities, } from "./kernel.js";
+import { OrbitMoaAdapter } from "./moa-adapter.js";
+import { applyCommanderNeedsUser, applyCorrectionStep, applyExecutorCapabilityUnavailable, applyExecutorInterrupted, applyExecutorResume, applyExecutorSuccess, applyFinalAppend, applyFinalSuccess, applyPlan, applyStepPass, baseStepIdOf, beginStep, clearExecutorChild, clearGuardRecovery, correctionBlockCode, correctionDepthOf, createInitialState, enterBudgetExhausted, enterNeedsUser, ensureAutomaticLoopBudgetForPlan, markStrategyChallengeUsed, normalizePlan, assertMoaPlanWithinPolicy, normalizeExecutionMode, openWatchdogAttempt, recordGuardRecovery, recordPlanFailure, recordWatchdogDecision, restoreEvaluationState, resumeFromNeedsUser, stopRun, upsertStepResult, normalizeCapabilities, } from "./kernel.js";
 import { truncateSafe } from "./sanitize.js";
 import { OrbitStateStore } from "./state-store.js";
 import { executorToolsFor, EXECUTOR_READ_ONLY_TOOLS, READ_ONLY_ROLE_TOOLS } from "./capabilities.js";
 import { COMMANDER_EXTENSION_MS, COMMANDER_HARD_CEILING_MS, COMMANDER_SOFT_DEADLINE_MS, DEFAULT_CAPABILITIES, EXECUTOR_TIMEOUT_MS, GUARD_ESCALATION_THRESHOLD, GUARD_FIRST_INSTRUCTION, GUARD_NEEDS_USER_INSTRUCTION, GUARD_RECOVERY_CAP, GUARD_REPEAT_INSTRUCTION, GUARD_RETRY_INSTRUCTION, MAX_EXECUTOR_INTERRUPT_RETRIES, MAX_WATCHDOG_CALLS_PER_STEP, WATCHDOG_TIMEOUT_MS, } from "./types.js";
 import { resolveEffectiveRoutes } from "./routes.js";
-const COMMANDER_PLAN_PROMPT = (goal, constraints, userReply) => `你是 Orbit 指挥官（Commander），当前阶段：PLAN。
- 请为下述目标制定最小化的 1-5 个逻辑工程步骤。
+const COMMANDER_PLAN_PROMPT = (goal, constraints, userReply, moaPolicy) => `你是 Orbit 指挥官（Commander），当前阶段：PLAN。
+请为下述目标制定最小化的 1-5 个逻辑工程步骤。
 规则：基础读取不声明 capabilities；修改文件使用 "filesystem"，执行命令使用 "shell"，访问网页/API 使用 "web"，驱动真实浏览器使用 "browser"。只选择当前步骤真正需要的能力，可组合，保持最小化。
+execution_mode 只能是 SINGLE 或 MOA。普通、确定性步骤使用 SINGLE；只有存在明显多解、高不确定性且独立候选比较能提高质量时才使用 MOA。${moaPolicy ? `当前 Run 已启用 MoA，最多 ${moaPolicy.max_moa_steps} 个 MOA 步骤，候选数固定为 ${moaPolicy.candidate_count}。` : '当前 Run 未启用 MoA，所有步骤必须使用 SINGLE。'}
 请通过结构化结果协议提交最终计划。
 你的自然语言输出、推理说明和总结默认全部使用简体中文；decision 枚举、capability id、代码、命令、路径、provider/model ID 等机器标识保持原样。
 目标：${goal}
@@ -23,6 +25,7 @@ const COMMANDER_STEP_PROMPT = (goal, step, evidence, state) => `你是 Orbit 指
 你的自然语言输出、推理说明和总结默认全部使用简体中文；decision 枚举、代码、命令、路径、provider/model ID 等机器标识保持原样。
 原始目标：${goal}
 当前步骤 ${step.id}：${step.goal}
+执行模式：${normalizeExecutionMode(step.execution_mode)}
 迭代计数：loop ${state.loop.used}/${state.loop.max}${userReplyLine(state)}
 执行员证据：
 ${evidence}`;
@@ -34,7 +37,7 @@ const COMMANDER_FINAL_PROMPT = (goal, plan, evidence, state) => `你是 Orbit
 你的自然语言输出、推理说明和总结默认全部使用简体中文；decision 枚举、代码、命令、路径、provider/model ID 等机器标识保持原样。
 原始目标：${goal}
 计划摘要：${plan.summary}
-步骤：${plan.steps.map((step) => `${step.id}:${step.goal}[${step.status}]`).join('; ')}
+步骤：${plan.steps.map((step) => `${step.id}:${step.goal}[${step.status}/${normalizeExecutionMode(step.execution_mode)}]`).join('; ')}
 Loop：${state.loop.used}/${state.loop.max}${userReplyLine(state)}
 执行员证据：
 ${evidence}`;
@@ -42,6 +45,21 @@ ${evidence}`;
  * The durable user reply line for role prompts. The reply is the user's answer
  * to a NEEDS_USER question and never replaces the original goal.
  */
+function sumMoaUsage(items) {
+    const present = items.filter((item) => item !== undefined);
+    if (present.length === 0)
+        return undefined;
+    const costItems = present.filter((item) => item.cost_usd !== undefined);
+    const completeCost = costItems.length === present.length;
+    return {
+        input_tokens: present.reduce((sum, item) => sum + item.input_tokens, 0),
+        output_tokens: present.reduce((sum, item) => sum + item.output_tokens, 0),
+        total_tokens: present.reduce((sum, item) => sum + item.total_tokens, 0),
+        ...(present.some((item) => item.cache_read_tokens !== undefined) ? { cache_read_tokens: present.reduce((sum, item) => sum + (item.cache_read_tokens ?? 0), 0) } : {}),
+        ...(present.some((item) => item.cache_write_tokens !== undefined) ? { cache_write_tokens: present.reduce((sum, item) => sum + (item.cache_write_tokens ?? 0), 0) } : {}),
+        ...(completeCost ? { cost_usd: Number(costItems.reduce((sum, item) => sum + (item.cost_usd ?? 0), 0).toFixed(6)) } : {}),
+    };
+}
 function userReplyLine(state) {
     return state.pending_user_reply ? `\n用户回复（对上一个问题的回答）：${state.pending_user_reply}` : '';
 }
@@ -87,24 +105,28 @@ export class OrbitSupervisor {
     store;
     host;
     config;
+    moa;
     /** Evidence for the step that just settled; never persisted into state.json. */
     stepEvidence;
     constructor(store, host, config) {
         this.store = store;
         this.host = host;
         this.config = config;
+        this.moa = config.moaAdapter ?? new OrbitMoaAdapter(host);
     }
     now() {
         return this.host.now();
     }
     createState(input) {
         const ownerSessionId = this.config.resolveOwnerSessionId?.();
+        const moaPolicy = this.config.resolveMoaPolicy?.();
         return createInitialState({
             runId: typeof input.run_id === 'string' && input.run_id.length > 0 ? input.run_id : randomUUID(),
             now: this.now(),
             goal: (input.goal ?? '').trim(),
             ...(input.preset !== undefined ? { preset: input.preset } : {}),
             routes: this.resolveNewRoutes(),
+            ...(moaPolicy ? { moaPolicy } : {}),
             ...(input.approved_loop_count !== undefined ? { approvedLoopCount: input.approved_loop_count } : {}),
             ...(input.max_loops !== undefined ? { maxLoops: input.max_loops } : {}),
             ...(input.user_hard_constraints ? { userHardConstraints: input.user_hard_constraints } : {}),
@@ -117,9 +139,22 @@ export class OrbitSupervisor {
             return this.config.resolveRoutes();
         return resolveEffectiveRoutes({ configRoutes: this.config.defaultRoutes });
     }
-    async preflightRoutes(routes, signal) {
+    async preflightRoutes(state, signal) {
+        const routes = { ...state.routes };
+        const policy = state.moa_policy;
+        if (policy) {
+            policy.candidates.forEach((route, index) => { routes['moa_candidate_' + (index + 1)] = route; });
+            routes.moa_judge = policy.judge;
+        }
         const issues = await this.host.validateRoutes(routes, signal);
-        return issues.length === 0 ? undefined : `ORBIT_ROLE_MODEL_UNAVAILABLE: ${issues.join('；')}。请重新选择可用模型。`;
+        if (issues.length > 0)
+            return `ORBIT_ROLE_MODEL_UNAVAILABLE: ${issues.join('；')}。请重新选择可用模型。`;
+        if (policy) {
+            const availability = await this.moa.availability();
+            if (!availability.available)
+                return availability.reason ?? 'ORBIT_MOA_UNAVAILABLE';
+        }
+        return undefined;
     }
     async bootstrap(input, signal) {
         if (signal?.aborted)
@@ -132,7 +167,7 @@ export class OrbitSupervisor {
         const requestedGoal = (input.goal ?? '').trim();
         let state = this.store.readState();
         const raw = this.store.readRawState();
-        const legacy = raw !== null && raw['schema_version'] !== 2;
+        const legacy = raw !== null && Number(raw['schema_version'] ?? 0) < 2;
         if (legacy && requestedGoal) {
             let created;
             try {
@@ -141,7 +176,7 @@ export class OrbitSupervisor {
             catch (error) {
                 return { ok: false, action: 'run', message: error instanceof Error ? error.message : String(error) };
             }
-            const invalid = await this.preflightRoutes(created.routes, signal);
+            const invalid = await this.preflightRoutes(created, signal);
             if (invalid)
                 return { ok: false, action: 'run', message: invalid };
             state = this.store.writeState(created);
@@ -156,7 +191,7 @@ export class OrbitSupervisor {
             catch (error) {
                 return { ok: false, action: 'run', message: error instanceof Error ? error.message : String(error) };
             }
-            const invalid = await this.preflightRoutes(created.routes, signal);
+            const invalid = await this.preflightRoutes(created, signal);
             if (invalid)
                 return { ok: false, action: 'run', message: invalid };
             state = this.store.writeState(created);
@@ -172,7 +207,7 @@ export class OrbitSupervisor {
             catch (error) {
                 return { ok: false, action: 'run', message: error instanceof Error ? error.message : String(error) };
             }
-            const invalid = await this.preflightRoutes(created.routes, signal);
+            const invalid = await this.preflightRoutes(created, signal);
             if (invalid)
                 return { ok: false, action: 'run', message: invalid };
             state = this.store.writeState(created);
@@ -237,7 +272,7 @@ export class OrbitSupervisor {
         if (state.phase === 'BUDGET_EXHAUSTED')
             return this.result(state, true);
         if (preflight) {
-            const routeIssue = await this.preflightRoutes(state.routes, signal);
+            const routeIssue = await this.preflightRoutes(state, signal);
             if (routeIssue)
                 return this.result(state, false, routeIssue);
         }
@@ -294,7 +329,7 @@ export class OrbitSupervisor {
     }
     // ── commander supervised path ──────────────────────────────────────────────
     async makePlan(state, signal) {
-        const outcome = await this.runCommander(state, 'PLAN', COMMANDER_PLAN_PROMPT(state.goal, state.user_hard_constraints, userReplyLine(state)), COMMANDER_PLAN_SCHEMA, signal);
+        const outcome = await this.runCommander(state, 'PLAN', COMMANDER_PLAN_PROMPT(state.goal, state.user_hard_constraints, userReplyLine(state), state.moa_policy), COMMANDER_PLAN_SCHEMA, signal);
         if (outcome.kind === 'needs_user')
             return this.setNeedsUser(state, outcome.reason);
         if (outcome.kind === 'interrupted') {
@@ -304,6 +339,7 @@ export class OrbitSupervisor {
         }
         try {
             const plan = normalizePlan(outcome.structured);
+            assertMoaPlanWithinPolicy(plan, state.moa_policy);
             applyPlan(state, plan);
             ensureAutomaticLoopBudgetForPlan(state);
             this.store.writeState(state);
@@ -435,6 +471,106 @@ export class OrbitSupervisor {
     }
     // ── executor runtime ───────────────────────────────────────────────────────
     async executeStep(state, step, signal) {
+        if (normalizeExecutionMode(step.execution_mode) === 'MOA') {
+            const prepared = await this.prepareMoaStep(state, step, signal);
+            if (!prepared.ready)
+                return { done: prepared.done, ok: false, ...(prepared.message ? { message: prepared.message } : {}) };
+            return this.executeExecutorStep(state, step, signal, true);
+        }
+        return this.executeExecutorStep(state, step, signal, false);
+    }
+    async prepareMoaStep(state, step, signal) {
+        const policy = state.moa_policy;
+        if (!policy) {
+            enterNeedsUser(state, 'ORBIT_MOA_UNAVAILABLE: 当前 Run 没有冻结的 MoA 配置。');
+            this.store.writeState(state);
+            return { ready: false, done: true, message: state.last_error ?? undefined };
+        }
+        const availability = await this.moa.availability();
+        if (!availability.available) {
+            enterNeedsUser(state, availability.reason ?? 'ORBIT_MOA_UNAVAILABLE');
+            this.store.writeState(state);
+            return { ready: false, done: true, message: state.last_error ?? undefined };
+        }
+        const workspace = join(this.store.stateDir, '..');
+        if (state.moa_step?.step_id !== step.id) {
+            state.moa_step = {
+                step_id: step.id,
+                phase: 'FANOUT',
+                ...(availability.version ? { adapter_version: availability.version } : {}),
+                candidates: [],
+                successful_candidates: 0,
+                failed_candidates: 0,
+            };
+            this.store.writeState(state);
+        }
+        try {
+            if (state.moa_step.phase === 'FANOUT') {
+                const fanout = await this.moa.fanout({ workspace, runId: state.run_id, step, policy, ...(signal ? { signal } : {}) });
+                state.moa_step = {
+                    ...state.moa_step,
+                    phase: fanout.successful >= 2 ? 'JUDGE' : 'FAILED',
+                    adapter_version: fanout.adapterVersion,
+                    candidates: fanout.candidates,
+                    successful_candidates: fanout.successful,
+                    failed_candidates: fanout.failed,
+                    ...(sumMoaUsage(fanout.candidates.map((candidate) => candidate.usage)) ? { total_usage: sumMoaUsage(fanout.candidates.map((candidate) => candidate.usage)) } : {}),
+                    ...(fanout.successful >= 2 ? {} : { last_error: 'ORBIT_MOA_QUORUM_FAILED: 至少需要 2 个成功候选。' }),
+                };
+                this.store.writeState(state);
+            }
+            if (state.moa_step.phase === 'FAILED') {
+                applyExecutorSuccess(state, {
+                    summary: state.moa_step.last_error ?? 'ORBIT_MOA_FAILED',
+                    changedFiles: this.host.changedFiles(workspace),
+                    testSummary: [state.moa_step.last_error ?? 'ORBIT_MOA_FAILED'],
+                });
+                upsertStepResult(state, buildStepResult(step.id, state.current_step?.attempt ?? 1, buildEvidenceBundle({ executorOutput: state.moa_step.last_error ?? 'ORBIT_MOA_FAILED' }), state.test_summary));
+                this.store.writeState(state);
+                return { ready: false, done: false };
+            }
+            if (state.moa_step.phase === 'JUDGE') {
+                const judged = await this.moa.judge({ workspace, runId: state.run_id, step, policy, candidates: state.moa_step.candidates, ...(signal ? { signal } : {}) });
+                state.moa_step = {
+                    ...state.moa_step,
+                    phase: 'SELECTED',
+                    winning_candidate: judged.winningCandidate,
+                    winner_model: judged.winnerModel,
+                    judge_summary: judged.summary,
+                    ...(judged.usage ? { judge_usage: judged.usage } : {}),
+                    ...(sumMoaUsage([...state.moa_step.candidates.map((candidate) => candidate.usage), judged.usage]) ? { total_usage: sumMoaUsage([...state.moa_step.candidates.map((candidate) => candidate.usage), judged.usage]) } : {}),
+                };
+                this.store.writeState(state);
+            }
+            if (state.moa_step.phase === 'SELECTED') {
+                state.moa_step.phase = 'PROMOTING';
+                this.store.writeState(state);
+            }
+            if (state.moa_step.phase === 'PROMOTING') {
+                const winner = state.moa_step.winning_candidate;
+                if (!winner)
+                    throw new Error('ORBIT_MOA_WINNER_MISSING');
+                const receipt = await this.moa.promote({ workspace, runId: state.run_id, stepId: step.id, winningCandidate: winner });
+                state.moa_step = { ...state.moa_step, phase: 'PROMOTED', promotion_receipt: receipt };
+                this.store.writeState(state);
+            }
+            return { ready: state.moa_step.phase === 'PROMOTED', done: false };
+        }
+        catch (error) {
+            const reason = truncateSafe(error instanceof Error ? error.message : String(error), 500);
+            if (state.moa_step)
+                state.moa_step = { ...state.moa_step, phase: 'FAILED', last_error: reason };
+            applyExecutorSuccess(state, {
+                summary: reason,
+                changedFiles: this.host.changedFiles(workspace),
+                testSummary: [reason],
+            });
+            upsertStepResult(state, buildStepResult(step.id, state.current_step?.attempt ?? 1, buildEvidenceBundle({ executorOutput: reason }), state.test_summary));
+            this.store.writeState(state);
+            return { ready: false, done: false, message: reason };
+        }
+    }
+    async executeExecutorStep(state, step, signal, moaVerification) {
         const capabilities = normalizeCapabilities(step.capabilities) ?? [];
         if (capabilities.includes('browser') && !this.config.browserTools.some((tool) => this.host.hasTool(tool))) {
             applyExecutorCapabilityUnavailable(state, step.id);
@@ -459,7 +595,7 @@ export class OrbitSupervisor {
             handle = await this.host.startRole({
                 role: 'executor',
                 label: `executor-${step.id}`,
-                prompt: this.executorPrompt(state, step),
+                prompt: this.executorPrompt(state, step, moaVerification),
                 route: state.routes.executor,
                 workspace: join(this.store.stateDir, '..'),
                 toolFilter,
@@ -513,9 +649,12 @@ export class OrbitSupervisor {
             }
             return { done: false, ok: false };
         }
+        const moaPrefix = moaVerification && state.moa_step
+            ? `MoA Judge 选择：${state.moa_step.winner_model ?? 'unknown'}（候选 ${state.moa_step.winning_candidate ?? '?'}）。\nJudge：${state.moa_step.judge_summary ?? ''}\n`
+            : '';
         applyExecutorSuccess(state, {
             ...(result.childId ? { childId: result.childId } : {}),
-            summary: truncateSafe(result.output, 2000),
+            summary: truncateSafe(moaPrefix + result.output, 2000),
             changedFiles: result.changedFiles ?? this.host.changedFiles(join(this.store.stateDir, '..')),
             testSummary: result.testSummary ?? [],
         });
@@ -523,7 +662,7 @@ export class OrbitSupervisor {
             stepId: step.id,
             bundle: buildEvidenceBundle({
                 settlement: result.settlement,
-                executorOutput: result.output,
+                executorOutput: moaPrefix + result.output,
                 changedFiles: state.changed_files,
                 tools: result.toolEvidence,
                 telemetry: result.telemetry,
@@ -550,7 +689,7 @@ export class OrbitSupervisor {
             ...(telemetry ? { telemetry } : {}),
         };
     }
-    executorPrompt(state, step) {
+    executorPrompt(state, step, moaVerification = false) {
         const lines = [
             '你是 Orbit 执行员（Executor）。',
             '你只负责执行当前步骤：不要重新规划整个任务，也不要自行改变当前步骤的目标。',
@@ -558,6 +697,12 @@ export class OrbitSupervisor {
             '完成后用简体中文提交简洁的执行证据：做了什么、运行了哪些命令/测试、验证结果以及仍存在的风险。',
             '你的自然语言输出、执行说明和总结默认全部使用简体中文；代码、命令、路径、provider/model ID 等机器标识保持原样。',
             `当前步骤 ${step.id}：${step.goal}`,
+            ...(moaVerification ? [
+                '该步骤已由 MoA 生成多个候选并由 Judge 选出胜者，Supervisor 已确定性地把胜出文件提升到项目目录。',
+                '你的职责是对已应用结果做真实验证：检查 diff、运行必要测试，并只在验证发现明确小问题时做最小修正。不要重新运行 MoA，也不要自行选择另一个候选。',
+                `MoA 胜出：${state.moa_step?.winner_model ?? 'unknown'} / candidate-${state.moa_step?.winning_candidate ?? '?'}`,
+                `胜出候选摘要：${state.moa_step?.candidates.find((candidate) => candidate.index === state.moa_step?.winning_candidate)?.summary ?? '无'}`,
+            ] : []),
             `工作目录：${join(this.store.stateDir, '..')}`,
             `硬性约束：${state.user_hard_constraints.join('；') || '无'}`,
         ];
@@ -638,9 +783,19 @@ export class OrbitSupervisor {
             if (reconsider.kind === 'replace')
                 nextGoal = reconsider.replacementGoal;
         }
+        const correctionMode = decision.next_step_execution_mode === undefined
+            ? normalizeExecutionMode(step.execution_mode)
+            : normalizeExecutionMode(decision.next_step_execution_mode);
+        if (correctionMode === 'MOA') {
+            const currentMoa = state.plan.steps.filter((candidate) => normalizeExecutionMode(candidate.execution_mode) === 'MOA').length;
+            if (state.moa_policy === undefined || currentMoa >= state.moa_policy.max_moa_steps) {
+                return this.setNeedsUser(state, 'ORBIT_MOA_STEP_BUDGET_EXCEEDED');
+            }
+        }
         applyCorrectionStep(state, step, {
             nextGoal,
             capabilities: decision.next_step_capabilities,
+            executionMode: correctionMode,
         });
         this.store.writeState(state);
         return undefined;
@@ -892,6 +1047,8 @@ export class OrbitSupervisor {
             last_error: state.last_error,
             pending_user_reply: state.pending_user_reply,
             step_results: state.step_results,
+            moa_policy: state.moa_policy,
+            moa_step: state.moa_step,
             changed_files: state.changed_files,
             test_summary: state.test_summary,
             driver_ownership: state.driver_ownership,

package/lib/types.js

@@ -1,5 +1,5 @@
 /** Durable Orbit state and decision vocabulary. */
-export const ORBIT_SCHEMA_VERSION = 2;
+export const ORBIT_SCHEMA_VERSION = 3;
 export const COMMANDER_SOFT_DEADLINE_MS = 6 * 60_000;
 export const COMMANDER_EXTENSION_MS = 4 * 60_000;
 export const COMMANDER_HARD_CEILING_MS = 14 * 60_000;
@@ -12,6 +12,10 @@ export const MAX_WATCHDOG_CALLS_PER_STEP = 2;
 export const MAX_EXECUTOR_INTERRUPT_RETRIES = 2;
 export const MAX_PLAN_STEPS = 5;
 export const MIN_PLAN_STEPS = 1;
+export const MIN_MOA_CANDIDATES = 2;
+export const MAX_MOA_CANDIDATES = 4;
+export const DEFAULT_MOA_CANDIDATES = 3;
+export const DEFAULT_MAX_MOA_STEPS = 2;
 export const DEFAULT_LOOP_BUDGET = 5;
 /** Automatic runs reserve two bounded execution slots beyond the accepted base plan. */
 export const AUTOMATIC_LOOP_RECOVERY_RESERVE = 2;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kasenri/dsh-orbit",
-  "version": "0.5.10",
+  "version": "0.6.1",
   "type": "module",
   "description": "让 AI 项目可以在无人监管下持续推进。Orbit 会自动规划任务、分工执行、逐步检查并继续完成后续工作；不同环节可以使用不同模型，让低成本模型承担执行任务、强模型负责规划和审核，从而降低整体 AI 使用成本。Watchdog 还会监控运行异常，在任务卡死或中断时协助恢复。",
   "license": "MIT",
@@ -61,7 +61,8 @@
     "@deepseek-ai/dsh-commands": "^0.1.5-rc.2",
     "@deepseek-ai/dsh-llm": "^0.1.5-rc.2",
     "@deepseek-ai/dsh-subagent": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-tools": "^0.1.5-rc.2"
+    "@deepseek-ai/dsh-tools": "^0.1.5-rc.2",
+    "@goodandready/dsh-moa": ">=0.2.19"
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/dsh-commands": {
@@ -69,6 +70,9 @@
     },
     "@deepseek-ai/dsh-llm": {
       "optional": true
+    },
+    "@goodandready/dsh-moa": {
+      "optional": true
     }
   }
 }