dev-flow-deepseek 0.1.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,129 @@
+# dev-flow-deepseek
+
+`dev-flow-deepseek` is a prebuilt DeepSeek Harness bundle that connects
+the official DSH MCP client to an independently installed Dev Flow Orchestrator
+runtime. Its local STDIO projection proxy exposes exactly six tools and renders
+each complete Dev Flow result envelope as deterministic canonical JSON while
+preserving valid upstream success and domain-error semantics. The external
+Python Controller remains the only workflow and task-state authority.
+
+## Exact compatibility
+
+| Component | Supported baseline |
+|---|---|
+| This package | `0.1.0` |
+| DeepSeek Harness | `@deepseek-ai/dsh@0.1.0-rc.6`, npm SHA-1 `de9fbf39056c7f4e658a3e284cb1d66ebc86d040`, public source baseline `47f943859bef60e4160492346772ded9b24f765a` |
+| Dev Flow Orchestrator | release `0.6.12`, commit `7edd4fa12fe6787aac57f16246cbab00b8d79272` |
+| Dev Flow MCP interface | `dev-flow-mcp/1.0.0` |
+| Dev Flow result schema | `dev-flow-mcp-result/1.0.0` |
+| Dev Flow model namespace | `0.4.0` |
+| Node.js | `^22.19.0 || >=24.0.0` |
+| MCP SDK | `1.12.0` |
+
+Compatibility is exact. Later DSH or Dev Flow releases are not inferred to be
+compatible.
+
+## Prerequisites and installation
+
+Install DeepSeek Harness `0.1.0-rc.6` and the separate `dev-flow-mcp` executable
+from Dev Flow Orchestrator `0.6.12` before using this bundle. The executable may
+be on `PATH` or selected with an absolute `DEV_FLOW_MCP_COMMAND` value. This npm
+package does not install, update, repair, migrate, or remove Python, `uv`, or the
+Dev Flow runtime.
+
+Install the stable release into an isolated DSH profile:
+
+```sh
+dsh plugin --profile web add dev-flow-deepseek@latest
+```
+
+Alternatively, build and pack locally with the pinned package manager:
+
+```sh
+corepack pnpm@11.7.0 install --frozen-lockfile
+corepack pnpm@11.7.0 run build
+corepack pnpm@11.7.0 pack
+```
+
+Add the resulting tarball to an isolated DSH profile, for example the `web`
+profile, then remove it by package name when no longer needed:
+
+```sh
+dsh plugin --profile web add /absolute/path/dev-flow-deepseek-0.1.0.tgz
+dsh plugin --profile web remove dev-flow-deepseek
+```
+
+Removal deletes only the profile dependency and bundle layer. It does not
+delete Dev Flow task data.
+
+## Data and use
+
+By default the bundle sets `DEV_FLOW_DATA_DIR` to
+`$DSH_HOME/dev-flow-orchestrator/data`; the compatible backend appends its
+`0.4.0` namespace. This keeps DSH tasks separate from Codex Dev Flow data. An
+explicit `DEV_FLOW_DATA_DIR` set before DSH starts overrides that root.
+
+Inside one existing Git worktree, invoke the Skill explicitly:
+
+```text
+/dev-flow Implement the requested change and verify it.
+```
+
+The Skill validates the exact runtime identity, discovers a compatible active
+task or starts one `lite` task, follows only the Controller's fresh action and
+binding, and stops on the Controller's Delivery Dossier.
+
+The outward raw MCP surface is exactly:
+
+- `dev_flow_server_info`
+- `dev_flow_find_tasks_for_path`
+- `dev_flow_get_task`
+- `dev_flow_get_next_action`
+- `dev_flow_start_task`
+- `dev_flow_apply_action`
+
+## Supported and unsupported scope
+
+The MVP supports explicit `/dev-flow`, one current Git repository, compatible
+active `lite` task resume, new `lite` tasks, local STDIO, safe mutation
+read-after-write recovery, and complete spilled-result retrieval.
+
+It does not support implicit activation, multiple repositories, another
+workflow, task listing or cancellation, governance decisions, finding
+disposition, contract revision, custom DSH UI, runtime installation, a generic
+shell MCP, HTTP/SSE/remote MCP, OAuth, branch or worktree management, commits,
+pushes, pull requests, tags, or releases. Windows is unverified.
+
+## Troubleshooting
+
+- If no Dev Flow tools appear, confirm that the package layer is installed and
+  that `DEV_FLOW_MCP_COMMAND` resolves directly to the `0.6.12`
+  `dev-flow-mcp` executable. DSH remains usable when startup fails because the
+  bundle sets `failOnStartupError: false`.
+- If `/dev-flow` reports an incompatible identity, use the exact versions in
+  the compatibility table. Do not substitute a newer release.
+- If a mutation response is lost, do not replay it. The Skill rediscovers a
+  possibly created task or reads the task and fresh action before any retry.
+- If DSH reports a spilled, truncated, pruned, or preview result, the Skill
+  must read the complete saved canonical JSON text before using authority
+  fields.
+
+## Trust and verification
+
+The installed bundle executes its prebuilt Node proxy and the selected local
+Dev Flow executable outside the DSH agent sandbox. Install the package only
+from a publisher you trust. The proxy reduces ambient authority by using no
+shell, passing only a closed child environment, opening no listener, and
+exposing no tool outside the six-tool allowlist; it does not claim code signing,
+provenance attestation, automatic updates, or protection from a compromised
+publisher or runtime.
+
+Deterministic verification consists of 25 bounded unit cases, one local fake
+MCP suite with exactly eight scenarios, one package-contract check, strict
+OpenSpec validation, and the documented default gate. The real-runtime smoke is
+opt-in and requires Dev Flow `0.6.12`. A fake backend or static inspection is not
+evidence of a real DSH GUI journey. The recorded evidence verifies the real DSH
+happy path and restart/resume/removal journey on macOS arm64. The stable
+release artifact was separately revalidated for package installation, composed
+path resolution, and removal. Linux x64 and Windows remain `UNVERIFIED`; see
+`tests/manual/deepseek-harness-journey.md` for the exact evidence boundary.

