@quonaro/dsh-plugin-devin 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 quonaro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,80 @@
-# Temporary Holding Version
+# dsh-plugin-devin
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Unofficial bridge between the [Devin CLI](https://devin.ai) and DeepSeek Harness: a `devin` delegation tool plus a `/devin` command running `devin -p` (headless print mode), and a `devin` LLM provider route with automatic model discovery — all over the `ctx.subprocess` seam. Not affiliated with Cognition.
+
+## What the agent gets
+
+- **`devin` tool** — spawns `devin -p "<prompt>"` as a managed child process. Per-call `cwd`, `model`, `permissionMode`, `resume`, `cloud`, and `timeoutMs`. Returns `{ ok, exitCode, stdout, stderr, timedOut, truncated }`.
+- **`/devin <task>`** — slash command shortcut (when the profile composes the commands service).
+
+Cancelling the tool call aborts the child via the subprocess seam's terminate escalation (SIGTERM → grace → SIGKILL on the process tree); output capture is bounded and keeps the tail on overflow.
+
+## Prerequisites
+
+- `devin` CLI on `PATH` (or set `devinPath` to an absolute path)
+- `devin auth login` completed, or `WINDSURF_API_KEY` exported (forwarded to the child via `forwardEnv`)
+
+## Install
+
+```sh
+# from npm
+dsh plugin --profile <your-profile> add @quonaro/dsh-plugin-devin
+
+# or straight from a git host
+dsh plugin --profile <your-profile> add github:quonaro/dsh-plugin-devin
+
+# or from a local checkout
+dsh plugin --profile <your-profile> add /path/to/dsh-plugin-devin
+```
+
+The package declares `dsh.bundle`, so `dsh plugin add` applies `cordis.patch.yml` to the profile automatically. On pnpm ≥ 10 the first git install refuses the `prepare` build — copy the package key pnpm prints into the profile's `pnpm-workspace.yaml` `allowBuilds:` and re-run.
+
+## Configuration
+
+Edit the `dsh-plugin-devin` row in the profile's `cordis.patch.yml`, or the derived settings namespace in the GUI. All fields are volatile — changes apply to the next call without a restart.
+
+| Key | Default | Notes |
+| --- | --- | --- |
+| `devinPath` | `devin` | Executable name or absolute path |
+| `permissionMode` | `accept-edits` | Headless runs can't answer prompts; `bypass`/`autonomous` for fully unattended work |
+| `model` | `''` | Devin model; empty = CLI/account default |
+| `cloud` | `false` | `true` → `devin --cloud` (Devin Cloud sessions) |
+| `timeoutMs` | `600000` | Cooperative per-call timeout |
+| `maxOutputBytes` | `1048576` | In-memory cap per captured stream; tail kept on overflow |
+| `respectWorkspaceTrust` | `false` | `false` → passes `--respect-workspace-trust false` (required for `-p` in untrusted dirs) |
+| `forwardEnv` | PATH/HOME/USER/XDG_*/WINDSURF_API_KEY | Env var names forwarded to the child on top of the scrubbed base |
+| `extraArgs` | `[]` | Extra flags appended verbatim, e.g. `['--sandbox']` |
+
+## Develop
+
+```sh
+pnpm install
+pnpm test        # typecheck + tsdown build + smoke test (uses a fake devin binary)
+```
+
+## Notes
+
+- The plugin hard-injects `tools` and `subprocess` — profiles must compose a subprocess provider (all shipped base profiles do; `sdk-minimal` does not).
+- `--print` mode fails on the workspace-trust prompt in untrusted directories; that's why `respectWorkspaceTrust: false` is the default. Set it `true` if you prefer Devin's own trust flow.
+- An alternative shape — a persistent `devin acp` bridge with resumable sessions — is deliberately out of scope for v0.1; `resume` still lets you chain `-p` calls by session ID.
+
+## Provider half (`@quonaro/dsh-plugin-devin/provider`)
+
+The package also ships an LLM-adapter entry point that registers `devin` as a **provider route** — it shows up in Settings → Models and `/model`, and the whole dsh agent loop can run on it.
+
+Each generation spawns `devin -p` with the flattened conversation transcript and streams stdout back as one text block. `listModels` probes `devin acp` (ACP `initialize` + `session/new`) for the account's real model catalog and falls back to the static `models` table (`{id, devinModel, name}`) on failure; the session-title aux call is answered locally when `localSessionTitles` is on.
+
+**Semantics:** Devin is an agent, not a model. Every model call is a complete headless Devin session running its own tool loop — per-response latency is minutes, and harness-side tools are never invoked. The `devin` *tool* (main entry) is the right shape for delegation; the provider exists for routing whole conversations through Devin.
+
+| Extra config | Default | Notes |
+| --- | --- | --- |
+| `cwd` | `''` | Working dir for spawned sessions; empty = harness cwd |
+| `timeoutMs` | `1800000` | Provider calls get a longer budget than tool calls |
+| `models` | `default`, `opus` | Advertised model ids → `--model` value + display name |
+| `brief` | (English wrapper) | Instruction prepended to each flattened transcript |
+| `localSessionTitles` | `true` | Don't spend a Devin run on session-title generation |
+| `autoDiscoverModels` | `true` | Probe `devin acp` (`initialize` + `session/new`) for the account's real model catalog — the same mechanism ACP clients like Zed use. Falls back to the static `models` table on failure |
+| `discoveryTimeoutMs` | `60000` | Timeout for one discovery probe |
+| `discoveryCacheMs` | `300000` | Cache a successful probe before re-probing |
+
+Both halves are independent rows in `cordis.patch.yml` — remove `dsh-plugin-devin-provider` to keep only the tool, or `dsh-plugin-devin` to keep only the provider.

package/cordis.patch.yml

@@ -0,0 +1,72 @@
+# Bundle config layer for dsh-plugin-devin. Applied to a profile by `dsh plugin add`.
+#
+# The row `id` is also the settings namespace the loader derives for volatile
+# Config fields, so it must match `name` in package.json and src/index.ts.
+- insert:
+    - id: dsh-plugin-devin
+      name: '@quonaro/dsh-plugin-devin'
+      config:
+        # Path or PATH-resolved name of the Devin CLI executable.
+        devinPath: 'devin'
+        # Permission mode passed as `--permission-mode`. Headless `devin -p`
+        # cannot answer prompts, so pick a mode that does not stall:
+        # accept-edits auto-approves file edits, bypass auto-approves everything.
+        permissionMode: 'accept-edits'
+        # Default model for spawned sessions; empty means the CLI/account default.
+        model: ''
+        # Pass --cloud to drive Devin Cloud sessions instead of the local agent.
+        cloud: false
+        # Cooperative timeout for one delegation call.
+        timeoutMs: 600000
+        # In-memory cap per output stream; overflow keeps the tail.
+        maxOutputBytes: 1048576
+        # When false (default) the plugin passes `--respect-workspace-trust false`
+        # so non-interactive runs do not fail in untrusted directories.
+        respectWorkspaceTrust: false
+        # Environment variable names forwarded to the devin child process on top
+        # of the subprocess seam's scrubbed base. Devin needs HOME/XDG paths to
+        # find stored credentials; WINDSURF_API_KEY is forwarded when present.
+        forwardEnv:
+          - PATH
+          - HOME
+          - USER
+          - XDG_CONFIG_HOME
+          - XDG_DATA_HOME
+          - WINDSURF_API_KEY
+        # Extra CLI flags appended verbatim before the prompt, e.g. ['--sandbox'].
+        extraArgs: []
+
+    # Provider half: registers `devin` as an LLM provider route (Settings → Models).
+    # Remove this row if you only want the delegation tool.
+    - id: dsh-plugin-devin-provider
+      name: '@quonaro/dsh-plugin-devin/provider'
+      config:
+        devinPath: 'devin'
+        permissionMode: 'accept-edits'
+        cloud: false
+        cwd: ''
+        timeoutMs: 1800000
+        stderrMaxBytes: 65536
+        respectWorkspaceTrust: false
+        forwardEnv:
+          - PATH
+          - HOME
+          - USER
+          - XDG_CONFIG_HOME
+          - XDG_DATA_HOME
+          - WINDSURF_API_KEY
+        extraArgs: []
+        models:
+          - id: default
+            devinModel: ''
+            name: 'Devin (account default)'
+          - id: opus
+            devinModel: 'opus'
+            name: 'Devin Opus'
+        localSessionTitles: true
+        # Probe `devin acp` (initialize + session/new) for the account's real
+        # model catalog; falls back to the static `models` table on failure.
+        autoDiscoverModels: true
+        discoveryTimeoutMs: 60000
+        # Cache a successful probe this long before re-probing.
+        discoveryCacheMs: 300000

package/lib/index.d.ts

@@ -0,0 +1,79 @@
+import Schema from "@deepseek-ai/schemastery";
+import { Context, Volatile } from "@deepseek-ai/cordis";
+//#region src/index.d.ts
+/** Host plugin name; must match package.json `name` and the cordis.patch.yml row id. */
+declare const name = "@quonaro/dsh-plugin-devin";
+/** Services this plugin needs before it loads: the tool registry and a subprocess provider. */
+declare const inject: string[];
+/** Plugin configuration; every field is a Volatile re-read at each call. */
+interface Config {
+  /** Path or PATH-resolved name of the Devin CLI executable. */
+  devinPath: Volatile<string>;
+  /** `--permission-mode` for spawned sessions; headless runs cannot answer prompts. */
+  permissionMode: Volatile<string>;
+  /** Default `--model`; empty string means the CLI/account default. */
+  model: Volatile<string>;
+  /** Spawn with `--cloud` to drive Devin Cloud sessions instead of the local agent. */
+  cloud: Volatile<boolean>;
+  /** Cooperative timeout in milliseconds for one delegation call. */
+  timeoutMs: Volatile<number>;
+  /** In-memory cap per captured stream; overflow keeps the tail. */
+  maxOutputBytes: Volatile<number>;
+  /** When false, `--respect-workspace-trust false` is passed (non-interactive runs cannot show the trust prompt). */
+  respectWorkspaceTrust: Volatile<boolean>;
+  /** Environment variable names forwarded to the devin child process. */
+  forwardEnv: Volatile<string[]>;
+  /** Extra CLI flags appended verbatim before the prompt. */
+  extraArgs: Volatile<string[]>;
+}
+/** Schemastery schema: defaults live here; cordis.yml and GUI edits are validated against it. */
+declare const Config: Schema<Schemastery.ObjectS<NoInfer<{
+  devinPath: Schema<string, string, "volatile-defined">;
+  permissionMode: Schema<"normal" | "accept-edits" | "smart" | "bypass" | "autonomous", "normal" | "accept-edits" | "smart" | "bypass" | "autonomous", "volatile-defined">;
+  model: Schema<string, string, "volatile-defined">;
+  cloud: Schema<boolean, boolean, "volatile-defined">;
+  timeoutMs: Schema<number, number, "volatile-defined">;
+  maxOutputBytes: Schema<number, number, "volatile-defined">;
+  respectWorkspaceTrust: Schema<boolean, boolean, "volatile-defined">;
+  forwardEnv: Schema<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+  extraArgs: Schema<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+  devinPath: Schema<string, string, "volatile-defined">;
+  permissionMode: Schema<"normal" | "accept-edits" | "smart" | "bypass" | "autonomous", "normal" | "accept-edits" | "smart" | "bypass" | "autonomous", "volatile-defined">;
+  model: Schema<string, string, "volatile-defined">;
+  cloud: Schema<boolean, boolean, "volatile-defined">;
+  timeoutMs: Schema<number, number, "volatile-defined">;
+  maxOutputBytes: Schema<number, number, "volatile-defined">;
+  respectWorkspaceTrust: Schema<boolean, boolean, "volatile-defined">;
+  forwardEnv: Schema<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+  extraArgs: Schema<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+}>>, "plain">;
+/** /devin command payload shape (minimal subset of dsh-commands CommandInvocation). */
+interface DevinCommandInvocation {
+  readonly rawInput: string;
+}
+interface DevinCommandResult {
+  kind: 'success' | 'error';
+  text?: string;
+}
+interface DevinCommandsLike {
+  register(definition: {
+    readonly name: string;
+    readonly description: string;
+    readonly handler: (invocation: DevinCommandInvocation) => DevinCommandResult | Promise<DevinCommandResult>;
+  }): unknown;
+}
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    /** Command registry (provided at runtime by @deepseek-ai/dsh-commands, optional). */
+    commands: DevinCommandsLike;
+  }
+}
+/**
+ * Plugin body: register the `devin` tool, and `/devin` when a commands
+ * service is composed. All registrations are effects — unloading the plugin
+ * reverts them automatically.
+ */
+declare function apply(ctx: Context, config: Config): void;
+//#endregion
+export { Config, apply, inject, name };

