@kasenri/dsh-orbit 0.5.5 → 0.5.6

package/lib/activation.js

@@ -1,13 +1,14 @@
 /**
  * Deterministic Orbit activation.
  *
- * - `/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.
+ * Both entry points hand control to the host runtime directly:
+ * - an explicit `/agent-orbit <goal>` statement (host command or genuine
+ *   message), whatever the Session toggle says, and
+ * - every ordinary user message in a Session whose toggle is ON.
+ *
+ * The pre-step boundary consumes the turn (no parent model call, no parent
+ * mutation) and starts or resumes the existing `OrbitService`; the same
+ * `orbit_controller` tool + Supervisor remain the only runtime.
  */
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { ORBIT_TOGGLE_COMMAND, parseOrbitToggle } from "./session-state.js";
@@ -53,28 +54,13 @@ export function invokedOrbitMessage(messages) {
     }
     return undefined;
 }
-/**
- * The one deterministic directive injected for an explicit activation. It only
- * states the activation and carries the goal verbatim; every Orbit rule still
- * comes from the existing tool, service and protocol.
- */
-export function buildOrbitActivationDirective(goal) {
-    const lines = [
-        'Orbit activation is explicit for this turn. Start or resume Orbit through the existing orbit_controller tool; do not ask the user to confirm the mode.',
-        'Treat the text following /agent-orbit as the requested goal, without summarizing or rewriting it.',
-    ];
-    lines.push(goal === ''
-        ? 'No goal was provided — ask the user what Orbit should accomplish; do not start an empty run.'
-        : `Goal: ${goal}`);
-    return lines.join('\n');
-}
 /**
  * Register the closed-namespace `/agent-orbit` host command.
  *
- * The handler never injects a directive itself. It reposts the original
- * command line as a genuine user message, so the gesture boundary stays the
- * only activation point and a command-registered surface cannot double
- * activate through both routes.
+ * The handler never runs Orbit itself. It reposts the original command line as
+ * a genuine user message, so the gesture boundary stays the only activation
+ * point and a command-registered surface cannot double activate through both
+ * routes.
  */
 export function registerOrbitCommand(ctx) {
     ctx.effect(() => ctx.commands.register({
@@ -122,47 +108,33 @@ export function registerOrbitToggleCommand(ctx) {
     }), 'dsh-orbit: /orbit-toggle host command');
 }
 /**
- * Install the gesture boundary. It runs for every proposed step.
+ * Install the activation boundary. It runs for every proposed step.
  *
- * An explicit `/agent-orbit` always wins and always activates, whatever the
- * 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.
+ * An explicit `/agent-orbit <goal>` always wins and always activates, whatever
+ * the Session toggle says. Otherwise, an enabled Session hands the ordinary
+ * user message to Orbit. Either way the step is consumed with no parent model
+ * 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) => {
         const decision = await next();
         if (decision.kind === 'reject')
             return decision;
-        if (decision.messages.some((message) => message.source.kind === 'orbit-command'))
-            return decision;
         const explicit = invokedOrbitActivation(messages);
-        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 goal = explicit !== undefined
+            ? explicit.goal
+            : options.sessionEnabled?.(agent.session) === true
+                ? invokedOrbitMessage(messages)?.goal
+                : undefined;
         const activate = options.activate;
-        if (ordinary === undefined || activate === undefined)
+        if (goal === undefined || goal === '' || activate === undefined)
             return decision;
         signal.throwIfAborted();
         // 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);
+        await activate(agent, goal, signal);
         return { kind: 'enter', messages: [] };
     });
 }

package/lib/client.js

@@ -132,22 +132,22 @@ window.__ModuleLoader__.load({
 			document.head.appendChild(tag);
 		}
 		var OrbitModelSelect_module_css_default = {
-			"check": "f77nca_check",
-			"switchControl": "f77nca_switchControl",
-			"switchRow": "f77nca_switchRow",
 			"rowDetail": "f77nca_rowDetail",
+			"switchControl": "f77nca_switchControl",
+			"rowValue": "f77nca_rowValue",
 			"title": "f77nca_title",
-			"panel": "f77nca_panel",
+			"chevron": "f77nca_chevron",
+			"switchRow": "f77nca_switchRow",
+			"group": "f77nca_group",
 			"row": "f77nca_row",
+			"back": "f77nca_back",
+			"check": "f77nca_check",
 			"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"
+			"error": "f77nca_error",
+			"hint": "f77nca_hint",
+			"panel": "f77nca_panel",
+			"rowValueActive": "f77nca_rowValueActive"
 		};
 		//#endregion
 		//#region client/OrbitModelSelect.tsx

package/lib/index.js

@@ -1,3 +1,4 @@
+import { boundContextSummary, createUserMessage } from '@deepseek-ai/dsh-llm';
 import z from '@deepseek-ai/schemastery';
 import { installOrbitGestureBoundary, registerOrbitCommand, registerOrbitToggleCommand } from "./activation.js";
 import { estimateLoopCount } from "./kernel.js";
@@ -108,40 +109,41 @@ export function apply(ctx, config) {
         ctx.tools.register(createOrbitTool(ctx));
         ctx.tools.register(createOrbitTool(ctx, { legacy: true }));
     }
-    // Deterministic activation surfaces: the closed-namespace `/agent-orbit`
-    // host command (surfaces in the Web GUI slash menu through the Harness
-    // commands client) and the genuine-user-message gesture boundary for
-    // surfaces without command adjudication (headless CLI). Both default on.
-    //
-    // `commands` is registered lazily, not a required inject: every standard
-    // profile mounts it, but a minimal composition that omits the command
-    // registry keeps Orbit fully functional — the fiber never pends on it and
-    // simply never gains the slash command, while the gesture boundary still
-    // works.
-    if (config.slashCommand) {
-        ctx.inject(['commands'], (commandCtx) => {
+    // Slash-command registration is its own switch: the `/agent-orbit` command
+    // (surfaces in the Web GUI slash menu through the Harness commands client)
+    // rides `slashCommand`, while the per-chat toggle command and the host
+    // activation boundary below never depend on it. `commands` is registered
+    // lazily: a minimal composition without the command registry keeps Orbit
+    // fully functional — the fiber never pends on it, and the activation
+    // boundary (explicit `/agent-orbit` messages and enabled-Session ordinary
+    // messages) still runs.
+    ctx.inject(['commands'], (commandCtx) => {
+        registerOrbitToggleCommand(commandCtx);
+        if (config.slashCommand)
             registerOrbitCommand(commandCtx);
-            registerOrbitToggleCommand(commandCtx);
-        });
-        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.
-                }
-            },
-        });
-    }
+    });
+    installOrbitGestureBoundary(ctx, {
+        sessionEnabled: (session) => orbitEnabledOf(ctx, session),
+        activate: async (agent, goal, 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: Math.max(estimateLoopCount(goal), HARD_ACTIVATION_MIN_LOOPS),
+                }, cwd, signal));
+            }
+            catch (error) {
+                appendOrbitNotice(agent.session, `Orbit 启动失败：${error instanceof Error ? error.message : String(error)}`);
+                return;
+            }
+            const notice = activationNotice(result);
+            if (notice !== undefined)
+                appendOrbitNotice(agent.session, notice);
+        },
+    });
     // Per-Session Orbit enable state: natively durable through the Session log
     // and the projection registry. Minimal compositions without the registry
     // keep the feature inert (OFF) while `/agent-orbit` keeps working.
@@ -169,3 +171,36 @@ export function apply(ctx, config) {
         ctx.on('tools/pre-execute', (exec, next) => handler(exec, next));
     }
 }
+/**
+ * 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
+ * text stays part of the conversation so the next turn can read the outcome.
+ */
+function appendOrbitNotice(session, text) {
+    session.append('user/message', createUserMessage({
+        content: [{ type: 'text', text }],
+        source: { kind: 'plugin', plugin: 'dsh-orbit', form: 'notice', summary: boundContextSummary(text) },
+    }), { surfaceOp: 'append' });
+}
+/**
+ * What the user must see when a hard-activated turn did not simply succeed:
+ * the waiting run's question, a refused start, or an unfinished run. The
+ * host stays the only mutation driver; the notice is reporting, never a
+ * hand-back of execution to the parent model.
+ */
+function activationNotice(result) {
+    if (result.ok && result.phase !== 'NEEDS_USER')
+        return undefined;
+    const lastError = result.data?.['last_error'];
+    const reason = result.message ?? (typeof lastError === 'string' && lastError !== '' ? lastError : undefined);
+    if (result.phase === 'NEEDS_USER') {
+        return reason !== undefined && !reason.startsWith('COMMANDER_')
+            ? `Orbit 需要你的回复：${reason}`
+            : 'Orbit 需要你的回复：请回复当前运行需要的信息。';
+    }
+    if (result.message?.startsWith('ORBIT_ACTIVE_RUN_EXISTS') === true) {
+        return `Orbit 未接受这条新任务：${result.message}`;
+    }
+    const phase = result.phase ?? 'UNKNOWN';
+    return `Orbit 运行未完成（phase=${phase}）${reason !== undefined ? `：${reason}` : ''}`;
+}

package/lib/kernel.js

@@ -151,15 +151,19 @@ export function createInitialState(input) {
         changed_files: [],
         test_summary: [],
         last_error: null,
+        pending_user_reply: null,
         user_hard_constraints: input.userHardConstraints ? [...input.userHardConstraints] : [],
         github_allowed: input.githubAllowed === true,
         interruption_retries: 0,
     };
 }