package/cordis.patch.yml

@@ -0,0 +1,27 @@
+- insert:
+    - id: dev-flow-mcp
+      name: '@deepseek-ai/dsh-mcp-client'
+      config:
+        serverName: dev-flow
+        transport: stdio
+        command: !!js process.execPath
+        args:
+          - !!js process.getBuiltinModule('node:module').createRequire(baseUrl).resolve('dev-flow-deepseek/lib/proxy.js')
+        env:
+          DEV_FLOW_MCP_COMMAND: !!js process.env.DEV_FLOW_MCP_COMMAND ?? 'dev-flow-mcp'
+          DEV_FLOW_DATA_DIR: !!js process.env.DEV_FLOW_DATA_DIR ?? dshHomePath('dev-flow-orchestrator/data')
+        toolCallTimeoutMs: 120000
+        failOnStartupError: false
+        reconnect:
+          enabled: true
+          initialDelayMs: 500
+          maxDelayMs: 30000
+          maxAttempts: 10
+
+    - id: dev-flow-skill-provider
+      name: '@deepseek-ai/dsh-skill-filesystem'
+      config:
+        providerName: dev-flow-bundle
+        includeDefaultRoots: false
+        customSkillDirs:
+          - !!js process.getBuiltinModule('node:path').join(process.getBuiltinModule('node:path').dirname(process.getBuiltinModule('node:module').createRequire(baseUrl).resolve('dev-flow-deepseek/package.json')), 'skills')

package/lib/backend-client.js