package/lib/index.js

@@ -0,0 +1,209 @@
+import { n as forwardedEnv, t as devinPrintArgv } from "./shared-ClK2vJrs.js";
+import Schema from "@deepseek-ai/schemastery";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+//#region src/index.ts
+/** Host plugin name; must match package.json `name` and the cordis.patch.yml row id. */
+const name = "@quonaro/dsh-plugin-devin";
+/** Services this plugin needs before it loads: the tool registry and a subprocess provider. */
+const inject = ["tools", "subprocess"];
+/** Schemastery schema: defaults live here; cordis.yml and GUI edits are validated against it. */
+const Config = Schema.object({
+	devinPath: Schema.string().default("devin").volatile(),
+	permissionMode: Schema.union([
+		"normal",
+		"accept-edits",
+		"smart",
+		"bypass",
+		"autonomous"
+	]).default("accept-edits").volatile(),
+	model: Schema.string().default("").volatile(),
+	cloud: Schema.boolean().default(false).volatile(),
+	timeoutMs: Schema.number().default(6e5).volatile(),
+	maxOutputBytes: Schema.number().default(1048576).volatile(),
+	respectWorkspaceTrust: Schema.boolean().default(false).volatile(),
+	forwardEnv: Schema.array(Schema.string()).default([
+		"PATH",
+		"HOME",
+		"USER",
+		"XDG_CONFIG_HOME",
+		"XDG_DATA_HOME",
+		"WINDSURF_API_KEY"
+	]).volatile(),
+	extraArgs: Schema.array(Schema.string()).default([]).volatile()
+});
+/** Spawn `devin -p` once and collect bounded stdout/stderr. Shared by the tool and the command. */
+async function runDevin(ctx, config, options) {
+	const env = forwardedEnv(config.forwardEnv.get());
+	const executable = await ctx.subprocess.resolveExecutable(config.devinPath.get(), env, options.signal);
+	const timeoutMs = options.timeoutMs ?? config.timeoutMs.get();
+	const argv = [executable, ...devinPrintArgv({
+		model: options.model ?? config.model.get(),
+		permissionMode: options.permissionMode ?? config.permissionMode.get(),
+		cloud: options.cloud ?? config.cloud.get(),
+		resume: options.resume,
+		respectWorkspaceTrust: config.respectWorkspaceTrust.get(),
+		extraArgs: config.extraArgs.get()
+	}, options.prompt)];
+	const timeout = AbortSignal.timeout(timeoutMs);
+	const signal = options.signal ? AbortSignal.any([options.signal, timeout]) : timeout;
+	const maxBytes = config.maxOutputBytes.get();
+	const handle = ctx.subprocess.spawn({
+		argv,
+		cwd: options.cwd,
+		stdio: {
+			stdin: "ignore",
+			stdout: { maxBytes },
+			stderr: { maxBytes }
+		},
+		graceMs: 1e4,
+		signal,
+		env
+	});
+	const outcome = await handle.done;
+	const stdout = handle.collected.stdout?.readFrom(0);
+	const stderr = handle.collected.stderr?.readFrom(0);
+	const timedOut = timeout.aborted;
+	return {
+		ok: !timedOut && outcome.exitCode === 0,
+		exitCode: outcome.exitCode ?? -1,
+		signal: outcome.signal ?? "",
+		timedOut,
+		truncated: Boolean(stdout?.lossy || stderr?.lossy),
+		stdout: stdout?.text ?? "",
+		stderr: stderr?.text ?? ""
+	};
+}
+function renderResult(result) {
+	const head = result.timedOut ? "devin timed out and was terminated." : result.ok ? "devin finished successfully." : `devin exited with code ${result.exitCode}${result.signal ? ` (signal ${result.signal})` : ""}.`;
+	const tail = result.truncated ? "\n[output truncated — tail shown]" : "";
+	return `${head}\n\n${result.stdout || "(no stdout)"}${result.stderr ? `\n\n--- stderr ---\n${result.stderr}` : ""}${tail}`;
+}
+/**
+* Plugin body: register the `devin` tool, and `/devin` when a commands
+* service is composed. All registrations are effects — unloading the plugin
+* reverts them automatically.
+*/
+function apply(ctx, config) {
+	ctx.tools.register(defineTool({
+		name: "devin",
+		description: "Delegate a task to the Devin CLI agent (`devin -p`, headless). Devin works autonomously in the given directory and its final answer is returned as text. Prefer this for self-contained chunks of work you want a second agent to own end-to-end. The call blocks until Devin finishes or the configured timeout fires.",
+		parameters: {
+			prompt: {
+				type: "string",
+				required: true,
+				description: "The task for Devin, written self-contained — it does not see this conversation."
+			},
+			cwd: {
+				type: "string",
+				description: "Working directory for the Devin session. Defaults to the current directory."
+			},
+			model: {
+				type: "string",
+				description: "Devin model override for this call (e.g. \"opus\"). Defaults to the plugin config value."
+			},
+			permissionMode: {
+				type: "string",
+				enum: [
+					"normal",
+					"accept-edits",
+					"smart",
+					"bypass",
+					"autonomous"
+				],
+				description: "Permission mode for the spawned session. Headless runs cannot answer prompts; the default comes from plugin config."
+			},
+			resume: {
+				type: "string",
+				description: "Resume an existing Devin session by ID (or cloud session URL with cloud=true) instead of starting a new one."
+			},
+			cloud: {
+				type: "boolean",
+				description: "Drive a Devin Cloud session instead of the local agent. Defaults to the plugin config value."
+			},
+			timeoutMs: {
+				type: "number",
+				description: "Timeout in milliseconds for this call. Defaults to the plugin config value."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				properties: {
+					ok: {
+						type: "boolean",
+						required: true
+					},
+					exitCode: {
+						type: "integer",
+						required: true
+					},
+					signal: {
+						type: "string",
+						required: true
+					},
+					timedOut: {
+						type: "boolean",
+						required: true
+					},
+					truncated: {
+						type: "boolean",
+						required: true
+					},
+					stdout: {
+						type: "string",
+						required: true
+					},
+					stderr: {
+						type: "string",
+						required: true
+					}
+				},
+				additionalProperties: false
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: renderResult(value)
+			}]
+		},
+		async execute(args, exec) {
+			return runDevin(ctx, config, {
+				prompt: args.prompt,
+				cwd: args.cwd ?? process.cwd(),
+				model: args.model,
+				permissionMode: args.permissionMode,
+				resume: args.resume,
+				cloud: args.cloud,
+				timeoutMs: args.timeoutMs,
+				signal: exec.signal
+			});
+		},
+		presentResult: (_args, result) => ({
+			card: "generic",
+			title: "devin",
+			content: result.content
+		})
+	}));
+	ctx.inject(["commands"], (commandCtx) => {
+		commandCtx.commands.register({
+			name: "devin",
+			description: "Delegate a task to the Devin CLI (devin -p). Usage: /devin <task>",
+			handler: async ({ rawInput }) => {
+				const prompt = rawInput.trim();
+				if (!prompt) return {
+					kind: "error",
+					text: "Usage: /devin <task for Devin>"
+				};
+				const result = await runDevin(ctx, config, {
+					prompt,
+					cwd: process.cwd()
+				});
+				return {
+					kind: result.ok ? "success" : "error",
+					text: renderResult(result)
+				};
+			}
+		});
+	});
+}
+//#endregion
+export { Config, apply, inject, name };

