@zumikua/dsh-junie-subagent 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zumi Kua
+
+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,89 @@
-# Temporary Holding Version
+# @zumikua/dsh-junie-subagent
 
-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.
+English | [中文](README.zh.md)
+
+Delegates one task to the JetBrains Junie CLI over the Agent Client Protocol and
+returns Junie's final answer as a subagent result.
+
+## Requirements
+
+- DSH `>= 0.2.1-rc.2`;
+- the JetBrains Junie CLI installed and signed in — the provider resolves
+  `junie.exe` from `~/.local/share/junie/current` and fails loudly when it
+  cannot start it.
+
+## Install
+
+Open the **Plugins** page in the DSH Web UI and install `@zumikua/dsh-junie-subagent`
+from the catalog; the plugin manager installs the package and selects its bundle
+in one step. The bundle patch inserts one provider and one `dsh-tool-subagent`
+instance named `junie`.
+
+Restart DSH once after installing: the browser half (`client.js`) enters the
+page's module table at startup. Then open **Settings → Junie** and pick a model
+and thinking depth.
+
+## How one run works
+
+```
+spawn <junie.exe> --acp=true --skip-update-check
+  → initialize
+  → session/new { cwd, mcpServers: [] }
+  → session/set_config_option (model / effort / brave_mode, when configured)
+  → session/prompt { prompt: [{ type: "text", text }] }
+  ← session/update … agent_message_chunk text …
+  ← result { stopReason }
+  → dispose (session/cancel, stdin EOF, terminate, wait for exit)
+```
+
+Each run owns its own process and session: the subagent seam has no
+continuation surface for out-of-process children, so a run accepts no follow-up
+message.
+
+## Confinement
+
+The child is spawned through `ctx.subprocess` **without** a sandbox policy. It
+therefore runs as the signed-in user with that user's full file access — which
+is what lets Junie persist sessions under `~/.junie`. Confinement is Junie's own
+permission model: `brave_mode`, the action allowlist, and
+`session/request_permission`, which this provider answers from `permission`.
+
+## Configuration
+
+| Key | Default | Meaning |
+|---|---|---|
+| `providerName` | `junie` | Name on `ctx.subagents` |
+| `command` | managed install | `junie.exe` path; resolved from `~/.local/share/junie/current` when omitted |
+| `args` | `["--acp=true"]` | Extra arguments; `--acp=true` and `--skip-update-check` are always ensured |
+| `model` | `mix.normal` | Fallback model when the settings page has stored none |
+| `effort` | `high` | Fallback effort when the settings page has stored none |
+| `braveMode` | `brave-auto` | `brave-auto` / `on` / `off` |
+| `permission` | `reject` | Auto-answer `session/request_permission` with reject (default) or the first allow option |
+| `timeoutMs` | `900000` | Whole-run bound |
+| `graceMs` | `3000` | Subprocess teardown grace |
+
+## Choosing a model
+
+The bundle registers exactly one provider (`junie`) and one model-facing tool
+(`junie`). The model and the thinking depth are chosen on the settings page and
+stored by the Host; the `model` / `effort` keys above are only the fallback used
+before anything is stored.
+
+Per-call model selection through the shared `provider` / `model` /
+`reasoning_effort` tool fields is **not** available: `dsh-tool-subagent`
+validates those against the Host's LLM catalog (`llm.resolveCallConfig`), and
+Junie model ids are not LLM routes — which is also why the official Codex,
+Claude Code, and ACP providers advertise no `agentOptions` capability.
+
+## Settings page and storage
+
+1. The page is the **Junie** section in the settings panel; it picks the model
+   and the thinking depth.
+2. Values are read and written through a same-origin route the Host registers —
+   `GET/PUT /junie-subagent/config` — and stored in `~/.dsh/junie-settings.json`.
+3. The model list comes from the `configOptions` of Junie's own ACP
+   `session/new` (rendered by group, cached for ten minutes, costs no credits).
+4. Thinking depths are model-specific. Saving validates the pair against a
+   throwaway Junie session; an unsupported combination answers `400` with the
+   values that model accepts, and the option list in the page is left untouched.
+5. A change applies from the next delegation.

package/README.zh.md