@@ -0,0 +1,139 @@
+import { ADAPTER_ERROR_CODES, APPROVED_RAW_TOOLS, PACKAGE_NAME, PACKAGE_VERSION, SHUTDOWN_TIMEOUT_MS } from "./compatibility.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+
+//#region src/backend-client.ts
+const BACKEND_CALL_TIMEOUT_MS = 12e4;
+var BackendStartupError = class extends Error {
+	code;
+	constructor(code) {
+		if (!ADAPTER_ERROR_CODES.includes(code)) throw new TypeError("Backend startup error code is not approved.");
+		super("The Dev Flow projection proxy could not start its backend.");
+		this.name = "BackendStartupError";
+		this.code = code;
+	}
+};
+var OwnedStdioClientTransport = class extends StdioClientTransport {
+	#child;
+	#resolveClosed;
+	#closed = new Promise((resolve) => {
+		this.#resolveClosed = resolve;
+	});
+	spawned = false;
+	get closed() {
+		return this.#closed;
+	}
+	async start() {
+		await super.start();
+		this.spawned = true;
+		const child = this._process;
+		if (child === void 0) throw new BackendStartupError("BACKEND_START_FAILED");
+		this.#child = child;
+		child.once("close", (code, signal) => {
+			this.#resolveClosed?.({
+				code,
+				signal
+			});
+			this.#resolveClosed = void 0;
+		});
+	}
+	async close() {
+		const child = this.#child;
+		await super.close();
+		if (child === void 0 || child.exitCode !== null || child.signalCode !== null) return;
+		let timer;
+		const exited = await Promise.race([this.#closed.then(() => true), new Promise((resolve) => {
+			timer = setTimeout(() => resolve(false), SHUTDOWN_TIMEOUT_MS);
+			timer.unref();
+		})]);
+		if (timer !== void 0) clearTimeout(timer);
+		if (!exited && child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+	}
+};
+function isApprovedTool(name) {
+	return APPROVED_RAW_TOOLS.includes(name);
+}
+function filterCatalog(tools) {
+	const discovered = /* @__PURE__ */ new Map();
+	for (const tool of APPROVED_RAW_TOOLS) discovered.set(tool, []);
+	for (const tool of tools) if (isApprovedTool(tool.name)) discovered.get(tool.name)?.push(tool);
+	const filtered = [];
+	for (const name of APPROVED_RAW_TOOLS) {
+		const matches = discovered.get(name);
+		if (matches === void 0 || matches.length !== 1) throw new BackendStartupError("BACKEND_CATALOG_INVALID");
+		const definition = matches[0];
+		if (definition === void 0) throw new BackendStartupError("BACKEND_CATALOG_INVALID");
+		filtered.push(definition);
+	}
+	return Object.freeze(filtered);
+}
+async function discoverTools(client) {
+	const tools = [];
+	const seenCursors = /* @__PURE__ */ new Set();
+	let cursor;
+	do {
+		const page = await client.listTools(cursor === void 0 ? void 0 : { cursor });
+		tools.push(...page.tools);
+		cursor = page.nextCursor;
+		if (cursor !== void 0) {
+			if (seenCursors.has(cursor)) throw new BackendStartupError("BACKEND_CATALOG_INVALID");
+			seenCursors.add(cursor);
+		}
+	} while (cursor !== void 0);
+	return filterCatalog(tools);
+}
+var BackendClient = class BackendClient {
+	#client;
+	#transport;
+	tools;
+	constructor(client, transport, tools) {
+		this.#client = client;
+		this.#transport = transport;
+		this.tools = tools;
+	}
+	static async connect(config) {
+		const transport = new OwnedStdioClientTransport({
+			command: config.command,
+			args: [...config.args],
+			env: config.env,
+			cwd: config.cwd,
+			stderr: "ignore"
+		});
+		const client = new Client({
+			name: `${PACKAGE_NAME}-backend-client`,
+			version: PACKAGE_VERSION
+		}, { capabilities: {} });
+		try {
+			await client.connect(transport);
+		} catch {
+			await transport.close().catch(() => void 0);
+			throw new BackendStartupError(transport.spawned ? "BACKEND_INITIALIZE_FAILED" : "BACKEND_START_FAILED");
+		}
+		try {
+			const tools = await discoverTools(client);
+			return new BackendClient(client, transport, tools);
+		} catch {
+			await client.close().catch(() => void 0);
+			throw new BackendStartupError("BACKEND_CATALOG_INVALID");
+		}
+	}
+	get closed() {
+		return this.#transport.closed;
+	}
+	async call(tool, args, signal) {
+		return await this.#client.callTool({
+			name: tool,
+			arguments: args
+		}, void 0, {
+			signal,
+			timeout: BACKEND_CALL_TIMEOUT_MS,
+			maxTotalTimeout: BACKEND_CALL_TIMEOUT_MS
+		});
+	}
+	async close() {
+		await this.#client.close();
+	}
+};
+
+//#endregion
+export { BackendClient, BackendStartupError };

package/lib/canonical-json.js

@@ -0,0 +1,61 @@
+import { MAX_CANONICAL_JSON_BYTES, MAX_CANONICAL_JSON_DEPTH } from "./compatibility.js";
+
+//#region src/canonical-json.ts
+var CanonicalJsonError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CanonicalJsonError";
+	}
+};
+function reject(reason) {
+	throw new CanonicalJsonError(`Value is not lossless JSON: ${reason}.`);
+}
+function normalize(value, depth, ancestors) {
+	if (depth > 128) reject(`nesting exceeds depth ${128}`);
+	if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) reject("number is not finite");
+		return value;
+	}
+	if (typeof value !== "object") reject(`unsupported ${typeof value} value`);
+	if (ancestors.has(value)) reject("cycle detected");
+	ancestors.add(value);
+	try {
+		if (Array.isArray(value)) {
+			const result = [];
+			for (let index = 0; index < value.length; index += 1) {
+				if (!Object.hasOwn(value, index)) reject("sparse array hole detected");
+				result.push(normalize(value[index], depth + 1, ancestors));
+			}
+			if (Reflect.ownKeys(value).some((key) => {
+				if (key === "length") return false;
+				return typeof key !== "string" || !/^(0|[1-9]\d*)$/.test(key) || Number(key) >= value.length;
+			})) reject("array has non-index properties");
+			return result;
+		}
+		const prototype = Object.getPrototypeOf(value);
+		if (prototype !== Object.prototype && prototype !== null) reject("object is not plain");
+		const keys = Object.keys(value).sort();
+		const ownKeys = Reflect.ownKeys(value);
+		if (ownKeys.length !== keys.length || ownKeys.some((key) => typeof key !== "string")) reject("object has non-JSON properties");
+		const result = {};
+		const record = value;
+		for (const key of keys) {
+			const descriptor = Object.getOwnPropertyDescriptor(value, key);
+			if (descriptor === void 0 || descriptor.enumerable !== true || !("value" in descriptor)) reject("object has an accessor or non-enumerable property");
+			result[key] = normalize(record[key], depth + 1, ancestors);
+		}
+		return result;
+	} finally {
+		ancestors.delete(value);
+	}
+}
+function canonicalJson(value) {
+	const normalized = normalize(value, 0, /* @__PURE__ */ new WeakSet());
+	const text = JSON.stringify(normalized);
+	if (Buffer.byteLength(text, "utf8") > 524288) throw new CanonicalJsonError(`Canonical JSON exceeds ${MAX_CANONICAL_JSON_BYTES} UTF-8 bytes.`);
+	return text;
+}
+
+//#endregion
+export { CanonicalJsonError, canonicalJson };

