dsh-dsml-rescue 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 zlZayn
+
+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
+<p align="center">
+  <img src="icon.svg" alt="dsh-dsml-rescue" width="80" height="80">
+</p>
 
-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.
+<h1 align="center">dsh-dsml-rescue</h1>
+
+<div align="center">
+  <p><strong>A stalled turn gets another one</strong></p>
+  <p><em>空转的轮次，替你续上</em></p>
+
+  <p>
+    <a href="https://github.com/deepseek-ai/deepseek-harness"><img src="https://img.shields.io/badge/powered_by-dsh-4D6BFE?style=flat-square&logo=deepseek&logoColor=white" alt="powered by dsh"></a>
+  </p>
+
+  <p>
+    <a href="https://github.com/dsh-plugin-lab/dsh-dsml-rescue/actions/workflows/ci.yml"><img src="https://github.com/dsh-plugin-lab/dsh-dsml-rescue/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
+    <a href="https://www.npmjs.com/package/dsh-dsml-rescue"><img src="https://img.shields.io/npm/v/dsh-dsml-rescue.svg?style=flat" alt="npm"></a>
+    <a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-blue.svg?style=flat" alt="MIT License"></a>
+  </p>
+
+  <p>
+    Per-version changes → <a href="https://github.com/dsh-plugin-lab/dsh-dsml-rescue/releases">Releases</a>
+  </p>
+
+  <p>
+    <strong><a href="README.md">English</a></strong> · <a href="README_zh.md">简体中文</a>
+  </p>
+</div>
+
+---
+
+## Does this look familiar?
+
+You asked for something. The model reasoned for a while. Then the turn simply ended — no answer, no
+tool call, nothing. The reasoning output ended with lines like these:
+
+```
+</｜｜DSML｜｜ parameter>
+</｜｜DSML｜｜ invoke>
+</｜｜DSML｜｜ calls>
+```
+
+DSML (DeepSeek Markup Language) is how DeepSeek formats a tool call. Some provider routes hand that
+markup back as **ordinary reasoning text** instead of an actual call, so the call never happens, the
+turn closes with no output, and everything waits for someone to type "continue".
+
+This plugin types it.
+
+## What it does
+
+- Continues a stalled turn: DSML markup at the end of the reasoning, and nothing else produced.
+- Sends one short, neutral line — carry on, or wrap up if the work is done.
+- Backs off while you are typing.
+- Gives up after a few attempts instead of burning requests.
+- Covers subagents too, so a delegated task is not falsely reported as completed while it is stuck.
+
+## Install
+
+```bash
+dsh plugin --profile web add dsh-dsml-rescue
+```
+
+Then restart `dsh --profile web`. There is nothing to configure — the defaults are the intended
+behaviour.
+
+Working from source: clone, `pnpm install && pnpm run build`, then
+`dsh plugin --profile web add "$PWD"`.
+
+## What it will not do
+
+- **It does not fix the cause.** The markup leaks below the model, out of reach of any prompt. What
+  it buys you is the wait, shortened.
+- **It does not rescue other empty turns.** No DSML markup, no rescue: a cancellation, a failed
+  request, or a reply cut off at the output limit is left alone on purpose.
+- **It does not touch your conversation.** Nothing is rewritten or replayed; it adds one message and
+  lets the host carry on.
+
+## Going deeper
+
+- Which three settings exist and what each one changes →
+  [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md#configuration)
+- How a stalled turn is recognised, and the rules that must not be broken →
+  [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md)
+- What the tests prove, and how to reproduce the whole thing locally →
+  [docs/VERIFICATION.md](docs/VERIFICATION.md)
+
+## License
+
+[MIT](LICENSE)

package/README_zh.md

@@ -0,0 +1,78 @@
+<p align="center">
+  <img src="icon.svg" alt="dsh-dsml-rescue" width="80" height="80">
+</p>
+
+<h1 align="center">dsh-dsml-rescue</h1>
+
+<div align="center">
+  <p><strong>空转的轮次，替你续上</strong></p>
+  <p><em>A stalled turn gets another one</em></p>
+
+  <p>
+    <a href="https://github.com/deepseek-ai/deepseek-harness"><img src="https://img.shields.io/badge/powered_by-dsh-4D6BFE?style=flat-square&logo=deepseek&logoColor=white" alt="powered by dsh"></a>
+  </p>
+
+  <p>
+    <a href="https://github.com/dsh-plugin-lab/dsh-dsml-rescue/actions/workflows/ci.yml"><img src="https://github.com/dsh-plugin-lab/dsh-dsml-rescue/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
+    <a href="https://www.npmjs.com/package/dsh-dsml-rescue"><img src="https://img.shields.io/npm/v/dsh-dsml-rescue.svg?style=flat" alt="npm"></a>
+    <a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-blue.svg?style=flat" alt="MIT License"></a>
+  </p>
+
+  <p>
+    每个版本改了什么 → <a href="https://github.com/dsh-plugin-lab/dsh-dsml-rescue/releases">Releases</a>
+  </p>
+
+  <p>
+    <a href="README.md">English</a> · <strong><a href="README_zh.md">简体中文</a></strong>
+  </p>
+</div>
+
+---
+
+## 这场景眼熟吗
+
+你提了要求，模型推理了一会儿，然后这一轮就这么结束了——没有回复、没有工具调用，什么都没有。推理过程的最后几行是这样：
+
+```
+</｜｜DSML｜｜ parameter>
+</｜｜DSML｜｜ invoke>
+</｜｜DSML｜｜ calls>
+```
+
+DSML（DeepSeek Markup Language）是 DeepSeek 表示工具调用的协议标记。某些 provider 路由会把这段标记当成**普通推理文本**返回，而不是真的发出调用；于是调用没有发生，这一轮空着结束，所有人都在等一句「继续」。
+
+这个插件替你把这句「继续」发出去。
+
+## 它做什么
+
+- 只救空转的轮次：推理过程末尾带着 DSML 标记，而且没有产出任何别的内容。
+- 发一句很短、很中性的话：接着做，或者已经做完就收尾。
+- 你正在打字时它让开。
+- 连着几次没救回来就收手，不会一直烧请求。
+- 子代理也管：被派出去的任务不会在卡住时被误报为已完成。
+
+## 安装
+
+```bash
+dsh plugin --profile web add dsh-dsml-rescue
+```
+
+然后重启 `dsh --profile web`。不需要配置，默认值就是预期行为。
+
+从源码装：先 clone，`pnpm install && pnpm run build`，再 `dsh plugin --profile web add "$PWD"`。
+
+## 它不会做什么
+
+- **不修根因。** 标记泄漏发生在模型之下，提示词够不着。它换来的只有那段等待被缩短。
+- **不救别的空转轮次。** 没有 DSML 标记就不出手：你主动取消、请求失败、回复被输出上限截断，这些都刻意不碰。
+- **不动你的对话。** 不改写、不重放历史，只多加一条消息，剩下的交给宿主。
+
+## 想了解更多
+
+- 有哪三个配置项、各自会改变什么 → [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md#configuration)
+- 怎么认定一个空转轮次、哪些规则不能破 → [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md)
+- 测试能证明什么、怎么在本机完整复现 → [docs/VERIFICATION.md](docs/VERIFICATION.md)
+
+## 许可
+
+[MIT](LICENSE)

package/cordis.patch.yml

@@ -0,0 +1,15 @@
+# Bundle patch: inserts this plugin as one row in a dsh profile.
+#
+# The format follows the official DSH bundle patch: the top level is an array of loader patch entries,
+# and `insert` appends plugin rows at the profile root.
+#
+# About `name`: it must be a module id the loader can resolve from the profile's node_modules, which is
+# this package's own name.
+#
+# About `config`: **never put credentials here.** This is no longer a source of values, so writing one
+# here has exactly two consequences — the startup migration moves it into the credential store, and the
+# row cannot be deleted from the composed config, so every startup warns you to remove it by hand.
+# Secrets belong in the plugin's configuration card, or in an environment variable.
+- insert:
+    - id: 'dsh-dsml-rescue'
+      name: 'dsh-dsml-rescue'

package/icon.svg

@@ -0,0 +1,10 @@
+<svg width="36" height="36" viewBox="0 0 36 36" fill="none" xmlns="http://www.w3.org/2000/svg" role="img" aria-label="dsh-dsml-rescue">
+  <!--
+    Two chevrons advancing to the right: the turn continues. The second one is
+    lighter so the pair reads as motion rather than as a single direction sign.
+    Transparent canvas, no background plate, colours fixed because the host
+    paints this as an image.
+  -->
+  <path d="M11 10.5 L18 18 L11 25.5" stroke="#4D6BFE" stroke-width="2.6" stroke-linecap="round" stroke-linejoin="round"/>
+  <path d="M18.5 10.5 L25.5 18 L18.5 25.5" stroke="#93A5FF" stroke-width="2.6" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

package/lib/index.d.ts

@@ -0,0 +1,33 @@
+import z from "@deepseek-ai/schemastery";
+import { Context } from "@deepseek-ai/cordis";
+/** Cordis plugin name, used by the loader for diagnostics. */
+declare const name = "dsh-dsml-rescue";
+/** The agent registry, needed to map a session back to its live agent. */
+declare const inject: string[];
+/** Rescues allowed in a row before an agent is left alone. */
+declare const DEFAULT_MAX_CONSECUTIVE = 3;
+/** Whether child agents are rescued by default. */
+declare const DEFAULT_APPLY_TO_SUBAGENTS = true;
+/** Validated configuration; the defaults are the documented behaviour. */
+interface Config {
+  /** Whether the plugin acts at all. Turn it off without uninstalling. */
+  enabled?: boolean;
+  /**
+   * Consecutive rescues allowed for one agent before it is left alone. Each
+   * rescue costs one model request, so this is the only spend control here.
+   */
+  maxConsecutive?: number;
+  /**
+   * Whether child agents are rescued too. Their stalls otherwise settle
+   * silently and reach their parent only as "finished".
+   */
+  applyToSubagents?: boolean;
+}
+declare const Config: z<Config>;
+/**
+ * Mount the plugin.
+ * @param ctx - host context.
+ * @param config - validated configuration; the schema fills in every default.
+ */
+declare function apply(ctx: Context, config: Config): void;
+export { Config, DEFAULT_APPLY_TO_SUBAGENTS, DEFAULT_MAX_CONSECUTIVE, apply, inject, name };

package/lib/index.js

@@ -0,0 +1,358 @@
+import z from "@deepseek-ai/schemastery";
+import { boundContextSummary, createUserMessage } from "@deepseek-ai/dsh-llm";
+// src/protocol.ts
+/**
+* Protocol-mark detection over one reasoning stream.
+*
+* Some provider routes deliver the model's tool-call dialect as ordinary
+* reasoning text instead of a structured tool call. The dialect's closing
+* tokens then sit at the very end of the thinking stream, and the turn ends
+* having done nothing. This module answers one question about that text: does
+* it end with such a token? It knows nothing about turns, agents, or sessions.
+*
+* @module dsh-dsml-rescue/protocol
+*/
+/**
+* The marker that opens and closes every token of the dialect. Matched on
+* NFKC-normalized text, so the full-width vertical bar the dialect actually
+* uses arrives here as an ASCII pipe and needs no separate alternative.
+*/
+const MARKER = /\|\|\s*dsml\s*\|\|/i;
+/**
+* How many trailing non-blank lines are considered. A leak puts its closing
+* tokens at the end; scanning further back starts matching prose *about* the
+* dialect, including examples a model quotes while explaining it.
+*/
+const TAIL_LINES = 3;
+/**
+* A line that is protocol markup rather than a sentence.
+*
+* Requiring the line to open with `<` is what separates the two: a model that
+* mentions the marker inside a sentence starts that line with ordinary text,
+* while genuine leaked markup starts with its opening angle bracket.
+* @param line - one NFKC-normalized line, trimmed.
+* @returns whether the line opens as markup and carries the marker.
+*/
+function isMarkupLine(line) {
+	return line.startsWith("<") && MARKER.test(line);
+}
+/**
+* Whether a reasoning stream ends with leaked protocol markup.
+*
+* Empty or absent reasoning is not a leak: a turn that produced nothing at all
+* is a different failure and stays outside this plugin's scope.
+* @param reasoning - the complete reasoning text of one assistant message.
+* @returns whether any of its last few non-blank lines is protocol markup.
+*/
+function hasLeakedProtocolTail(reasoning) {
+	if (reasoning === "") return false;
+	const lines = reasoning.normalize("NFKC").split(/\r?\n/);
+	let scanned = 0;
+	for (let index = lines.length - 1; index >= 0 && scanned < TAIL_LINES; index -= 1) {
+		const line = (lines[index] ?? "").trim();
+		if (line === "") continue;
+		scanned += 1;
+		if (isMarkupLine(line)) return true;
+	}
+	return false;
+}
+// src/detect.ts
+/**
+* The one judgment this plugin makes: does a finished turn deserve a rescue?
+*
+* It deserves one when the turn ended normally yet produced nothing the loop or
+* the user can act on, and its reasoning ends in leaked protocol markup. Both
+* halves are required — a turn that produced nothing for another reason stays
+* untouched, because rescuing it would paper over an unrelated failure.
+*
+* Pure: no host types, no events, no clock. The caller adapts real session
+* events into {@link TurnObservation}.
+*
+* @module dsh-dsml-rescue/detect
+*/
+/**
+* Whether one block produced something a caller could act on.
+*
+* Reasoning never counts — that is where the leak lives, not where the work
+* lands. An unknown block type does count, on purpose: a provider that adds a
+* content kind this plugin has never seen is far likelier to have produced
+* output than to have produced nothing, and a false rescue costs a request.
+* @param block - one content block of the closing message.
+* @returns whether the block is visible text, a tool call, or an unknown kind.
+*/
+function isActionable(block) {
+	if (block.type === "reasoning") return false;
+	if (block.type !== "text") return true;
+	return block.text !== void 0 && /\S/.test(block.text);
+}
+/**
+* Concatenate every reasoning block of a message.
+* @param blocks - the turn's closing content blocks.
+* @returns the joined reasoning text, or the empty string when there is none.
+*/
+function joinReasoning(blocks) {
+	return blocks.filter((block) => block.type === "reasoning" && block.text !== void 0).map((block) => block.text ?? "").join("\n");
+}
+/**
+* Decide whether one finished turn is a leaking stall.
+* @param observation - the turn's end reason and its closing message blocks.
+* @returns true only when the turn completed, produced nothing actionable, and
+*   its reasoning ends in protocol markup.
+*/
+function isRescueCandidate(observation) {
+	if (!observation.completed) return false;
+	if (observation.blocks.some(isActionable)) return false;
+	return hasLeakedProtocolTail(joinReasoning(observation.blocks));
+}
+// src/policy.ts
+/**
+* Decide what one finished turn deserves.
+*
+* Order matters: a spent cap outranks a waiting human, because giving way would
+* leave the cap unrecorded and the streak silently unbounded.
+* @param input - detection verdict, current streak, cap, and human presence.
+* @returns the decision and the streak to store.
+*/
+function evaluate(input) {
+	if (!input.candidate) return {
+		decision: "ignore",
+		consecutive: 0
+	};
+	if (input.consecutive >= input.maxConsecutive) return {
+		decision: "give-up",
+		consecutive: 0
+	};
+	if (input.humanPending) return {
+		decision: "yield",
+		consecutive: input.consecutive
+	};
+	return {
+		decision: "rescue",
+		consecutive: input.consecutive + 1
+	};
+}
+// src/machine.ts
+/**
+* One agent's turn-to-turn decision, as a pure reducer.
+*
+* The runtime's only job is translation: Cordis events in, this reducer called,
+* one side effect out. Keeping the sequencing here means the recorded sessions
+* under `test/fixtures/` exercise the same code the host runs, instead of a
+* second implementation written for the tests.
+*
+* @module dsh-dsml-rescue/machine
+*/
+/** The state a machine starts in. */
+const INITIAL_STATE = {
+	consecutive: 0,
+	turn: void 0,
+	blocks: [],
+	outputTokens: void 0
+};
+/** Nothing to do, with the state unchanged. */
+function nothing(state) {
+	return {
+		state,
+		decision: "ignore",
+		round: 0
+	};
+}
+/**
+* Whether the step being closed spent its whole output budget.
+*
+* Reads as exhausted only when both numbers are known: an unknown ceiling or a
+* missing count reports "not exhausted" on purpose, because a wrong `true`
+* would silence the rescue this plugin exists for, while a wrong `false` only
+* costs the streak one attempt.
+* @param state - state carrying the closing message's output tokens.
+* @param ceiling - the ceiling the request was sent under, when known.
+* @returns whether the model was cut off rather than finished.
+*/
+function spentBudget(state, ceiling) {
+	if (state.outputTokens === void 0) return false;
+	if (ceiling === void 0 || ceiling <= 0) return false;
+	return state.outputTokens >= ceiling;
+}
+/**
+* Advance one agent's machine by one event.
+*
+* The streak clears on two facts only: a turn that ended abnormally (a
+* different failure, which a rescue would hide) and human input (the human now
+* owns the conversation). It is *not* cleared by the plugin's own notices.
+* @param state - state after the previous event.
+* @param event - the fact to apply.
+* @param limits - configured cap.
+* @returns the next state and what to do about it.
+*/
+function reduce(state, event, limits) {
+	switch (event.kind) {
+		case "assistant-message": return nothing({
+			...state,
+			turn: event.turn,
+			blocks: event.blocks,
+			outputTokens: event.outputTokens
+		});
+		case "human-message": return nothing({
+			...state,
+			consecutive: 0
+		});
+		case "turn-end": return event.completed ? nothing(state) : nothing({
+			...state,
+			consecutive: 0
+		});
+		case "turn-stopping": {
+			const outcome = evaluate({
+				candidate: isRescueCandidate({
+					completed: true,
+					blocks: state.turn === event.turn && !spentBudget(state, event.outputCeiling) ? state.blocks : []
+				}),
+				consecutive: state.consecutive,
+				maxConsecutive: limits.maxConsecutive,
+				humanPending: event.humanPending
+			});
+			return {
+				state: {
+					...state,
+					consecutive: outcome.consecutive
+				},
+				decision: outcome.decision,
+				round: outcome.decision === "rescue" ? outcome.consecutive : 0
+			};
+		}
+	}
+}
+// src/messages.ts
+/**
+* The one message this plugin shows the model, and the attribution it carries.
+*
+* Deliberately says nothing about why the previous turn ended empty. The cause
+* sits below the model — a provider route delivering tool-call markup as text —
+* so nothing the model does can avoid it, and naming it would only invite the
+* model to talk about the failure instead of continuing the work. The wording
+* is fixed rather than configurable: one sentence that asks for the next step,
+* plus one legal way out so a rescue cannot become an open-ended loop.
+*
+* @module dsh-dsml-rescue/messages
+*/
+/** What the model reads. Two instructions: continue, or close out if finished. */
+const CONTINUE_PROMPT = "Continue with the task. Take the next concrete step now, using a tool if needed. If the work is complete, reply with a short summary.";
+/**
+* Build the continuation turn's message.
+* @param round - this rescue's ordinal in the current streak, from 1.
+* @param max - the configured cap, for the durable one-line summary.
+* @returns an immutable user-role message attributed to this plugin.
+*/
+function createRescueMessage(round, max) {
+	return createUserMessage({
+		content: [{
+			type: "text",
+			text: CONTINUE_PROMPT
+		}],
+		source: {
+			kind: "dsml-rescue",
+			form: "notice",
+			summary: boundContextSummary(`Auto-continue ${round}/${max}`)
+		}
+	});
+}
+// src/runtime.ts
+/** Whether the inbox already holds input a human queued. */
+function humanPending(agent) {
+	return agent.inbox.nextTurn.some((message) => message.source.kind === "user") || agent.inbox.nextStep.some((message) => message.source.kind === "user");
+}
+/**
+* Install the turn watcher and its continuation side effect.
+* @param ctx - plugin context; listeners are disposed with it.
+* @param config - validated limits.
+*/
+function install(ctx, config) {
+	const states = /* @__PURE__ */ new Map();
+	/** Apply one reducer event and store the result. */
+	function advance(agent, event) {
+		const step = reduce(states.get(agent) ?? INITIAL_STATE, event, { maxConsecutive: config.maxConsecutive });
+		states.set(agent, step.state);
+		return step;
+	}
+	/** Whether this agent was created by another agent instead of at the root. */
+	function isSubagent(agent) {
+		return !ctx.agents.roots().includes(agent);
+	}
+	ctx.on("session/event", (session, event) => {
+		const agent = ctx.agents.get(session.id);
+		if (agent === void 0 || agent.session !== session) return;
+		switch (event.type) {
+			case "assistant/message":
+				advance(agent, {
+					kind: "assistant-message",
+					turn: event.data.turn,
+					blocks: event.data.message.content,
+					outputTokens: event.data.usage?.outputTokens
+				});
+				return;
+			case "user/message":
+				if (event.data.source.kind === "user") advance(agent, { kind: "human-message" });
+				return;
+			case "turn/end":
+				advance(agent, {
+					kind: "turn-end",
+					turn: event.data.turn,
+					completed: event.data.reason.kind === "completed"
+				});
+				return;
+			default: return;
+		}
+	});
+	ctx.on("agent/turn-stopping", ({ agent, turn }) => {
+		if (!config.applyToSubagents && isSubagent(agent)) return;
+		const step = advance(agent, {
+			kind: "turn-stopping",
+			turn,
+			humanPending: humanPending(agent),
+			outputCeiling: agent.session.requestHeader()?.config.maxTokens
+		});
+		if (step.decision === "give-up") {
+			ctx.logger.warn(`dsml-rescue: agent "${agent.id}" stalled ${config.maxConsecutive} times in a row; stopped continuing it`);
+			return;
+		}
+		if (step.decision !== "rescue") return;
+		try {
+			agent.followup(createRescueMessage(step.round, config.maxConsecutive));
+		} catch (error) {
+			states.set(agent, {
+				...states.get(agent) ?? INITIAL_STATE,
+				consecutive: 0
+			});
+			ctx.logger.warn(`dsml-rescue: could not queue a continuation for agent "${agent.id}": ${String(error)}`);
+		}
+	});
+	ctx.on("agent/disposed", ({ agent }) => {
+		states.delete(agent);
+	});
+}
+// src/index.ts
+/** Cordis plugin name, used by the loader for diagnostics. */
+const name = "dsh-dsml-rescue";
+/** The agent registry, needed to map a session back to its live agent. */
+const inject = ["agents"];
+/** Rescues allowed in a row before an agent is left alone. */
+const DEFAULT_MAX_CONSECUTIVE = 3;
+/** Whether child agents are rescued by default. */
+const DEFAULT_APPLY_TO_SUBAGENTS = true;
+const Config = z.object({
+	enabled: z.boolean().default(true),
+	maxConsecutive: z.natural().min(1).default(3),
+	applyToSubagents: z.boolean().default(true)
+});
+/**
+* Mount the plugin.
+* @param ctx - host context.
+* @param config - validated configuration; the schema fills in every default.
+*/
+function apply(ctx, config) {
+	if (config.enabled === false) return;
+	install(ctx, {
+		maxConsecutive: config.maxConsecutive ?? 3,
+		applyToSubagents: config.applyToSubagents ?? true
+	});
+}
+export { Config, DEFAULT_APPLY_TO_SUBAGENTS, DEFAULT_MAX_CONSECUTIVE, apply, inject, name };

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "DSML Rescue",
+    "description": "Continues the turn a model stalled by writing tool-call markup into its reasoning instead of calling a tool."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "DSML Rescue",
+    "description": "模型把工具调用协议标记写进思考、导致回合空转时，自动补发一条中性指令把回合续上。"
+  }
+}

