dsh-openwrite 0.2.18 → 0.2.20

package/README.md

@@ -29,14 +29,12 @@
 
 ## 快速安装
 
-**0.2.13 标准插件包**兼容精确 dsh 版本 **0.1.2-rc.1 / 0.1.5-alpha.1 / 0.2.0-rc.2**。0.2.0-rc.2 已完成 Web 工作台渲染与 DoG 数据读取验证，Windows Electron 桌面端启动/恢复链路尚未实机复测。可下载版本、各平台验收结果和 SHA-256 以 [GitHub Release](https://github.com/LiPu-jpg/Openwrite/releases/latest) 附件为准；验收方法见 [发布验收](docs/RELEASE_ACCEPTANCE.md)。默认使用 npm `latest` 渠道；商城所需的精确预览版兼容性、验证范围和安装限制见 [DSH STORE 接入](docs/DSH_STORE.md)。
+**0.2.20 标准插件包**兼容精确 dsh 版本 **0.1.2-rc.1 / 0.1.5-alpha.1 / 0.2.0-rc.2**。三个版本均已完成 Web 工作台渲染与 DoG 数据读取验证，Windows Electron 桌面端启动/恢复链路尚未实机复测。可下载版本、各平台验收结果和 SHA-256 以 [GitHub Release](https://github.com/LiPu-jpg/Openwrite/releases/latest) 附件为准；验收方法见 [发布验收](docs/RELEASE_ACCEPTANCE.md)。默认使用 npm `latest` 渠道；商城所需的精确预览版兼容性、验证范围和安装限制见 [DSH STORE 接入](docs/DSH_STORE.md)。
 
 npm 包和对应 GitHub Release 使用同一份验收产物。也可安装精确版本的 Release 包：
 
-**0.2.13 的 GitHub 安装包已发布，npm `latest` 暂时仍为 0.2.12，等待本次发布的 2FA 验证后同步发布。** 0.2.12 不包含 #57 的创作页刷新循环修复；请使用下方已发布的 0.2.13 Release 包。
-
 ```sh
-dsh plugin --profile web add -w https://github.com/LiPu-jpg/Openwrite/releases/download/v0.2.13/dsh-openwrite-0.2.13.tgz
+dsh plugin --profile web add -w https://github.com/LiPu-jpg/Openwrite/releases/download/v0.2.20/dsh-openwrite-0.2.20.tgz
 dsh web
 ```
 
@@ -66,6 +64,10 @@ dsh web
 
 ### dsh 0.2 桌面端升级
 
+`0.2.20` 捆绑 Core 5.8.10，修复 [#76](https://github.com/LiPu-jpg/Openwrite/issues/76) 的草稿恢复、任务状态、编辑和审稿契约，并补充 [#65](https://github.com/LiPu-jpg/Openwrite/issues/65) 的英文使用支持。行为与范围见 [修复说明](docs/ISSUE_76_REPAIRS.md)。正式可下载版本以 npm `latest` 和 GitHub Release 为准。
+
+`0.2.19` 候选包修复两个加载/工具问题：部分安装下「OpenWrite 创作」预设从列表消失、DoG 工具不可用（dsh-dog 宿主包解析失败，[#74](https://github.com/LiPu-jpg/Openwrite/issues/74)），以及 `novel_*` 工具的对象/数组参数在模型输出 JSON 字符串时预览失败、`data` 字段丢失（[#75](https://github.com/LiPu-jpg/Openwrite/issues/75)）。正式可下载版本以 npm `latest` 和 GitHub Release 为准。升级后需停止并重新启动 dsh，再刷新浏览器页面。
+
 `0.2.18` 候选包修正 `auto:cheapest`（Core 5.8.9）：零价模型不再参与比价，自动落到付费低价模型上。正式可下载版本以 npm `latest` 和 GitHub Release 为准。升级后需停止并重新启动 dsh，再刷新浏览器页面。
 
 `0.2.17` 候选包新增自动选模（Core 5.8.8）：模型档案的模型名写成 `auto:cheapest` 会自动选用服务商价格目录中总价最低且满足上下文/输出要求的模型（目录缓存一小时，价格变动自动跟随），写成 `auto:popular`（OpenRouter）则由官方 `openrouter/auto` 按社区用量自动选模型。正式可下载版本以 npm `latest` 和 GitHub Release 为准。升级后需停止并重新启动 dsh，再刷新浏览器页面。
@@ -101,7 +103,7 @@ dsh web
 
 已有会话不会自动切换预设。详细操作与工作区规则见 [使用流程](docs/WORKFLOWS.md)。
 
-**界面语言**：面板已内置中文与英文词典，跟随 dsh 语言设置。切换方法：Settings → General → Language → English（选择后存为 `locale.preference`）。注意 Agent 的 persona、技能说明与部分后端状态/报错信息仍以中文为主；Agent 会用你在对话中使用的语言回复。
+**界面语言**：面板已内置中文与英文词典，跟随 dsh 语言设置。切换方法：Settings → General → Language → English（选择后存为 `locale.preference`）。Agent 的 persona 和所有技能入口要求用作者的对话语言回复；运行环境与任务状态提供英文，Studio 报错附带英文说明和稳定错误码。已有作品内容不会自动翻译，正文按作者指定的语言生成。
 
 ## 配置模型
 
@@ -165,3 +167,18 @@ conductor/                 连续写章、评审与修订编排
 Logo 基于 OpenWrite `native-core` 分支，已调整深浅主题配色；基于 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness)，图谱集成使用 [dsh-dog](https://github.com/Fun10165/dsh-dog)。
 
 生态目录：[dsh-TUI](https://github.com/ccch1mneyyy/dsh-TUI) · [社区插件市场](https://dshtui.com/plugins/)。OpenWrite 当前面向 DeepSeek Harness 的 `web` profile，使用 `dsh web` 打开创作工作台；尚未验证 dsh-TUI 界面兼容性。
+
+## Language / 语言
+
+In dsh, choose **Settings → General → Language → English** (`locale.preference`).
+The OpenWrite panel follows the host language. The writing agent and slash-command
+help follow your conversation language; manuscripts, outlines and assets retain
+their existing language. You can say “Please write and review this novel in English.”
+The bundled Chinese skill files are procedural instructions, not an output-language
+restriction. Runtime setup messages use English. Backend failures include stable
+`code`, English `message`, `request_id`, and the original diagnostic text.
+
+在 dsh 的 **设置 → 通用 → 语言 → English** 切换面板语言。Agent 的回复和命令帮助跟随
+当前对话语言；正文与资产遵循作品已有语言，除非作者要求翻译。
+
+任务恢复、编辑确认及审稿职责范围见 [可靠性修复说明](docs/ISSUE_76_REPAIRS.md)。

package/docs/ISSUE_76_REPAIRS.md

@@ -0,0 +1,61 @@
+# Reliability and language changes (issues #76 and #65)
+
+This change targets the deterministic failures reported against plugin 0.2.19 / Core 5.8.9. It does not calibrate literary scores or make model reviews deterministic. Automated regression tests use isolated registries and fake model responses.
+
+## Writing and recovery
+
+`novel_write_chapter` now submits `chapter_write` to the durable task queue and returns `task_id` immediately. Poll `novel_task_get`. A transport error cannot prove rejection: use `novel_tasks_list(since=<ISO timestamp>)` or `novel_chapter_run_action(action="list", since=...)` before submitting again. Transport diagnostics store endpoint, timestamp and call identity, without credentials or prompt content.
+
+If commit fails, generated prose remains recoverable. New manuscripts remain on disk with a `.uncommitted.json` sidecar; an existing manuscript is restored and the generated replacement is saved separately. The error includes `run_id_v2`, `draft_artifact`, and `draft_path`. Resume with `novel_write_chapter(chapter_id=..., run_id_v2=...)` or `resume_from_draft=true`. Recovery reuses the completed draft and facts, verifies the input revisions, and retains its original target and model provenance. Reconcile stale acceptance first when requested. `novel_task_retry` also resumes eligible drafts and completed continuous tasks with failed chapters.
+
+`PROJECT_BUSY` defers the task and retries after two seconds. It does not consume the continuous failure budget. Cancellation is cooperative: `cancel_requested=true` means requested; `cancelled=true` means the persisted task is actually cancelled. `wait_seconds` waits up to 30 seconds; otherwise poll. In-flight model calls may finish before cancellation is observed, but cancelled runs reject late commits.
+
+The chapter target contract is **200–50000**, with precedence **explicit argument → chapter outline → 3000**. Preview and write return `target_words_source` and the effective range, **−20% / +50%**. Resume retains the draft's target; changing it requires a fresh generation. Outline chapter metadata is validated on structural edits, document writes and change plans; volume totals have separate limits. Runs retain `model_profile`, `requested_model`, actual `model` and `provider`; differing model resolution is flagged.
+
+## Acceptance and editing
+
+A `STALE_ACCEPTED_REVISION` error includes the operation handle and recovery actions. Inspect the operation before choosing:
+
+- `resume` continues an incomplete acceptance using its frozen input.
+- `abandon`, with `operation_id` and `confirm=true`, releases only that operation's pending heads and retains its audit record. It does not delete or silently accept manuscript text. A real unaccepted manuscript still requires baseline/external acceptance.
+- `external`, with `confirm=true`, explicitly accepts the currently observed manuscript as a new source revision. This supersedes the prior pending revision; it is a deliberate re-baseline, not a reread or a retry.
+
+Capture rejects missing chapters. `acknowledge` supports outline, foreshadowing, canon, chapter_memory, character_state, runtime_facts, review, plan, search and downstream_chapters. It records human review of impacts; it does not repair a stale acceptance operation.
+
+Document change plans accept **1–50 edits**. Their default response contains a bounded diff and edit summary; workspace output is opt-in. Both range endpoints must be individually unique. Exact matching preserves UTF-8 bytes and line endings; no automatic fuzzy selector is used by the public tool. `normalizations` reports any explicitly selected compatibility normalization. Apply/undo require the stored preview token **and `confirm=true`**. Revision is checked again under the project lock and written bytes are verified against the accepted preview.
+
+Asset lists include revisions usable by asset update. `update_summary` replaces the synopsis; supplying a full structured body replaces its metadata too. A prose-only synopsis retains execution metadata. `promote` or `delete(cascade=false)` removes a container while preserving child chapters and their IDs. `get_meta`/`set_meta` accept a chapter ID and metadata fields `target_words`, `beats`, `hooks`, `characters`; `updates[]` reads/writes up to 50 chapters atomically under one outline revision.
+
+## Review scope and history
+
+A restricted dimension request retains the complete rubric and marks unrequested criteria inconclusive. The hard gate and the minimum manuscript structure check always run. Partial reviews, insufficient coverage and unverifiable canon cannot produce delivery `pass`. Tagged model reasoning is removed; unclosed reasoning or unstructured/preamble output is rejected before manuscript generation is accepted. Chinese and English chapter headings are supported.
+
+Uncalibrated review scores are advisory. The review v2 response omits `production_gate_status` unless the caller explicitly enables a calibrated production gate. Legacy adapters and benchmark metadata may still carry their calibration fields. `strict` records the requested review mode; it does not turn missing canon evidence into `blocked`, add another audit pass, or guarantee higher detection. A confirmed hard violation remains blocked in every mode.
+
+`novel_review_chapter(action="versions", chapter_id=...)` lists review snapshots. `action="compare", revision=<listed SHA>` compares that snapshot to the current review. Existing current records are archived on their next save; versions overwritten by older releases cannot be reconstructed.
+
+The supported review scope is **chapter**, returned as `check_scope="chapter"`. Book-wide repeated sentences, recurring phrase habits, quotation-style consistency and cross-chapter template detection are outside the 37-check contract. The new structure check covers headings, preamble and reasoning contamination; it is not a complete copyediting audit.
+
+Foreshadow overdue status is **advisory**, visible through continuity/diagnostics and chapter obligations. It does not automatically block delivery. DAG cycle checks operate only on explicitly recorded dependencies; `edges: []` means no supplied dependencies, not evidence that all narrative relationships were checked. Authors must record dependencies and decide whether to delay writing for overdue promises.
+
+## Report coverage
+
+| #76 item | Treatment |
+|---|---|
+| 1–2 | Preserve failed-commit prose; expose and resume draft handles; partial task retry |
+| 3–5 | Structured outgoing errors; immediate task handle; `since`; transport/orphan diagnostics |
+| 6–7 | Busy deferral without failure accounting; truthful cancellation and bounded wait |
+| 8–9 | Executable acceptance recovery/abandon; distinct actual model provenance |
+| 10–11 | Shared target resolver and outline validation; asymmetric length window |
+| 12–15 | Unique anchors/confirmation; asset revisions; synopsis replacement; preserve children |
+| 16–17 | Full rubric coverage, permanent hard/structure checks, reasoning rejection |
+| 18–24 | Async write, queue retry, shared targets, ghost cleanup, run archive, compact batches, byte verification |
+| 25–28 | Optional production field; inconclusive canon/coverage; explicit strict scope; review history |
+| 29 | Explicit chapter scope; minimal format gate; book aggregation explicitly out of scope |
+| 30 | Revision-gated field metadata, including atomic chapter batches |
+| 31 | Documented advisory overdue responsibilities and explicit DAG dependency scope |
+| 32 | Expanded acknowledgement domains |
+
+## English (#65)
+
+Choose **Settings → General → Language → English** in dsh (`locale.preference`). The panel follows the active locale. The agent persona and every skill entry point instruct the agent to answer in the author's language, including slash-command help, plans and explanations. An explicitly requested manuscript language takes precedence for creative text. Managed runtime messages are English; Studio HTTP errors include English `message`, stable `code`, `details` and `request_id`, while retaining the original diagnostic in `error`. Task phases/errors provide English text. Existing Chinese project/source content is not translated automatically.

package/docs/RELEASE_ACCEPTANCE.md

@@ -6,9 +6,18 @@
 
 新建作品的验收请求最多等待 60 秒（原为 15 秒），保留成功耗时和失败诊断；不重试写请求，超时仍失败。此调整容纳慢速运行器，不代表初始化耗时问题已被修复。
 
+## 0.2.19
+
+[GitHub Release](https://github.com/LiPu-jpg/Openwrite/releases/tag/v0.2.19) 已发布，直接使用[完整 CI](https://github.com/LiPu-jpg/Openwrite/actions/runs/38167325137) 验收的同一份包。来源提交 `e0c1ab7`，npm 包 SHA-256 为 `97f89586e4c43071ebca67abd5af1df1ae42b637cf6637d4fc26ca31c133d784`。六组原生平台/Node、源码安装与 alpha 兼容共 8 份运行报告、三代宿主客户端 3 份报告全部通过；Release 四份附件的校验值已与 CI `validated-release` 产物逐一核对。npm `dsh-openwrite@0.2.19` 已发布到官方 registry（registry.npmjs.org），`latest` 已更新到 0.2.19；从官方 registry 无认证重新下载后，SHA-256 与上述 CI 包一致。
+
+修复 [#74](https://github.com/LiPu-jpg/Openwrite/issues/74) 与 [#75](https://github.com/LiPu-jpg/Openwrite/issues/75)，均为插件侧改动，Core 保持 5.8.9（native-core `d0a75e30047c28c99af909e1b85b07190abb1fb7`），wheel 与 requirements.lock 未变。
+
+- #74：vendor/dsh-dog 运行时不再裸导入 `@deepseek-ai/dsh-home-paths` 与 `@deepseek-ai/dsh-tools` 两个 peer 宿主包（pnpm 隔离布局下从 vendor 目录不可解析 → openwrite-dog 条目导入失败 → openwriteDog 未注册 → 预设从列表消失）。`dshHomePath` 与 `defineTool` 由新增 `src/host-shims.ts` 自包含实现，行为对齐宿主；构建产物 `lib/index.js` 只导入 node 内置模块与 dependencies 内的 `@deepseek-ai/schemastery`，独立 `import()` 成功。新增 host-shims 单元测试 10 例，dsh-dog 共 60/60 通过。
+- #75：bridge 的 90 个 `novel_*` 工具统一经本地 `defineTool`（复用宿主 `parameterSchemaSpecToJsonSchema`/`valueSchemaSpecToJsonSchema`/`validateJsonSchemaValue`/`ToolArgsError`），在 schema 校验前对 `type: 'json'` 参数（含 array 的 json items）做字符串 `JSON.parse` 归一化；报错带参数名与实际类型。8 项归一化冒烟用例通过；四个宿主符号已核对在 0.1.2-rc.1 / 0.1.5-alpha.1 / 0.2.0-rc.2 三个受支持宿主中均导出且签名一致。
+
 ## 0.2.18
 
-<!-- TODO: 发布后回填 PR、CI、Release 链接与 SHA -->
+[GitHub Release](https://github.com/LiPu-jpg/Openwrite/releases/tag/v0.2.18) 已发布，直接使用[完整 CI](https://github.com/LiPu-jpg/Openwrite/actions/runs/38059156641)验收的同一份包。来源提交 `6e84c2a`，npm 包 SHA-256 为 `edd510c6d4de58bfa09eb30f8a3b74e5a0e6cf7cf2425bc6fe3681b732c1a196`。六组原生平台/Node、源码安装、alpha 兼容及三代宿主客户端共 12 份报告全部通过；Release 四份附件的校验值已与 CI `validated-release` 产物逐一核对。合并来源 [PR #73](https://github.com/LiPu-jpg/Openwrite/pull/73)。npm `dsh-openwrite@0.2.18` 已发布到官方 registry（registry.npmjs.org），`latest` 已更新到 0.2.18；从官方 registry 无认证重新下载后，SHA-256 与上述 CI 包一致。main CI 首次运行 source-install 因 pnpm `--find-links` 目录瞬时不存在失败，重跑同一提交通过，判定为运行器 flake。
 
 修正 0.2.17 的 `auto:cheapest`：真实 Key 实测发现 OpenRouter 上部分免费模型没有 `:free` 后缀（`inclusionai/ling-3.1-flash` 定价 0/0），会被低价策略选中；免费模型可用性不稳定，Core 5.8.9（native-core `d0a75e30047c28c99af909e1b85b07190abb1fb7`）把零价模型一并排除，`auto:cheapest` 现在落在付费低价模型上。回归测试补充零价排除断言，9/9 通过。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-openwrite",
-  "version": "0.2.18",
+  "version": "0.2.20",
   "description": "OpenWrite 长篇小说领域后端接入 DeepSeek Harness：统一创作 Agent 预设 + 原生创作工作台",
   "type": "module",
   "scripts": {

package/packages/openwrite-bridge/lib/client.d.ts

@@ -39,6 +39,7 @@ export declare class StudioError extends Error {
     readonly status: number;
     readonly code: string;
     readonly details: JsonValue;
+    requestId: string | null;
     constructor(message: string, status: number, code: string, details?: JsonValue);
 }
 export interface StudioClientOptions {

package/packages/openwrite-bridge/lib/client.js

@@ -1,3 +1,6 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
 /** Header OpenWrite requires on every write request (POST/PUT). */
 const WRITE_HEADER = 'X-OpenWrite-Studio';
 /** HTTP header values are bytes, so Unicode paths need explicit wire encoding.
@@ -13,6 +16,7 @@ export class StudioError extends Error {
     status;
     code;
     details;
+    requestId = null;
     constructor(message, status, code, details = null) {
         super(message);
         this.name = 'StudioError';
@@ -61,6 +65,8 @@ export function mutationAffectsState(path, body, headers) {
     if (declared === '0' || declared === '1')
         return declared === '1';
     const endpoint = path.split('?')[0]?.replace(/^\/+/, '').replace(/^api\//, '');
+    if (endpoint === 'review/history')
+        return false;
     if (endpoint !== 'manuscript-editing')
         return true;
     let payload = body;
@@ -180,6 +186,18 @@ export class StudioClient {
             return await fetch(target, { ...init, headers, signal: AbortSignal.any(signals) });
         }
         catch (error) {
+            if (this.context?.workspaceRoot) {
+                try {
+                    const root = join(this.context.workspaceRoot, '.openwrite', 'transport-errors');
+                    await mkdir(root, { recursive: true });
+                    await writeFile(join(root, `${randomUUID()}.json`), JSON.stringify({
+                        source: 'transport', code: signal?.aborted ? 'REQUEST_ABORTED' : 'NETWORK_ERROR',
+                        created_at: new Date().toISOString(), path: url.pathname,
+                        tool_name: this.context.toolName ?? '', tool_call_id: this.context.toolCallId ?? '',
+                    }));
+                }
+                catch { /* A diagnostic failure must not hide the transport failure. */ }
+            }
             if (signal?.aborted)
                 throw error;
             const cause = error instanceof Error ? error.cause : undefined;
@@ -203,10 +221,14 @@ export class StudioClient {
         const body = asJson(parsed);
         if (typeof body === 'object' && body !== null && !Array.isArray(body)) {
             const error = body['error'];
-            if (typeof error === 'string' && error.length > 0) {
-                const code = typeof body['code'] === 'string' ? body['code'] : 'STUDIO_ERROR';
-                const details = 'details' in body ? body['details'] : null;
-                throw new StudioError(error, response.status, code, details);
+            if (error !== undefined && error !== null && error !== false && error !== '') {
+                const nested = typeof error === 'object' && !Array.isArray(error) ? error : {};
+                const code = typeof body['code'] === 'string' ? body['code'] : typeof nested['code'] === 'string' ? nested['code'] : 'STUDIO_ERROR';
+                const message = typeof body['message'] === 'string' ? body['message'] : typeof error === 'string' ? error : typeof nested['message'] === 'string' ? nested['message'] : JSON.stringify(error);
+                const details = body['details'] ?? nested['details'] ?? null;
+                const failure = new StudioError(message, response.status, code, details);
+                failure.requestId = typeof body['request_id'] === 'string' ? body['request_id'] : null;
+                throw failure;
             }
             // HTTP status remains authoritative even when a proxy or incompatible
             // server sends a success-shaped envelope with an error status.

package/packages/openwrite-bridge/lib/contracts-generated.d.ts

@@ -6,7 +6,7 @@ export interface ReviewV2Decision {
     coverage: number;
     gate_status: "pass" | "blocked" | "inconclusive";
     delivery_status: "pass" | "revise" | "blocked" | "inconclusive" | "stale";
-    production_gate_status: "pass" | "revise" | "blocked" | "inconclusive" | "stale" | "disabled" | "disabled_uncalibrated";
+    production_gate_status?: "pass" | "revise" | "blocked" | "inconclusive" | "stale" | "disabled" | "disabled_uncalibrated";
     [key: string]: unknown;
 }
 /** dsh-novel review manifest v2. Extra keys are allowed (additionalProperties). */

package/packages/openwrite-bridge/lib/contracts-generated.js

@@ -1466,8 +1466,7 @@ const SCHEMAS = {
             "quality_score",
             "coverage",
             "gate_status",
-            "delivery_status",
-            "production_gate_status"
+            "delivery_status"
         ],
         "title": "OpenWrite review v2 decision",
         "type": "object"

package/packages/openwrite-bridge/lib/domain.js

@@ -41,6 +41,8 @@ const WRITABLE_PATHS = new Set([
     'manuscript/acceptance/external',
     'manuscript/acceptance/reconcile',
     'manuscript/acceptance/ack',
+    'manuscript/acceptance/abandon',
+    'review/history',
     'project/init',
     'project/metadata',
     'model',

package/packages/openwrite-bridge/lib/index.js

@@ -46,15 +46,15 @@ export function apply(ctx, config) {
             const respond = (code, data) => { res.writeHead(code, { 'content-type': 'application/json', 'cache-control': 'no-store' }); res.end(JSON.stringify(data)); };
             const rejection = authorizeRequest(req.headers);
             if (rejection !== undefined) {
-                respond(rejection, { error: 'dsh browser authentication required' });
+                respond(rejection, { error: 'dsh browser authentication required', message: 'dsh browser authentication required', code: 'AUTHENTICATION_REQUIRED' });
                 return;
             }
             if (req.method === 'GET') {
-                respond(200, runtime?.status() ?? { phase: 'ready', message: '使用外部写作环境' });
+                respond(200, runtime?.status() ?? { phase: 'ready', message: 'Using an external writing environment' });
                 return;
             }
             if (req.method !== 'POST' || req.headers['x-openwrite-studio'] !== '1') {
-                respond(405, { error: '操作不允许' });
+                respond(405, { error: 'Method not allowed', message: 'Method not allowed', code: 'METHOD_NOT_ALLOWED' });
                 return;
             }
             const chunks = [];
@@ -62,7 +62,7 @@ export function apply(ctx, config) {
             for await (const chunk of req) {
                 size += chunk.length;
                 if (size > 1024) {
-                    respond(413, { error: '请求过大' });
+                    respond(413, { error: 'Request too large', message: 'Request too large', code: 'REQUEST_TOO_LARGE' });
                     return;
                 }
                 ;
@@ -75,13 +75,13 @@ export function apply(ctx, config) {
                 else if (action === 'prepare' || action === 'retry')
                     void runtime?.ensure().catch(() => { });
                 else {
-                    respond(400, { error: '未知操作' });
+                    respond(400, { error: 'Unknown action', message: 'Unknown action', code: 'INVALID_ACTION' });
                     return;
                 }
                 respond(202, runtime?.status() ?? { phase: 'ready' });
             }
             catch {
-                respond(400, { error: '请求无效' });
+                respond(400, { error: 'Invalid request', message: 'Invalid request', code: 'INVALID_INPUT' });
             }
         },
     }), 'openwrite: runtime controls'));

package/packages/openwrite-bridge/lib/managed-runtime.js

@@ -147,7 +147,7 @@ export async function stopOwnedProcess(child) {
 export class ManagedRuntime {
     root;
     artifacts;
-    state = { phase: 'idle', message: '首次使用将准备写作环境' };
+    state = { phase: 'idle', message: 'The writing environment will be prepared on first use' };
     pending;
     controller;
     child;
@@ -175,7 +175,7 @@ export class ManagedRuntime {
     }
     ensure() {
         if (this.closed)
-            return Promise.reject(new Error('OpenWrite 已卸载'));
+            return Promise.reject(new Error('OpenWrite was removed'));
         if (this.connection)
             return this.verifyConnection(this.connection);
         if (this.pending)
@@ -189,7 +189,7 @@ export class ManagedRuntime {
         this.controller = controller;
         this.pending = this.prepare(controller.signal).catch(error => {
             this.state = { phase: controller.signal.aborted ? 'cancelled' : 'error',
-                message: controller.signal.aborted ? '准备已取消，可重试' : '写作环境未就绪，可重试',
+                message: controller.signal.aborted ? 'Setup was cancelled; retry when ready' : 'The writing environment is not ready; retry setup',
                 error: controller.signal.aborted ? undefined : sanitizeDiagnostic(String(error instanceof Error ? error.message : error)) };
             throw error;
         }).finally(() => { this.pending = undefined; this.controller = undefined; });
@@ -205,7 +205,7 @@ export class ManagedRuntime {
     async verifyConnection(connection) {
         if (await this.probeHealth(connection)) {
             if (this.closed)
-                throw new Error('OpenWrite 已卸载');
+                throw new Error('OpenWrite was removed');
             const current = this.connection;
             if (current)
                 return current;
@@ -219,10 +219,10 @@ export class ManagedRuntime {
         if (child)
             await stopOwnedProcess(child).catch(() => { });
         if (this.closed)
-            throw new Error('OpenWrite 已卸载');
+            throw new Error('OpenWrite was removed');
         if (!this.allowRevive)
-            throw new Error('准备已取消，可重试');
-        this.update('recovering', '写作后端无响应，正在恢复');
+            throw new Error('Setup was cancelled; retry when ready');
+        this.update('recovering', 'The writing backend is unresponsive; recovering');
         return this.queueRestart();
     }
     /** Short-timeout liveness probe; false covers exit, refusal, hang, and auth drift. */
@@ -257,7 +257,7 @@ export class ManagedRuntime {
             this.child = undefined;
         }
         this.connection = undefined;
-        this.update('uninstalled', 'OpenWrite 已卸载，作品和配置已保留');
+        this.update('uninstalled', 'OpenWrite was removed; manuscripts and settings were preserved');
     }
     exitDiagnostic(code, signalName, stderr = '') {
         return sanitizeDiagnostic(`exit ${code ?? 'none'} signal ${signalName ?? 'none'}${stderr ? `: ${stderr}` : ''}`);
@@ -272,17 +272,17 @@ export class ManagedRuntime {
             return;
         const error = this.exitDiagnostic(code, signalName, stderr);
         if (!this.allowRevive) {
-            this.update('cancelled', '准备已取消，可重试', { error });
+            this.update('cancelled', 'Setup was cancelled; retry when ready', { error });
             return;
         }
         this.restartAttempts += 1;
         if (this.restartAttempts > this.restartLimit) {
             this.allowRevive = false;
-            this.update('error', '写作后端多次异常退出，已停止自动恢复，可手动重试', { error });
+            this.update('error', 'The writing backend exited repeatedly; automatic recovery stopped. Retry manually', { error });
             return;
         }
         this.recovered = true;
-        this.update('recovering', `写作后端异常退出，正在恢复（${this.restartAttempts}/${this.restartLimit}）`, { error });
+        this.update('recovering', `The writing backend exited; recovering (${this.restartAttempts}/${this.restartLimit})`, { error });
         // Auto-recovery has no caller; never let a rejected prepare become an unhandled rejection that kills dsh.
         void this.queueRestart().catch(() => { });
     }
@@ -293,11 +293,11 @@ export class ManagedRuntime {
             let assigned;
             const chained = prior.then(connection => {
                 if (this.closed)
-                    throw new Error('OpenWrite 已卸载');
+                    throw new Error('OpenWrite was removed');
                 if (this.live())
                     return connection;
                 if (!this.allowRevive)
-                    throw new Error('准备已取消，可重试');
+                    throw new Error('Setup was cancelled; retry when ready');
                 if (this.pending === assigned)
                     this.pending = undefined;
                 return this.queueRestart();
@@ -347,16 +347,16 @@ export class ManagedRuntime {
                 const diagnostic = sanitizeDiagnostic(String(error instanceof Error ? error.message : error));
                 if (this.restartAttempts > this.restartLimit) {
                     this.allowRevive = false;
-                    this.update('error', '写作后端多次异常退出，已停止自动恢复，可手动重试', { error: diagnostic });
+                    this.update('error', 'The writing backend exited repeatedly; automatic recovery stopped. Retry manually', { error: diagnostic });
                     throw error;
                 }
-                this.update('recovering', `写作后端异常退出，正在恢复（${this.restartAttempts}/${this.restartLimit}）`, { error: diagnostic });
+                this.update('recovering', `The writing backend exited; recovering (${this.restartAttempts}/${this.restartLimit})`, { error: diagnostic });
             }
         }
         if (this.closed)
-            throw new Error('OpenWrite 已卸载');
-        this.update('cancelled', '准备已取消，可重试');
-        throw lastError instanceof Error ? lastError : new Error('准备已取消，可重试');
+            throw new Error('OpenWrite was removed');
+        this.update('cancelled', 'Setup was cancelled; retry when ready');
+        throw lastError instanceof Error ? lastError : new Error('Setup was cancelled; retry when ready');
     }
     async download(item, signal) {
         const cache = join(this.root, 'cache');
@@ -365,11 +365,11 @@ export class ManagedRuntime {
         if (await sha256(destination).catch(() => '') === item.sha256)
             return destination;
         const partial = destination + '.' + randomUUID() + '.partial';
-        this.update('downloading', '正在下载并校验写作环境');
+        this.update('downloading', 'Downloading and verifying the writing environment');
         try {
             const response = await fetch(item.url, { signal: AbortSignal.any([signal, AbortSignal.timeout(600_000)]) });
             if (!response.ok || !response.body)
-                throw new Error(`下载失败：HTTP ${response.status}`);
+                throw new Error(`Download failed: HTTP ${response.status}`);
             const size = Number(response.headers.get('content-length')) || undefined;
             const file = await open(partial, 'wx', 0o600);
             let received = 0;
@@ -378,16 +378,16 @@ export class ManagedRuntime {
                     signal.throwIfAborted();
                     received += chunk.length;
                     if (received > 1024 ** 3)
-                        throw new Error('下载超过允许大小');
+                        throw new Error('Download exceeds the allowed size');
                     await file.write(chunk);
-                    this.state = { phase: 'downloading', message: '正在下载并校验写作环境', downloadedBytes: received, totalBytes: size };
+                    this.state = { phase: 'downloading', message: 'Downloading and verifying the writing environment', downloadedBytes: received, totalBytes: size };
                 }
             }
             finally {
                 await file.close();
             }
             if (await sha256(partial) !== item.sha256)
-                throw new Error('下载校验失败，请重试');
+                throw new Error('Download checksum failed; retry');
             await rename(partial, destination);
             return destination;
         }
@@ -408,7 +408,7 @@ export class ManagedRuntime {
             for (const [name, bytes] of Object.entries(unzipSync(await readFile(archive)))) {
                 const target = resolve(dir, name);
                 if (isAbsolute(name) || !target.startsWith(dir + sep))
-                    throw new Error('压缩包路径无效');
+                    throw new Error('Invalid archive path');
                 if (name.endsWith('/'))
                     await mkdir(target, { recursive: true });
                 else {
@@ -437,7 +437,7 @@ export class ManagedRuntime {
         try {
             await new Promise((done, reject) => {
                 child.once('error', reject);
-                child.once('exit', code => code === 0 ? done() : reject(new Error(`环境准备失败 (${code})：${failure}`)));
+                child.once('exit', code => code === 0 ? done() : reject(new Error(`Environment setup failed (${code})：${failure}`)));
             });
             signal.throwIfAborted();
         }
@@ -457,7 +457,7 @@ export class ManagedRuntime {
             catch (error) {
                 if (error.code !== 'ELOCKED')
                     throw error;
-                this.update('waiting', '另一个 OpenWrite 正在准备环境，等待完成');
+                this.update('waiting', 'Another OpenWrite instance is preparing the environment; waiting');
                 await this.wait(250, undefined, { signal });
             }
         }
@@ -466,17 +466,17 @@ export class ManagedRuntime {
         const manifest = JSON.parse(await readFile(join(this.artifacts, 'runtime-manifest.json'), 'utf8'));
         const platform = manifest.platforms[`${process.platform}-${process.arch}`];
         if (!platform)
-            throw new Error(`暂不支持 ${process.platform}/${process.arch}`);
+            throw new Error(`Unsupported platform: ${process.platform}/${process.arch}`);
         if (!manifest.wheel || !manifest.requirements)
-            throw new Error('发布包缺少 Core 或依赖校验清单');
+            throw new Error('The package is missing Core or dependency checksums');
         const wheel = join(this.artifacts, manifest.wheel.file);
         const requirements = join(this.artifacts, manifest.requirements.file);
         if (await sha256(wheel) !== manifest.wheel.sha256 || await sha256(requirements) !== manifest.requirements.sha256) {
-            throw new Error('发布包校验失败，请重新安装');
+            throw new Error('Package verification failed; reinstall OpenWrite');
         }
         for (const artifact of manifest.dependency_wheels ?? []) {
             if (await sha256(join(this.artifacts, artifact.file)) !== artifact.sha256)
-                throw new Error('平台依赖校验失败，请重新安装');
+                throw new Error('Platform dependency verification failed; reinstall OpenWrite');
         }
         await mkdir(this.root, { recursive: true, mode: 0o700 });
         const unlock = await this.lock(signal);
@@ -488,7 +488,7 @@ export class ManagedRuntime {
             if (await readFile(join(destination, '.complete'), 'utf8').catch(() => '') !== generation) {
                 const uv = await this.extract(platform.uv, signal);
                 const basePython = await this.extract(platform.python, signal);
-                this.update('installing', '正在安装隔离依赖，首次使用可能需要几分钟');
+                this.update('installing', 'Installing isolated dependencies; first use may take several minutes');
                 await rm(destination, { recursive: true, force: true });
                 try {
                     await this.command(uv, ['venv', '--python', basePython, destination], signal);
@@ -504,7 +504,7 @@ export class ManagedRuntime {
                 }
             }
             signal.throwIfAborted();
-            this.update(this.recovered ? 'recovering' : 'starting', this.recovered ? '正在恢复写作环境' : '正在启动写作环境');
+            this.update(this.recovered ? 'recovering' : 'starting', this.recovered ? 'Recovering the writing environment' : 'Starting the writing environment');
             const connection = await this.start(python, manifest, signal);
             const pending = join(this.root, 'active.' + randomUUID() + '.json');
             try {
@@ -562,9 +562,9 @@ export class ManagedRuntime {
                 child.once('exit', (code, signalName) => {
                     if (started)
                         return;
-                    reject(new Error(`写作后端在启动时退出 (${code ?? 'none'}/${signalName ?? 'none'})`));
+                    reject(new Error(`The writing backend exited during startup (${code ?? 'none'}/${signalName ?? 'none'})`));
                 });
-                timer = setTimeout(() => reject(new Error('写作后端启动超时')), 120_000);
+                timer = setTimeout(() => reject(new Error('Writing backend startup timed out')), 120_000);
                 lines.on('line', line => {
                     try {
                         const message = JSON.parse(line);
@@ -591,15 +591,15 @@ export class ManagedRuntime {
             });
             const result = await health.json();
             if (!health.ok || result.core_version !== manifest.core_version || result.contract_version !== manifest.contract_version) {
-                throw new Error('写作后端版本或接口不匹配，请重新安装');
+                throw new Error('Writing backend version or API mismatch; reinstall OpenWrite');
             }
             this.connection = connection;
             started = true;
             if (!this.recovered)
                 this.restartAttempts = 0;
             this.update('ready', this.recovered
-                ? '写作环境已恢复；进行中的写作或评审任务不会自动重试'
-                : '写作环境已就绪');
+                ? 'The writing environment recovered; in-progress writing and review tasks require an explicit retry'
+                : 'The writing environment is ready');
             return connection;
         }
         catch (error) {