package/lib/compatibility.js

@@ -0,0 +1,47 @@
+//#region src/compatibility.ts
+const PACKAGE_NAME = "dev-flow-deepseek";
+const PACKAGE_VERSION = "0.1.0";
+const NODE_ENGINE = "^22.19.0 || >=24.0.0";
+const OPENSPEC_VERSION = "1.7.0";
+const MCP_SDK_VERSION = "1.12.0";
+const DSH_VERSION = "0.1.0-rc.6";
+const DSH_COMMIT = "47f943859bef60e4160492346772ded9b24f765a";
+const DEV_FLOW_RELEASE = "0.6.12";
+const DEV_FLOW_COMMIT = "7edd4fa12fe6787aac57f16246cbab00b8d79272";
+const DEV_FLOW_MCP_INTERFACE = "dev-flow-mcp/1.0.0";
+const DEV_FLOW_RESULT_SCHEMA = "dev-flow-mcp-result/1.0.0";
+const DEV_FLOW_MODEL_NAMESPACE = "0.4.0";
+const APPROVED_RAW_TOOLS = Object.freeze([
+	"dev_flow_server_info",
+	"dev_flow_find_tasks_for_path",
+	"dev_flow_get_task",
+	"dev_flow_get_next_action",
+	"dev_flow_start_task",
+	"dev_flow_apply_action"
+]);
+const APPROVED_MODEL_TOOLS = Object.freeze([
+	"mcp__dev-flow__dev_flow_server_info",
+	"mcp__dev-flow__dev_flow_find_tasks_for_path",
+	"mcp__dev-flow__dev_flow_get_task",
+	"mcp__dev-flow__dev_flow_get_next_action",
+	"mcp__dev-flow__dev_flow_start_task",
+	"mcp__dev-flow__dev_flow_apply_action"
+]);
+const MUTATION_TOOLS = Object.freeze(["dev_flow_start_task", "dev_flow_apply_action"]);
+const ADAPTER_ERROR_SCHEMA = "dsh-dev-flow-proxy-error/1.0.0";
+const ADAPTER_ERROR_CODES = Object.freeze([
+	"BACKEND_START_FAILED",
+	"BACKEND_INITIALIZE_FAILED",
+	"BACKEND_CATALOG_INVALID",
+	"UPSTREAM_CALL_FAILED",
+	"UPSTREAM_RESULT_INVALID",
+	"REQUEST_CANCELLED"
+]);
+const MAX_CANONICAL_JSON_DEPTH = 128;
+const MAX_CANONICAL_JSON_BYTES = 524288;
+const MAX_ADAPTER_DIAGNOSTIC_BYTES = 4096;
+const SHUTDOWN_TIMEOUT_MS = 5e3;
+const STARTUP_EXIT_CODE = 2;
+
+//#endregion
+export { ADAPTER_ERROR_CODES, ADAPTER_ERROR_SCHEMA, APPROVED_MODEL_TOOLS, APPROVED_RAW_TOOLS, DEV_FLOW_COMMIT, DEV_FLOW_MCP_INTERFACE, DEV_FLOW_MODEL_NAMESPACE, DEV_FLOW_RELEASE, DEV_FLOW_RESULT_SCHEMA, DSH_COMMIT, DSH_VERSION, MAX_ADAPTER_DIAGNOSTIC_BYTES, MAX_CANONICAL_JSON_BYTES, MAX_CANONICAL_JSON_DEPTH, MCP_SDK_VERSION, MUTATION_TOOLS, NODE_ENGINE, OPENSPEC_VERSION, PACKAGE_NAME, PACKAGE_VERSION, SHUTDOWN_TIMEOUT_MS, STARTUP_EXIT_CODE };

package/lib/environment.js