package/lib/provider.d.ts

@@ -0,0 +1,112 @@
+import Schema from "@deepseek-ai/schemastery";
+import { Context, Volatile } from "@deepseek-ai/cordis";
+//#region node_modules/.pnpm/@deepseek-ai+cosmokit@1.8.5/node_modules/@deepseek-ai/cosmokit/lib/types/misc.d.ts
+/** String/symbol keyed dictionary type. */
+type Dict<T = any, K extends string | symbol = string> = { [key in K]: T; };
+//#endregion
+//#region src/provider.d.ts
+/** Plugin name; the cordis.patch.yml row uses the `@quonaro/dsh-plugin-devin/provider` specifier. */
+declare const name = "@quonaro/dsh-plugin-devin/provider";
+/** Services this plugin needs: the llm adapter registry and a subprocess provider. */
+declare const inject: string[];
+/** Plugin configuration; every field is a Volatile re-read at each call. */
+interface Config {
+  /** Path or PATH-resolved name of the Devin CLI executable. */
+  devinPath: Volatile<string>;
+  /** `--permission-mode` for spawned sessions; headless runs cannot answer prompts. */
+  permissionMode: Volatile<string>;
+  /** Spawn with `--cloud` to drive Devin Cloud sessions instead of the local agent. */
+  cloud: Volatile<boolean>;
+  /** Working directory for every spawned session; empty = the harness cwd. */
+  cwd: Volatile<string>;
+  /** Cooperative timeout in milliseconds per generation. Devin runs are slow. */
+  timeoutMs: Volatile<number>;
+  /** In-memory cap for the captured stderr tail surfaced on failure. */
+  stderrMaxBytes: Volatile<number>;
+  /** When false, `--respect-workspace-trust false` is passed. */
+  respectWorkspaceTrust: Volatile<boolean>;
+  /** Environment variable names forwarded to the devin child process. */
+  forwardEnv: Volatile<string[]>;
+  /** Extra CLI flags appended verbatim before the prompt. */
+  extraArgs: Volatile<string[]>;
+  /**
+   * Advertised models, in selector order. `id` is the route model id passed via
+   * GenerateOptions.model; `devinModel` is the `--model` value ('' = the
+   * CLI/account default); `name` is the display name in the model selector.
+   */
+  models: Volatile<{
+    id: string;
+    devinModel: string;
+    name: string;
+  }[]>;
+  /**
+   * Instruction prepended to every flattened transcript, telling Devin it runs
+   * as a model backend and must finish autonomously.
+   */
+  brief: Volatile<string>;
+  /** Answer session-title requests locally instead of spending a Devin run on them. */
+  localSessionTitles: Volatile<boolean>;
+  /** Probe `devin acp` for the account's real model catalog instead of using the static `models` table. */
+  autoDiscoverModels: Volatile<boolean>;
+  /** Timeout for one ACP discovery probe (initialize + session/new). */
+  discoveryTimeoutMs: Volatile<number>;
+  /** How long a successful discovery result is cached before re-probing. */
+  discoveryCacheMs: Volatile<number>;
+}
+/** Schemastery schema: defaults live here; cordis.yml and GUI edits are validated against it. */
+declare const Config: Schema<Schemastery.ObjectS<NoInfer<{
+  devinPath: Schema<string, string, "volatile-defined">;
+  permissionMode: Schema<"normal" | "accept-edits" | "smart" | "bypass" | "autonomous", "normal" | "accept-edits" | "smart" | "bypass" | "autonomous", "volatile-defined">;
+  cloud: Schema<boolean, boolean, "volatile-defined">;
+  cwd: Schema<string, string, "volatile-defined">;
+  timeoutMs: Schema<number, number, "volatile-defined">;
+  stderrMaxBytes: Schema<number, number, "volatile-defined">;
+  respectWorkspaceTrust: Schema<boolean, boolean, "volatile-defined">;
+  forwardEnv: Schema<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+  extraArgs: Schema<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+  models: Schema<NoInfer<({
+    id?: string | null;
+    devinModel?: string | null;
+    name?: string | null;
+  } & Dict)[]>, NoInfer<Schemastery.ObjectT<NoInfer<{
+    id: Schema<string, string, "plain">;
+    devinModel: Schema<string, string, "defined">;
+    name: Schema<string, string, "defined">;
+  }>>[]>, "volatile-defined">;
+  brief: Schema<string, string, "volatile-defined">;
+  localSessionTitles: Schema<boolean, boolean, "volatile-defined">;
+  autoDiscoverModels: Schema<boolean, boolean, "volatile-defined">;
+  discoveryTimeoutMs: Schema<number, number, "volatile-defined">;
+  discoveryCacheMs: Schema<number, number, "volatile-defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+  devinPath: Schema<string, string, "volatile-defined">;
+  permissionMode: Schema<"normal" | "accept-edits" | "smart" | "bypass" | "autonomous", "normal" | "accept-edits" | "smart" | "bypass" | "autonomous", "volatile-defined">;
+  cloud: Schema<boolean, boolean, "volatile-defined">;
+  cwd: Schema<string, string, "volatile-defined">;
+  timeoutMs: Schema<number, number, "volatile-defined">;
+  stderrMaxBytes: Schema<number, number, "volatile-defined">;
+  respectWorkspaceTrust: Schema<boolean, boolean, "volatile-defined">;
+  forwardEnv: Schema<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+  extraArgs: Schema<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+  models: Schema<NoInfer<({
+    id?: string | null;
+    devinModel?: string | null;
+    name?: string | null;
+  } & Dict)[]>, NoInfer<Schemastery.ObjectT<NoInfer<{
+    id: Schema<string, string, "plain">;
+    devinModel: Schema<string, string, "defined">;
+    name: Schema<string, string, "defined">;
+  }>>[]>, "volatile-defined">;
+  brief: Schema<string, string, "volatile-defined">;
+  localSessionTitles: Schema<boolean, boolean, "volatile-defined">;
+  autoDiscoverModels: Schema<boolean, boolean, "volatile-defined">;
+  discoveryTimeoutMs: Schema<number, number, "volatile-defined">;
+  discoveryCacheMs: Schema<number, number, "volatile-defined">;
+}>>, "plain">;
+/**
+ * Plugin body: register the `devin` provider route and declare it in the
+ * configurable-provider directory so the web Models page can see it.
+ */
+declare function apply(ctx: Context, config: Config): void;
+//#endregion
+export { Config, type Dict, apply, inject, name };

