@kasenri/dsh-orbit 0.5.9 → 0.6.0

package/lib/decisions.js

@@ -26,6 +26,7 @@ export const COMMANDER_PLAN_SCHEMA = {
                     id: { type: 'string', description: '稳定标识，例如 P0。' },
                     goal: { type: 'string' },
                     capabilities: { type: 'array', items: { type: 'string', enum: CAPABILITY_ENUM } },
+                    execution_mode: { type: 'string', enum: ['SINGLE', 'MOA'] },
                 },
             },
         },
@@ -40,6 +41,7 @@ export const COMMANDER_STEP_EVALUATE_SCHEMA = {
         reason: { type: 'string' },
         next_step_goal: { type: 'string' },
         next_step_capabilities: { type: 'array', items: { type: 'string', enum: CAPABILITY_ENUM } },
+        next_step_execution_mode: { type: 'string', enum: ['SINGLE', 'MOA'] },
     },
 };
 export const COMMANDER_FINAL_EVALUATE_SCHEMA = {
@@ -51,6 +53,7 @@ export const COMMANDER_FINAL_EVALUATE_SCHEMA = {
         summary: { type: 'string' },
         next_step_goal: { type: 'string' },
         next_step_capabilities: { type: 'array', items: { type: 'string', enum: CAPABILITY_ENUM } },
+        next_step_execution_mode: { type: 'string', enum: ['SINGLE', 'MOA'] },
         next_steps: {
             type: 'array',
             items: {
@@ -63,6 +66,7 @@ export const COMMANDER_FINAL_EVALUATE_SCHEMA = {
                         properties: {
                             goal: { type: 'string' },
                             capabilities: { type: 'array', items: { type: 'string', enum: CAPABILITY_ENUM } },
+                            execution_mode: { type: 'string', enum: ['SINGLE', 'MOA'] },
                         },
                     },
                 ],

package/lib/dsh-host.js

@@ -60,6 +60,28 @@ export class DshOrbitHost {
         }
         return this.startOneShot(parent, request, prompt, agentOptions);
     }
+    async runModel(request) {
+        const handle = await this.startRole({
+            role: 'commander',
+            label: request.label,
+            prompt: request.prompt,
+            route: request.route,
+            toolFilter: { allow: [] },
+            ...(request.signal ? { signal: request.signal } : {}),
+        });
+        try {
+            const result = await handle.result;
+            return {
+                output: result.visibleOutput ?? result.output,
+                interrupted: result.interrupted,
+                ...(result.reason ? { reason: result.reason } : {}),
+                ...(result.tokenUsage ? { usage: result.tokenUsage } : {}),
+            };
+        }
+        finally {
+            await this.releaseRole(handle);
+        }
+    }
     parent() {
         const initiator = this.ctx.agents.currentInitiator();
         if (initiator)
@@ -89,6 +111,7 @@ export class DshOrbitHost {
             ...(value.stopReason !== 'completed' ? { reason: value.stopReason } : {}),
             ...(value.diagnostic ? { testSummary: [value.diagnostic] } : {}),
             ...(value.structured !== undefined ? { structured: value.structured } : {}),
+            ...(this.readTokenUsage(run.localAgent) ? { tokenUsage: this.readTokenUsage(run.localAgent) } : {}),
         }))
             .catch((error) => ({
             childId: run.id,
@@ -262,6 +285,25 @@ export class DshOrbitHost {
         const events = agent.session?.snapshotEvents?.() ?? [];
         return events.filter((event) => event.type === 'turn/start').length > previousTurns;
     }
+    readTokenUsage(agent) {
+        const events = agent?.session?.snapshotEvents?.() ?? agent?.session?.ownEvents?.() ?? [];
+        for (let index = events.length - 1; index >= 0; index -= 1) {
+            const event = events[index];
+            if (!event || event.type !== 'assistant/message')
+                continue;
+            const usage = event.data?.usage;
+            if (typeof usage?.inputTokens !== 'number' || typeof usage.outputTokens !== 'number')
+                continue;
+            return {
+                inputTokens: usage.inputTokens,
+                outputTokens: usage.outputTokens,
+                ...(typeof usage.totalTokens === 'number' ? { totalTokens: usage.totalTokens } : {}),
+                ...(typeof usage.cacheReadTokens === 'number' ? { cacheReadTokens: usage.cacheReadTokens } : {}),
+                ...(typeof usage.cacheWriteTokens === 'number' ? { cacheWriteTokens: usage.cacheWriteTokens } : {}),
+            };
+        }
+        return undefined;
+    }
     readFinalOutput(agent) {
         const events = agent.session?.snapshotEvents?.() ?? agent.session?.ownEvents?.() ?? [];
         for (let index = events.length - 1; index >= 0; index -= 1) {
@@ -344,8 +386,8 @@ export class DshOrbitHost {
     async validateRoutes(routes, signal) {
         const issues = [];
         const labels = { commander: '指挥官', executor: '执行员', watchdog: '监控模型' };
-        for (const role of ['commander', 'executor', 'watchdog']) {
-            const route = routes[role];
+        for (const [role, route] of Object.entries(routes)) {
+            const label = labels[role] ?? role;
             try {
                 const llm = this.ctx.reflect.get('llm');
                 if (!llm)
@@ -355,18 +397,18 @@ export class DshOrbitHost {
                 const info = await llm.resolveModelInfo(route.provider, route.model, activeSignal);
                 const catalog = await llm.listModels(route.provider);
                 if (catalog.length > 0 && !catalog.some((entry) => entry.id === route.model)) {
-                    issues.push(`${labels[role]}：ORBIT_MODEL_UNAVAILABLE (${route.provider}/${route.model})，当前模型目录中不存在，请重新选择。`);
+                    issues.push(`${label}：ORBIT_MODEL_UNAVAILABLE (${route.provider}/${route.model})，当前模型目录中不存在，请重新选择。`);
                     continue;
                 }
                 if (route.reasoningEffort !== undefined) {
                     const efforts = info.reasoning?.efforts ?? [];
                     if (!efforts.some((effort) => effort.id === route.reasoningEffort)) {
-                        issues.push(`${labels[role]}：ORBIT_REASONING_EFFORT_UNAVAILABLE (${route.provider}/${route.model}/${route.reasoningEffort})，当前模型未声明此推理等级。`);
+                        issues.push(`${label}：ORBIT_REASONING_EFFORT_UNAVAILABLE (${route.provider}/${route.model}/${route.reasoningEffort})，当前模型未声明此推理等级。`);
                     }
                 }
             }
             catch (error) {
-                issues.push(`${labels[role]}：ORBIT_MODEL_UNAVAILABLE (${route.provider}/${route.model})，当前不可用，请重新选择：${truncateSafe(error instanceof Error ? error.message : String(error), 200)}`);
+                issues.push(`${label}：ORBIT_MODEL_UNAVAILABLE (${route.provider}/${route.model})，当前不可用，请重新选择：${truncateSafe(error instanceof Error ? error.message : String(error), 200)}`);
             }
         }
         return issues;

package/lib/index.js

@@ -2,17 +2,12 @@ import { AssistantStreamAccumulator, boundContextSummary, createAssistantMessage
 import z from '@deepseek-ai/schemastery';
 import { installOrbitGestureBoundary, registerOrbitCommand, registerOrbitToggleCommand } from "./activation.js";
 import { createOrbitPreExecuteHandler } from "./pipeline-guard.js";
-import { agentDefaultSelectionOf, resolveEffectiveRoutes, sessionModelSelectionOf, sessionModelStateOf } from "./routes.js";
+import { agentDefaultSelectionOf, resolveEffectiveRoutes, resolveMoaPolicy, sessionModelSelectionOf, sessionModelStateOf } from "./routes.js";
 import { installOrbitSessionProjection, orbitEnabledOf } from "./session-state.js";
 import { OrbitService } from "./service.js";
 import { createOrbitTool } from "./tool.js";
-/**
- * Fixed hard-activation budget. Explicit tool calls may still supply a bounded
- * user-owned budget; ordinary activation never guesses complexity from words.
- */
-const HARD_ACTIVATION_LOOP_BUDGET = 5;
 export const name = 'dsh-orbit';
-export const inject = ['tools', 'agents', 'subagents'];
+export const inject = ['tools', 'agents', 'subagents', 'sessions'];
 const Route = z.object({
     provider: z.string(),
     model: z.string(),
@@ -24,9 +19,18 @@ const RoleRoute = z.object({
     reasoningEffort: z.string().default(''),
 });
 /** `orbit` settings namespace: the two role routes Orbit persists itself. */
+export const OrbitMoaSettingsSchema = z.object({
+    enabled: z.boolean().default(false),
+    candidateCount: z.natural().default(3),
+    peerCritique: z.boolean().default(false),
+    maxMoaSteps: z.natural().default(2),
+    candidates: z.array(RoleRoute).default([]),
+    judge: RoleRoute,
+});
 export const OrbitRouteSettingsSchema = z.object({
     commander: RoleRoute,
     watchdog: RoleRoute,
+    moa: OrbitMoaSettingsSchema,
 });
 export const Config = z.object({
     projectDir: z.string(),
@@ -37,6 +41,7 @@ export const Config = z.object({
         watchdog: Route,
     })
         .default({}),
+    moa: OrbitMoaSettingsSchema.default({}),
     browserTools: z.array(z.string()).default(['agent_browser']),
     commanderReadOnlyTools: z.array(z.string()).default(['read', 'read_image', 'glob', 'grep', 'web_search', 'web_fetch']),
     watchdogTools: z.array(z.string()).default(['read', 'read_image', 'glob', 'grep']),
@@ -52,15 +57,37 @@ export function apply(ctx, config) {
     // Orbit settings bridge. The package ships no model defaults; only explicit
     // profile routes can act as a headless compatibility fallback.
     let readRouteSettings = () => undefined;
+    let readMoaPrices = () => undefined;
     ctx.inject(['settings'], (settingsCtx) => {
         const scope = settingsCtx.settings.register('orbit', OrbitRouteSettingsSchema, {
             base: {
                 commander: { provider: '', model: '', reasoningEffort: '' },
                 watchdog: { provider: '', model: '', reasoningEffort: '' },
+                moa: {
+                    enabled: config.moa.enabled ?? false,
+                    candidateCount: config.moa.candidateCount ?? 3,
+                    peerCritique: config.moa.peerCritique ?? false,
+                    maxMoaSteps: config.moa.maxMoaSteps ?? 2,
+                    candidates: (config.moa.candidates ?? []).map((route) => ({
+                        provider: route.provider,
+                        model: route.model,
+                        reasoningEffort: route.reasoningEffort ?? '',
+                    })),
+                    judge: config.moa.judge
+                        ? { provider: config.moa.judge.provider, model: config.moa.judge.model, reasoningEffort: config.moa.judge.reasoningEffort ?? '' }
+                        : { provider: '', model: '', reasoningEffort: '' },
+                },
             },
         });
         readRouteSettings = () => scope.get();
-        settingsCtx.effect(() => () => { readRouteSettings = () => undefined; });
+        readMoaPrices = () => {
+            const value = settingsCtx.settings.get('dsh-moa');
+            return value?.prices;
+        };
+        settingsCtx.effect(() => () => {
+            readRouteSettings = () => undefined;
+            readMoaPrices = () => undefined;
+        });
     });
     // A NEW run resolves its three routes exactly once: Commander/Watchdog from
     // the Orbit settings (base = config), Executor from the initiating Session's
@@ -82,6 +109,11 @@ export function apply(ctx, config) {
     };
     // The DSH Session driving the current operation: a new run records it, and
     // only that Session may answer the run's NEEDS_USER question.
+    const resolveMoaPolicyForRun = () => resolveMoaPolicy({
+        settings: readRouteSettings()?.moa,
+        config: config.moa,
+        ...(readMoaPrices() ? { prices: readMoaPrices() } : {}),
+    });
     const resolveOwnerSessionId = () => {
         const agent = ctx.agents.currentInitiator();
         return agent === undefined ? undefined : String(agent.session.id);
@@ -89,6 +121,7 @@ export function apply(ctx, config) {
     const serviceConfig = {
         routes: config.routes,
         resolveRoutes,
+        resolveMoaPolicy: resolveMoaPolicyForRun,
         resolveOwnerSessionId,
         browserTools: config.browserTools,
         commanderReadOnlyTools: config.commanderReadOnlyTools,
@@ -120,16 +153,24 @@ export function apply(ctx, config) {
     });
     installOrbitGestureBoundary(ctx, {
         sessionEnabled: (session) => orbitEnabledOf(ctx, session),
+        competingMutationBlock: (agent, messages) => {
+            const cwd = agent.session.header.cwd ?? process.cwd();
+            if (!service.hasActiveRun(cwd))
+                return undefined;
+            const latest = [...messages].reverse().find((message) => message.source.kind === 'user');
+            const text = latest?.content.filter((block) => block.type === 'text').map((block) => block.text).join('\n').trimStart() ?? '';
+            return /^\/moa(?=$|[\t\n\r ])/u.test(text)
+                ? 'ORBIT_MUTATION_DRIVER_CONFLICT: 当前 workspace 已由 Orbit 持有，不能同时启动独立 /moa。请先完成或停止当前 Orbit Run。'
+                : undefined;
+        },
+        onBlocked: (agent, reason) => appendOrbitNotice(agent.session, reason),
         activate: async (agent, goal, position, signal) => {
             const cwd = agent.session.header.cwd ?? process.cwd();
             let result;
             try {
                 // The initiator scope makes the run's children belong to this Agent;
                 // the parent model is never asked to decide or to run the task.
-                result = await ctx.agents.withInitiator(agent, () => service.run({
-                    goal,
-                    approved_loop_count: HARD_ACTIVATION_LOOP_BUDGET,
-                }, cwd, signal));
+                result = await ctx.agents.withInitiator(agent, () => service.run({ goal }, cwd, signal));
             }
             catch (error) {
                 appendOrbitNotice(agent.session, `Orbit 启动失败：${error instanceof Error ? error.message : String(error)}`);

package/lib/kernel.js

@@ -5,11 +5,60 @@
  * read a clock, or use randomness. Runtime values (routes, timestamps, run ids)
  * are supplied by the supervisor, which owns orchestration and persistence.
  */
-import { MAX_CORRECTION_DEPTH, DEFAULT_LOOP_BUDGET, MAX_PLAN_STEPS, MAX_WATCHDOG_CALLS_PER_STEP, MIN_PLAN_STEPS, ORBIT_SCHEMA_VERSION, } from "./types.js";
+import { MAX_CORRECTION_DEPTH, DEFAULT_LOOP_BUDGET, AUTOMATIC_LOOP_RECOVERY_RESERVE, MAX_AUTOMATIC_LOOP_BUDGET, MAX_PLAN_STEPS, MAX_WATCHDOG_CALLS_PER_STEP, MIN_PLAN_STEPS, MIN_MOA_CANDIDATES, MAX_MOA_CANDIDATES, DEFAULT_MAX_MOA_STEPS, ORBIT_SCHEMA_VERSION, } from "./types.js";
 /** Capabilities a plan step may request. */
 export const ORBIT_CAPABILITIES = ['filesystem', 'shell', 'web', 'browser'];
 const STEP_CAPABILITIES = new Set(ORBIT_CAPABILITIES);
 const PLAN_STEP_ID = /^P\d+$/u;
+export function normalizeExecutionMode(value) {
+    return value === 'MOA' ? 'MOA' : 'SINGLE';
+}
+export function normalizeMoaPolicy(policy) {
+    if (policy === undefined || policy.enabled !== true)
+        return undefined;
+    if (!Number.isSafeInteger(policy.candidate_count) || policy.candidate_count < MIN_MOA_CANDIDATES || policy.candidate_count > MAX_MOA_CANDIDATES) {
+        throw new Error(`ORBIT_MOA_CANDIDATE_COUNT_INVALID: expected ${MIN_MOA_CANDIDATES}-${MAX_MOA_CANDIDATES}`);
+    }
+    if (!Number.isSafeInteger(policy.max_moa_steps) || policy.max_moa_steps < 1 || policy.max_moa_steps > MAX_PLAN_STEPS) {
+        throw new Error(`ORBIT_MOA_STEP_BUDGET_INVALID: expected 1-${MAX_PLAN_STEPS}`);
+    }
+    if (policy.candidates.length < policy.candidate_count) {
+        throw new Error('ORBIT_MOA_ROUTES_INCOMPLETE: 候选模型数量不足。');
+    }
+    const candidates = policy.candidates.slice(0, policy.candidate_count).map((route) => structuredClone(route));
+    if (candidates.some((route) => !route.provider || !route.model) || !policy.judge?.provider || !policy.judge.model) {
+        throw new Error('ORBIT_MOA_ROUTES_INCOMPLETE: 候选模型或 Judge 未完整配置。');
+    }
+    const prices = policy.prices === undefined
+        ? undefined
+        : Object.fromEntries(Object.entries(policy.prices).flatMap(([key, row]) => {
+            const input = Number(row?.input);
+            const output = Number(row?.output);
+            const cacheHit = row?.cacheHit === undefined ? undefined : Number(row.cacheHit);
+            if (!Number.isFinite(input) || input < 0 || !Number.isFinite(output) || output < 0 || (cacheHit !== undefined && (!Number.isFinite(cacheHit) || cacheHit < 0)))
+                return [];
+            return [[key, { input, output, ...(cacheHit === undefined ? {} : { cacheHit }) }]];
+        }));
+    return {
+        enabled: true,
+        candidate_count: policy.candidate_count,
+        peer_critique: policy.peer_critique === true,
+        max_moa_steps: policy.max_moa_steps || DEFAULT_MAX_MOA_STEPS,
+        candidates,
+        judge: structuredClone(policy.judge),
+        ...(prices && Object.keys(prices).length > 0 ? { prices } : {}),
+    };
+}
+export function assertMoaPlanWithinPolicy(plan, policy) {
+    const moaSteps = plan.steps.filter((step) => normalizeExecutionMode(step.execution_mode) === 'MOA').length;
+    if (moaSteps === 0)
+        return;
+    if (policy === undefined)
+        throw new Error('ORBIT_MOA_UNAVAILABLE: 当前 Run 未启用或未完整配置 MoA。');
+    if (moaSteps > policy.max_moa_steps) {
+        throw new Error(`ORBIT_MOA_STEP_BUDGET_EXCEEDED: plan requests ${moaSteps}, max is ${policy.max_moa_steps}`);
+    }
+}
 export function normalizeCapabilities(value) {
     if (!Array.isArray(value))
         return undefined;
@@ -40,10 +89,12 @@ export function normalizePlan(plan) {
         const id = PLAN_STEP_ID.test(rawId) ? rawId : `P${index}`;
         const goal = String(record.goal ?? '').trim();
         const capabilities = normalizeCapabilities(record.capabilities);
+        const execution_mode = normalizeExecutionMode(record.execution_mode);
         return {
             id,
             goal,
             ...(capabilities ? { capabilities } : {}),
+            ...(execution_mode === 'MOA' ? { execution_mode } : {}),
             status: 'pending',
         };
     });
@@ -83,6 +134,29 @@ export function updateLoopBudget(state, budget) {
     state.loop_count = state.loop.used;
     state.remaining_budget = Math.max(0, budget - state.loop.used);
 }
+/**
+ * Deterministic budget for an Orbit-owned run after PLAN is known.
+ * Small plans keep the historical floor of five; four/five-step plans gain two
+ * bounded recovery slots, with a hard automatic ceiling of seven.
+ */
+export function automaticLoopBudgetForPlan(stepCount) {
+    if (!Number.isSafeInteger(stepCount) || stepCount < MIN_PLAN_STEPS || stepCount > MAX_PLAN_STEPS) {
+        throw new Error(`ORBIT_PLAN_STEP_COUNT_INVALID: expected ${MIN_PLAN_STEPS}-${MAX_PLAN_STEPS}, got ${stepCount}`);
+    }
+    return Math.min(MAX_AUTOMATIC_LOOP_BUDGET, Math.max(DEFAULT_LOOP_BUDGET, stepCount + AUTOMATIC_LOOP_RECOVERY_RESERVE));
+}
+/**
+ * Expand only Orbit-owned automatic budgets. Explicit user/tool budgets and
+ * old states without a recorded mode are never silently increased.
+ */
+export function ensureAutomaticLoopBudgetForPlan(state) {
+    if (state.loop_budget_mode !== 'automatic')
+        return;
+    const baseSteps = state.plan.steps.filter((step) => isBaseStepId(step.id)).length;
+    const target = automaticLoopBudgetForPlan(baseSteps);
+    if (target > state.loop.max)
+        updateLoopBudget(state, target);
+}
 export function hashGoal(goal) {
     let hash = 0;
     for (let index = 0; index < goal.length; index += 1) {
@@ -101,14 +175,16 @@ export function normalizeAppend(decision) {
                 const goal = String(entry.goal ?? '').trim();
                 if (goal) {
                     const capabilities = normalizeCapabilities(entry.capabilities);
-                    items.push({ goal, ...(capabilities ? { capabilities } : {}) });
+                    const execution_mode = normalizeExecutionMode(entry.execution_mode);
+                    items.push({ goal, ...(capabilities ? { capabilities } : {}), ...(execution_mode === 'MOA' ? { execution_mode } : {}) });
                 }
             }
         }
     }
     if (items.length === 0 && decision.next_step_goal?.trim()) {
         const capabilities = normalizeCapabilities(decision.next_step_capabilities);
-        items.push({ goal: decision.next_step_goal.trim(), ...(capabilities ? { capabilities } : {}) });
+        const execution_mode = normalizeExecutionMode(decision.next_step_execution_mode);
+        items.push({ goal: decision.next_step_goal.trim(), ...(capabilities ? { capabilities } : {}), ...(execution_mode === 'MOA' ? { execution_mode } : {}) });
     }
     return items;
 }
@@ -123,8 +199,9 @@ export function correctionBlockCode(state, step) {
     return undefined;
 }
 export function createInitialState(input) {
-    const max = explicitLoopBudget({ approved_loop_count: input.approvedLoopCount, max_loops: input.maxLoops }) ??
-        DEFAULT_LOOP_BUDGET;
+    const explicit = explicitLoopBudget({ approved_loop_count: input.approvedLoopCount, max_loops: input.maxLoops });
+    const max = explicit ?? DEFAULT_LOOP_BUDGET;
+    const moaPolicy = normalizeMoaPolicy(input.moaPolicy);
     return {
         schema_version: ORBIT_SCHEMA_VERSION,
         active_run_id: input.runId,
@@ -138,7 +215,9 @@ export function createInitialState(input) {
         goal_hash: hashGoal(input.goal),
         preset: input.preset ?? 'orbit-lite',
         routes: structuredClone(input.routes),
+        ...(moaPolicy ? { moa_policy: moaPolicy } : {}),
         loop: { used: 0, max },
+        loop_budget_mode: explicit === undefined ? 'automatic' : 'explicit',
         approved_loop_count: max,
         remaining_budget: max,
         loop_count: 0,
@@ -265,6 +344,10 @@ export function applyFinalAppend(state, decision) {
     const appended = normalizeAppend(decision);
     if (appended.length === 0)
         return 'invalid';
+    const currentMoa = state.plan.steps.filter((step) => normalizeExecutionMode(step.execution_mode) === 'MOA').length;
+    const addedMoa = appended.filter((step) => normalizeExecutionMode(step.execution_mode) === 'MOA').length;
+    if (addedMoa > 0 && (state.moa_policy === undefined || currentMoa + addedMoa > state.moa_policy.max_moa_steps))
+        return 'invalid';
     if (remaining <= 0) {
         enterBudgetExhausted(state);
         return 'budget_exhausted';
@@ -277,6 +360,7 @@ export function applyFinalAppend(state, decision) {
             id: `P${index}`,
             goal: item.goal,
             ...(item.capabilities ? { capabilities: item.capabilities } : {}),
+            ...(item.execution_mode === 'MOA' ? { execution_mode: 'MOA' } : {}),
             status: 'pending',
         });
     }
@@ -294,10 +378,14 @@ export function applyCorrectionStep(state, step, input) {
     const correctionCapabilities = input.capabilities === undefined
         ? step.capabilities
         : normalizeCapabilities(input.capabilities);
+    const correctionMode = input.executionMode === undefined
+        ? normalizeExecutionMode(step.execution_mode)
+        : normalizeExecutionMode(input.executionMode);
     state.plan.steps.splice(insertAt, 0, {
         id: `${base}-${number}`,
         goal: input.nextGoal,
         ...(correctionCapabilities ? { capabilities: correctionCapabilities } : {}),
+        ...(correctionMode === 'MOA' ? { execution_mode: 'MOA' } : {}),
         status: 'pending',
     });
     state.phase = 'EXECUTE';