@@ -0,0 +1,79 @@
+# @zumikua/dsh-junie-subagent
+
+[English](README.md) | 中文
+
+把一次性任务通过 Agent Client Protocol 交给 JetBrains Junie CLI 执行，并把
+Junie 的最终答复作为子智能体结果返回。
+
+## 前置条件
+
+- DSH `>= 0.2.1-rc.2`；
+- 已安装并登录 JetBrains Junie CLI —— provider 会从 `~/.local/share/junie/current`
+  解析 `junie.exe`，启动失败时会明确报错。
+
+## 安装
+
+在 DSH Web UI 的**插件**页里安装 `@zumikua/dsh-junie-subagent` 即可：插件管理器会一步完成
+"安装包 + 选中 bundle"。bundle 的 patch 会插入一个 provider 和一个名为 `junie` 的
+`dsh-tool-subagent` 实例。
+
+安装完成后需要重启一次 DSH：浏览器半边（`client.js`）是在启动时进入页面模块表的。
+之后打开**设置 → Junie**，选择模型和思考深度。
+
+## 一次运行的时序
+
+```
+spawn <junie.exe> --acp=true --skip-update-check
+  → initialize
+  → session/new { cwd, mcpServers: [] }
+  → session/set_config_option（model / effort / brave_mode，按配置下发）
+  → session/prompt { prompt: [{ type: "text", text }] }
+  ← session/update … agent_message_chunk 文本 …
+  ← result { stopReason }
+  → dispose（session/cancel、stdin EOF、terminate、等待退出）
+```
+
+每次运行独占一个进程和一个会话：子智能体 seam 对外部子级没有续接接口，因此一次运行
+不会接受后续消息。
+
+## 隔离边界
+
+子进程通过 `ctx.subprocess` 启动，**不携带沙箱策略**，因此它以当前登录用户的身份运行、
+拥有该用户的完整文件权限 —— 这也是 Junie 能把会话写进 `~/.junie` 的前提。约束来自
+Junie 自己的权限模型：`brave_mode`、命令允许列表，以及
+`session/request_permission`（由本 provider 按 `permission` 回答）。
+
+## 配置
+
+| 键 | 默认值 | 含义 |
+|---|---|---|
+| `providerName` | `junie` | 在 `ctx.subagents` 上的名字 |
+| `command` | 自动解析 | `junie.exe` 路径；省略时从 `~/.local/share/junie/current` 解析 |
+| `args` | `["--acp=true"]` | 额外参数；`--acp=true` 与 `--skip-update-check` 始终会补齐 |
+| `model` | `mix.normal` | 设置页尚未保存任何值时的兜底模型 |
+| `effort` | `high` | 设置页尚未保存任何值时的兜底思考深度 |
+| `braveMode` | `brave-auto` | `brave-auto` / `on` / `off` |
+| `permission` | `reject` | 自动回答 `session/request_permission`：默认拒绝，或选第一个允许项 |
+| `timeoutMs` | `900000` | 单次运行的总时限 |
+| `graceMs` | `3000` | 子进程回收宽限 |
+
+## 模型选择
+
+bundle 只注册一个 provider（`junie`）和一个面向模型的工具（`junie`）。模型与思考
+深度在设置页选择、由宿主保存；上面的 `model` / `effort` 只是"尚未保存过"时的兜底。
+
+工具层面的 `provider` / `model` / `reasoning_effort` 参数**不可用**：
+`dsh-tool-subagent` 会用宿主的 LLM 目录（`llm.resolveCallConfig`）校验它们，而 Junie
+的模型 id 并不是 LLM 路由 —— 官方 Codex、Claude Code 与 ACP provider 之所以不声明
+`agentOptions` 能力，也是同一个原因。
+
+## 设置页与存储
+
+1. 设置页位于设置面板左侧的「Junie」分区，可以选择模型和思考深度；
+2. 读写走宿主注册的同源路由 `GET/PUT /junie-subagent/config`，数据存放在
+   `~/.dsh/junie-settings.json`；
+3. 模型下拉列表来自 Junie 自己 ACP `session/new` 返回的 `configOptions`
+   （分组渲染，缓存 10 分钟，不消耗额度）；
+4. 思考深度的可选项取决于模型。保存时会用一个临时会话向 Junie 校验，不支持的组合
+   返回 `400` 并提示该模型支持哪些档位，且不会改动界面上的选项列表；
+5. 修改从下一次委派开始生效。

package/client.js