@@ -0,0 +1,50 @@
+import path from "node:path";
+
+//#region src/environment.ts
+const CHILD_ENVIRONMENT_KEYS = Object.freeze([
+	"PATH",
+	"HOME",
+	"USERPROFILE",
+	"LOCALAPPDATA",
+	"SYSTEMROOT",
+	"COMSPEC",
+	"TEMP",
+	"TMP",
+	"TMPDIR",
+	"LANG",
+	"LC_ALL",
+	"LC_CTYPE"
+]);
+function validateCommand(command) {
+	if (command.length === 0 || command.trim() !== command || command.includes("\0") || command.includes("\n") || command.includes("\r")) throw new TypeError("DEV_FLOW_MCP_COMMAND must identify one direct executable.");
+	if (path.isAbsolute(command)) return command;
+	if (!/^[A-Za-z0-9._-]+$/.test(command)) throw new TypeError("DEV_FLOW_MCP_COMMAND must be an absolute path or a PATH-resolved executable name.");
+	return command;
+}
+function validateDataDirectory(value) {
+	if (value === void 0 || value.length === 0 || value.trim() !== value || value.includes("\0") || !path.isAbsolute(value)) throw new TypeError("DEV_FLOW_DATA_DIR must be a non-empty absolute path.");
+	return value;
+}
+function buildChildEnvironment(parent, dataDirectory) {
+	const env = {};
+	for (const key of CHILD_ENVIRONMENT_KEYS) {
+		const value = parent[key];
+		if (typeof value === "string" && value.length > 0) env[key] = value;
+	}
+	env.DEV_FLOW_DATA_DIR = dataDirectory;
+	return env;
+}
+function readBackendConfiguration(source = process.env, cwd = process.cwd()) {
+	const command = validateCommand(source.DEV_FLOW_MCP_COMMAND ?? "dev-flow-mcp");
+	const dataDirectory = validateDataDirectory(source.DEV_FLOW_DATA_DIR);
+	if (!path.isAbsolute(cwd)) throw new TypeError("The proxy working directory must be absolute.");
+	return Object.freeze({
+		command,
+		args: Object.freeze(["--stdio"]),
+		env: Object.freeze(buildChildEnvironment(source, dataDirectory)),
+		cwd
+	});
+}
+
+//#endregion
+export { buildChildEnvironment, readBackendConfiguration };

package/lib/proxy.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+import { APPROVED_RAW_TOOLS, MAX_ADAPTER_DIAGNOSTIC_BYTES, PACKAGE_NAME, PACKAGE_VERSION, STARTUP_EXIT_CODE } from "./compatibility.js";
+import { BackendClient, BackendStartupError } from "./backend-client.js";
+import { readBackendConfiguration } from "./environment.js";
+import { createAdapterErrorResult, projectBackendResult } from "./result-envelope.js";
+import process from "node:process";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+//#region src/proxy.ts
+function isApprovedTool(name) {
+	return APPROVED_RAW_TOOLS.includes(name);
+}
+function startupDiagnostic(code) {
+	const text = `dsh-dev-flow projection proxy startup failed (${code}).`;
+	if (Buffer.byteLength(text, "utf8") > 4096) return "dsh-dev-flow projection proxy startup failed.";
+	return text;
+}
+async function startProxy() {
+	let backend;
+	try {
+		backend = await BackendClient.connect(readBackendConfiguration());
+	} catch (error) {
+		const code = error instanceof BackendStartupError ? error.code : "BACKEND_START_FAILED";
+		process.stderr.write(`${startupDiagnostic(code)}\n`);
+		process.exitCode = 2;
+		return;
+	}
+	const server = new Server({
+		name: PACKAGE_NAME,
+		version: PACKAGE_VERSION
+	}, { capabilities: { tools: {} } });
+	server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [...backend.tools] }));
+	server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+		const name = request.params.name;
+		if (!isApprovedTool(name)) throw new TypeError("Requested tool is not exposed by this proxy.");
+		let upstream;
+		try {
+			upstream = await backend.call(name, request.params.arguments ?? {}, extra.signal);
+		} catch {
+			const code = extra.signal.aborted ? "REQUEST_CANCELLED" : "UPSTREAM_CALL_FAILED";
+			return createAdapterErrorResult(name, code);
+		}
+		try {
+			return projectBackendResult(name, upstream);
+		} catch {
+			return createAdapterErrorResult(name, "UPSTREAM_RESULT_INVALID");
+		}
+	});
+	const outwardTransport = new StdioServerTransport();
+	let shuttingDown = false;
+	const shutdown = async (exitCode) => {
+		if (shuttingDown) return;
+		shuttingDown = true;
+		if (exitCode !== 0) process.exitCode = exitCode;
+		await Promise.allSettled([server.close(), backend.close()]);
+	};
+	process.once("SIGINT", () => {
+		shutdown(0);
+	});
+	process.once("SIGTERM", () => {
+		shutdown(0);
+	});
+	backend.closed.then(() => {
+		if (!shuttingDown) shutdown(1);
+	});
+	try {
+		await server.connect(outwardTransport);
+	} catch {
+		process.stderr.write(`${startupDiagnostic("BACKEND_INITIALIZE_FAILED")}\n`);
+		await shutdown(2);
+		return;
+	}
+	const protocolClose = outwardTransport.onclose;
+	outwardTransport.onclose = () => {
+		protocolClose?.();
+		if (!shuttingDown) shutdown(0);
+	};
+}
+startProxy().catch(() => {
+	process.stderr.write(`${startupDiagnostic("BACKEND_INITIALIZE_FAILED")}\n`);
+	process.exitCode = 2;
+});
+
+//#endregion
+export {  };