package/lib/provider.js

@@ -0,0 +1,447 @@
+import { n as forwardedEnv, t as devinPrintArgv } from "./shared-ClK2vJrs.js";
+import Schema from "@deepseek-ai/schemastery";
+//#region src/discover.ts
+function isModeOption(c) {
+	return c.category === "mode" || c.id === "mode" || c.id.includes("permission_mode") || c.id.includes("cognition/permission");
+}
+function isModelOption(c) {
+	return c.category === "model" || !isModeOption(c) && c.id.includes("model");
+}
+/** Flatten a select option's `options` (flat list or grouped sub-lists). */
+function flattenOptions(opt) {
+	const out = [];
+	for (const entry of opt?.options ?? []) {
+		const items = Array.isArray(entry.options) ? entry.options : [entry];
+		for (const item of items) {
+			if (item.value === void 0 || item.value === null) continue;
+			const id = String(item.value);
+			out.push({
+				id,
+				name: item.name ?? item.label ?? id,
+				description: item.description
+			});
+		}
+	}
+	return out;
+}
+/** Extract the model catalog from a session/new result. */
+function modelsFromSessionNew(result) {
+	const configOptions = result?.configOptions;
+	if (!Array.isArray(configOptions)) return null;
+	const modelOpt = configOptions.find(isModelOption);
+	const models = flattenOptions(modelOpt);
+	if (models.length === 0) return null;
+	return {
+		models,
+		currentId: modelOpt?.currentValue === void 0 ? void 0 : String(modelOpt.currentValue)
+	};
+}
+/**
+* Discover the model catalog by probing `devin acp`.
+* The child is terminated once session/new answers (or the timeout aborts it).
+*/
+async function discoverModelsViaAcp(ctx, opts) {
+	const env = forwardedEnv(opts.env);
+	const executable = await ctx.subprocess.resolveExecutable(opts.devinPath, env, opts.signal);
+	const timeout = AbortSignal.timeout(opts.timeoutMs);
+	const signal = opts.signal ? AbortSignal.any([opts.signal, timeout]) : timeout;
+	const handle = ctx.subprocess.spawn({
+		argv: [executable, "acp"],
+		cwd: opts.cwd,
+		stdio: {
+			stdin: "pipe",
+			stdout: "pipe",
+			stderr: { maxBytes: opts.stderrMaxBytes ?? 65536 }
+		},
+		graceMs: 5e3,
+		signal,
+		env
+	});
+	try {
+		const stdin = handle.stdin;
+		const stdout = handle.stdout;
+		if (!stdin || !stdout) return null;
+		const pending = /* @__PURE__ */ new Map();
+		let buffer = "";
+		let nextId = 1;
+		handle.done.then((outcome) => {
+			const err = /* @__PURE__ */ new Error(`devin acp exited early (code ${outcome.exitCode ?? `signal ${outcome.signal}`})`);
+			for (const p of pending.values()) p.reject(err);
+			pending.clear();
+		});
+		stdout.on("data", (chunk) => {
+			buffer += chunk.toString();
+			let idx;
+			while ((idx = buffer.indexOf("\n")) >= 0) {
+				const line = buffer.slice(0, idx);
+				buffer = buffer.slice(idx + 1);
+				if (!line.trim()) continue;
+				let msg;
+				try {
+					msg = JSON.parse(line);
+				} catch {
+					continue;
+				}
+				if (msg.id !== void 0 && msg.method === void 0) {
+					const p = pending.get(msg.id);
+					if (p) {
+						pending.delete(msg.id);
+						if (msg.error) p.reject(/* @__PURE__ */ new Error(`[${msg.error.code}] ${msg.error.message}`));
+						else p.resolve(msg.result);
+					}
+				} else if (msg.method !== void 0 && msg.id !== void 0) stdin.write(JSON.stringify({
+					jsonrpc: "2.0",
+					id: msg.id,
+					error: {
+						code: -32601,
+						message: "not supported by dsh-plugin-devin discovery"
+					}
+				}) + "\n");
+			}
+		});
+		const request = (method, params) => new Promise((resolve, reject) => {
+			const id = nextId++;
+			pending.set(id, {
+				resolve,
+				reject
+			});
+			stdin.write(JSON.stringify({
+				jsonrpc: "2.0",
+				id,
+				method,
+				params
+			}) + "\n");
+		});
+		await request("initialize", {
+			protocolVersion: 1,
+			clientInfo: {
+				name: "@quonaro/dsh-plugin-devin",
+				version: "0.1.0"
+			},
+			clientCapabilities: { fs: {
+				readTextFile: true,
+				writeTextFile: true
+			} }
+		});
+		return modelsFromSessionNew(await request("session/new", {
+			cwd: opts.cwd,
+			mcpServers: []
+		}));
+	} finally {
+		handle.terminate();
+		await handle.waitForExit(AbortSignal.timeout(6e3)).catch(() => false);
+	}
+}
+//#endregion
+//#region src/provider.ts
+/** Plugin name; the cordis.patch.yml row uses the `@quonaro/dsh-plugin-devin/provider` specifier. */
+const name = "@quonaro/dsh-plugin-devin/provider";
+/** Services this plugin needs: the llm adapter registry and a subprocess provider. */
+const inject = ["llm", "subprocess"];
+/** Schemastery schema: defaults live here; cordis.yml and GUI edits are validated against it. */
+const Config = Schema.object({
+	devinPath: Schema.string().default("devin").volatile(),
+	permissionMode: Schema.union([
+		"normal",
+		"accept-edits",
+		"smart",
+		"bypass",
+		"autonomous"
+	]).default("accept-edits").volatile(),
+	cloud: Schema.boolean().default(false).volatile(),
+	cwd: Schema.string().default("").volatile(),
+	timeoutMs: Schema.number().default(18e5).volatile(),
+	stderrMaxBytes: Schema.number().default(65536).volatile(),
+	respectWorkspaceTrust: Schema.boolean().default(false).volatile(),
+	forwardEnv: Schema.array(Schema.string()).default([
+		"PATH",
+		"HOME",
+		"USER",
+		"XDG_CONFIG_HOME",
+		"XDG_DATA_HOME",
+		"WINDSURF_API_KEY"
+	]).volatile(),
+	extraArgs: Schema.array(Schema.string()).default([]).volatile(),
+	models: Schema.array(Schema.object({
+		id: Schema.string(),
+		devinModel: Schema.string().default(""),
+		name: Schema.string().default("")
+	})).default([{
+		id: "default",
+		devinModel: "",
+		name: "Devin (account default)"
+	}, {
+		id: "opus",
+		devinModel: "opus",
+		name: "Devin Opus"
+	}]).volatile(),
+	brief: Schema.string().default("You are Devin, an autonomous software-engineering agent, invoked as the model backend of another agent harness. The transcript of the calling conversation is below. Carry out the most recent user request end-to-end using your own tools and judgment. Do not ask questions — act autonomously. Your final printed answer is returned verbatim as the model's reply.").volatile(),
+	localSessionTitles: Schema.boolean().default(true).volatile(),
+	autoDiscoverModels: Schema.boolean().default(true).volatile(),
+	discoveryTimeoutMs: Schema.number().default(6e4).volatile(),
+	discoveryCacheMs: Schema.number().default(3e5).volatile()
+});
+const ROLE_LABEL = {
+	system: "system",
+	developer: "developer",
+	user: "user",
+	assistant: "assistant",
+	tool: "tool result"
+};
+/** Project one message's blocks into transcript text. */
+function blocksToText(blocks) {
+	return blocks.map((block) => {
+		switch (block.type) {
+			case "text": return block.text;
+			case "reasoning": return `<thinking>\n${block.text}\n</thinking>`;
+			case "tool-call": return `[tool call ${block.name} #${block.id}]: ${block.arguments}`;
+			case "image": return "[image]";
+			case "file": return "[file]";
+			case "tool-addition": return `[tool enabled: ${block.toolName}]`;
+			case "tool-removal": return `[tool disabled: ${block.toolName}]`;
+			default: return `[${block.type}]`;
+		}
+	}).join("\n");
+}
+/** Flatten one generation request into the prompt handed to `devin -p`. */
+function buildPrompt(options, brief) {
+	const parts = [
+		brief,
+		"",
+		"<transcript>"
+	];
+	if (options.system) parts.push("## system", options.system, "");
+	for (const message of options.messages) parts.push(`## ${ROLE_LABEL[message.role] ?? message.role}`, blocksToText(message.content), "");
+	parts.push("</transcript>");
+	if (options.tools?.length) {
+		const names = options.tools.map((tool) => tool.name).slice(0, 12).join(", ");
+		parts.push("", `[note: the caller declared ${options.tools.length} of its own tools (${names}${options.tools.length > 12 ? ", …" : ""}) — you cannot invoke them; complete the work with your own capabilities.]`);
+	}
+	return parts.join("\n");
+}
+/** Map an advertised route id to its `--model` value; unknown ids pass through verbatim. */
+function resolveDevinModel(routeId, table) {
+	const entry = table.find((m) => m.id === routeId);
+	if (entry) return entry.devinModel;
+	return routeId === "default" ? "" : routeId;
+}
+/** Last user text, for cheap local session titles. */
+function lastUserText(messages) {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const message = messages[i];
+		if (message.role === "user") {
+			const text = blocksToText(message.content).replace(/\s+/g, " ").trim();
+			if (text) return text;
+		}
+	}
+	return "Devin session";
+}
+/**
+* The provider-wire adapter. Duck-typed against the documented LlmAdapter
+* surface — the registry validates behavior, not inheritance — so this class
+* carries no runtime import of @deepseek-ai/dsh-llm.
+*/
+var DevinLlmAdapter = class {
+	ctx;
+	config;
+	constructor(ctx, config) {
+		this.ctx = ctx;
+		this.config = config;
+	}
+	providerInfo(provider) {
+		return {
+			id: provider,
+			name: "Devin"
+		};
+	}
+	providerRetryPolicy(_provider) {}
+	imageRequestPricing(_provider, _model) {}
+	discovered;
+	/** Probe `devin acp` for the real catalog (cached); null on failure/disabled. */
+	async discover() {
+		if (!this.config.autoDiscoverModels.get()) return null;
+		const cacheMs = this.config.discoveryCacheMs.get();
+		if (this.discovered && Date.now() - this.discovered.at < cacheMs) return this.discovered.result;
+		try {
+			const result = await discoverModelsViaAcp(this.ctx, {
+				devinPath: this.config.devinPath.get(),
+				env: this.config.forwardEnv.get(),
+				cwd: this.config.cwd.get() || process.cwd(),
+				timeoutMs: this.config.discoveryTimeoutMs.get(),
+				stderrMaxBytes: this.config.stderrMaxBytes.get()
+			});
+			if (result) this.discovered = {
+				at: Date.now(),
+				result
+			};
+			return result;
+		} catch {
+			return null;
+		}
+	}
+	async listModels(provider) {
+		const discovered = await this.discover();
+		if (discovered && discovered.models.length > 0) {
+			const currentId = discovered.currentId;
+			return [{
+				provider,
+				id: "default",
+				name: "Devin (account default)",
+				description: currentId ? `Resolves to the session default (${currentId})` : "Devin CLI agent, spawned headless per generation",
+				inputModalities: ["text"]
+			}, ...discovered.models.map((m) => ({
+				provider,
+				id: m.id,
+				name: m.name,
+				description: m.description ?? "Devin CLI agent, spawned headless per generation",
+				inputModalities: ["text"]
+			}))];
+		}
+		return this.config.models.get().map((entry) => ({
+			provider,
+			id: entry.id,
+			name: entry.name || `Devin ${entry.id}`,
+			description: "Devin CLI agent, spawned headless per generation",
+			inputModalities: ["text"]
+		}));
+	}
+	resolveModel(provider, model, _signal) {
+		return Promise.resolve({
+			provider,
+			id: model,
+			name: `Devin ${model}`,
+			inputModalities: ["text"]
+		});
+	}
+	async prepareCall(provider, model, signal) {
+		return {
+			model: await this.resolveModel(provider, model, signal),
+			stream: (options) => this.stream(options)
+		};
+	}
+	async *stream(options) {
+		if (options.purpose === "session-title" && this.config.localSessionTitles.get()) {
+			const text = lastUserText(options.messages).slice(0, 80);
+			yield {
+				type: "block-start",
+				index: 0,
+				blockType: "text"
+			};
+			yield {
+				type: "text-delta",
+				index: 0,
+				text
+			};
+			yield {
+				type: "block-end",
+				index: 0,
+				block: {
+					type: "text",
+					text
+				}
+			};
+			yield {
+				type: "finish",
+				reason: { kind: "stop" }
+			};
+			return;
+		}
+		const env = forwardedEnv(this.config.forwardEnv.get());
+		const executable = await this.ctx.subprocess.resolveExecutable(this.config.devinPath.get(), env, options.signal);
+		const timeout = AbortSignal.timeout(this.config.timeoutMs.get());
+		const signal = options.signal ? AbortSignal.any([options.signal, timeout]) : timeout;
+		const prompt = buildPrompt(options, this.config.brief.get());
+		const argv = [executable, ...devinPrintArgv({
+			model: resolveDevinModel(options.model, this.config.models.get()),
+			permissionMode: this.config.permissionMode.get(),
+			cloud: this.config.cloud.get(),
+			respectWorkspaceTrust: this.config.respectWorkspaceTrust.get(),
+			extraArgs: this.config.extraArgs.get()
+		}, prompt)];
+		const handle = this.ctx.subprocess.spawn({
+			argv,
+			cwd: this.config.cwd.get() || process.cwd(),
+			stdio: {
+				stdin: "ignore",
+				stdout: "pipe",
+				stderr: { maxBytes: this.config.stderrMaxBytes.get() }
+			},
+			graceMs: 1e4,
+			signal,
+			env
+		});
+		let text = "";
+		yield {
+			type: "block-start",
+			index: 0,
+			blockType: "text"
+		};
+		const stdout = handle.stdout;
+		if (stdout) for await (const chunk of stdout) {
+			const piece = new TextDecoder().decode(chunk);
+			text += piece;
+			yield {
+				type: "text-delta",
+				index: 0,
+				text: piece
+			};
+		}
+		const outcome = await handle.done;
+		yield {
+			type: "block-end",
+			index: 0,
+			block: {
+				type: "text",
+				text
+			}
+		};
+		yield {
+			type: "usage",
+			usage: {
+				inputTokens: Math.ceil(prompt.length / 4),
+				outputTokens: Math.ceil(text.length / 4)
+			}
+		};
+		if (timeout.aborted) yield {
+			type: "finish",
+			reason: {
+				kind: "error",
+				failure: {
+					code: "DEVIN_TIMEOUT",
+					message: `devin exceeded timeoutMs=${this.config.timeoutMs.get()} and was terminated`
+				}
+			}
+		};
+		else if (outcome.exitCode !== 0) {
+			const stderr = handle.collected.stderr?.readFrom(0)?.text ?? "";
+			yield {
+				type: "finish",
+				reason: {
+					kind: "error",
+					failure: {
+						code: "DEVIN_EXIT",
+						message: `devin exited ${outcome.exitCode ?? `signal ${outcome.signal}`}${stderr ? ` — ${stderr.slice(-400)}` : ""}`
+					}
+				}
+			};
+		} else yield {
+			type: "finish",
+			reason: { kind: "stop" }
+		};
+	}
+};
+/**
+* Plugin body: register the `devin` provider route and declare it in the
+* configurable-provider directory so the web Models page can see it.
+*/
+function apply(ctx, config) {
+	ctx.llm.registerAdapter(["devin"], new DevinLlmAdapter(ctx, config));
+	ctx.llm.registerConfigurableProviders([{
+		provider: "devin",
+		displayName: "Devin",
+		settingsNs: name,
+		settingsPath: []
+	}]);
+}
+//#endregion
+export { Config, apply, inject, name };

