@kasenri/dsh-orbit 0.5.1

package/lib/tool.js

@@ -0,0 +1,82 @@
+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}`;
+function summarize(result) {
+    const lines = [`orbit ${result.action}: ok=${result.ok} phase=${result.phase ?? '-'} status=${result.status ?? '-'}`];
+    if (result.run_id)
+        lines.push(`run_id: ${result.run_id}`);
+    if (result.message)
+        lines.push(`message: ${result.message}`);
+    const data = result.data;
+    if (data) {
+        if (data['loop'])
+            lines.push(`loop: ${JSON.stringify(data['loop'])}`);
+        if (data['current_step'])
+            lines.push(`current_step: ${JSON.stringify(data['current_step'])}`);
+        if (data['last_error'])
+            lines.push(`last_error: ${JSON.stringify(data['last_error'])}`);
+        if (Array.isArray(data['plan']))
+            lines.push(`plan: ${JSON.stringify(data['plan'])}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * One tool implementation shared by the canonical `orbit_controller` tool and
+ * the legacy `cx_controller` alias. Both names call the same OrbitService.
+ */
+export function createOrbitTool(ctx, options = {}) {
+    const legacy = options.legacy === true;
+    return defineTool({
+        name: legacy ? LEGACY_CX_TOOL_NAME : ORBIT_TOOL_NAME,
+        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.' },
+            user_hard_constraints: { type: 'array', items: { type: 'string' } },
+            github_allowed: { type: 'boolean', description: 'Allow GitHub remote writes for this run.' },
+        },
+        output: {
+            schema: { type: 'json' },
+            render: (_args, value) => {
+                const result = value;
+                return [{ type: 'text', text: summarize(result) }];
+            },
+        },
+        async execute(args, exec) {
+            // The service is provided by this plugin's own fiber; reading it through
+            // `agent.ctx` would require an inject declaration on the agent scope.
+            const scope = ctx;
+            const service = scope.orbit ?? scope.cx;
+            if (!service)
+                throw new Error('orbit service is unavailable; dsh-orbit is not loaded.');
+            const agent = exec.agent;
+            const cwd = agent?.session?.header?.cwd ?? process.cwd();
+            const input = {
+                ...(args.goal !== undefined ? { goal: args.goal } : {}),
+                ...(args.preset !== undefined ? { preset: args.preset } : {}),
+                ...(args.approved_loop_count !== undefined ? { approved_loop_count: args.approved_loop_count } : {}),
+                ...(args.run_id !== undefined ? { run_id: args.run_id } : {}),
+                ...(args.user_hard_constraints !== undefined ? { user_hard_constraints: args.user_hard_constraints } : {}),
+                ...(args.github_allowed !== undefined ? { github_allowed: args.github_allowed } : {}),
+            };
+            if (args.action === 'status')
+                return (await service.status(cwd));
+            if (args.action === 'stop')
+                return service.stop(args.run_id, cwd);
+            if (args.action === 'doctor')
+                return (await service.doctor(cwd));
+            if (args.action === 'resume')
+                return (await service.resume(input, cwd, exec.signal));
+            return (await service.run(input, cwd, exec.signal));
+        },
+    });
+}

package/lib/types.js

@@ -0,0 +1,19 @@
+/** Durable Orbit state and decision vocabulary. */
+export const ORBIT_SCHEMA_VERSION = 2;
+export const COMMANDER_SOFT_DEADLINE_MS = 6 * 60_000;
+export const COMMANDER_EXTENSION_MS = 4 * 60_000;
+export const COMMANDER_HARD_CEILING_MS = 14 * 60_000;
+export const EXECUTOR_TIMEOUT_MS = 8 * 60_000;
+export const WATCHDOG_TIMEOUT_MS = 2 * 60_000;
+export const GUARD_ESCALATION_THRESHOLD = 3;
+export const GUARD_RECOVERY_CAP = 4;
+export const MAX_CORRECTION_DEPTH = 2;
+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'];

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@kasenri/dsh-orbit",
+  "version": "0.5.1",
+  "type": "module",
+  "description": "Deterministic engineering orchestration for DeepSeek Harness with Commander, Executor, Smart Watchdog, bounded recovery and durable execution state.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/KasenRi/dsh-orbit-browser-plugins.git",
+    "directory": "packages/orbit"
+  },
+  "homepage": "https://github.com/KasenRi/dsh-orbit-browser-plugins/tree/main/packages/orbit#readme",
+  "bugs": {
+    "url": "https://github.com/KasenRi/dsh-orbit-browser-plugins/issues"
+  },
+  "keywords": [
+    "dsh-plugin",
+    "deepseek-harness",
+    "orbit",
+    "engineering-orchestration",
+    "agent-orchestration",
+    "autonomous-engineering",
+    "bounded-loop",
+    "workflow"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-api-remotes",
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-model-selection"
+      ]
+    }
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-agent": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-commands": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-llm": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-subagent": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-tools": "^0.1.5-rc.2"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh-commands": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-llm": {
+      "optional": true
+    }
+  }
+}