-/** A user answers a NEEDS_USER run with the same goal: execution continues. */
-export function resumeFromNeedsUser(state) {
+/** A user answers a NEEDS_USER run: execution continues with the reply kept durable. */
+export function resumeFromNeedsUser(state, userReply) {
     state.phase = 'EXECUTE';
     state.status = 'running';
+    const reply = (userReply ?? '').trim();
+    if (reply !== '')
+        state.pending_user_reply = reply;
 }
 /** Accept the Commander plan and move to execution. */
 export function applyPlan(state, plan) {

package/lib/supervisor.js

@@ -6,18 +6,18 @@ import { applyCommanderNeedsUser, applyCorrectionStep, applyExecutorCapabilityUn
 import { truncateSafe } from "./sanitize.js";
 import { OrbitStateStore } from "./state-store.js";
 import { COMMANDER_EXTENSION_MS, COMMANDER_HARD_CEILING_MS, COMMANDER_SOFT_DEADLINE_MS, DEFAULT_CAPABILITIES, EXECUTOR_TIMEOUT_MS, GUARD_ESCALATION_THRESHOLD, GUARD_FIRST_INSTRUCTION, GUARD_NEEDS_USER_INSTRUCTION, GUARD_RECOVERY_CAP, GUARD_REPEAT_INSTRUCTION, GUARD_RETRY_INSTRUCTION, MAX_EXECUTOR_INTERRUPT_RETRIES, MAX_WATCHDOG_CALLS_PER_STEP, WATCHDOG_TIMEOUT_MS, } from "./types.js";
-const COMMANDER_PLAN_PROMPT = (goal, constraints) => `You are the Orbit Commander. Produce the smallest set of 2-5 logical engineering steps for this goal.
+const COMMANDER_PLAN_PROMPT = (goal, constraints, userReply) => `You are the Orbit Commander. Produce the smallest set of 2-5 logical engineering steps for this goal.
 Rules: ordinary engineering steps must omit capabilities. Add capability "browser" only when the step must drive a real web page, and "web-api-recon" when it must analyze captured network/API traffic. Keep it minimal.
 Submit your final plan through the structured result protocol.
 Goal: ${goal}
-Hard constraints: ${constraints.join('; ') || 'none'}`;
+Hard constraints: ${constraints.join('; ') || 'none'}${userReply}`;
 const COMMANDER_STEP_PROMPT = (goal, step, evidence, state) => `You are the Orbit Commander doing STEP_EVALUATE. Verify the real project state; do not trust the Executor claim alone. Treat verified execution evidence as authoritative.
 Allowed decisions ONLY: PASS_CURRENT_STEP | CORRECT_CURRENT_STEP | NEEDS_USER.
 - CORRECT_CURRENT_STEP requires a concrete next step goal (optional capabilities).
 Submit your final judgment through the structured result protocol.
 Original goal: ${goal}
 Current step ${step.id}: ${step.goal}
-Iteration counters: loop ${state.loop.used}/${state.loop.max}
+Iteration counters: loop ${state.loop.used}/${state.loop.max}${userReplyLine(state)}
 Executor claim:
 ${evidence}`;
 const COMMANDER_FINAL_PROMPT = (goal, plan, evidence, state) => `You are the Orbit Commander doing FINAL_EVALUATE. All planned steps are done. Decide whether the original goal is truly satisfied against the real project state.
@@ -27,9 +27,16 @@ Submit your final judgment through the structured result protocol.
 Original goal: ${goal}
 Plan summary: ${plan.summary}
 Steps: ${plan.steps.map((step) => `${step.id}:${step.goal}[${step.status}]`).join('; ')}
-Loop: ${state.loop.used}/${state.loop.max}
+Loop: ${state.loop.used}/${state.loop.max}${userReplyLine(state)}
 Executor claim:
 ${evidence}`;
+/**
+ * The durable user reply line for role prompts. The reply is the user's answer
+ * to a NEEDS_USER question and never replaces the original goal.
+ */
+function userReplyLine(state) {
+    return state.pending_user_reply ? `\nUser reply (the user's answer to the previous question): ${state.pending_user_reply}` : '';
+}
 const COMMANDER_STRATEGY_PROMPT = (goal, base, challenge, state) => `You are the Orbit Commander reconsidering strategy after a repeated correction on ${base} (STRATEGY_RECONSIDER).
 Allowed decisions ONLY: KEEP_APPROACH | REPLACE_CURRENT_STEP | NEEDS_USER.
 - REPLACE_CURRENT_STEP requires a replacement goal.
@@ -104,7 +111,13 @@ export class OrbitSupervisor {
         if (['SUCCESS', 'STOPPED', 'BUDGET_EXHAUSTED'].includes(state.phase) && requestedGoal) {
             state = this.store.writeState(this.createState(input));
         }
-        if (!legacy && requestedGoal && state.goal && state.goal !== requestedGoal) {
+        if (state.phase === 'NEEDS_USER' && requestedGoal) {
+            // A reply to the Commander's question is not a new goal: keep the run,
+            // its original goal and its frozen routes, and carry the reply durably.
+            resumeFromNeedsUser(state, requestedGoal);
+            this.store.writeState(state);
+        }
+        else if (!legacy && requestedGoal && state.goal && state.goal !== requestedGoal) {
             return {
                 ok: false,
                 action: 'run',
@@ -112,10 +125,6 @@ export class OrbitSupervisor {
                 message: 'ORBIT_ACTIVE_RUN_EXISTS: current Lite run owns this project; resume it or stop it before starting a different goal.',
             };
         }
-        if (state.phase === 'NEEDS_USER' && requestedGoal) {
-            resumeFromNeedsUser(state);
-            this.store.writeState(state);
-        }
         return this.run(state, signal);
     }
     async run(state, signal) {
@@ -194,7 +203,7 @@ export class OrbitSupervisor {
     }
     // ── commander supervised path ──────────────────────────────────────────────
     async makePlan(state, signal) {
-        const outcome = await this.runCommander(state, 'PLAN', COMMANDER_PLAN_PROMPT(state.goal, state.user_hard_constraints), COMMANDER_PLAN_SCHEMA, signal);
+        const outcome = await this.runCommander(state, 'PLAN', COMMANDER_PLAN_PROMPT(state.goal, state.user_hard_constraints, userReplyLine(state)), COMMANDER_PLAN_SCHEMA, signal);
         if (outcome.kind === 'needs_user')
             return this.setNeedsUser(state, outcome.reason);
         if (outcome.kind === 'interrupted') {
@@ -448,6 +457,8 @@ export class OrbitSupervisor {
             `Working directory: ${join(this.store.stateDir, '..')}`,
             `Hard constraints: ${state.user_hard_constraints.join('; ') || 'none'}`,
         ];
+        if (state.pending_user_reply)
+            lines.push(`User reply (the user's answer to the previous question): ${state.pending_user_reply}`);
         if ((step.capabilities ?? []).length > 0)
             lines.push(`Capabilities: ${(step.capabilities ?? []).join(', ')}`);
         lines.push('Return a compact evidence summary: what changed, commands/tests run, and residual risks.');
@@ -773,6 +784,7 @@ export class OrbitSupervisor {
             strategy_challenge: state.strategy_challenge,
             guard_recovery: state.guard_recovery,
             last_error: state.last_error,
+            pending_user_reply: state.pending_user_reply,
             changed_files: state.changed_files,
             test_summary: state.test_summary,
             driver_ownership: state.driver_ownership,

package/package.json

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