package/lib/shared-ClK2vJrs.js

@@ -0,0 +1,27 @@
+//#region src/shared.ts
+/** Collect the env entries a forwardEnv list names, skipping unset variables. */
+function forwardedEnv(names) {
+	const env = {};
+	for (const key of names) {
+		const value = process.env[key];
+		if (value !== void 0) env[key] = value;
+	}
+	return env;
+}
+/**
+* Assemble `devin --print` argv (without the executable itself).
+* The prompt is always last, behind `--`, so it can never parse as a flag.
+*/
+function devinPrintArgv(flags, prompt) {
+	const argv = [];
+	if (flags.model) argv.push("--model", flags.model);
+	if (flags.permissionMode) argv.push("--permission-mode", flags.permissionMode);
+	if (flags.cloud) argv.push("--cloud");
+	if (flags.resume) argv.push("--resume", flags.resume);
+	if (!flags.respectWorkspaceTrust) argv.push("--respect-workspace-trust", "false");
+	if (flags.extraArgs) argv.push(...flags.extraArgs);
+	argv.push("-p", "--", prompt);
+	return argv;
+}
+//#endregion
+export { forwardedEnv as n, devinPrintArgv as t };

package/package.json

@@ -1,6 +1,79 @@
 {
   "name": "@quonaro/dsh-plugin-devin",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Devin CLI inside DeepSeek Harness: a `devin` delegation tool, a /devin command, and a `devin` LLM provider route — all over the ctx.subprocess seam.",
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "dsh-plugin",
+    "cordis",
+    "devin",
+    "subagent",
+    "delegation"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/quonaro/dsh-plugin-devin.git"
+  },
+  "bugs": "https://github.com/quonaro/dsh-plugin-devin/issues",
+  "homepage": "https://github.com/quonaro/dsh-plugin-devin#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json",
+    "./provider": {
+      "types": "./lib/provider.d.ts",
+      "default": "./lib/provider.js"
+    }
+  },
+  "files": [
+    "lib/",
+    "cordis.patch.yml"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf lib",
+    "smoke": "node test/smoke.mjs && node test/smoke-provider.mjs && node test/smoke-discover.mjs",
+    "test": "pnpm typecheck && pnpm build && pnpm smoke",
+    "prepare": "tsdown"
+  },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "~3.18.4"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.4",
+    "@deepseek-ai/dsh-llm": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-subprocess": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-tools": "^0.2.0-rc.2"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "~4.0.4",
+    "@deepseek-ai/cosmokit": "^1.8.5",
+    "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-subprocess": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-tools": "0.2.0-rc.2",
+    "@deepseek-ai/schemastery": "~3.18.4",
+    "@types/node": "^22.20.0",
+    "tsdown": "^0.22.2",
+    "typescript": "^6.0.3"
+  }
+}