@kasenri/dsh-orbit 0.5.8 → 0.5.10

package/README.md

@@ -3,10 +3,12 @@
 Community plugin for [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) (DSH).
 Not affiliated with or endorsed by DeepSeek.
 
+**让 AI 项目可以在无人监管下持续推进。**
+Orbit 会自动规划任务、分工执行、逐步检查并继续完成后续工作；不同环节可以使用不同模型，让低成本模型承担执行任务、强模型负责规划和审核，从而降低整体 AI 使用成本。Watchdog 还会监控运行异常，在任务卡死或中断时协助恢复。
+
 **Orbit — Deterministic Engineering Orchestration for DeepSeek Harness**
 
-Orbit is a deterministic engineering orchestration runtime for DSH, implemented
-as a Cordis plugin:
+Technical integration:
 
 - an `OrbitService` on `ctx.orbit`
 - a model-facing `orbit_controller` tool (`cx_controller` remains a legacy alias)
@@ -104,12 +106,16 @@ Orbit supports three activation styles:
 
 All three routes converge on the existing `orbit_controller` tool and
 `OrbitService`; the activation layer never starts a run of its own.
+After a hard-activated run reaches `SUCCESS`, the initiating Session displays
+the Final Commander's user-visible result directly, with the Commander's frozen
+provider/model provenance. The parent model and parent tools remain bypassed.
 
 ## Model configuration (Web)
 
