@kasenri/dsh-orbit 0.5.9 → 0.6.0

package/lib/moa-adapter.js

@@ -0,0 +1,434 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { createHash } from 'node:crypto';
+import { createRequire } from 'node:module';
+import { dirname, join, relative, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { copyFile, lstat, mkdir, readFile, readdir, realpath, stat, writeFile } from 'node:fs/promises';
+import { redactText, truncateSafe } from "./sanitize.js";
+const SUPPORTED_MOA_VERSION = '0.2.19';
+const MAX_CONTEXT_CHARS = 16_000;
+const MAX_CANDIDATE_TEXT = 12_000;
+const MAX_JUDGE_TEXT = 8_000;
+const MAX_PROMOTED_FILES = 64;
+const MAX_PROMOTED_FILE_BYTES = 2 * 1024 * 1024;
+const CODE_FENCE = String.fromCharCode(96, 96, 96);
+function sha256(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function priceFor(route, prices) {
+    if (!prices)
+        return undefined;
+    const provider = route.provider.trim().toLowerCase();
+    const model = route.model.trim().toLowerCase();
+    const row = prices[`${provider}/${model}`] ?? prices[model] ?? prices[`${provider}/*`] ?? prices['*'];
+    if (!row)
+        return undefined;
+    return { input: row.input, output: row.output, cacheHit: row.cacheHit ?? row.input };
+}
+function toMoaUsage(route, usage, prices) {
+    if (!usage)
+        return undefined;
+    const cacheRead = usage.cacheReadTokens ?? 0;
+    const cacheWrite = usage.cacheWriteTokens ?? 0;
+    const total = usage.totalTokens ?? usage.inputTokens + usage.outputTokens + cacheRead + cacheWrite;
+    const rates = priceFor(route, prices);
+    const cost = rates
+        ? ((usage.inputTokens + cacheWrite) / 1_000_000) * rates.input + (cacheRead / 1_000_000) * rates.cacheHit + (usage.outputTokens / 1_000_000) * rates.output
+        : undefined;
+    return {
+        input_tokens: usage.inputTokens,
+        output_tokens: usage.outputTokens,
+        total_tokens: total,
+        ...(cacheRead > 0 ? { cache_read_tokens: cacheRead } : {}),
+        ...(cacheWrite > 0 ? { cache_write_tokens: cacheWrite } : {}),
+        ...(cost === undefined ? {} : { cost_usd: Number(cost.toFixed(6)) }),
+    };
+}
+function combineUsage(first, second) {
+    if (!first)
+        return second;
+    if (!second)
+        return first;
+    const cost = (first.cost_usd ?? 0) + (second.cost_usd ?? 0);
+    const hasCost = first.cost_usd !== undefined || second.cost_usd !== undefined;
+    return {
+        input_tokens: first.input_tokens + second.input_tokens,
+        output_tokens: first.output_tokens + second.output_tokens,
+        total_tokens: first.total_tokens + second.total_tokens,
+        ...((first.cache_read_tokens ?? 0) + (second.cache_read_tokens ?? 0) > 0 ? { cache_read_tokens: (first.cache_read_tokens ?? 0) + (second.cache_read_tokens ?? 0) } : {}),
+        ...((first.cache_write_tokens ?? 0) + (second.cache_write_tokens ?? 0) > 0 ? { cache_write_tokens: (first.cache_write_tokens ?? 0) + (second.cache_write_tokens ?? 0) } : {}),
+        ...(hasCost ? { cost_usd: Number(cost.toFixed(6)) } : {}),
+    };
+}
+function safeSegment(value) {
+    return value.replace(/[^A-Za-z0-9_.-]/gu, '_').slice(0, 120);
+}
+function stepRoot(workspace, runId, stepId) {
+    return join(workspace, '.cx', 'moa', safeSegment(runId), safeSegment(stepId));
+}
+function candidateDir(workspace, runId, stepId, index) {
+    return join(stepRoot(workspace, runId, stepId), 'candidate-' + index);
+}
+function candidateMetaPath(workspace, runId, stepId, index) {
+    return join(stepRoot(workspace, runId, stepId), 'candidate-' + index + '.json');
+}
+function judgePath(workspace, runId, stepId) {
+    return join(stepRoot(workspace, runId, stepId), 'decision.json');
+}
+function sanitizeRelativePath(value) {
+    const trimmed = value.trim().replace(/\\/gu, '/').replace(/^\/+/, '');
+    if (trimmed === '')
+        return undefined;
+    const first = trimmed.split('/')[0]?.toLowerCase();
+    if (first === '.cx' || first === '.git' || first === '.moa')
+        return undefined;
+    const normalized = trimmed.split('/').filter((part) => part !== '' && part !== '.').join('/');
+    if (normalized.split('/').some((part) => part === '..'))
+        return undefined;
+    return normalized;
+}
+function extractFileBlocks(text) {
+    const files = [];
+    const seen = new Set();
+    const fenced = /\x60{3}[\w-]*\s+(?:file|path|filepath)=["']?([^\s"'\n\r]+)["']?[\r\n]+([\s\S]*?)\x60{3}/giu;
+    for (const match of text.matchAll(fenced)) {
+        const path = sanitizeRelativePath(match[1] ?? '');
+        if (!path || seen.has(path))
+            continue;
+        seen.add(path);
+        files.push({ path, content: match[2] ?? '' });
+    }
+    const headed = /(?:###?\s*File:\s*|File:\s*)["']?([A-Za-z0-9_.\-/\\]+)["']?\s*[\r\n]+\x60{3}[\w-]*[\r\n]+([\s\S]*?)\x60{3}/giu;
+    for (const match of text.matchAll(headed)) {
+        const path = sanitizeRelativePath(match[1] ?? '');
+        if (!path || seen.has(path))
+            continue;
+        seen.add(path);
+        files.push({ path, content: match[2] ?? '' });
+    }
+    return files;
+}
+async function assertNoSymlinkTraversal(root, relativePath) {
+    let current = root;
+    for (const part of relativePath.split('/')) {
+        current = join(current, part);
+        try {
+            const info = await lstat(current);
+            if (info.isSymbolicLink())
+                throw new Error('ORBIT_MOA_PROMOTION_SYMLINK: ' + relativePath);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return;
+            throw error;
+        }
+    }
+}
+async function writeCandidateFiles(root, files) {
+    const paths = [];
+    for (const file of files.slice(0, MAX_PROMOTED_FILES)) {
+        if (Buffer.byteLength(file.content, 'utf8') > MAX_PROMOTED_FILE_BYTES)
+            continue;
+        const target = resolve(root, file.path);
+        if (relative(root, target).startsWith('..'))
+            continue;
+        await mkdir(dirname(target), { recursive: true, mode: 0o700 });
+        await writeFile(target, file.content, { encoding: 'utf8', mode: 0o600 });
+        paths.push(file.path);
+    }
+    return paths;
+}
+function modelPrompt(step, context, index, total) {
+    return [
+        '你是 Orbit 的 MoA 独立候选模型。',
+        '你正在处理候选 ' + index + '/' + total + '。请独立解决当前步骤，不要假设其他候选会补救你的方案。',
+        '你没有工具调用权限，也不能声称已经实际修改或测试项目。',
+        '如果方案需要修改文件，请输出完整文件内容，并使用严格格式：' + CODE_FENCE + '语言 file="相对路径"' + '。不要写入 .cx。',
+        '优先给出可以直接应用、最小且完整的实现；说明关键取舍与预期验证方式。',
+        '自然语言默认使用简体中文；代码、命令、路径、provider/model ID 保持原样。',
+        '当前步骤：' + step.goal,
+        context ? '当前项目上下文（只读）：\n' + context : '当前项目上下文：无可读文本文件。',
+    ].join('\n');
+}
+function critiquePrompt(step, own, others) {
+    return [
+        '你是 Orbit 的 MoA 候选模型，现在进入一次有界的同伴互评修订。',
+        '请保留自己方案中正确的部分，吸收其他候选的优点，修复明确缺陷，然后重新输出完整候选。',
+        '不要把多个方案简单拼接；最终仍必须是一份可独立应用的完整方案。',
+        '如果修改文件，继续使用带 file="相对路径" 的完整文件代码块格式。',
+        '当前步骤：' + step.goal,
+        '你上一轮的方案：\n' + truncateSafe(own, 6_000),
+        '其他候选摘要：\n' + truncateSafe(others, 8_000),
+    ].join('\n');
+}
+function judgePrompt(step, candidates, texts) {
+    const body = candidates
+        .filter((candidate) => candidate.ok)
+        .map((candidate) => [
+        '候选 ' + candidate.index + '（' + candidate.provider + '/' + candidate.model + '）',
+        '文件：' + (candidate.files.join(', ') || '无'),
+        truncateSafe(texts[candidate.index - 1] ?? candidate.summary, 4_000),
+    ].join('\n'))
+        .join('\n\n---\n\n');
+    return [
+        '你是 Orbit 的 MoA Judge。',
+        '你的职责只有相对比较：从现有成功候选中选择最适合当前步骤的一份。不要生成新的综合代码，不要决定 Orbit Step 是否通过。',
+        '必须考虑正确性、最小改动、可验证性、回归风险和用户原始步骤目标。',
+        '最终必须单独输出机器标记：WINNER_CANDIDATE_INDEX: <数字>。',
+        '自然语言默认使用简体中文。',
+        '当前步骤：' + step.goal,
+        body,
+    ].join('\n\n');
+}
+function winnerIndex(text, allowed) {
+    const match = text.match(/WINNER_CANDIDATE_INDEX\s*:\s*(\d+)/iu);
+    if (!match)
+        return undefined;
+    const index = Number(match[1]);
+    return allowed.has(index) ? index : undefined;
+}
+async function readJson(path) {
+    try {
+        return JSON.parse(await readFile(path, 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+export class OrbitMoaAdapter {
+    host;
+    modulePromise;
+    constructor(host) {
+        this.host = host;
+    }
+    async load() {
+        if (this.modulePromise)
+            return this.modulePromise;
+        this.modulePromise = (async () => {
+            const require = createRequire(import.meta.url);
+            let packageJsonPath;
+            try {
+                packageJsonPath = require.resolve('@goodandready/dsh-moa/package.json');
+            }
+            catch {
+                throw new Error('ORBIT_MOA_UNAVAILABLE: 未安装 @goodandready/dsh-moa。');
+            }
+            const pkg = JSON.parse(await readFile(packageJsonPath, 'utf8'));
+            const version = String(pkg.version ?? '');
+            if (version !== SUPPORTED_MOA_VERSION) {
+                throw new Error('ORBIT_MOA_VERSION_UNSUPPORTED: 当前支持 ' + SUPPORTED_MOA_VERSION + '，检测到 ' + (version || 'unknown') + '。');
+            }
+            const entry = require.resolve('@goodandready/dsh-moa');
+            const api = await import(__rewriteRelativeImportExtension(pathToFileURL(entry).href));
+            if (typeof api.collectProjectContext !== 'function' || typeof api.formatProjectContext !== 'function') {
+                throw new Error('ORBIT_MOA_API_UNAVAILABLE: dsh-moa 缺少项目上下文接口。');
+            }
+            return { version, api };
+        })();
+        return this.modulePromise;
+    }
+    async availability() {
+        if (!this.host.runModel)
+            return { available: false, reason: 'ORBIT_MOA_MODEL_RUNNER_UNAVAILABLE' };
+        try {
+            const loaded = await this.load();
+            return { available: true, version: loaded.version };
+        }
+        catch (error) {
+            return { available: false, reason: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    async call(route, label, prompt, signal) {
+        if (!this.host.runModel)
+            throw new Error('ORBIT_MOA_MODEL_RUNNER_UNAVAILABLE');
+        const request = { label, prompt, route, ...(signal ? { signal } : {}) };
+        const result = await this.host.runModel(request);
+        if (result.interrupted)
+            throw new Error(result.reason ?? 'ORBIT_MOA_MODEL_INTERRUPTED');
+        return { text: result.output, ...(result.usage ? { usage: result.usage } : {}) };
+    }
+    async fanout(input) {
+        const loaded = await this.load();
+        const collected = await loaded.api.collectProjectContext(input.workspace, MAX_CONTEXT_CHARS);
+        const context = loaded.api.formatProjectContext(collected.files ?? [], {
+            skippedFiles: collected.skippedFiles ?? 0,
+            skippedList: collected.skippedList ?? [],
+        });
+        const count = input.policy.candidate_count;
+        await mkdir(stepRoot(input.workspace, input.runId, input.step.id), { recursive: true, mode: 0o700 });
+        const texts = new Array(count).fill('');
+        const firstPass = await Promise.all(input.policy.candidates.slice(0, count).map(async (route, offset) => {
+            const index = offset + 1;
+            const metaPath = candidateMetaPath(input.workspace, input.runId, input.step.id, index);
+            const routeHash = sha256(JSON.stringify(route));
+            const cached = await readJson(metaPath);
+            if (cached?.route_hash === routeHash && typeof cached.text === 'string') {
+                texts[offset] = cached.text;
+                return cached;
+            }
+            try {
+                const call = await this.call(route, 'moa-candidate-' + input.step.id + '-' + index, modelPrompt(input.step, context, index, count), input.signal);
+                const text = call.text;
+                texts[offset] = text;
+                const written = await writeCandidateFiles(candidateDir(input.workspace, input.runId, input.step.id, index), extractFileBlocks(text));
+                const result = {
+                    index,
+                    provider: route.provider,
+                    model: route.model,
+                    ok: true,
+                    summary: redactText(truncateSafe(text, 2_000)),
+                    files: written,
+                    ...(toMoaUsage(route, call.usage, input.policy.prices) ? { usage: toMoaUsage(route, call.usage, input.policy.prices) } : {}),
+                    text: truncateSafe(text, MAX_CANDIDATE_TEXT),
+                    route_hash: routeHash,
+                };
+                await writeFile(metaPath, JSON.stringify(result, null, 2), { encoding: 'utf8', mode: 0o600 });
+                return result;
+            }
+            catch (error) {
+                const message = redactText(truncateSafe(error instanceof Error ? error.message : String(error), 500));
+                const result = {
+                    index,
+                    provider: route.provider,
+                    model: route.model,
+                    ok: false,
+                    summary: message,
+                    files: [],
+                    error: message,
+                    route_hash: routeHash,
+                };
+                await writeFile(metaPath, JSON.stringify(result, null, 2), { encoding: 'utf8', mode: 0o600 });
+                return result;
+            }
+        }));
+        if (input.policy.peer_critique) {
+            await Promise.all(firstPass.map(async (candidate, offset) => {
+                if (!candidate.ok)
+                    return;
+                const route = input.policy.candidates[offset];
+                const others = firstPass.filter((other) => other.ok && other.index !== candidate.index).map((other) => '候选 ' + other.index + ': ' + other.summary).join('\n\n');
+                try {
+                    const revisedCall = await this.call(route, 'moa-critique-' + input.step.id + '-' + candidate.index, critiquePrompt(input.step, texts[offset] ?? candidate.summary, others), input.signal);
+                    const revised = revisedCall.text;
+                    texts[offset] = revised;
+                    candidate.summary = redactText(truncateSafe(revised, 2_000));
+                    candidate.files = await writeCandidateFiles(candidateDir(input.workspace, input.runId, input.step.id, candidate.index), extractFileBlocks(revised));
+                    candidate.usage = combineUsage(candidate.usage, toMoaUsage(route, revisedCall.usage, input.policy.prices));
+                    await writeFile(candidateMetaPath(input.workspace, input.runId, input.step.id, candidate.index), JSON.stringify({
+                        ...candidate,
+                        text: truncateSafe(revised, MAX_CANDIDATE_TEXT),
+                        route_hash: sha256(JSON.stringify(route)),
+                        peer_critique: true,
+                    }, null, 2), { encoding: 'utf8', mode: 0o600 });
+                }
+                catch (error) {
+                    candidate.ok = false;
+                    candidate.error = redactText(truncateSafe(error instanceof Error ? error.message : String(error), 500));
+                }
+            }));
+        }
+        const candidates = firstPass.map((candidate) => {
+            const copy = { ...candidate };
+            delete copy.text;
+            delete copy.route_hash;
+            return copy;
+        });
+        const successful = candidates.filter((candidate) => candidate.ok).length;
+        return { adapterVersion: loaded.version, candidates, successful, failed: candidates.length - successful };
+    }
+    async judge(input) {
+        const cached = await readJson(judgePath(input.workspace, input.runId, input.step.id));
+        if (cached?.winningCandidate && cached.summary)
+            return cached;
+        const successful = input.candidates.filter((candidate) => candidate.ok);
+        if (successful.length < 2)
+            throw new Error('ORBIT_MOA_QUORUM_FAILED: 至少需要 2 个成功候选。');
+        const texts = [];
+        for (const candidate of input.candidates) {
+            const meta = await readJson(candidateMetaPath(input.workspace, input.runId, input.step.id, candidate.index));
+            texts[candidate.index - 1] = meta?.text ?? candidate.summary;
+        }
+        const judgeCall = await this.call(input.policy.judge, 'moa-judge-' + input.step.id, judgePrompt(input.step, input.candidates, texts), input.signal);
+        const output = judgeCall.text;
+        const allowed = new Set(successful.map((candidate) => candidate.index));
+        const selected = winnerIndex(output, allowed);
+        if (selected === undefined)
+            throw new Error('ORBIT_MOA_JUDGE_INVALID: Judge 未返回有效 WINNER_CANDIDATE_INDEX。');
+        const winner = input.candidates[selected - 1];
+        if (!winner)
+            throw new Error('ORBIT_MOA_JUDGE_INVALID: winner 不存在。');
+        const result = {
+            winningCandidate: selected,
+            winnerModel: winner.provider + '/' + winner.model,
+            summary: redactText(truncateSafe(output, MAX_JUDGE_TEXT)),
+            ...(toMoaUsage(input.policy.judge, judgeCall.usage, input.policy.prices) ? { usage: toMoaUsage(input.policy.judge, judgeCall.usage, input.policy.prices) } : {}),
+        };
+        await writeFile(judgePath(input.workspace, input.runId, input.step.id), JSON.stringify(result, null, 2), { encoding: 'utf8', mode: 0o600 });
+        return result;
+    }
+    async promote(input) {
+        const sourceRoot = candidateDir(input.workspace, input.runId, input.stepId, input.winningCandidate);
+        const workspaceRoot = await realpath(input.workspace).catch(() => resolve(input.workspace));
+        const receiptPath = join(stepRoot(input.workspace, input.runId, input.stepId), 'promotion.json');
+        const cached = await readJson(receiptPath);
+        if (cached && Array.isArray(cached.files)) {
+            if (cached.files.length === 0)
+                return cached;
+            const matches = await Promise.all(cached.files.map(async (entry) => {
+                try {
+                    return sha256(await readFile(join(workspaceRoot, entry.path))) === entry.promoted_sha256;
+                }
+                catch {
+                    return false;
+                }
+            }));
+            if (matches.every(Boolean))
+                return cached;
+        }
+        const files = [];
+        const walk = async (dir) => {
+            for (const entry of await readdir(dir, { withFileTypes: true })) {
+                const absolute = join(dir, entry.name);
+                if (entry.isDirectory())
+                    await walk(absolute);
+                else if (entry.isFile())
+                    files.push(relative(sourceRoot, absolute).replace(/\\/gu, '/'));
+            }
+        };
+        await walk(sourceRoot);
+        if (files.length > MAX_PROMOTED_FILES)
+            throw new Error('ORBIT_MOA_PROMOTION_TOO_LARGE: 文件数量超过安全上限。');
+        const receipt = { files: [], promoted_at: new Date().toISOString() };
+        if (files.length === 0) {
+            await writeFile(receiptPath, JSON.stringify(receipt, null, 2), { encoding: 'utf8', mode: 0o600 });
+            return receipt;
+        }
+        for (const rel of files.sort()) {
+            const safe = sanitizeRelativePath(rel);
+            if (!safe)
+                throw new Error('ORBIT_MOA_PROMOTION_PATH_INVALID: ' + rel);
+            const source = resolve(sourceRoot, safe);
+            const info = await stat(source);
+            if (!info.isFile() || info.size > MAX_PROMOTED_FILE_BYTES)
+                throw new Error('ORBIT_MOA_PROMOTION_FILE_INVALID: ' + safe);
+            const destination = resolve(workspaceRoot, safe);
+            if (relative(workspaceRoot, destination).startsWith('..'))
+                throw new Error('ORBIT_MOA_PROMOTION_PATH_INVALID: ' + safe);
+            await assertNoSymlinkTraversal(workspaceRoot, safe);
+            await mkdir(dirname(destination), { recursive: true });
+            const candidateBytes = await readFile(source);
+            await copyFile(source, destination);
+            const promotedBytes = await readFile(destination);
+            receipt.files.push({ path: safe, candidate_sha256: sha256(candidateBytes), promoted_sha256: sha256(promotedBytes) });
+        }
+        await writeFile(receiptPath, JSON.stringify(receipt, null, 2), { encoding: 'utf8', mode: 0o600 });
+        return receipt;
+    }
+}

package/lib/routes.js

@@ -1,4 +1,5 @@
 /** Effective route resolution for a new Orbit run. */
+import { DEFAULT_MAX_MOA_STEPS, DEFAULT_MOA_CANDIDATES } from "./types.js";
 export function projectionRegistryOf(ctx) {
     const reflect = ctx?.reflect;
     const registry = reflect?.get('sessionProjections');
@@ -56,6 +57,33 @@ export function routeFromSelection(selection) {
         ...(typeof effort === 'string' && effort.trim() !== '' ? { reasoningEffort: effort.trim() } : {}),
     };
 }
+/** Resolve the optional MoA policy for a NEW run. No model is guessed or inherited. */
+export function resolveMoaPolicy(input) {
+    const enabled = input.settings?.enabled ?? input.config?.enabled ?? false;
+    if (!enabled)
+        return undefined;
+    const candidateCount = input.settings?.candidateCount ?? input.config?.candidateCount ?? DEFAULT_MOA_CANDIDATES;
+    const peerCritique = input.settings?.peerCritique ?? input.config?.peerCritique ?? false;
+    const maxMoaSteps = input.settings?.maxMoaSteps ?? input.config?.maxMoaSteps ?? DEFAULT_MAX_MOA_STEPS;
+    const rawCandidates = input.settings?.candidates?.length ? input.settings.candidates : input.config?.candidates ?? [];
+    const candidates = rawCandidates.map((route) => routeFromSelection(route)).filter((route) => route !== undefined);
+    const judge = routeFromSelection(input.settings?.judge) ?? routeFromSelection(input.config?.judge);
+    if (!Number.isSafeInteger(candidateCount) || candidateCount < 2 || candidateCount > 4) {
+        throw new Error('ORBIT_MOA_CANDIDATE_COUNT_INVALID: 候选数量必须为 2-4。');
+    }
+    if (candidates.length < candidateCount || judge === undefined) {
+        throw new Error('ORBIT_MOA_MODEL_CONFIGURATION_REQUIRED: 请为所有 MoA 候选和 Judge 选择模型。');
+    }
+    return {
+        enabled: true,
+        candidate_count: candidateCount,
+        peer_critique: peerCritique,
+        max_moa_steps: maxMoaSteps,
+        candidates: candidates.slice(0, candidateCount),
+        judge,
+        ...(input.prices && Object.keys(input.prices).length > 0 ? { prices: structuredClone(input.prices) } : {}),
+    };
+}
 const ROLE_LABELS = {
     commander: 'Commander',
     executor: 'Executor',

package/lib/service.js

@@ -1,22 +1,37 @@
 import { accessSync, constants, existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { Service } from '@deepseek-ai/cordis';
+import { SessionId } from '@deepseek-ai/dsh-session';
 import { DshOrbitHost } from "./dsh-host.js";
+import { OrbitMoaAdapter } from "./moa-adapter.js";
 import { OrbitStateStore } from "./state-store.js";
 import { OrbitSupervisor } from "./supervisor.js";
+import { orbitRuntimeFromState } from "./session-state.js";
 export class OrbitService extends Service {
+    root;
     host;
     config;
     executions = new Map();
     constructor(ctx, config) {
         super(ctx, 'orbit');
+        this.root = ctx;
         this.host = new DshOrbitHost(ctx);
         this.config = config;
     }
+    publishRuntime(state) {
+        const owner = state.owner_session_id;
+        if (!owner)
+            return;
+        const session = this.root.sessions.get(SessionId(owner));
+        if (!session)
+            return;
+        session.append('orbit/runtime', orbitRuntimeFromState(state));
+    }
     supervisorFor(projectDir) {
-        return new OrbitSupervisor(new OrbitStateStore(projectDir), this.host, {
+        return new OrbitSupervisor(new OrbitStateStore(projectDir, (state) => this.publishRuntime(state)), this.host, {
             defaultRoutes: this.config.routes,
             ...(this.config.resolveRoutes ? { resolveRoutes: this.config.resolveRoutes } : {}),
+            ...(this.config.resolveMoaPolicy ? { resolveMoaPolicy: this.config.resolveMoaPolicy } : {}),
             ...(this.config.resolveOwnerSessionId ? { resolveOwnerSessionId: this.config.resolveOwnerSessionId } : {}),
             browserTools: this.config.browserTools,
             commanderReadOnlyTools: this.config.commanderReadOnlyTools,
@@ -148,10 +163,26 @@ export class OrbitService extends Service {
         });
         const reflect = this.ctx.reflect;
         checks.push({ name: 'model-registry', status: reflect.get('llm') ? 'pass' : 'fail', detail: '使用 DSH 当前 LLM registry 校验模型，不内置角色模型。' });
-        checks.push({ name: 'orbit-settings', status: reflect.get('settings') ? 'pass' : 'warn', detail: 'Commander / Watchdog 使用用户 Orbit 设置或显式 profile routes。' });
+        checks.push({ name: 'orbit-settings', status: reflect.get('settings') ? 'pass' : 'warn', detail: 'Commander / Watchdog / MoA 使用用户 Orbit 设置或显式 profile routes。' });
+        try {
+            const policy = this.config.resolveMoaPolicy?.();
+            const availability = await new OrbitMoaAdapter(this.host).availability();
+            checks.push({
+                name: 'moa-integration',
+                status: policy && !availability.available ? 'warn' : 'pass',
+                detail: availability.available
+                    ? `@goodandready/dsh-moa ${availability.version ?? ''} 可用；Orbit 使用隔离候选、Judge 选优和受控 Promotion。`
+                    : policy
+                        ? availability.reason ?? 'MoA 不可用'
+                        : 'MoA 未启用；Orbit 单 Executor 模式不受影响。',
+            });
+        }
+        catch (error) {
+            checks.push({ name: 'moa-integration', status: 'warn', detail: String(error) });
+        }
         try {
             const routes = this.config.resolveRoutes?.();
-            const issues = routes ? await this.host.validateRoutes(routes) : ['未配置模型解析来源'];
+            const issues = routes ? await this.host.validateRoutes({ ...routes }) : ['未配置模型解析来源'];
             checks.push({ name: 'role-model-configuration', status: issues.length ? 'warn' : 'pass', detail: issues.join('；') || '三角色用户模型配置可用。' });
         }
         catch (error) {