@kasenri/dsh-orbit 0.5.9 → 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)
@@ -110,9 +112,10 @@ 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
@@ -143,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/client.js

@@ -94,22 +94,22 @@ window.__ModuleLoader__.load({
 			document.head.appendChild(tag);
 		}
 		var OrbitModelSelect_module_css_default = {
+			"check": "f77nca_check",
+			"chevron": "f77nca_chevron",
+			"rowDetail": "f77nca_rowDetail",
 			"title": "f77nca_title",
+			"separator": "f77nca_separator",
+			"row": "f77nca_row",
+			"group": "f77nca_group",
 			"panel": "f77nca_panel",
+			"rowLabel": "f77nca_rowLabel",
+			"rowValue": "f77nca_rowValue",
+			"hint": "f77nca_hint",
+			"back": "f77nca_back",
 			"switchControl": "f77nca_switchControl",
-			"error": "f77nca_error",
-			"rowDetail": "f77nca_rowDetail",
-			"chevron": "f77nca_chevron",
-			"group": "f77nca_group",
-			"row": "f77nca_row",
 			"switchRow": "f77nca_switchRow",
-			"hint": "f77nca_hint",
-			"rowValueActive": "f77nca_rowValueActive",
-			"rowValue": "f77nca_rowValue",
-			"rowLabel": "f77nca_rowLabel",
-			"check": "f77nca_check",
-			"separator": "f77nca_separator",
-			"back": "f77nca_back"
+			"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/index.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({
@@ -126,10 +121,7 @@ export function apply(ctx, config) {
             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,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;
         }

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.9",
+  "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",