-The Orbit model control sits immediately left of the native composer model
-seat (`conversation.input.right` renders before `conversation.input.model`).
-Its button names the Commander's model; the menu edits three roles:
+The Orbit model control is the final entry in `conversation.input.right`, so
+other composer-side controls (for example DSH's rollback control) stay to its
+left while the native `conversation.input.model` seat stays immediately to its
+right. Its button names the Commander's model; the menu edits three roles:
 
 - **Commander** and **Watchdog** pick from the same native model catalog and
   persist into the DSH `orbit` settings namespace (`settings.yaml`). Picking a
@@ -140,6 +146,11 @@ PLAN → EXECUTE → EVALUATE → SUCCESS
 ```
 
 - Only a normally completed Executor step consumes one loop from the budget.
+- Runs without an explicit user/tool budget start from the historical floor of
+  5 loops; after PLAN, Orbit deterministically reserves two extra bounded slots
+  beyond the accepted base plan (`max(5, steps + 2)`, therefore at most 7 for
+  the 1–5-step plan schema). Explicit `approved_loop_count` / `max_loops`
+  values are never enlarged automatically.
 - Corrections are limited per base step and reserve budget for the remaining
   planned steps.
 - Commander decisions are validated in code (`PASS_CURRENT_STEP` /

package/lib/activation.js

@@ -116,7 +116,8 @@ export function registerOrbitToggleCommand(ctx) {
  * call while the message stays in the conversation as durable history.
  */
 export function installOrbitGestureBoundary(ctx, options = {}) {
-    ctx.on('agent/pre-step', async ({ agent, messages, signal }, next) => {
+    ctx.on('agent/pre-step', async (payload, next) => {
+        const { agent, messages, signal } = payload;
         const decision = await next();
         if (decision.kind === 'reject')
             return decision;
@@ -134,7 +135,7 @@ export function installOrbitGestureBoundary(ctx, options = {}) {
         // `decision.messages`, which this path leaves empty.
         for (const message of messages)
             agent.session.append('user/message', message, { surfaceOp: 'append' });
-        await activate(agent, goal, signal);
+        await activate(agent, goal, { turn: payload.turn, step: payload.step }, signal);
         return { kind: 'enter', messages: [] };
     });
 }

package/lib/client.js

@@ -94,22 +94,22 @@ window.__ModuleLoader__.load({
 			document.head.appendChild(tag);
 		}
 		var OrbitModelSelect_module_css_default = {
-			"hint": "f77nca_hint",
-			"rowValueActive": "f77nca_rowValueActive",
-			"rowValue": "f77nca_rowValue",
-			"switchControl": "f77nca_switchControl",
+			"check": "f77nca_check",
+			"chevron": "f77nca_chevron",
 			"rowDetail": "f77nca_rowDetail",
-			"rowLabel": "f77nca_rowLabel",
-			"switchRow": "f77nca_switchRow",
+			"title": "f77nca_title",
 			"separator": "f77nca_separator",
-			"chevron": "f77nca_chevron",
 			"row": "f77nca_row",
 			"group": "f77nca_group",
-			"error": "f77nca_error",
-			"check": "f77nca_check",
-			"title": "f77nca_title",
+			"panel": "f77nca_panel",
+			"rowLabel": "f77nca_rowLabel",
+			"rowValue": "f77nca_rowValue",
+			"hint": "f77nca_hint",
 			"back": "f77nca_back",
-			"panel": "f77nca_panel"
+			"switchControl": "f77nca_switchControl",
+			"switchRow": "f77nca_switchRow",
+			"error": "f77nca_error",
+			"rowValueActive": "f77nca_rowValueActive"
 		};
 		//#endregion
 		//#region client/OrbitModelSelect.tsx
@@ -592,6 +592,13 @@ window.__ModuleLoader__.load({
 		//#region client/index.ts
 		/** The host settings namespace Orbit registers for its own two roles. */
 		const ORBIT_SETTINGS_NS = "orbit";
+		/**
+		* Keep Orbit as the final list entry in `conversation.input.right`.
+		* DSH renders the whole right list before the named model seat, so this gives
+		* the stable local order: other right-side controls → Orbit → model selector.
+		*/
+		const ORBIT_INPUT_RIGHT_PRIORITY = Number.MAX_SAFE_INTEGER;
+		const ORBIT_INPUT_RIGHT_ORDER = Number.MAX_SAFE_INTEGER;
 		/** Required client services: slots, the shared model directory, Remote (settings namespace), and locale. */
 		const inject = [
 			"slots",
@@ -718,13 +725,16 @@ window.__ModuleLoader__.load({
 				scope.slots.inject("conversation.input.right", () => scope.slots.register({
 					name: "conversation.input.right",
 					id: "orbit-model",
-					order: 10,
+					priority: ORBIT_INPUT_RIGHT_PRIORITY,
+					order: ORBIT_INPUT_RIGHT_ORDER,
 					locale: NS,
 					inject: injected
 				}, OrbitModelSelect));
 			});
 		}
 		//#endregion
+		exports.ORBIT_INPUT_RIGHT_ORDER = ORBIT_INPUT_RIGHT_ORDER;
+		exports.ORBIT_INPUT_RIGHT_PRIORITY = ORBIT_INPUT_RIGHT_PRIORITY;
 		exports.ORBIT_SETTINGS_NS = ORBIT_SETTINGS_NS;
 		exports.apply = apply;
 		exports.inject = inject;

package/lib/dsh-host.js

@@ -13,6 +13,9 @@ function contentToText(blocks) {
         .map((block) => (block.type === 'text' ? block.text : `[${block.type}]`))
         .join('\n');
 }
+function visibleContentToText(blocks) {
+    return blocks?.flatMap((block) => block.type === 'text' && block.text.trim() !== '' ? [block.text] : []).join('\n') ?? '';
+}
 /**
  * Wire the Orbit supervisor to DeepSeek Harness native Agent/Subagent services.
  *
@@ -81,6 +84,7 @@ export class DshOrbitHost {
             .then((value) => ({
             childId: run.id,
             output: contentToText(value.output),
+            visibleOutput: visibleContentToText(value.output),
             interrupted: value.stopReason !== 'completed',
             ...(value.stopReason !== 'completed' ? { reason: value.stopReason } : {}),
             ...(value.diagnostic ? { testSummary: [value.diagnostic] } : {}),

package/lib/index.js

@@ -1,4 +1,4 @@
-import { boundContextSummary, createUserMessage } from '@deepseek-ai/dsh-llm';
+import { AssistantStreamAccumulator, boundContextSummary, createAssistantMessage, createUserMessage } from '@deepseek-ai/dsh-llm';
 import z from '@deepseek-ai/schemastery';
 import { installOrbitGestureBoundary, registerOrbitCommand, registerOrbitToggleCommand } from "./activation.js";
 import { createOrbitPreExecuteHandler } from "./pipeline-guard.js";
@@ -6,11 +6,6 @@ import { agentDefaultSelectionOf, resolveEffectiveRoutes, sessionModelSelectionO
 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'];
 const Route = z.object({
@@ -120,21 +115,22 @@ export function apply(ctx, config) {
     });
     installOrbitGestureBoundary(ctx, {
         sessionEnabled: (session) => orbitEnabledOf(ctx, session),
-        activate: async (agent, goal, signal) => {
+        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)}`);
                 return;
             }