package/package.json

@@ -1,6 +1,87 @@
 {
   "name": "dsh-dsml-rescue",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.0",
+  "description": "Continue the turn a model stalled by writing tool-call markup into its reasoning",
+  "keywords": [
+    "dsh",
+    "deepseek-harness",
+    "dsh-plugin",
+    "reasoning",
+    "auto-continue"
+  ],
+  "license": "MIT",
+  "author": "zlZayn",
+  "icon": "./icon.svg",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dsh-plugin-lab/dsh-dsml-rescue.git"
+  },
+  "bugs": {
+    "url": "https://github.com/dsh-plugin-lab/dsh-dsml-rescue/issues"
+  },
+  "homepage": "https://github.com/dsh-plugin-lab/dsh-dsml-rescue#readme",
+  "type": "module",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js"
+    },
+    "./locale/*.json": "./locale/*.json",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "!lib/**/*.map",
+    "icon.svg",
+    "locale/*.json",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE",
+    "README_zh.md"
+  ],
+  "engines": {
+    "node": ">=20",
+    "dsh": "^0.1.7-rc.1 || ^0.2.0-rc.1 || ^0.2.1-rc.1"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.4",
+    "@deepseek-ai/dsh-llm": "^0.1.7-rc.1 || ^0.2.0-rc.1 || ^0.2.1-rc.1",
+    "@deepseek-ai/schemastery": "^3.18.2"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.4",
+    "@deepseek-ai/dsh-agent": "^0.1.7-rc.1 || ^0.2.0-rc.1 || ^0.2.1-rc.1",
+    "@deepseek-ai/dsh-llm": "^0.1.7-rc.1 || ^0.2.0-rc.1 || ^0.2.1-rc.1",
+    "@deepseek-ai/dsh-session": "^0.1.7-rc.1 || ^0.2.0-rc.1 || ^0.2.1-rc.1",
+    "@deepseek-ai/schemastery": "^3.18.2",
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^22.20.0",
+    "@vitest/coverage-v8": "^4.1.11",
+    "eslint": "^10.11.0",
+    "eslint-config-prettier": "^10.1.8",
+    "globals": "^17.12.0",
+    "prettier": "^3.9.9",
+    "tsdown": "^0.22.2",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.70.1",
+    "vitest": "^4.1.11"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "check:release": "node scripts/check-release.mjs",
+    "check": "pnpm run typecheck && pnpm run build && pnpm run test && pnpm run check:release"
+  }
 }