package/lib/result-envelope.js

@@ -0,0 +1,105 @@
+import { ADAPTER_ERROR_CODES, ADAPTER_ERROR_SCHEMA, APPROVED_RAW_TOOLS, DEV_FLOW_RESULT_SCHEMA, MAX_ADAPTER_DIAGNOSTIC_BYTES } from "./compatibility.js";
+import { canonicalJson } from "./canonical-json.js";
+
+//#region src/result-envelope.ts
+const REQUEST_ID_PATTERN = /^mcp-[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+const ADAPTER_MESSAGES = Object.freeze({
+	BACKEND_START_FAILED: "The Dev Flow backend could not be started.",
+	BACKEND_INITIALIZE_FAILED: "The Dev Flow backend could not be initialized.",
+	BACKEND_CATALOG_INVALID: "The Dev Flow backend tool catalog is invalid.",
+	UPSTREAM_CALL_FAILED: "The Dev Flow backend call did not return a valid result.",
+	UPSTREAM_RESULT_INVALID: "The Dev Flow backend returned an invalid result.",
+	REQUEST_CANCELLED: "The Dev Flow backend call was cancelled before a valid result was received."
+});
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function hasExactKeys(value, expected) {
+	const actual = Object.keys(value).sort();
+	const sortedExpected = [...expected].sort();
+	return actual.length === sortedExpected.length && actual.every((key, index) => key === sortedExpected[index]);
+}
+function invalid(reason) {
+	throw new TypeError(`Invalid Dev Flow result envelope: ${reason}.`);
+}
+function validateDevFlowEnvelope(value, invokedTool) {
+	if (!APPROVED_RAW_TOOLS.includes(invokedTool)) invalid("invoked tool is not approved");
+	if (!isPlainObject(value)) invalid("structuredContent is not a plain object");
+	if (!hasExactKeys(value, [
+		"schema",
+		"ok",
+		"tool",
+		"request_id",
+		"result",
+		"error"
+	])) invalid("top-level fields do not match the closed envelope");
+	if (value.schema !== "dev-flow-mcp-result/1.0.0") invalid("schema identity does not match");
+	if (value.tool !== invokedTool) invalid("tool identity does not match the invoked tool");
+	if (typeof value.request_id !== "string" || !REQUEST_ID_PATTERN.test(value.request_id)) invalid("request_id does not match the pinned grammar");
+	if (typeof value.ok !== "boolean") invalid("ok is not boolean");
+	if (value.ok) {
+		if (value.error !== null) invalid("successful envelope error is not null");
+	} else {
+		if (value.result !== null) invalid("error envelope result is not null");
+		if (!isPlainObject(value.error)) invalid("error is not a plain object");
+		if (!hasExactKeys(value.error, [
+			"code",
+			"message",
+			"details",
+			"recovery"
+		])) invalid("error fields do not match the closed union");
+		if (typeof value.error.code !== "string" || value.error.code.length === 0) invalid("error code is not a non-empty string");
+		if (typeof value.error.message !== "string" || value.error.message.length === 0) invalid("error message is not a non-empty string");
+		if (!isPlainObject(value.error.details)) invalid("error details is not a plain object");
+		if (value.error.recovery !== null && !isPlainObject(value.error.recovery)) invalid("error recovery is neither a plain object nor null");
+	}
+	canonicalJson(value);
+	return value;
+}
+function projectBackendResult(invokedTool, upstream) {
+	const envelope = validateDevFlowEnvelope(upstream.structuredContent, invokedTool);
+	return {
+		...upstream,
+		content: [{
+			type: "text",
+			text: canonicalJson(envelope)
+		}]
+	};
+}
+function recoveryFor(tool) {
+	if (tool === "dev_flow_start_task") return Object.freeze(["dev_flow_find_tasks_for_path"]);
+	if (tool === "dev_flow_apply_action") return Object.freeze(["dev_flow_get_task", "dev_flow_get_next_action"]);
+	return Object.freeze([tool]);
+}
+function createAdapterErrorEnvelope(tool, code) {
+	if (!APPROVED_RAW_TOOLS.includes(tool)) throw new TypeError("Adapter error tool is not approved.");
+	if (!ADAPTER_ERROR_CODES.includes(code)) throw new TypeError("Adapter error code is not approved.");
+	const message = ADAPTER_MESSAGES[code];
+	if (Buffer.byteLength(message, "utf8") > 4096) throw new TypeError("Adapter diagnostic exceeds its fixed byte limit.");
+	return Object.freeze({
+		schema: ADAPTER_ERROR_SCHEMA,
+		ok: false,
+		tool,
+		error: Object.freeze({
+			code,
+			message,
+			mutation_uncertain: tool === "dev_flow_start_task" || tool === "dev_flow_apply_action",
+			recovery: recoveryFor(tool)
+		})
+	});
+}
+function createAdapterErrorResult(tool, code) {
+	const envelope = createAdapterErrorEnvelope(tool, code);
+	return {
+		content: [{
+			type: "text",
+			text: canonicalJson(envelope)
+		}],
+		isError: true
+	};
+}
+
+//#endregion
+export { createAdapterErrorEnvelope, createAdapterErrorResult, projectBackendResult, validateDevFlowEnvelope };

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "dev-flow-deepseek",
+  "version": "0.1.0",
+  "description": "DeepSeek Harness bundle for the external Dev Flow Orchestrator MCP runtime.",
+  "type": "module",
+  "license": "Apache-2.0",
+  "keywords": [
+    "deepseek",
+    "deepseek-harness",
+    "dev-flow",
+    "mcp",
+    "plugin"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Innocent-children/dev-flow-deepseek.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Innocent-children/dev-flow-deepseek/issues"
+  },
+  "homepage": "https://github.com/Innocent-children/dev-flow-deepseek#readme",
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  },
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "files": [
+    "lib/",
+    "cordis.patch.yml",
+    "skills/",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.12.0"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "4.0.9",
+    "@types/node": "22.15.3",
+    "js-yaml": "4.1.0",
+    "tsdown": "0.15.4",
+    "typescript": "5.8.3"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "scripts": {
+    "build": "tsdown && chmod 755 lib/proxy.js",
+    "typecheck": "tsc --noEmit",
+    "test": "node --test tests/unit/*.test.mjs tests/integration/proxy.test.mjs tests/package/package-contract.test.mjs",
+    "test:real": "node --test tests/integration/real-runtime.test.mjs",
+    "verify:package": "node scripts/verify-package.mjs"
+  }
+}

