@kasenri/dsh-orbit 0.5.4 → 0.5.5

package/lib/activation.js

@@ -1,15 +1,13 @@
 /**
- * Deterministic `/agent-orbit` activation.
+ * Deterministic Orbit activation.
  *
- * Two routes converge on the same tiny pre-step directive:
- * - a closed-namespace DSH host command for surfaces with command adjudication
- *   (the Web GUI slash menu), and
- * - a strict genuine-user-message gesture boundary for headless/CLI surfaces
- *   without one.
- *
- * Neither route creates an execution entry of its own: the directive only
- * states that activation is explicit, and the existing `orbit_controller`
- * tool + `OrbitService` + Supervisor remain the sole Orbit runtime.
+ * - `/agent-orbit` (host command or genuine-message gesture) keeps its explicit
+ *   directive; the existing `orbit_controller` tool + `OrbitService` remain the
+ *   runtime.
+ * - A Session whose toggle is ON hands every ordinary user message straight to
+ *   `OrbitService`: the pre-step boundary consumes the turn (no parent model
+ *   call, no parent mutation) and the host starts or resumes the run. The model
+ *   never decides whether Orbit runs.
  */
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { ORBIT_TOGGLE_COMMAND, parseOrbitToggle } from "./session-state.js";
@@ -70,17 +68,6 @@ export function buildOrbitActivationDirective(goal) {
         : `Goal: ${goal}`);
     return lines.join('\n');
 }
