dsh-openwrite 0.2.19 → 0.2.21

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.21 标准插件包**兼容精确 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.21/dsh-openwrite-0.2.21.tgz
 dsh web
 ```
 
@@ -66,6 +64,10 @@ dsh web
 
 ### dsh 0.2 桌面端升级
 
+`0.2.21` 修复 [#79](https://github.com/LiPu-jpg/Openwrite/issues/79) 的 Windows Desktop 目录选择：宿主接口失败后使用桌面提供的系统文件夹对话框，覆盖侧栏进入与工作台内目录选择。Core 保持 5.8.10。排查与手填路径方式见 [安装指南](docs/INSTALL.md#windows-desktop-目录选择)。
+
+`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，再刷新浏览器页面。
@@ -84,7 +86,7 @@ dsh web
 
 `0.2.11` 修复 [#45](https://github.com/LiPu-jpg/Openwrite/issues/45)，适配精确宿主版本 `0.2.0-rc.2`：工作台兼容新的 turn-tail list 槽位，DoG 调试面板使用新的 `sessionStatus`；根包和所有子包的兼容声明同步更新。已验证 0.2.0-rc.2 的 Web 客户端启动、OpenWrite 入口、DoG 面板及其他插件共存；Windows Electron 桌面端恢复链路尚未实机复测。
 
-**`dsh-openwrite@0.2.10` 不包含这项修复，请升级到 `0.2.13` 的 GitHub Release 包。** 不要通过给旧子包授权来代替升级：`dsh-openwrite` 的版本豁免不会覆盖 `@dsh-novel/studio-panel@<ver>` 和 `@dsh-external/dsh-dog@<ver>`，而旧客户端在 0.2.0-rc.2 上激活失败可能触发桌面端的 profile 恢复。
+**`dsh-openwrite@0.2.10` 不包含这项修复，请升级到 `0.2.21` 的 GitHub Release 包。** 不要通过给旧子包授权来代替升级：`dsh-openwrite` 的版本豁免不会覆盖 `@dsh-novel/studio-panel@<ver>` 和 `@dsh-external/dsh-dog@<ver>`，而旧客户端在 0.2.0-rc.2 上激活失败可能触发桌面端的 profile 恢复。
 
 若已发生恢复，先关闭桌面端并备份当前 profile，再从自己的 `cordis.patch.yml.bak-*` 备份恢复 patch，同时恢复原 `package.json` 的 `dsh.profile.bundles` 列表。安装包和作品目录通常仍在；不要用出厂模板覆盖其他插件配置。详细排查见 [安装指南](docs/INSTALL.md#dsh-02-客户端兼容排查)。
 
@@ -103,7 +105,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 报错附带英文说明和稳定错误码。已有作品内容不会自动翻译，正文按作者指定的语言生成。
 
 ## 配置模型
 
@@ -167,3 +169,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/INSTALL.md

@@ -2,6 +2,12 @@
 
 安装已发布的版本；可下载产物、SHA-256 和实际平台结果以 [GitHub Release](https://github.com/LiPu-jpg/Openwrite/releases/latest) 附件为准。验收方法见 [验收报告](RELEASE_ACCEPTANCE.md)。
 
+## Windows Desktop 目录选择
+
+若留空作品目录并点击“选择目录并进入”时出现 `directoryPicker.pick needs the native capability; the composed picker serves "browse"`，这是桌面宿主组合的目录选择能力与其接口要求不一致。OpenWrite 0.2.21 在宿主接口失败后调用桌面公开的 `__DSH_DESKTOP_PICK_DIRECTORY__`，覆盖侧栏进入、作品绑定、新建与恢复目录选择。取消目录对话框不会创建作品或会话；手填绝对路径仍可直接进入。
+
+没有桌面选择通道的宿主会保留原始错误。此时可在同一个输入框填写作品的完整绝对路径，例如 `A:\AI\我的小说`，点击“进入作品”。升级插件后需要停止并重新启动 dsh，使客户端重新加载。
+
 ## 标准安装
 
 本次锁定 dsh `0.1.2-rc.1`，Node 24 为完整验收基线；Node 22.19 / 26 做兼容检查。安装不自动升级 dsh。先执行 `dsh --version` 核对宿主。

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,22 @@
 
 新建作品的验收请求最多等待 60 秒（原为 15 秒），保留成功耗时和失败诊断；不重试写请求，超时仍失败。此调整容纳慢速运行器，不代表初始化耗时问题已被修复。
 
+## 0.2.20
+
+[GitHub Release](https://github.com/LiPu-jpg/Openwrite/releases/tag/v0.2.20) 与 npm `dsh-openwrite@0.2.20` 已发布，npm `latest` 已更新到 0.2.20。使用[主分支完整 CI](https://github.com/LiPu-jpg/Openwrite/actions/runs/38296670387) 验收的同一份原始产物，来源提交 `4d54f3c619f853a4243cd60e67ef6c8ba8d336af`，npm 包 SHA-256 为 `486c20fbd36909e32cc6cac1fd1e734872abec53da749c0860f8e5e1d4cf6cda`。六组原生平台/Node、源码安装与 alpha 兼容共 8 份运行报告、三代宿主客户端 3 份报告全部通过；GitHub 四份附件逐一与 CI 原文件比对一致，从官方 npm registry 无认证重新下载后，包字节及 SHA-256 也一致。
+
+修复 [#76](https://github.com/LiPu-jpg/Openwrite/issues/76) 与 [#65](https://github.com/LiPu-jpg/Openwrite/issues/65)，合并来源为引擎 [PR #77](https://github.com/LiPu-jpg/Openwrite/pull/77) 和插件 [PR #78](https://github.com/LiPu-jpg/Openwrite/pull/78)。捆绑 Core 5.8.10，wheel 来源提交 `18a500015f5d5da00f2f4d5ccd2325b084fed24b` 已包含在合并后的 native-core 分支；wheel SHA-256 为 `f121410300c7e7c55d594d0b8d7f4da41f8a17f0dfb5dc3b195e447b618bfd4d`。
+
+- 生成后提交失败保留正文与恢复句柄；恢复提交复用已有草稿。写章返回持久化 task_id，忙碌延后、取消请求与终态分离，传输错误可追踪。
+- 统一字数目标，补齐验收恢复、批量与字段级编辑、精确文本/换行保护、完整审稿覆盖与硬检查、正文结构及推理污染检查、审稿历史。
+- persona 和所有技能入口跟随作者语言；运行环境与任务状态提供英文，Studio 错误附带英文说明和错误码。
+- Core 全套 pytest 1397 passed / 32 skipped，专项回归 21 passed。本地 macOS arm64 真实候选包安装、生命周期及浏览器验收通过；正式包以以上主分支 CI 报告为准。真实模型写作未实测，不计为通过。
+
+恢复步骤与明确的范围见 [修复说明](ISSUE_76_REPAIRS.md)。跨章聚合与逾期伏笔硬阻断按 issue 允许的方案声明职责范围，本版未新增这些功能。
+
 ## 0.2.19
 
-<!-- TODO: 发布后回填 CI、Release、npm 链接与 SHA -->
+[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 未变。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-openwrite",
-  "version": "0.2.19",
+  "version": "0.2.21",
   "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) {