package/skills/dev-flow/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: dev-flow
+description: Start or resume a governed single-repository Dev Flow lite task.
+whenToUse: Use only when the user explicitly invokes /dev-flow for substantive repository work.
+disable-model-invocation: true
+user-invocable: true
+---
+
+# Dev Flow
+
+Use this Skill only after the user explicitly invokes `/dev-flow` with a
+substantive repository task. Never activate it for an ordinary coding request.
+
+Read [activation-and-routing.md](references/activation-and-routing.md) before
+discovering, selecting, starting, or applying a task.
+
+## Entry checks
+
+Before task discovery or mutation:
+
+1. Verify that all and only the required Dev Flow surface is available to this
+   Skill under these six model-facing names:
+   `mcp__dev-flow__dev_flow_server_info`,
+   `mcp__dev-flow__dev_flow_find_tasks_for_path`,
+   `mcp__dev-flow__dev_flow_get_task`,
+   `mcp__dev-flow__dev_flow_get_next_action`,
+   `mcp__dev-flow__dev_flow_start_task`, and
+   `mcp__dev-flow__dev_flow_apply_action`.
+2. Call `mcp__dev-flow__dev_flow_server_info` and parse its complete canonical
+   JSON text. Require server `dev-flow`, release `0.6.12`, model version and
+   model namespace `0.4.0`, interface `dev-flow-mcp/1.0.0`, result schema
+   `dev-flow-mcp-result/1.0.0`, transport `stdio`, and health status `ready`.
+   Stop and name the exact incompatible field when any value differs; never
+   infer compatibility from a version range.
+3. Require a substantive task after `/dev-flow`. Ask for the missing task and
+   do not create anything when the invocation is empty or conversational.
+4. Resolve the current worktree root with `git rev-parse --show-toplevel`.
+   Stop before discovery when it fails. The exact canonical result is the sole
+   repository root; reject requests that require another repository.
+
+If the runtime or tool surface is missing, report the separately installed
+`dev-flow-mcp` release `0.6.12` prerequisite. Do not install, update, repair, or
+replace the runtime.
+
+## Authority boundary
+
+The external Dev Flow Controller is the only workflow and task-state
+authority. For every step, use the fresh returned action, guidance, allowed
+effects, required evidence, payload schema, binding, repository set, recovery,
+and terminal result. Do not invent actions, payload fields, transitions,
+completion rules, task state, or a Delivery Dossier.
+
+Use ordinary DSH Bash, filesystem, and search tools only for the currently
+authorized repository work. Never use a generic shell MCP. Never create or
+switch a branch or worktree, and never commit, push, open a pull request,
+publish, tag, or release.
+
+Stop only when the Controller returns a terminal result, then report that
+result and its Delivery Dossier exactly.