@@ -0,0 +1,178 @@
+window.__ModuleLoader__.load({
+  id: '@zumikua/dsh-junie-subagent',
+  factory(require) {
+    const React = require('react')
+    const h = React.createElement
+    const { useCallback, useEffect, useState } = React
+
+    // Same-origin route registered by this bundle's Host half.
+    const ROUTE = '/junie-subagent/config'
+    const CUSTOM = '__custom__'
+    const EFFORT_LABEL = { low: '低', medium: '中', high: '高', xhigh: '很高', max: '最高' }
+
+    // Inherit the host theme instead of inventing colors: these tokens exist in
+    // both light and dark themes, which is what keeps the panel legible.
+    const rowStyle = { display: 'flex', alignItems: 'center', gap: '12px', margin: '12px 0' }
+    const labelStyle = { width: '120px', color: 'var(--dsw-alias-label-secondary)', flex: '0 0 auto', fontSize: '13px' }
+    const controlStyle = {
+      minWidth: '300px',
+      padding: '6px 8px',
+      background: 'var(--dsw-alias-bg-layer-1)',
+      color: 'var(--dsw-alias-label-primary)',
+      border: '1px solid var(--dsw-alias-border-l1)',
+      borderRadius: '8px',
+      fontSize: '13px',
+      outline: 'none',
+    }
+    const buttonStyle = {
+      ...controlStyle,
+      minWidth: '88px',
+      width: 'auto',
+      cursor: 'pointer',
+      color: 'var(--dsw-alias-label-primary)',
+    }
+    const hintStyle = { color: 'var(--dsw-alias-label-secondary)', fontSize: '12px', marginTop: '12px', lineHeight: 1.6 }
+    const noteStyle = { fontSize: '12px', marginTop: '8px', color: 'var(--dsw-alias-label-secondary)' }
+
+    function groupOptions(models) {
+      const groups = new Map()
+      for (const entry of models) {
+        const key = entry.group && entry.group.length > 0 ? entry.group : ''
+        if (!groups.has(key)) groups.set(key, [])
+        groups.get(key).push(entry)
+      }
+      return [...groups.entries()]
+    }
+
+    function JunieSettings() {
+      const [model, setModel] = useState('')
+      const [effort, setEffort] = useState('high')
+      const [models, setModels] = useState([])
+      const [custom, setCustom] = useState(false)
+      const [loaded, setLoaded] = useState(false)
+      const [note, setNote] = useState(null)
+      const [busy, setBusy] = useState(false)
+
+      const load = useCallback(async (keepNote = false) => {
+        try {
+          const response = await fetch(ROUTE, { credentials: 'same-origin', cache: 'no-store' })
+          if (!response.ok) {
+            setNote(`读取失败：HTTP ${response.status}`)
+            return
+          }
+          const body = await response.json()
+          const nextModel = typeof body.model === 'string' ? body.model : 'mix.normal'
+          const catalog = Array.isArray(body.models) ? body.models : []
+          setModel(nextModel)
+          setEffort(typeof body.effort === 'string' ? body.effort : 'high')
+          setModels(catalog)
+          setCustom(catalog.length === 0 || !catalog.some((entry) => entry.value === nextModel))
+          setLoaded(true)
+          if (!keepNote) setNote(null)
+        } catch (error) {
+          setNote(`读取失败：${String(error?.message ?? error)}`)
+        }
+      }, [])
+
+      useEffect(() => {
+        load()
+      }, [load])
+
+      const save = useCallback(async () => {
+        setBusy(true)
+        try {
+          const response = await fetch(ROUTE, {
+            method: 'PUT',
+            credentials: 'same-origin',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ model, effort }),
+          })
+          const body = await response.json().catch(() => ({}))
+          if (!response.ok) {
+            // The refusal already names the values this model accepts; the
+            // option list itself stays complete so switching models recovers.
+            setNote(body.error ?? `保存失败：HTTP ${response.status}`)
+            return
+          }
+          await load(true)
+          setNote('已保存，下一次委派生效')
+        } catch (error) {
+          setNote(`保存失败：${String(error?.message ?? error)}`)
+        } finally {
+          setBusy(false)
+        }
+      }, [model, effort, load])
+
+      if (!loaded) return h('div', { style: hintStyle }, note ?? '正在读取 Junie 配置…')
+
+      const known = models.some((entry) => entry.value === model)
+      return h('div', null,
+        h('div', { style: rowStyle },
+          h('span', { style: labelStyle }, '模型'),
+          custom
+            ? h('input', {
+                style: { ...controlStyle, width: '300px' },
+                value: model,
+                disabled: busy,
+                spellCheck: false,
+                placeholder: '例如 mix.normal 或 v1:12:jetbrains-ai:gemini-3.7-flash',
+                onChange: (event) => setModel(event.target.value),
+              })
+            : h('select', {
+                style: controlStyle,
+                value: known ? model : CUSTOM,
+                disabled: busy,
+                onChange: (event) => {
+                  if (event.target.value === CUSTOM) {
+                    setCustom(true)
+                    return
+                  }
+                  setModel(event.target.value)
+                },
+              },
+                models.length === 0 ? h('option', { value: model }, model) : null,
+                groupOptions(models).map(([group, entries]) =>
+                  group.length > 0
+                    ? h('optgroup', { key: group, label: group },
+                        entries.map((entry) => h('option', { key: entry.value, value: entry.value }, entry.name)))
+                    : entries.map((entry) => h('option', { key: entry.value, value: entry.value }, entry.name))),
+                h('option', { value: CUSTOM }, '自定义…')),
+          h('button', {
+            type: 'button',
+            style: buttonStyle,
+            disabled: busy,
+            onClick: () => setCustom((value) => !value),
+          }, custom ? '用列表' : '手动输入')),
+        h('div', { style: rowStyle },
+          h('span', { style: labelStyle }, '思考深度'),
+          h('select', {
+            style: controlStyle,
+            value: effort,
+            disabled: busy,
+            onChange: (event) => setEffort(event.target.value),
+          }, ['low', 'medium', 'high', 'xhigh', 'max'].map((id) =>
+            h('option', { key: id, value: id }, `${EFFORT_LABEL[id] ?? id}（${id}）`)))),
+        h('div', { style: rowStyle },
+          h('span', { style: labelStyle }, ''),
+          h('button', { type: 'button', style: buttonStyle, disabled: busy, onClick: save },
+            busy ? '保存中…' : '保存')),
+        note === null ? null : h('div', { style: noteStyle }, note),
+        h('div', { style: hintStyle },
+          '修改后下一次 Junie 委派生效。思考深度的可选项取决于模型，不支持的组合会在保存时提示，不会改动这里的选项。'),
+        h('div', { style: hintStyle },
+          '模型列表来自 Junie 自己的 ACP 配置项，设置保存在 ~/.dsh/junie-settings.json。'))
+    }
+
+    return {
+      inject: ['slots'],
+      apply(ctx) {
+        ctx.effect(() => ctx.slots.inject('settings.section', () => ctx.slots.register({
+          name: 'settings.section',
+          id: 'junie',
+          order: 40,
+          label: () => 'Junie',
+        }, JunieSettings)))
+      },
+    }
+  },
+})

package/cordis.patch.yml

