dsh-dsml-rescue 0.0.0-stage → 0.1.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,79 @@
-# 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>Continue the turn a model stalled by writing tool-call markup into its reasoning</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&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="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>
+
+---
+
+Some provider routes deliver a model's tool call as **reasoning text carrying the call's own markup**
+instead of a structured call. The call never happens, the turn closes having produced nothing, and
+the conversation waits for someone to type "continue". This plugin types it for you.
+
+## What it does
+
+- Continues a turn that closed with leaked protocol markup and **nothing else**.
+- Sends one neutral sentence: take the next step, or close out with a summary.
+- Waits for you — if you are already typing, it stays out of the way.
+- Stops after a few attempts instead of spending requests forever.
+- Covers child agents too, so a delegated run is not reported finished while it is stuck.
+
+## Getting started
+
+**Prerequisites**: DSH on its current RC line; Node `>= 20`. The only source for the compatible range
+is `engines.dsh` in [package.json](package.json).
+
+```bash
+dsh plugin --profile web add dsh-dsml-rescue
+```
+
+Restart `dsh --profile web`. Nothing to configure: the defaults are the intended behaviour.
+
+From source: `git clone`, then `pnpm install && pnpm run build`, then
+`dsh plugin --profile web add "$PWD"`.
+
+## What it will not do
+
+- **It does not fix the cause.** The leak happens below the model, so no prompt prevents it; this
+  plugin only shortens the pause that follows.
+- **It does not rescue turns that ended empty for other reasons.** No markup, no rescue — a
+  cancellation, a failure, or a step cut off at its output ceiling all stay untouched.
+- **It does not touch your conversation.** Nothing is rewritten or re-sent; it adds one message and
+  lets the host run.
+
+## Configuration
+
+Three keys, all optional: `enabled`, `maxConsecutive`, `applyToSubagents`. Defaults, and what moving
+each one changes → [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md#configuration).
+
+## Under the hood
+
+How a stall is recognized, why the continuation is queued where it is, and what must not change →
+[docs/ARCHITECTURE.md](docs/ARCHITECTURE.md).
+What each check establishes, and a repeatable end-to-end run → [docs/VERIFICATION.md](docs/VERIFICATION.md).
+
+## License
+
+[MIT](LICENSE)

package/README_zh.md

@@ -0,0 +1,72 @@
+<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>Continue the turn a model stalled by writing tool-call markup into its reasoning</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&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="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>
+
+---
+
+有些 provider 路由会把模型的工具调用当成**普通思考文本**吐回来，里面夹着调用本身的协议标记。于是调用没有发生，回合以"什么都没产出"结束，会话就停在那儿等人敲一句"继续"。这个插件替你敲。
+
+## 它做什么
+
+- 只续一种回合：以泄漏的协议标记结束、且**没有产出任何别的**内容的回合。
+- 只发一句中性的话：要么执行下一步，要么收尾给结论。
+- 让着你：你已经在打字时它不插话。
+- 续几次就停，不会无限花请求。
+- 子 agent 也管，被派出去的活儿不会"卡着却被告知已结束"。
+
+## 开始用
+
+**前置**：DSH 当前 RC 线；Node `>= 20`。兼容区间的唯一来源是 [package.json](package.json) 里的 `engines.dsh`。
+
+```bash
+dsh plugin --profile web add dsh-dsml-rescue
+```
+
+重启 `dsh --profile web` 即可。不需要配置，默认值就是预期行为。
+
+从源码装：`git clone` 后 `pnpm install && pnpm run build`，再 `dsh plugin --profile web add "$PWD"`。
+
+## 它不做什么
+
+- **不修根因。** 泄漏发生在模型之下，任何提示词都规避不了；本插件只把随之而来的停顿缩短。
+- **不救其他空转。** 没有标记就不救——用户主动取消、请求失败、以及输出被长度截断后停在原地的回合，都不碰。
+- **不动你的对话。** 不改写、不重发；只多加一条消息，然后交给宿主继续跑。
+
+## 配置
+
+三个键，都可选：`enabled`、`maxConsecutive`、`applyToSubagents`。默认值以及改动各自的影响 →
+[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,29 @@
+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[];
+/** 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.
+ */
+declare function apply(ctx: Context, config: Config): void;
+export { Config, apply, inject, name };

package/lib/index.js

@@ -0,0 +1,373 @@
+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?
+*
+* A turn deserves one when it 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 a text block carries anything other than whitespace. */
+function carriesText(block) {
+	return block.type === "text" && block.text !== void 0 && /\S/.test(block.text);
+}
+/**
+* Whether the turn produced anything a caller could act on.
+*
+* An unknown block type counts as actionable on purpose: a provider that adds
+* a content kind this plugin has never seen is far more likely to have produced
+* output than to have produced nothing, and a false rescue costs a request.
+* @param blocks - the turn's closing content blocks.
+* @returns whether any block is visible text, a tool call, or an unknown kind.
+*/
+function hasActionableContent(blocks) {
+	return blocks.some((block) => block.type === "reasoning" ? false : block.type === "text" ? carriesText(block) : true);
+}
+/**
+* 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.flatMap((block) => block.type === "reasoning" && block.text !== void 0 ? [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 (hasActionableContent(observation.blocks)) 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: []
+};
+/**
+* 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 {
+			state: {
+				...state,
+				turn: event.turn,
+				blocks: event.blocks
+			},
+			decision: "ignore",
+			round: 0
+		};
+		case "human-message": return {
+			state: {
+				...state,
+				consecutive: 0
+			},
+			decision: "ignore",
+			round: 0
+		};
+		case "turn-end": return event.completed ? {
+			state,
+			decision: "ignore",
+			round: 0
+		} : {
+			state: {
+				...state,
+				consecutive: 0
+			},
+			decision: "ignore",
+			round: 0
+		};
+		case "turn-stopping": {
+			const blocks = state.turn === event.turn ? state.blocks : [];
+			const outcome = evaluate({
+				candidate: !event.outputExhausted && isRescueCandidate({
+					completed: true,
+					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");
+}
+/**
+* Whether the step being closed spent its whole output budget.
+*
+* The seam carries no stop reason, so this compares the closing message's
+* output-token count with the ceiling the request was sent under. Both numbers
+* are the caller's own accounting — the count is what the provider reported and
+* the ceiling is what this session last requested — so equality means the model
+* was cut off, not that it chose to stop.
+*
+* The comparison is deliberately one-sided: an unknown ceiling or a missing
+* count reports "not exhausted", because a wrong `true` would silence the
+* rescue this plugin exists for, while a wrong `false` only costs the rescue
+* one attempt of the streak.
+* @param agent - the agent whose turn is closing.
+* @param turn - the turn being closed.
+* @param usage - the closing message's token accounting, when the host logged it.
+* @returns whether the output budget is spent.
+*/
+function outputExhausted(agent, usage) {
+	if (usage === void 0) return false;
+	const ceiling = agent.session.requestHeader()?.config.maxTokens;
+	if (ceiling === void 0 || ceiling <= 0) return false;
+	return usage.outputTokens >= ceiling;
+}
+/**
+* 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();
+	/** Output accounting of the last assistant message, per agent. */
+	const usageByAgent = /* @__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
+				});
+				usageByAgent.set(agent, event.data.usage);
+				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),
+			outputExhausted: outputExhausted(agent, usageByAgent.get(agent))
+		});
+		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);
+		usageByAgent.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"];
+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.
+*/
+function apply(ctx, config) {
+	if (config.enabled === false) return;
+	install(ctx, {
+		maxConsecutive: config.maxConsecutive ?? 3,
+		applyToSubagents: config.applyToSubagents ?? true
+	});
+}
+export { Config, 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.1.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"
+    }
+  },
+  "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"
+  },
+  "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"
+  }
+}