-/**
- * The directive for a Session whose toggle is ON: an ordinary user message
- * becomes the Orbit goal without changing the activation machinery.
- */
-export function buildOrbitSessionDirective(goal) {
-    return [
-        'Orbit is enabled for this chat, so treat this ordinary user message as the requested goal. Start or resume Orbit through the existing orbit_controller tool; do not ask the user to confirm the mode.',
-        'Use the message as the goal, without summarizing or rewriting it.',
-        `Goal: ${goal}`,
-    ].join('\n');
-}
 /**
  * Register the closed-namespace `/agent-orbit` host command.
  *
@@ -135,15 +122,13 @@ export function registerOrbitToggleCommand(ctx) {
     }), 'dsh-orbit: /orbit-toggle host command');
 }
 /**
- * Install the gesture boundary. It runs for every proposed step and injects
- * the activation directive once, for the step that carries the genuine user
- * message. The in-step guard keeps a step that already holds an Orbit
- * directive from gaining a second one, without any durable state.
+ * Install the gesture boundary. It runs for every proposed step.
  *
  * An explicit `/agent-orbit` always wins and always activates, whatever the
- * Session toggle says. Only when no explicit activation is present does the
- * Session toggle (when the composition provides it) promote an ordinary user
- * message into an Orbit goal.
+ * Session toggle says: it keeps the existing activation directive and the
+ * `orbit_controller` tool. Otherwise, an enabled Session hands the ordinary
+ * user message to Orbit directly — the step is consumed with no model call and
+ * the message stays in the conversation as durable history.
  */
 export function installOrbitGestureBoundary(ctx, options = {}) {
     ctx.on('agent/pre-step', async ({ agent, messages, signal }, next) => {
@@ -153,25 +138,31 @@ export function installOrbitGestureBoundary(ctx, options = {}) {
         if (decision.messages.some((message) => message.source.kind === 'orbit-command'))
             return decision;
         const explicit = invokedOrbitActivation(messages);
-        const implicit = explicit === undefined && options.sessionEnabled?.(agent.session) === true
-            ? invokedOrbitMessage(messages)
-            : undefined;
-        if (explicit === undefined && implicit === undefined)
+        if (explicit !== undefined) {
+            signal.throwIfAborted();
+            return {
+                kind: 'enter',
+                messages: [
+                    ...decision.messages,
+                    createUserMessage({
+                        content: [{ type: 'text', text: buildOrbitActivationDirective(explicit.goal) }],
+                        source: { kind: 'orbit-command', ...(explicit.goal === '' ? {} : { goal: explicit.goal }) },
+                    }),
+                ],
+            };
+        }
+        if (options.sessionEnabled?.(agent.session) !== true)
+            return decision;
+        const ordinary = invokedOrbitMessage(messages);
+        const activate = options.activate;
+        if (ordinary === undefined || activate === undefined)
             return decision;
         signal.throwIfAborted();
-        const activation = explicit ?? implicit ?? { goal: '' };
-        const directive = explicit === undefined
-            ? buildOrbitSessionDirective(activation.goal)
-            : buildOrbitActivationDirective(activation.goal);
-        return {
-            kind: 'enter',
-            messages: [
-                ...decision.messages,
-                createUserMessage({
-                    content: [{ type: 'text', text: directive }],
-                    source: { kind: 'orbit-command', ...(activation.goal === '' ? {} : { goal: activation.goal }) },
-                }),
-            ],
-        };
+        // The claimed batch enters the conversation exactly once: the loop commits
+        // `decision.messages`, which this path leaves empty.
+        for (const message of messages)
+            agent.session.append('user/message', message, { surfaceOp: 'append' });
+        await activate(agent, ordinary.goal, signal);
+        return { kind: 'enter', messages: [] };
     });
 }

package/lib/client.js

@@ -133,21 +133,21 @@ window.__ModuleLoader__.load({
 		}
 		var OrbitModelSelect_module_css_default = {
 			"check": "f77nca_check",
-			"back": "f77nca_back",
+			"switchControl": "f77nca_switchControl",
 			"switchRow": "f77nca_switchRow",
-			"hint": "f77nca_hint",
 			"rowDetail": "f77nca_rowDetail",
-			"group": "f77nca_group",
-			"switchControl": "f77nca_switchControl",
-			"rowValue": "f77nca_rowValue",
-			"chevron": "f77nca_chevron",
 			"title": "f77nca_title",
-			"error": "f77nca_error",
-			"rowLabel": "f77nca_rowLabel",
-			"separator": "f77nca_separator",
 			"panel": "f77nca_panel",
 			"row": "f77nca_row",
-			"rowValueActive": "f77nca_rowValueActive"
+			"rowLabel": "f77nca_rowLabel",
+			"group": "f77nca_group",
+			"error": "f77nca_error",
+			"rowValueActive": "f77nca_rowValueActive",
+			"separator": "f77nca_separator",
+			"chevron": "f77nca_chevron",
+			"rowValue": "f77nca_rowValue",
+			"back": "f77nca_back",
+			"hint": "f77nca_hint"
 		};
 		//#endregion
 		//#region client/OrbitModelSelect.tsx

package/lib/index.js

@@ -1,10 +1,18 @@
 import z from '@deepseek-ai/schemastery';
 import { installOrbitGestureBoundary, registerOrbitCommand, registerOrbitToggleCommand } from "./activation.js";
+import { estimateLoopCount } from "./kernel.js";
 import { createOrbitPreExecuteHandler } from "./pipeline-guard.js";
 import { resolveEffectiveRoutes, sessionSelectionOf } from "./routes.js";
 import { installOrbitSessionProjection, orbitEnabledOf } from "./session-state.js";
 import { OrbitService } from "./service.js";
 import { createOrbitTool } from "./tool.js";
+/**
+ * Minimum loop budget for a hard-activated run. The Commander is asked for a
+ * 2-5 step plan and every executed step consumes one loop slot, so the host
+ * must grant a budget that can finish a full plan; the goal complexity
+ * estimate raises it further when the goal asks for more.
+ */
+const HARD_ACTIVATION_MIN_LOOPS = 5;
 export const name = 'dsh-orbit';
 export const inject = ['tools', 'agents', 'subagents'];
 const Route = z.object({
@@ -117,6 +125,21 @@ export function apply(ctx, config) {
         });
         installOrbitGestureBoundary(ctx, {
             sessionEnabled: (session) => orbitEnabledOf(ctx, session),
+            activate: async (agent, goal, signal) => {
+                const cwd = agent.session.header.cwd ?? process.cwd();
+                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.
+                    await ctx.agents.withInitiator(agent, () => service.run({
+                        goal,
+                        approved_loop_count: Math.max(estimateLoopCount(goal), HARD_ACTIVATION_MIN_LOOPS),
+                    }, cwd, signal));
+                }
+                catch {
+                    // Durable run state owns failure reporting; a takeover failure must
+                    // not fail the consumed parent turn.
+                }
+            },
         });
     }
     // Per-Session Orbit enable state: natively durable through the Session log

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kasenri/dsh-orbit",
-  "version": "0.5.4",
+  "version": "0.5.5",
   "type": "module",
   "description": "Deterministic engineering orchestration for DeepSeek Harness with Commander, Executor, Smart Watchdog, bounded recovery and durable execution state.",
   "license": "MIT",