@@ -0,0 +1,18 @@
+# Junie as a one-shot subagent backend.
+#
+# One provider, one tool. The model and thinking depth are `Config` fields, so
+# they belong to the settings projection: change them in Settings and the next
+# delegation uses the new pair. The tool exists exactly while the provider is
+# registered, so the two rows belong together.
+- insert:
+    - id: junie-subagent
+      name: '@zumikua/dsh-junie-subagent'
+      config:
+        model: mix.normal
+        effort: high
+    - id: subagent-junie
+      name: '@deepseek-ai/dsh-tool-subagent'
+      config:
+        provider: junie
+        toolName: junie
+        maxDepth: provider-managed

package/icon.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64" role="img" aria-label="Junie subagent">
+  <rect x="4" y="4" width="56" height="56" rx="14" fill="#101828"/>
+  <path d="M38 18v20a8 8 0 0 1-16 0" fill="none" stroke="#36d399" stroke-width="6" stroke-linecap="round"/>
+  <circle cx="46" cy="20" r="4" fill="#fbbf24"/>
+</svg>

package/index.js

@@ -0,0 +1,651 @@
+/**
+ * Junie CLI as a one-shot subagent provider over the Agent Client Protocol.
+ *
+ * The child process is spawned through the `dsh-subprocess` seam with no
+ * sandbox policy, so Junie runs as the signed-in user: it can persist its own
+ * session state under `~/.junie` and is confined only by Junie's own permission
+ * model (brave mode, allowlist, `session/request_permission`).
+ *
+ * One run = one `junie --acp` process = one ACP session, because the provider
+ * contract has no continuation surface for out-of-process children.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { homedir } from 'node:os'
+import { randomUUID } from 'node:crypto'
+import {
+  NO_START_CAPABILITIES,
+  assertPositiveFinite,
+  assertUsableCwd,
+  settleRunResult,
+  subprocessRunHandle,
+} from '@deepseek-ai/dsh-subagent'
+import Schema from '@deepseek-ai/schemastery'
+
+export const name = 'junie-subagent'
+
+/** Provider, subprocess seam, and the web route the settings page reads. */
+export const inject = ['subagents', 'subprocess', 'webServer']
+
+/** Diagnostic prefix shared by every failure this plugin reports. */
+const PREFIX = 'junie-subagent'
+
+/** Same-origin route of the settings page; the Host owns the response. */
+const ROUTE_PATH = '/junie-subagent/config'
+
+/** Host-side store the provider reads on every run. */
+const SETTINGS_FILE = join(homedir(), '.dsh', 'junie-settings.json')
+
+/** Efforts Junie accepts through its ACP `effort` session option. */
+const EFFORTS = new Set(['low', 'medium', 'high', 'xhigh', 'max'])
+
+/**
+ * Read the stored settings, tolerating a missing or malformed file: the row
+ * config remains the fallback so a broken store cannot break delegation.
+ * @returns the stored `model`/`effort` subset, possibly empty.
+ */
+function readStoredSettings() {
+  try {
+    const parsed = JSON.parse(readFileSync(SETTINGS_FILE, 'utf8'))
+    if (parsed === null || typeof parsed !== 'object') return {}
+    const next = {}
+    if (typeof parsed.model === 'string' && parsed.model.length > 0) next.model = parsed.model
+    if (typeof parsed.effort === 'string' && EFFORTS.has(parsed.effort)) next.effort = parsed.effort
+    return next
+  } catch {
+    return {}
+  }
+}
+
+/**
+ * Persist the settings page's choice.
+ * @param value - the validated `model`/`effort` pair.
+ */
+function writeStoredSettings(value) {
+  mkdirSync(dirname(SETTINGS_FILE), { recursive: true })
+  writeFileSync(SETTINGS_FILE, `${JSON.stringify(value, null, 2)}\n`, 'utf8')
+}
+
+/**
+ * Collect a JSON request body.
+ * @param req - the incoming request.
+ * @returns the parsed body, or undefined when it is absent or invalid.
+ */
+async function readJsonBody(req) {
+  const chunks = []
+  for await (const chunk of req) chunks.push(chunk)
+  const text = Buffer.concat(chunks).toString('utf8').trim()
+  if (text.length === 0) return undefined
+  try {
+    return JSON.parse(text)
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Ask Junie for its ACP configuration options: no prompt is sent, so this costs
+ * no credits. The process exists only for the handshake.
+ * @param ctx - the plugin context (subprocess seam).
+ * @param cfg - the effective configuration.
+ * @returns the `configOptions` array from `session/new`.
+ */
+async function probeConfigOptions(ctx, cfg) {
+  const cwd = homedir()
+  const handle = ctx.subprocess.spawn({
+    argv: [cfg.command, ...cfg.args],
+    cwd,
+    stdio: { stdin: 'pipe', stdout: 'pipe', stderr: 'pipe' },
+    graceMs: cfg.graceMs,
+    env: { ...cfg.env },
+  })
+  const client = createClient(handle, { permission: 'reject', onText: () => {} })
+  let sessionId
+  try {
+    await client.request('initialize', {
+      protocolVersion: 1,
+      clientCapabilities: { fs: { readTextFile: true, writeTextFile: true } },
+    })
+    const session = await client.request('session/new', { cwd, mcpServers: [] })
+    sessionId = session?.sessionId
+    return Array.isArray(session?.configOptions) ? session.configOptions : []
+  } finally {
+    try {
+      if (typeof sessionId === 'string') client.notify('session/cancel', { sessionId })
+    } catch {
+      // The child may already be gone.
+    }
+    try {
+      handle.stdin?.end()
+    } catch {
+      // Already closed.
+    }
+    try {
+      handle.terminate()
+    } catch {
+      // The seam owns final escalation.
+    }
+    client.close()
+  }
+}
+
+/** Cached model catalog; Junie's list changes with plan and authentication. */
+const modelCache = { at: 0, models: [] }
+
+/**
+ * Flatten Junie's grouped model options into one select list.
+ * @param ctx - the plugin context.
+ * @param cfg - the effective configuration.
+ * @returns the model entries, empty when the probe fails.
+ */
+async function listModels(ctx, cfg) {
+  if (Date.now() - modelCache.at < 600000 && modelCache.models.length > 0) return modelCache.models
+  try {
+    const options = await probeConfigOptions(ctx, cfg)
+    const modelOption = options.find((entry) => entry !== null && typeof entry === 'object' && entry.id === 'model')
+    const models = []
+    for (const entry of Array.isArray(modelOption?.options) ? modelOption.options : []) {
+      if (Array.isArray(entry?.options)) {
+        for (const item of entry.options) {
+          if (typeof item?.value === 'string') models.push({ value: item.value, name: String(item.name ?? item.value), group: String(entry.name ?? '') })
+        }
+      } else if (typeof entry?.value === 'string') {
+        models.push({ value: entry.value, name: String(entry.name ?? entry.value), group: '' })
+      }
+    }
+    if (models.length > 0) {
+      modelCache.at = Date.now()
+      modelCache.models = models
+    }
+    return models
+  } catch {
+    return modelCache.models
+  }
+}
+
+/**
+ * Apply one model/effort pair against a throwaway Junie session. Junie narrows
+ * the effort choices per model, so the page cannot know them offline; this
+ * answers the pair it actually accepts and the values the model supports.
+ * @param ctx - the plugin context.
+ * @param cfg - the effective configuration.
+ * @param model - the model id to apply.
+ * @param effort - the effort to apply.
+ * @returns the verdict plus the model's supported efforts.
+ */
+async function validateChoice(ctx, cfg, model, effort) {
+  const cwd = homedir()
+  const handle = ctx.subprocess.spawn({
+    argv: [cfg.command, ...cfg.args],
+    cwd,
+    stdio: { stdin: 'pipe', stdout: 'pipe', stderr: 'pipe' },
+    graceMs: cfg.graceMs,
+    env: { ...cfg.env },
+  })
+  const client = createClient(handle, { permission: 'reject', onText: () => {} })
+  let sessionId
+  try {
+    await client.request('initialize', {
+      protocolVersion: 1,
+      clientCapabilities: { fs: { readTextFile: true, writeTextFile: true } },
+    })
+    const session = await client.request('session/new', { cwd, mcpServers: [] })
+    sessionId = session?.sessionId
+    const afterModel = await client.request('session/set_config_option', {
+      sessionId,
+      configId: 'model',
+      value: model,
+    })
+    const effortOption = (afterModel?.configOptions ?? []).find(
+      (entry) => entry !== null && typeof entry === 'object' && entry.id === 'effort',
+    )
+    const allowed = (Array.isArray(effortOption?.options) ? effortOption.options : [])
+      .map((entry) => entry?.value)
+      .filter((value) => typeof value === 'string')
+    if (allowed.length === 0) return { ok: true, allowed: [...EFFORTS] }
+    if (!allowed.includes(effort)) {
+      return { ok: false, allowed, error: `模型 ${model} 只支持这些思考深度：${allowed.join(' / ')}` }
+    }
+    await client.request('session/set_config_option', { sessionId, configId: 'effort', value: effort })
+    return { ok: true, allowed }
+  } catch (error) {
+    const message = String(error?.message ?? error)
+    const match = message.match(/Supported values:\s*\[([^\]]+)\]/i)
+    const allowed = match === null
+      ? []
+      : match[1].split(',').map((value) => value.trim()).filter((value) => value.length > 0)
+    return { ok: false, allowed, error: message }
+  } finally {
+    try {
+      if (typeof sessionId === 'string') client.notify('session/cancel', { sessionId })
+    } catch {
+      // The child may already be gone.
+    }
+    try {
+      handle.stdin?.end()
+    } catch {
+      // Already closed.
+    }
+    try {
+      handle.terminate()
+    } catch {
+      // The seam owns final escalation.
+    }
+    client.close()
+  }
+}
+
+/**
+ * Answer the settings page: GET returns the effective pair plus the model
+ * catalog, PUT validates and stores one pair.
+ * @param ctx - the plugin context.
+ * @param cfg - the row configuration, used as the fallback values.
+ * @returns the route handler.
+ */
+function configRouteHandler(ctx, cfg) {
+  return async (req, res) => {
+    const send = (status, body) => {
+      const text = JSON.stringify(body)
+      res.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' })
+      res.end(text)
+    }
+    if (req.method === 'GET') {
+      const stored = readStoredSettings()
+      const models = await listModels(ctx, cfg)
+      send(200, {
+        model: stored.model ?? cfg.model,
+        effort: stored.effort ?? cfg.effort,
+        stored,
+        models,
+        efforts: [...EFFORTS],
+      })
+      return
+    }
+    if (req.method === 'PUT' || req.method === 'POST') {
+      const body = await readJsonBody(req)
+      if (body === undefined || typeof body !== 'object' || body === null) {
+        send(400, { ok: false, error: 'invalid JSON body' })
+        return
+      }
+      const model = typeof body.model === 'string' ? body.model.trim() : ''
+      const effort = typeof body.effort === 'string' ? body.effort.trim() : ''
+      if (model.length === 0) {
+        send(400, { ok: false, error: 'model is required' })
+        return
+      }
+      if (effort.length > 0 && !EFFORTS.has(effort)) {
+        send(400, { ok: false, error: `effort must be one of ${[...EFFORTS].join(', ')}` })
+        return
+      }
+      const next = { model, effort: effort.length > 0 ? effort : 'high' }
+      const verdict = await validateChoice(ctx, cfg, next.model, next.effort)
+      if (!verdict.ok) {
+        send(400, { ok: false, error: verdict.error, allowed: verdict.allowed })
+        return
+      }
+      try {
+        writeStoredSettings(next)
+      } catch (error) {
+        send(500, { ok: false, error: `cannot write settings: ${String(error?.message ?? error)}` })
+        return
+      }
+      send(200, { ok: true, ...next, allowed: verdict.allowed })
+      return
+    }
+    send(405, { ok: false, error: 'GET or PUT only' })
+  }
+}
+
+/**
+ * Row configuration, also the schema the settings service projects: `model`
+ * and `effort` are the two values a person changes from the settings page.
+ */
+export const Config = Schema.object({
+  providerName: Schema.string().default('junie'),
+  command: Schema.string().default(''),
+  args: Schema.array(Schema.string()).default([]),
+  model: Schema.string().default('mix.normal'),
+  effort: Schema.string().default('high'),
+  braveMode: Schema.string().default('brave-auto'),
+  permission: Schema.string().default('reject'),
+  timeoutMs: Schema.number().default(900000),
+  graceMs: Schema.number().default(3000),
+})
+
+
+
+/** ACP terminal reasons mapped onto the seam's stop-reason vocabulary. */
+const STOP_REASONS = new Map([
+  ['end_turn', 'completed'],
+  ['max_tokens', 'max-tokens'],
+  ['refusal', 'refusal'],
+  ['cancelled', 'aborted'],
+])
+
+const DIAGNOSTIC_LIMIT = 4000
+
+/**
+ * Resolve the Junie executable: explicit config first, then the managed
+ * launcher's `current` pointer, then whatever `junie.exe` is on PATH.
+ * @param config - the raw plugin config.
+ * @returns an absolute path when the managed install is present.
+ */
+function resolveCommand(config) {
+  if (typeof config.command === 'string' && config.command.length > 0) return config.command
+  const root = join(homedir(), '.local', 'share', 'junie')
+  try {
+    const current = readFileSync(join(root, 'current'), 'utf8').split(/\r?\n/)[0].trim()
+    if (current.length > 0) {
+      const exe = join(root, 'versions', current, 'junie', 'junie.exe')
+      if (existsSync(exe)) return exe
+    }
+  } catch {
+    // No managed install: fall through to PATH.
+  }
+  return 'junie.exe'
+}
+
+/**
+ * Flatten the seam's prompt blocks into the single text prompt ACP accepts.
+ * @param prompt - the request's content blocks.
+ * @returns the joined task text, empty when the request carries no text.
+ */
+function taskText(prompt) {
+  const parts = []
+  for (const block of prompt ?? []) {
+    if (block && block.type === 'text' && typeof block.text === 'string') parts.push(block.text)
+  }
+  return parts.join('\n\n').trim()
+}
+
+/**
+ * Normalise the row config, applying documented defaults.
+ * @param config - the raw plugin config.
+ * @returns the effective configuration.
+ */
+function normalize(config) {
+  const raw = config ?? {}
+  const args = Array.isArray(raw.args) && raw.args.length > 0 ? raw.args.map(String) : ['--acp=true']
+  if (!args.some((arg) => arg.startsWith('--acp'))) args.push('--acp=true')
+  if (!args.includes('--skip-update-check')) args.push('--skip-update-check')
+  return {
+    providerName: typeof raw.providerName === 'string' && raw.providerName.length > 0 ? raw.providerName : 'junie',
+    command: resolveCommand(raw),
+    args,
+    model: typeof raw.model === 'string' && raw.model.length > 0 ? raw.model : undefined,
+    effort: typeof raw.effort === 'string' && raw.effort.length > 0 ? raw.effort : undefined,
+    braveMode: typeof raw.braveMode === 'string' && raw.braveMode.length > 0 ? raw.braveMode : undefined,
+    permission: raw.permission === 'allow' ? 'allow' : 'reject',
+    timeoutMs: Number.isFinite(raw.timeoutMs) && raw.timeoutMs > 0 ? raw.timeoutMs : 900000,
+    graceMs: Number.isFinite(raw.graceMs) && raw.graceMs > 0 ? raw.graceMs : 3000,
+    env: raw.env && typeof raw.env === 'object' ? raw.env : {},
+  }
+}
+
+/**
+ * Minimal newline-delimited JSON-RPC client for the ACP wire.
+ * @param handle - the spawned subprocess handle.
+ * @param options - permission policy and a text-chunk sink.
+ * @returns the client verbs used by one run.
+ */
+function createClient(handle, options) {
+  let buffer = ''
+  let closed = false
+  let nextId = 0
+  let stderrTail = ''
+  const pending = new Map()
+
+  const fail = (error) => {
+    closed = true
+    for (const { reject } of pending.values()) reject(error)
+    pending.clear()
+  }
+
+  const write = (message) => {
+    if (closed || !handle.stdin) return
+    try {
+      handle.stdin.write(`${JSON.stringify(message)}\n`)
+    } catch {
+      fail(new Error('junie acp channel is not writable'))
+    }
+  }
+
+  const replyPermission = (message) => {
+    const choices = Array.isArray(message.params?.options) ? message.params.options : []
+    const wanted = options.permission === 'allow'
+      ? ['allow_once', 'allow_always', 'allow']
+      : ['reject_once', 'reject_always', 'reject']
+    const kindOf = (option) => String(option?.kind ?? option?.optionId ?? '')
+    const chosen = wanted
+      .map((kind) => choices.find((option) => kindOf(option) === kind))
+      .find((option) => option !== undefined)
+    write({
+      jsonrpc: '2.0',
+      id: message.id,
+      result: chosen === undefined
+        ? { outcome: { outcome: 'cancelled' } }
+        : { outcome: { outcome: 'selected', optionId: chosen.optionId } },
+    })
+  }
+
+  const dispatch = (message) => {
+    if (message.id !== undefined && pending.has(message.id)) {
+      const entry = pending.get(message.id)
+      pending.delete(message.id)
+      if (message.error) entry.reject(new Error(String(message.error.message ?? 'ACP request failed')))
+      else entry.resolve(message.result)
+      return
+    }
+    if (message.method === 'session/update') {
+      const update = message.params?.update
+      if (update?.sessionUpdate === 'agent_message_chunk' && update.content?.type === 'text') {
+        options.onText(String(update.content.text ?? ''))
+      }
+      return
+    }
+    if (message.method === 'session/request_permission') replyPermission(message)
+  }
+
+  handle.stdout?.on('data', (data) => {
+    buffer += data.toString('utf8')
+    let index = buffer.indexOf('\n')
+    while (index >= 0) {
+      const line = buffer.slice(0, index).trim()
+      buffer = buffer.slice(index + 1)
+      if (line.length > 0) {
+        try {
+          dispatch(JSON.parse(line))
+        } catch {
+          // A malformed frame is not a protocol reply; keep reading.
+        }
+      }
+      index = buffer.indexOf('\n')
+    }
+  })
+  handle.stdout?.on('end', () => fail(new Error('junie acp stream closed')))
+  handle.stderr?.on('data', (data) => {
+    stderrTail = `${stderrTail}${data.toString('utf8')}`.slice(-DIAGNOSTIC_LIMIT)
+  })
+
+  return {
+    request(method, params) {
+      return new Promise((resolve, reject) => {
+        if (closed) {
+          reject(new Error('junie acp channel is closed'))
+          return
+        }
+        const id = ++nextId
+        pending.set(id, { resolve, reject })
+        write({ jsonrpc: '2.0', id, method, params })
+      })
+    },
+    notify(method, params) {
+      write({ jsonrpc: '2.0', method, params })
+    },
+    stderrTail: () => stderrTail,
+    close: () => fail(new Error('junie acp channel closed by caller')),
+  }
+}
+
+/**
+ * Format a short, credential-free diagnostic line.
+ * @param handle - the subprocess handle, for its settled outcome.
+ * @param stderrTail - the tail of the child's stderr.
+ * @returns one bounded diagnostic line.
+ */
+function diagnosticOf(handle, stderrTail) {
+  const firstLine = String(stderrTail ?? '')
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .find((line) => line.length > 0)
+  const detail = firstLine === undefined ? 'no child output' : firstLine.slice(0, 300)
+  return `Junie run failed (${detail})`
+}
+
+/**
+ * Run one task: spawn, handshake, configure, prompt, settle, tear down.
+ * @param ctx - the plugin context.
+ * @param cfg - the effective configuration.
+ * @param request - the resolved start request.
+ * @returns the published run handle.
+ */
+async function startRun(ctx, cfg, request) {
+  const cwd = assertUsableCwd(PREFIX, 'request cwd', request.cwd)
+  let handle
+  try {
+    handle = ctx.subprocess.spawn({
+      argv: [cfg.command, ...cfg.args],
+      cwd,
+      stdio: { stdin: 'pipe', stdout: 'pipe', stderr: 'pipe' },
+      graceMs: cfg.graceMs,
+      env: { ...cfg.env },
+    })
+  } catch (error) {
+    throw new Error(`${PREFIX}: cannot start ${cfg.command}: ${error instanceof Error ? error.message : String(error)}`)
+  }
+
+  const chunks = []
+  const client = createClient(handle, {
+    permission: cfg.permission,
+    onText: (text) => chunks.push(text),
+  })
+
+  let sessionId
+  try {
+    await client.request('initialize', {
+      protocolVersion: 1,
+      clientCapabilities: { fs: { readTextFile: true, writeTextFile: true } },
+    })
+    const session = await client.request('session/new', { cwd, mcpServers: [] })
+    sessionId = session?.sessionId
+    if (typeof sessionId !== 'string' || sessionId.length === 0) {
+      throw new Error('ACP session/new returned no session id')
+    }
+    const stored = readStoredSettings()
+    const model = stored.model ?? cfg.model
+    const effort = stored.effort ?? cfg.effort
+    for (const [configId, value] of [['model', model], ['effort', effort], ['brave_mode', cfg.braveMode]]) {
+      if (value !== undefined) await client.request('session/set_config_option', { sessionId, configId, value })
+    }
+  } catch (error) {
+    client.close()
+    try {
+      handle.terminate()
+    } catch {
+      // Teardown failures cannot improve the startup rejection.
+    }
+    throw new Error(`${PREFIX}: ACP startup failed: ${error instanceof Error ? error.message : String(error)}`)
+  }
+
+  const collected = () => (chunks.length === 0 ? [] : [{ type: 'text', text: chunks.join('') }])
+
+  const requestStop = () => {
+    try {
+      client.notify('session/cancel', { sessionId })
+    } catch {
+      // The child may already be gone; termination below still applies.
+    }
+    try {
+      handle.terminate()
+    } catch {
+      // The seam owns final escalation.
+    }
+  }
+
+  const onAbort = () => requestStop()
+  request.signal.addEventListener('abort', onAbort, { once: true })
+
+  const timer = setTimeout(requestStop, cfg.timeoutMs)
+  if (typeof timer.unref === 'function') timer.unref()
+
+  const attempt = async () => {
+    const reply = await client.request('session/prompt', {
+      sessionId,
+      prompt: [{ type: 'text', text: taskText(request.prompt) || 'Continue.' }],
+    })
+    const mapped = STOP_REASONS.get(String(reply?.stopReason ?? ''))
+    if (mapped === undefined) {
+      throw new Error(`junie stopped with ${String(reply?.stopReason ?? 'an unknown reason')}`)
+    }
+    return { output: collected(), stopReason: mapped }
+  }
+
+  const result = settleRunResult({
+    attempt,
+    collectOutput: collected,
+    collectDiagnostic: () => diagnosticOf(handle, client.stderrTail()),
+    cancelled: () => request.signal.aborted,
+    signal: request.signal,
+    onAbort,
+  })
+
+  return subprocessRunHandle({
+    id: `junie-${randomUUID()}`,
+    result,
+    signal: request.signal,
+    onAbort,
+    requestCancel: requestStop,
+    teardown: async () => {
+      clearTimeout(timer)
+      request.signal.removeEventListener('abort', onAbort)
+      try {
+        handle.stdin?.end()
+      } catch {
+        // Already closed.
+      }
+      try {
+        await handle.waitForExit()
+      } catch {
+        // Teardown is best effort; the seam owns final escalation.
+      }
+      client.close()
+    },
+  })
+}
+
+/**
+ * Register the Junie provider and the settings route it shares with the page.
+ * Both registrations live in effects so Cordis disposes them with the fiber —
+ * an `apply` return value is not used as cleanup.
+ * @param ctx - the plugin context.
+ * @param config - the row config.
+ */
+export function apply(ctx, config) {
+  const cfg = normalize(config)
+  assertPositiveFinite(PREFIX, 'timeoutMs', cfg.timeoutMs)
+  assertPositiveFinite(PREFIX, 'graceMs', cfg.graceMs)
+
+  ctx.effect(() => ctx.subagents.registerProvider({
+    name: cfg.providerName,
+    capabilities: NO_START_CAPABILITIES,
+    inheritsParentContext: false,
+    start: (request) => startRun(ctx, cfg, request),
+  }))
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: ROUTE_PATH,
+    handler: configRouteHandler(ctx, cfg),
+  }))
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Junie subagent",
+    "description": "Delegates a one-shot task to the JetBrains Junie CLI over the Agent Client Protocol. Each call starts its own Junie process and returns Junie's final answer."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Junie 子智能体",
+    "description": "通过 Agent Client Protocol 把一次性任务委派给 JetBrains Junie CLI。每次调用都会启动独立的 Junie 进程，并回传 Junie 的最终答复。"
+  }
+}

package/package.json

@@ -1,6 +1,66 @@
 {
   "name": "@zumikua/dsh-junie-subagent",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "JetBrains Junie CLI as a one-shot DeepSeek Harness subagent provider over the Agent Client Protocol, with a settings page for model and thinking depth.",
+  "type": "module",
+  "license": "MIT",
+  "author": "Zumi Kua",
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "junie",
+    "jetbrains",
+    "subagent",
+    "acp",
+    "agent-client-protocol"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ZumiKua/dsh-junie-subagent.git"
+  },
+  "homepage": "https://github.com/ZumiKua/dsh-junie-subagent#readme",
+  "bugs": {
+    "url": "https://github.com/ZumiKua/dsh-junie-subagent/issues"
+  },
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "cordis.patch.yml",
+    "locale/*.json",
+    "icon.svg",
+    "README.md",
+    "README.zh.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "dsh": ">=0.2.1-rc.2"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.4",
+    "@deepseek-ai/dsh-subagent": "0.2.1-rc.2",
+    "@deepseek-ai/schemastery": "^3.0.0"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-api-remotes",
+        "@deepseek-ai/dsh-client-ui-settings"
+      ]
+    }
+  }
+}