package/skills/dev-flow/references/activation-and-routing.md

@@ -0,0 +1,89 @@
+# Activation and routing
+
+These rules refine explicit `/dev-flow` task selection and recovery. They do
+not define Controller actions, payload schemas, transitions, or terminal
+criteria.
+
+## Complete-result rule
+
+Treat tool text as authority only when it is the complete canonical JSON
+result. If any result mentions `spill`, `truncated`, `pruned`, `preview`, or
+`Full formatted result stored at`, use a normal DSH file-reading tool to read
+the complete saved text before parsing it. If the complete text cannot be
+read, stop. Never infer an action, binding, payload schema, repository set,
+recovery operation, or terminal result from a preview.
+
+## Select or start
+
+1. Call `mcp__dev-flow__dev_flow_find_tasks_for_path` with the exact current
+   canonical Git root. Inventory must be authoritative; stop if it is
+   unavailable or inconsistent.
+2. Discovery does not prove complete repository membership. For every
+   candidate that might be selected, call
+   `mcp__dev-flow__dev_flow_get_next_action` and use its fresh authority.
+3. Canonicalize every returned `repository_set.repositories[].path`. A
+   candidate is compatible only when its workflow is exactly `lite`, its
+   repository array has cardinality one, and that one canonical path equals
+   the current root. Reject subsets, supersets, different members,
+   multi-repository tasks, unrelated paths, and non-`lite` workflows.
+4. Resume one compatible active task when the result is unambiguous. If more
+   than one is compatible, present their bounded identities and ask the user
+   to choose; never select by recency. If discovery returns only incompatible
+   tasks, report the conflict and ask the user to resolve it outside this MVP.
+5. When authoritative discovery returns no candidate and the request is
+   substantive, call `mcp__dev-flow__dev_flow_start_task` with only the user
+   requirement, workflow `lite`, and a one-element repositories array holding
+   the current root. Omit custom task ID and contract fields.
+
+Never merge candidates, convert workflows, cancel tasks, revise contracts, or
+use an unexposed inventory or governance operation.
+
+## Drive current authority
+
+For each nonterminal result:
+
+1. Reconfirm exact one-root repository equality.
+2. Read the fresh action ID, objective, guidance, allowed effects, required
+   evidence, closed payload schema, and complete binding.
+3. Perform only that action in the current repository with normal DSH tools.
+4. Build a payload containing exactly the schema-declared fields.
+5. Call `mcp__dev-flow__dev_flow_apply_action` with the exact task ID, action
+   ID, payload, and unmodified current binding.
+6. Continue only from the fresh action returned by a successful mutation or a
+   new `mcp__dev-flow__dev_flow_get_next_action` read. Never reuse an old
+   binding.
+
+When the Controller returns a terminal result, report its Delivery Dossier.
+Do not announce completion before that authority exists.
+
+## Errors and mutation uncertainty
+
+A valid `dev-flow-mcp-result/1.0.0` envelope with `ok: false` remains a
+Controller domain error. Follow its recovery only when the named operation is
+one of the six exposed tools. If it requires a hidden governance,
+cancellation, finding, listing, or contract operation, report that the task is
+outside this MVP and stop.
+
+An adapter envelope with schema `dsh-dev-flow-proxy-error/1.0.0` is not a
+Controller result. For a failed read, wait until the six-tool surface is
+healthy and repeat that read at most once. Never reinterpret an adapter error
+as task state.
+
+If `mcp__dev-flow__dev_flow_start_task` loses or corrupts its response, assume
+neither success nor failure. Rediscover tasks for the current root and inspect
+fresh compatible authority before considering another start. Do not create a
+replacement for a task that may already exist.
+
+If `mcp__dev-flow__dev_flow_apply_action` loses or corrupts its response,
+assume neither success nor failure. First call
+`mcp__dev-flow__dev_flow_get_task`, then
+`mcp__dev-flow__dev_flow_get_next_action`, and compare the fresh revision,
+action, and binding. Retry only when that authority proves the mutation did not
+commit and the current binding still authorizes it. Never blindly replay a
+mutation.
+
+## Repository and product boundary
+
+Keep the repository set fixed at the one current user-prepared worktree. Do not
+manage Git topology or publishing. Do not install a runtime, add a UI, expose
+another MCP tool, use remote transport, or store adapter-owned task state.