+            if (result.ok && result.phase === 'SUCCESS' && result.final_output !== undefined) {
+                appendOrbitFinalOutput(agent.session, position, result.final_output);
+                return;
+            }
             const notice = activationNotice(result);
             if (notice !== undefined)
                 appendOrbitNotice(agent.session, notice);
@@ -168,6 +164,26 @@ export function apply(ctx, config) {
         ctx.on('tools/pre-execute', (exec, next) => handler(exec, next));
     }
 }
+/** Append the existing Final Commander answer as this consumed turn's sole assistant result. */
+function appendOrbitFinalOutput(session, position, output) {
+    const message = createAssistantMessage({
+        content: [{ type: 'text', text: output.text }],
+        source: { provider: output.provider, model: output.model },
+    });
+    const stream = new AssistantStreamAccumulator();
+    const time = Date.now();
+    stream.push({ time, chunk: { type: 'block-start', index: 0, blockType: 'text' } });
+    stream.push({ time, chunk: { type: 'text-delta', index: 0, text: output.text } });
+    stream.push({ time, chunk: { type: 'block-end', index: 0, block: { type: 'text', text: output.text } } });
+    stream.push({ time, chunk: { type: 'finish', reason: { kind: 'stop' } } });
+    session.append('step/start', position);
+    try {
+        session.append('assistant/message', { ...position, message, stream: [...stream.snapshot()] }, { surfaceOp: 'append' });
+    }
+    finally {
+        session.append('step/end', position);
+    }
+}
 /**
  * One durable, user-visible Orbit notice. The DSH `plugin` + `form: 'notice'`
  * source renders as a collapsed notice row instead of a user message, and the

package/lib/kernel.js

@@ -5,7 +5,7 @@
  * 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, 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);
@@ -83,6 +83,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) {
@@ -123,8 +146,8 @@ 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;
     return {
         schema_version: ORBIT_SCHEMA_VERSION,
         active_run_id: input.runId,
@@ -139,6 +162,7 @@ export function createInitialState(input) {
         preset: input.preset ?? 'orbit-lite',
         routes: structuredClone(input.routes),
         loop: { used: 0, max },
+        loop_budget_mode: explicit === undefined ? 'automatic' : 'explicit',
         approved_loop_count: max,
         remaining_budget: max,
         loop_count: 0,

package/lib/supervisor.js

@@ -2,7 +2,7 @@ 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, markStrategyChallengeUsed, normalizePlan, openWatchdogAttempt, recordGuardRecovery, recordPlanFailure, recordWatchdogDecision, restoreEvaluationState, resumeFromNeedsUser, stopRun, upsertStepResult, normalizeCapabilities, } from "./kernel.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 { truncateSafe } from "./sanitize.js";
 import { OrbitStateStore } from "./state-store.js";
 import { executorToolsFor, EXECUTOR_READ_ONLY_TOOLS, READ_ONLY_ROLE_TOOLS } from "./capabilities.js";
@@ -305,6 +305,7 @@ export class OrbitSupervisor {
         try {
             const plan = normalizePlan(outcome.structured);
             applyPlan(state, plan);
+            ensureAutomaticLoopBudgetForPlan(state);
             this.store.writeState(state);
             return undefined;
         }
@@ -328,7 +329,7 @@ export class OrbitSupervisor {
             return { kind: 'interrupted', reason: outcome.reason };
         try {
             const decision = assertCommanderDecision(outcome.structured, mode);
-            return { kind: 'decision', decision };
+            return { kind: 'decision', decision, output: outcome.output };
         }
         catch (error) {
             // Invalid/temporary output is recoverable; it must not become NEEDS_USER.
@@ -387,7 +388,7 @@ export class OrbitSupervisor {
                     if (raced.value.structured === undefined) {
                         return { kind: 'interrupted', reason: `${mode}_STRUCTURED_OUTPUT_MISSING` };
                     }
-                    return { kind: 'output', output: raced.value.output, structured: raced.value.structured };
+                    return { kind: 'output', output: raced.value.visibleOutput ?? raced.value.output, structured: raced.value.structured };
                 }
                 if (raced.kind === 'aborted' || signal?.aborted) {
                     await this.cancelHandle(handle, 'ORBIT_ABORTED');
@@ -586,7 +587,7 @@ export class OrbitSupervisor {
         if (decision.decision === 'SUCCESS') {
             applyFinalSuccess(state, decision.summary);
             this.store.writeState(state);
-            return this.result(state, true);
+            return this.result(state, true, undefined, outcome.output);
         }
         if (decision.decision === 'PASS_CURRENT_STEP') {
             applyStepPass(state, step, decision.summary);
@@ -873,7 +874,7 @@ export class OrbitSupervisor {
             return { ok: false, action: 'status', message: 'ORBIT_RUN_NOT_FOUND: 没有 Run 状态。' };
         return this.result(state, true);
     }
-    result(state, ok, message) {
+    result(state, ok, message, finalOutput) {
         // Tool output must be lossless JSON: optional state fields are omitted, not
         // emitted as `undefined`.
         const data = {
@@ -896,6 +897,7 @@ export class OrbitSupervisor {
             driver_ownership: state.driver_ownership,
             state_revision: state.state_revision,
         };
+        const displayText = state.phase === 'SUCCESS' ? finalOutput?.trim() || state.commander?.summary?.trim() : undefined;
         return {
             ok,
             action: 'run',
@@ -903,6 +905,13 @@ export class OrbitSupervisor {
             phase: state.phase,
             status: state.status,
             ...(message ? { message } : {}),
+            ...(displayText ? {
+                final_output: {
+                    text: displayText,
+                    provider: state.routes.commander.provider,
+                    model: state.routes.commander.model,
+                },
+            } : {}),
             data: Object.fromEntries(Object.entries(data).filter(([, value]) => value !== undefined)),
         };
     }

package/lib/types.js

@@ -13,6 +13,9 @@ export const MAX_EXECUTOR_INTERRUPT_RETRIES = 2;
 export const MAX_PLAN_STEPS = 5;
 export const MIN_PLAN_STEPS = 1;
 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;
+export const MAX_AUTOMATIC_LOOP_BUDGET = MAX_PLAN_STEPS + AUTOMATIC_LOOP_RECOVERY_RESERVE;
 export const GUARD_FIRST_INSTRUCTION = '请改用更安全的方法继续当前任务，不要原样重试刚被阻断的操作。';
 export const GUARD_REPEAT_INSTRUCTION = '同一操作再次被阻断。请停止重复，并选择不同的安全方案。';
 export const GUARD_RETRY_INSTRUCTION = '之前的方案反复触发 Orbit 安全护栏。请改用不同的安全方案，不要重试被阻断的操作。';

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@kasenri/dsh-orbit",
-  "version": "0.5.8",
+  "version": "0.5.10",
   "type": "module",
-  "description": "Deterministic engineering orchestration for DeepSeek Harness with Commander, Executor, Smart Watchdog, bounded recovery and durable execution state.",
+  "description": "让 AI 项目可以在无人监管下持续推进。Orbit 会自动规划任务、分工执行、逐步检查并继续完成后续工作；不同环节可以使用不同模型，让低成本模型承担执行任务、强模型负责规划和审核，从而降低整体 AI 使用成本。Watchdog 还会监控运行异常，在任务卡死或中断时协助恢复。",
   "license": "MIT",
   "repository": {
     "type": "git",