@kasenri/dsh-orbit 0.5.6 → 0.5.8

package/lib/supervisor.js

@@ -1,70 +1,88 @@
 import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { buildEvidenceBundle, formatEvidenceBundle } from "./evidence.js";
+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, } from "./kernel.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 { truncateSafe } from "./sanitize.js";
 import { OrbitStateStore } from "./state-store.js";
+import { executorToolsFor, EXECUTOR_READ_ONLY_TOOLS, READ_ONLY_ROLE_TOOLS } from "./capabilities.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, 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'}${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}${userReplyLine(state)}
-Executor claim:
+import { resolveEffectiveRoutes } from "./routes.js";
+const COMMANDER_PLAN_PROMPT = (goal, constraints, userReply) => `你是 Orbit 指挥官（Commander），当前阶段：PLAN。
+ 请为下述目标制定最小化的 1-5 个逻辑工程步骤。
+规则：基础读取不声明 capabilities；修改文件使用 "filesystem"，执行命令使用 "shell"，访问网页/API 使用 "web"，驱动真实浏览器使用 "browser"。只选择当前步骤真正需要的能力，可组合，保持最小化。
+请通过结构化结果协议提交最终计划。
+你的自然语言输出、推理说明和总结默认全部使用简体中文；decision 枚举、capability id、代码、命令、路径、provider/model ID 等机器标识保持原样。
+目标：${goal}
+硬性约束：${constraints.join('；') || '无'}${userReply}`;
+const COMMANDER_STEP_PROMPT = (goal, step, evidence, state) => `你是 Orbit 指挥官（Commander），当前阶段：STEP_EVALUATE。
+请核实真实项目状态，不要只相信执行员的说法；以可验证的执行证据为准。
+允许的 decision 仅限：PASS_CURRENT_STEP | CORRECT_CURRENT_STEP | NEEDS_USER。
+- CORRECT_CURRENT_STEP 必须给出具体的下一步目标（可选 capabilities）。
+请通过结构化结果协议提交最终判断。
+你的自然语言输出、推理说明和总结默认全部使用简体中文；decision 枚举、代码、命令、路径、provider/model ID 等机器标识保持原样。
+原始目标：${goal}
+当前步骤 ${step.id}：${step.goal}
+迭代计数：loop ${state.loop.used}/${state.loop.max}${userReplyLine(state)}
+执行员证据：
 ${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.
-Allowed decisions ONLY: SUCCESS | APPEND | NEEDS_USER.
-- APPEND requires next steps or a next step goal; appends are bounded by the remaining loop budget.
-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}${userReplyLine(state)}
-Executor claim:
+const COMMANDER_FINAL_PROMPT = (goal, plan, evidence, state) => `你是 Orbit 指挥官（Commander），当前阶段：FINAL_EVALUATE。
+所有计划步骤均已执行完毕。请依据真实项目状态判断原始目标是否真正达成。
+允许的 decision 仅限：SUCCESS | APPEND | NEEDS_USER。
+- APPEND 必须给出新增步骤或下一步目标；追加受剩余 loop 预算限制。
+请通过结构化结果协议提交最终判断。
+你的自然语言输出、推理说明和总结默认全部使用简体中文；decision 枚举、代码、命令、路径、provider/model ID 等机器标识保持原样。
+原始目标：${goal}
+计划摘要：${plan.summary}
+步骤：${plan.steps.map((step) => `${step.id}:${step.goal}[${step.status}]`).join('; ')}
+Loop：${state.loop.used}/${state.loop.max}${userReplyLine(state)}
+执行员证据：
 ${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}` : '';
+    return state.pending_user_reply ? `\n用户回复（对上一个问题的回答）：${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.
-Submit your final judgment through the structured result protocol.
-Goal: ${goal}
-Loop: ${state.loop.used}/${state.loop.max}
-Watchdog challenge: ${challenge}`;
-const WATCHDOG_RUNTIME_PROMPT = (step, reason, telemetry) => `You are the Orbit Smart Watchdog doing RUNTIME_DIAGNOSE. Diagnose only the current runtime anomaly. Do not review code quality.
-Allowed decisions ONLY: RESUME_CHILD | RESTART_STEP | NEEDS_USER | RUNTIME_BUG.
-Submit your final judgment through the structured result protocol.
-Failed step ${step.id}: ${step.goal}
-Runtime anomaly: ${reason}
-Telemetry: ${JSON.stringify(telemetry ?? {})}`;
-const WATCHDOG_STRATEGY_PROMPT = (step, reason, state) => `You are the Orbit Smart Watchdog doing STRATEGY_CHALLENGE. Ask: is the current approach tunnel vision? Is this blocker truly required? Is there a simpler route?
-Submit one focused challenge question through the structured result protocol.
-Step ${step.id}: ${step.goal}
-Repeated correction: ${reason}
-Loop: ${state.loop.used}/${state.loop.max}`;
-const WATCHDOG_GUARD_PROMPT = (code, count, stepId) => `You are the Orbit Smart Watchdog doing GUARD_ESCALATION. A safety guard blocked a tool ${count} times.
-Allowed decisions ONLY: RETRY_DIFFERENTLY | NEEDS_USER.
-Submit your final judgment through the structured result protocol.
-Guard code: ${code}
-Step: ${stepId}`;
-const WATCHDOG_TIMEOUT_PROMPT = (mode, elapsed, extensions, telemetry) => `You are the Orbit Smart Watchdog doing COMMANDER_TIMEOUT_REVIEW. The Commander has run ${elapsed}ms with ${extensions} extension(s).
-Allowed decisions ONLY: EXTEND | INTERRUPT | NEEDS_USER.
-Submit your final judgment through the structured result protocol.
-Mode: ${mode}
-Telemetry: ${JSON.stringify(telemetry ?? {})}`;
+const COMMANDER_STRATEGY_PROMPT = (goal, base, challenge, state) => `你是 Orbit 指挥官（Commander），当前阶段：STRATEGY_RECONSIDER。
+步骤 ${base} 已连续修正多次，请重新审视当前策略。
+允许的 decision 仅限：KEEP_APPROACH | REPLACE_CURRENT_STEP | NEEDS_USER。
+- REPLACE_CURRENT_STEP 必须给出替代目标。
+请通过结构化结果协议提交最终判断。
+你的自然语言输出、推理说明和总结默认全部使用简体中文；decision 枚举、代码、命令、路径、provider/model ID 等机器标识保持原样。
+目标：${goal}
+Loop：${state.loop.used}/${state.loop.max}
+监控模型质疑：${challenge}`;
+const WATCHDOG_RUNTIME_PROMPT = (step, reason, telemetry) => `你是 Orbit 监控模型（Smart Watchdog），当前阶段：RUNTIME_DIAGNOSE。
+只诊断当前运行时异常，不评审代码质量。
+允许的 decision 仅限：RESUME_CHILD | RESTART_STEP | NEEDS_USER | RUNTIME_BUG。
+请通过结构化结果协议提交最终判断。
+你的自然语言输出、推理说明和总结默认全部使用简体中文；decision 枚举、代码、命令、路径、provider/model ID 等机器标识保持原样。
+失败步骤 ${step.id}：${step.goal}
+运行时异常：${reason}
+遥测：${JSON.stringify(telemetry ?? {})}`;
+const WATCHDOG_STRATEGY_PROMPT = (step, reason, state) => `你是 Orbit 监控模型（Smart Watchdog），当前阶段：STRATEGY_CHALLENGE。
+请质疑：当前思路是否陷入隧道视野？这个阻塞是否真的必要？是否存在更简单的路径？
+请通过结构化结果协议提交一个聚焦的质疑问题。
+你的自然语言输出默认使用简体中文；decision 枚举、代码、命令、路径、provider/model ID 等机器标识保持原样。
+步骤 ${step.id}：${step.goal}
+重复修正：${reason}
+Loop：${state.loop.used}/${state.loop.max}`;
+const WATCHDOG_GUARD_PROMPT = (code, count, stepId) => `你是 Orbit 监控模型（Smart Watchdog），当前阶段：GUARD_ESCALATION。
+安全护栏已连续 ${count} 次拦截某个工具调用。
+允许的 decision 仅限：RETRY_DIFFERENTLY | NEEDS_USER。
+请通过结构化结果协议提交最终判断。
+你的自然语言输出默认使用简体中文；decision 枚举、代码、命令、路径、provider/model ID 等机器标识保持原样。
+护栏代码：${code}
+步骤：${stepId}`;
+const WATCHDOG_TIMEOUT_PROMPT = (mode, elapsed, extensions, telemetry) => `你是 Orbit 监控模型（Smart Watchdog），当前阶段：COMMANDER_TIMEOUT_REVIEW。
+指挥官已运行 ${elapsed}ms，期间延长 ${extensions} 次。
+允许的 decision 仅限：EXTEND | INTERRUPT | NEEDS_USER。
+请通过结构化结果协议提交最终判断。
+你的自然语言输出默认使用简体中文；decision 枚举、代码、命令、路径、provider/model ID 等机器标识保持原样。
+模式：${mode}
+遥测：${JSON.stringify(telemetry ?? {})}`;
 export class OrbitSupervisor {
     store;
     host;
@@ -80,40 +98,108 @@ export class OrbitSupervisor {
         return this.host.now();
     }
     createState(input) {
+        const ownerSessionId = this.config.resolveOwnerSessionId?.();
         return createInitialState({
             runId: typeof input.run_id === 'string' && input.run_id.length > 0 ? input.run_id : randomUUID(),
             now: this.now(),
             goal: (input.goal ?? '').trim(),
             ...(input.preset !== undefined ? { preset: input.preset } : {}),
-            routes: this.config.resolveRoutes?.() ?? this.config.defaultRoutes,
+            routes: this.resolveNewRoutes(),
             ...(input.approved_loop_count !== undefined ? { approvedLoopCount: input.approved_loop_count } : {}),
             ...(input.max_loops !== undefined ? { maxLoops: input.max_loops } : {}),
             ...(input.user_hard_constraints ? { userHardConstraints: input.user_hard_constraints } : {}),
             githubAllowed: input.github_allowed === true,
+            ...(ownerSessionId === undefined ? {} : { ownerSessionId }),
         });
     }
+    resolveNewRoutes() {
+        if (this.config.resolveRoutes)
+            return this.config.resolveRoutes();
+        return resolveEffectiveRoutes({ configRoutes: this.config.defaultRoutes });
+    }
+    async preflightRoutes(routes, signal) {
+        const issues = await this.host.validateRoutes(routes, signal);
+        return issues.length === 0 ? undefined : `ORBIT_ROLE_MODEL_UNAVAILABLE: ${issues.join('；')}。请重新选择可用模型。`;
+    }
     async bootstrap(input, signal) {
+        if (signal?.aborted)
+            return { ok: false, action: 'run', message: 'ORBIT_ABORTED' };
+        const competitors = await this.host.otherMutationDrivers(join(this.store.stateDir, '..'));
+        if (competitors.length > 0)
+            return {
+                ok: false, action: 'run', message: `ORBIT_MUTATION_DRIVER_CONFLICT: ${competitors.join(', ')} 已持有此 workspace 的修改权。`,
+            };
         const requestedGoal = (input.goal ?? '').trim();
         let state = this.store.readState();
         const raw = this.store.readRawState();
         const legacy = raw !== null && raw['schema_version'] !== 2;
         if (legacy && requestedGoal) {
-            state = this.store.writeState(this.createState(input));
+            let created;
+            try {
+                created = this.createState(input);
+            }
+            catch (error) {
+                return { ok: false, action: 'run', message: error instanceof Error ? error.message : String(error) };
+            }
+            const invalid = await this.preflightRoutes(created.routes, signal);
+            if (invalid)
+                return { ok: false, action: 'run', message: invalid };
+            state = this.store.writeState(created);
         }
         else if (!state) {
             if (!requestedGoal)
-                return { ok: false, action: 'run', message: 'ORBIT_GOAL_REQUIRED: provide a goal to start a run.' };
-            state = this.store.writeState(this.createState(input));
+                return { ok: false, action: 'run', message: 'ORBIT_GOAL_REQUIRED: 请提供要执行的目标。' };
+            let created;
+            try {
+                created = this.createState(input);
+            }
+            catch (error) {
+                return { ok: false, action: 'run', message: error instanceof Error ? error.message : String(error) };
+            }
+            const invalid = await this.preflightRoutes(created.routes, signal);
+            if (invalid)
+                return { ok: false, action: 'run', message: invalid };
+            state = this.store.writeState(created);
         }
         else if (input.run_id && input.run_id !== state.run_id && !legacy) {
             return { ok: false, action: 'run', message: `ORBIT_RUN_NOT_FOUND: ${input.run_id}` };
         }
         if (['SUCCESS', 'STOPPED', 'BUDGET_EXHAUSTED'].includes(state.phase) && requestedGoal) {
-            state = this.store.writeState(this.createState(input));
+            let created;
+            try {
+                created = this.createState(input);
+            }
+            catch (error) {
+                return { ok: false, action: 'run', message: error instanceof Error ? error.message : String(error) };
+            }
+            const invalid = await this.preflightRoutes(created.routes, signal);
+            if (invalid)
+                return { ok: false, action: 'run', message: invalid };
+            state = this.store.writeState(created);
         }
         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.
+            // its original goal and its frozen routes, and carry the reply durably —
+            // but only from the Session that owns the run. Another Session's message
+            // must never be consumed as this run's reply.
+            const owner = state.owner_session_id;
+            const incoming = this.config.resolveOwnerSessionId?.();
+            if (owner === undefined) {
+                return {
+                    ok: false, action: 'run', run_id: state.run_id, phase: state.phase,
+                    message: `ORBIT_NEEDS_USER_OWNER_UNKNOWN: 这是升级前遗留 Run ${state.run_id}，无法安全判断所属 Session。请显式 resume，或 stop 后重新开始。`,
+                };
+            }
+            if (incoming === undefined || incoming !== owner) {
+                return {
+                    ok: false,
+                    action: 'run',
+                    run_id: state.run_id,
+                    phase: state.phase,
+                    message: `ORBIT_NEEDS_USER_OTHER_SESSION: Run ${state.run_id}（goal: ${truncateSafe(state.goal, 120)}）仍在等待所属 Session 的用户回复；` +
+                        '当前消息未被当作回复。请在原 Session 回复，或显式 stop/resume。',
+                };
+            }
             resumeFromNeedsUser(state, requestedGoal);
             this.store.writeState(state);
         }
@@ -122,12 +208,12 @@ export class OrbitSupervisor {
                 ok: false,
                 action: 'run',
                 run_id: state.run_id,
-                message: 'ORBIT_ACTIVE_RUN_EXISTS: current Lite run owns this project; resume it or stop it before starting a different goal.',
+                message: 'ORBIT_ACTIVE_RUN_EXISTS: 当前项目已有活动中的 Orbit Run，请先继续或停止该 Run。',
             };
         }
         return this.run(state, signal);
     }
-    async run(state, signal) {
+    async run(state, signal, preflight = true) {
         if (signal?.aborted)
             return this.result(state, false, 'ORBIT_ABORTED');
         const projectDir = join(this.store.stateDir, '..');
@@ -139,7 +225,7 @@ export class OrbitSupervisor {
                 run_id: state.run_id,
                 phase: state.phase,
                 status: state.status,
-                message: `ORBIT_MUTATION_DRIVER_CONFLICT: ${competitors.join(', ')} already owns mutation in this workspace.`,
+                message: `ORBIT_MUTATION_DRIVER_CONFLICT: ${competitors.join(', ')} 已持有此 workspace 的修改权。`,
             };
         }
         if (state.phase === 'NEEDS_USER')
@@ -150,6 +236,11 @@ export class OrbitSupervisor {
             return this.result(state, true);
         if (state.phase === 'BUDGET_EXHAUSTED')
             return this.result(state, true);
+        if (preflight) {
+            const routeIssue = await this.preflightRoutes(state.routes, signal);
+            if (routeIssue)
+                return this.result(state, false, routeIssue);
+        }
         if (state.plan.steps.length === 0 && state.phase === 'PLAN') {
             const planOutcome = await this.makePlan(state, signal);
             if (planOutcome)
@@ -166,7 +257,7 @@ export class OrbitSupervisor {
             const applied = await this.applyCommanderOutcome(state, outcome, step, false, signal);
             if (applied)
                 return applied;
-            return this.run(state, signal);
+            return this.run(state, signal, false);
         }
         const step = state.plan.steps.find((candidate) => candidate.status === 'running') ??
             state.plan.steps.find((candidate) => candidate.status === 'pending');
@@ -175,7 +266,7 @@ export class OrbitSupervisor {
             const applied = await this.applyCommanderOutcome(state, outcome, undefined, true, signal);
             if (applied)
                 return applied;
-            return this.run(state, signal);
+            return this.run(state, signal, false);
         }
         if (state.loop.used >= state.loop.max) {
             enterBudgetExhausted(state, 'LOOP_BUDGET_EXHAUSTED');
@@ -187,7 +278,7 @@ export class OrbitSupervisor {
         const executed = await this.executeStep(state, step, signal);
         if (executed.done)
             return this.result(state, executed.ok, executed.message);
-        return this.run(state, signal);
+        return this.run(state, signal, false);
     }
     // ── tool scoping ───────────────────────────────────────────────────────────
     /**
@@ -197,7 +288,7 @@ export class OrbitSupervisor {
     toolAllow(names, label) {
         const allowed = names.filter((name) => this.host.hasTool(name));
         if (allowed.length === 0) {
-            throw new Error(`ORBIT_TOOL_FILTER_EMPTY: none of [${names.join(', ')}] are registered for ${label}`);
+            throw new Error(`ORBIT_TOOL_FILTER_EMPTY: ${label} 没有任何已注册的允许工具：[${names.join(', ')}]`);
         }
         return { allow: allowed };
     }
@@ -226,7 +317,7 @@ export class OrbitSupervisor {
     }
     async commanderEvaluate(state, step, final, signal) {
         const mode = final ? 'FINAL_EVALUATE' : 'STEP_EVALUATE';
-        const evidence = this.evidenceFor(state, step) ?? state.commander?.summary ?? state.last_error ?? 'no evidence recorded';
+        const evidence = this.evidenceFor(state, step, final) ?? state.commander?.summary ?? state.last_error ?? '未记录执行证据';
         const prompt = final
             ? COMMANDER_FINAL_PROMPT(state.goal, state.plan, evidence, state)
             : COMMANDER_STEP_PROMPT(state.goal, step, evidence, state);
@@ -249,11 +340,13 @@ export class OrbitSupervisor {
      * qualifies; after a cold resume the bundle is gone and the caller falls back
      * to the durable state summary.
      */
-    evidenceFor(state, step) {
+    evidenceFor(state, step, final = false) {
+        if (final)
+            return formatStepResults(state);
         const stepId = step?.id ?? state.current_step?.id;
-        if (!this.stepEvidence || this.stepEvidence.stepId !== stepId)
-            return undefined;
-        return formatEvidenceBundle(this.stepEvidence.bundle);
+        if (this.stepEvidence && this.stepEvidence.stepId === stepId)
+            return formatEvidenceBundle(this.stepEvidence.bundle);
+        return state.step_results?.find((entry) => entry.step_id === stepId)?.evidence;
     }
     /**
      * The single adaptive Commander runner for PLAN, STEP_EVALUATE, FINAL_EVALUATE
@@ -270,7 +363,8 @@ export class OrbitSupervisor {
                 label: `commander-${mode.toLowerCase()}`,
                 prompt,
                 route: state.routes.commander,
-                toolFilter: this.toolAllow(this.config.commanderReadOnlyTools, `commander ${mode}`),
+                workspace: join(this.store.stateDir, '..'),
+                toolFilter: this.toolAllow(this.config.commanderReadOnlyTools.filter((name) => READ_ONLY_ROLE_TOOLS.includes(name)), `commander ${mode}`),
                 outputSchema,
                 ...(signal ? { signal } : {}),
             });
@@ -329,27 +423,29 @@ export class OrbitSupervisor {
             ...(signal ? { signal } : {}),
         });
         if (!result || result.interrupted) {
-            return { decision: extensions === 0 ? 'EXTEND' : 'INTERRUPT', reason: 'Smart Watchdog unavailable' };
+            return { decision: extensions === 0 ? 'EXTEND' : 'INTERRUPT', reason: '监控模型暂时不可用' };
         }
         try {
             return assertTimeoutDecision(result.structured);
         }
         catch {
-            return { decision: extensions === 0 ? 'EXTEND' : 'INTERRUPT', reason: 'Smart Watchdog invalid output' };
+            return { decision: extensions === 0 ? 'EXTEND' : 'INTERRUPT', reason: '监控模型返回了无效结果' };
         }
     }
     // ── executor runtime ───────────────────────────────────────────────────────
     async executeStep(state, step, signal) {
-        const capabilities = step.capabilities ?? [];
-        if (capabilities.includes('browser') && !this.host.hasTool(this.config.browserTools[0] ?? 'agent_browser')) {
+        const capabilities = normalizeCapabilities(step.capabilities) ?? [];
+        if (capabilities.includes('browser') && !this.config.browserTools.some((tool) => this.host.hasTool(tool))) {
             applyExecutorCapabilityUnavailable(state, step.id);
+            upsertStepResult(state, buildStepResult(step.id, state.current_step?.attempt ?? 1, buildEvidenceBundle({
+                executorOutput: state.commander?.summary,
+            })));
             this.store.writeState(state);
             return { done: false, ok: false };
         }
         let toolFilter;
         try {
-            const capabilityTools = capabilities.includes('browser') ? [...this.config.browserTools] : [];
-            toolFilter = this.toolAllow([...this.config.executorTools, ...capabilityTools], `executor ${step.id}`);
+            toolFilter = this.toolAllow(executorToolsFor(capabilities, this.config.browserTools, this.config.executorTools), `executor ${step.id}`);
         }
         catch (error) {
             const reason = truncateSafe(error instanceof Error ? error.message : String(error), 500);
@@ -364,6 +460,7 @@ export class OrbitSupervisor {
                 label: `executor-${step.id}`,
                 prompt: this.executorPrompt(state, step),
                 route: state.routes.executor,
+                workspace: join(this.store.stateDir, '..'),
                 toolFilter,
                 capabilities,
                 ...(signal ? { signal } : {}),
@@ -431,6 +528,7 @@ export class OrbitSupervisor {
                 telemetry: result.telemetry,
             }),
         };
+        upsertStepResult(state, buildStepResult(step.id, state.current_step?.attempt ?? 1, this.stepEvidence.bundle, state.test_summary));
         this.store.writeState(state);
         await this.disposeHandle(handle);
         return { done: false, ok: false };
@@ -441,6 +539,7 @@ export class OrbitSupervisor {
         const raced = await this.raceWithSleep(handle.result, timeoutMs, signal);
         if (raced.kind === 'work')
             return raced.value;
+        await this.cancelHandle(handle, raced.kind === 'aborted' ? 'ORBIT_ABORTED' : 'EXECUTOR_TIMEOUT');
         const telemetry = await handle.runtimeSnapshot?.();
         return {
             ...(handle.childId ? { childId: handle.childId } : {}),
@@ -452,16 +551,19 @@ export class OrbitSupervisor {
     }
     executorPrompt(state, step) {
         const lines = [
-            'You are the Orbit Executor. Implement exactly the current step with real tools and real verification.',
-            `Current step ${step.id}: ${step.goal}`,
-            `Working directory: ${join(this.store.stateDir, '..')}`,
-            `Hard constraints: ${state.user_hard_constraints.join('; ') || 'none'}`,
+            '你是 Orbit 执行员（Executor）。',
+            '你只负责执行当前步骤：不要重新规划整个任务，也不要自行改变当前步骤的目标。',
+            '必须使用真实工具完成实际操作，并对结果进行真实验证。',
+            '完成后用简体中文提交简洁的执行证据：做了什么、运行了哪些命令/测试、验证结果以及仍存在的风险。',
+            '你的自然语言输出、执行说明和总结默认全部使用简体中文；代码、命令、路径、provider/model ID 等机器标识保持原样。',
+            `当前步骤 ${step.id}：${step.goal}`,
+            `工作目录：${join(this.store.stateDir, '..')}`,
+            `硬性约束：${state.user_hard_constraints.join('；') || '无'}`,
         ];
         if (state.pending_user_reply)
-            lines.push(`User reply (the user's answer to the previous question): ${state.pending_user_reply}`);
+            lines.push(`用户回复（对上一个问题的回答）：${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.');
+            lines.push(`能力：${(step.capabilities ?? []).join(', ')}`);
         return lines.join('\n');
     }
     // ── decision application ───────────────────────────────────────────────────
@@ -497,7 +599,7 @@ export class OrbitSupervisor {
         if (decision.decision === 'APPEND') {
             const append = applyFinalAppend(state, decision);
             if (append === 'invalid') {
-                return this.setNeedsUser(state, 'COMMANDER_EVALUATION_OUTPUT_INVALID: append needs next_steps or next_step_goal');
+                return this.setNeedsUser(state, 'COMMANDER_EVALUATION_OUTPUT_INVALID: APPEND 需要 next_steps 或 next_step_goal');
             }
             this.store.writeState(state);
             if (append === 'budget_exhausted')
@@ -514,7 +616,7 @@ export class OrbitSupervisor {
     }
     async applyCorrection(state, step, decision, signal) {
         if (!step || !decision.next_step_goal) {
-            return this.setNeedsUser(state, 'COMMANDER_EVALUATION_OUTPUT_INVALID: correction needs next_step_goal');
+            return this.setNeedsUser(state, 'COMMANDER_EVALUATION_OUTPUT_INVALID: CORRECT_CURRENT_STEP 需要 next_step_goal');
         }
         const base = baseStepIdOf(step.id);
         const correctionDepth = correctionDepthOf(step.id);
@@ -559,7 +661,7 @@ export class OrbitSupervisor {
         const challengeValue = challengeResult.structured;
         const challenge = typeof challengeValue.question === 'string' ? challengeValue.question.trim() : '';
         if (!challenge)
-            return { kind: 'interrupted', reason: 'SMART_WATCHDOG_STRATEGY_OUTPUT_INVALID: question is required' };
+            return { kind: 'interrupted', reason: 'SMART_WATCHDOG_STRATEGY_OUTPUT_INVALID: 缺少 question' };
         const outcome = await this.runCommander(state, 'STRATEGY_RECONSIDER', COMMANDER_STRATEGY_PROMPT(state.goal, base, challenge, state), COMMANDER_STRATEGY_SCHEMA, signal);
         if (outcome.kind === 'needs_user')
             return { kind: 'needs_user', reason: outcome.reason };
@@ -674,7 +776,9 @@ export class OrbitSupervisor {
      * even on interruption or timeout.
      */
     async runAuxRole(state, request) {
-        const names = request.role === 'watchdog' ? this.config.watchdogTools : this.config.commanderReadOnlyTools;
+        const configured = request.role === 'watchdog' ? this.config.watchdogTools : this.config.commanderReadOnlyTools;
+        const readOnly = request.role === 'watchdog' ? EXECUTOR_READ_ONLY_TOOLS : READ_ONLY_ROLE_TOOLS;
+        const names = configured.filter((name) => readOnly.includes(name));
         let handle;
         try {
             handle = await this.host.startRole({
@@ -682,6 +786,7 @@ export class OrbitSupervisor {
                 label: request.label,
                 prompt: request.prompt,
                 route: state.routes[request.role],
+                workspace: join(this.store.stateDir, '..'),
                 toolFilter: this.toolAllow(names, request.role),
                 ...(request.outputSchema ? { outputSchema: request.outputSchema } : {}),
                 ...(request.signal ? { signal: request.signal } : {}),
@@ -755,7 +860,7 @@ export class OrbitSupervisor {
     stop(action, runId) {
         const state = this.store.readState();
         if (!state)
-            return { ok: false, action, message: 'ORBIT_RUN_NOT_FOUND: no active run.' };
+            return { ok: false, action, message: 'ORBIT_RUN_NOT_FOUND: 没有活动中的 Run。' };
         if (runId && runId !== state.run_id)
             return { ok: false, action, message: `ORBIT_RUN_NOT_FOUND: ${runId}` };
         stopRun(state);
@@ -765,7 +870,7 @@ export class OrbitSupervisor {
     async status() {
         const state = this.store.readState();
         if (!state)
-            return { ok: false, action: 'status', message: 'ORBIT_RUN_NOT_FOUND: no run state.' };
+            return { ok: false, action: 'status', message: 'ORBIT_RUN_NOT_FOUND: 没有 Run 状态。' };
         return this.result(state, true);
     }
     result(state, ok, message) {
@@ -785,6 +890,7 @@ export class OrbitSupervisor {
             guard_recovery: state.guard_recovery,
             last_error: state.last_error,
             pending_user_reply: state.pending_user_reply,
+            step_results: state.step_results,
             changed_files: state.changed_files,
             test_summary: state.test_summary,
             driver_ownership: state.driver_ownership,

package/lib/tool.js

@@ -2,11 +2,10 @@ import { defineTool } from '@deepseek-ai/dsh-tools';
 export const ORBIT_TOOL_NAME = 'orbit_controller';
 /** Legacy tool name kept as a backward-compatible alias. */
 export const LEGACY_CX_TOOL_NAME = 'cx_controller';
-const TOOL_DESCRIPTION = 'Drive Orbit engineering autonomy for the current project. Orbit runs a deterministic Supervisor ' +
-    '(Commander -> Executor -> Smart Watchdog) over a durable .cx/state.json. Use action "run" with a ' +
-    'goal to start or continue, "resume" to continue a persisted run, "status" to inspect, "stop" to ' +
-    'close the run, and "doctor" to check the environment. Only Orbit writes .cx durable state.';
-const LEGACY_TOOL_DESCRIPTION = `Legacy compatibility alias. Prefer ${ORBIT_TOOL_NAME}. ${TOOL_DESCRIPTION}`;
+const TOOL_DESCRIPTION = '驱动当前项目的 Orbit 工程编排。Orbit 由确定性的 Supervisor 控制 Commander、Executor 和 Smart Watchdog，' +
+    '并将状态保存到 .cx/state.json。使用 action "run" 启动或继续，"resume" 继续持久化运行，"status" 查看状态，' +
+    '"stop" 关闭运行，"doctor" 检查环境。只有 Orbit 可以写入 .cx 持久状态。';
+const LEGACY_TOOL_DESCRIPTION = `Legacy compatibility alias（兼容旧接口），请优先使用 ${ORBIT_TOOL_NAME}。${TOOL_DESCRIPTION}`;
 function summarize(result) {
     const lines = [`orbit ${result.action}: ok=${result.ok} phase=${result.phase ?? '-'} status=${result.status ?? '-'}`];
     if (result.run_id)
@@ -37,12 +36,12 @@ export function createOrbitTool(ctx, options = {}) {
         description: legacy ? LEGACY_TOOL_DESCRIPTION : TOOL_DESCRIPTION,
         parameters: {
             action: { type: 'string', required: true, enum: ['run', 'start', 'resume', 'stop', 'status', 'doctor'] },
-            goal: { type: 'string', description: 'The engineering goal (required for run/start).' },
-            preset: { type: 'string', description: 'Run preset id.' },
-            approved_loop_count: { type: 'integer', description: 'Explicit loop budget (positive, <= 10).' },
-            run_id: { type: 'string', description: 'Target run id for resume/stop.' },
+            goal: { type: 'string', description: '工程目标，run/start 时必填。' },
+            preset: { type: 'string', description: 'Run preset id。' },
+            approved_loop_count: { type: 'integer', description: '用户显式批准的 loop 预算，正整数且不超过 10。' },
+            run_id: { type: 'string', description: 'resume/stop 的目标 run id。' },
             user_hard_constraints: { type: 'array', items: { type: 'string' } },
-            github_allowed: { type: 'boolean', description: 'Allow GitHub remote writes for this run.' },
+            github_allowed: { type: 'boolean', description: '是否允许此 Run 执行 GitHub 远程写入。' },
         },
         output: {
             schema: { type: 'json' },
@@ -71,7 +70,7 @@ export function createOrbitTool(ctx, options = {}) {
             if (args.action === 'status')
                 return (await service.status(cwd));
             if (args.action === 'stop')
-                return service.stop(args.run_id, cwd);
+                return (await service.stop(args.run_id, cwd));
             if (args.action === 'doctor')
                 return (await service.doctor(cwd));
             if (args.action === 'resume')

package/lib/types.js

@@ -12,8 +12,9 @@ export const MAX_WATCHDOG_CALLS_PER_STEP = 2;
 export const MAX_EXECUTOR_INTERRUPT_RETRIES = 2;
 export const MAX_PLAN_STEPS = 5;
 export const MIN_PLAN_STEPS = 1;
-export const GUARD_FIRST_INSTRUCTION = 'Use a safer method and continue the current task. Do not retry the same blocked operation unchanged.';
-export const GUARD_REPEAT_INSTRUCTION = 'The same blocked operation was attempted again. Stop repeating it and choose a different safe approach.';
-export const GUARD_RETRY_INSTRUCTION = 'The previous approach repeatedly hit Orbit safety guards. Use a different safe approach. Do not retry the blocked operation.';
-export const GUARD_NEEDS_USER_INSTRUCTION = 'This restricted action appears necessary for the user goal. Orbit has paused for user guidance.';
-export const DEFAULT_CAPABILITIES = ['browser', 'web-api-recon'];
+export const DEFAULT_LOOP_BUDGET = 5;
+export const GUARD_FIRST_INSTRUCTION = '请改用更安全的方法继续当前任务，不要原样重试刚被阻断的操作。';
+export const GUARD_REPEAT_INSTRUCTION = '同一操作再次被阻断。请停止重复，并选择不同的安全方案。';
+export const GUARD_RETRY_INSTRUCTION = '之前的方案反复触发 Orbit 安全护栏。请改用不同的安全方案，不要重试被阻断的操作。';
+export const GUARD_NEEDS_USER_INSTRUCTION = '受限操作可能是完成目标所必需的。Orbit 已暂停并等待用户指引。';
+export const DEFAULT_CAPABILITIES = ['filesystem', 'shell', 'web', 'browser'];

package/package.json

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