dsh-openwrite 0.2.28 → 0.2.34

package/plugin.mjs

@@ -3,23 +3,122 @@ import { createHash, randomUUID } from 'node:crypto'
 import { lock } from 'proper-lockfile'
 import { resolveDshHome } from '@deepseek-ai/dsh-home-paths'
 import { join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { legacyPresetIds, presetDefinition } from './preset-definition.mjs'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { createRequire } from 'node:module'
+import { legacyPresetIds, legacyAliasName, presetDefinition, referencedPresetIds } from './preset-definition.mjs'
+import { detectCompanions, OPENWRITE_OPS_OPTIONS, summarizeOpsPlan } from './companions.mjs'
 
 export const name = 'dsh-openwrite'
 
-async function digestTree(dir) {
-  const hash = createHash('sha256')
-  async function visit(path, prefix = '') {
-    for (const entry of (await readdir(path, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
-      if (entry.name === '.openwrite-managed.json') continue
-      const key = prefix + entry.name
-      hash.update(key)
-      if (entry.isDirectory()) await visit(join(path, entry.name), key + '/')
-      else hash.update(await readFile(join(path, entry.name)))
+/**
+ * Which companion plugins are installed and loadable here, for the workbench's
+ * companion section. Best-effort by design: an unreadable home reports nothing
+ * rather than failing the route.
+ */
+async function loadOpsResolver(home, entry) {
+  // The companion may live in a profile whose node_modules is not on this
+  // plugin's resolution path (dsh-openwrite can be a symlinked dev install), so
+  // resolve from the profile that actually owns dsh-ops first.
+  const candidates = []
+  if (typeof entry.profile === 'string' && entry.profile !== '') {
+    try {
+      const fromProfile = createRequire(join(home, 'profiles', entry.profile, 'package.json'))
+      candidates.push(fromProfile.resolve('dsh-ops/integration'))
+    } catch { /* fall through to the normal resolution path */ }
+  }
+  candidates.push('dsh-ops/integration')
+  for (const candidate of candidates) {
+    try {
+      const module = await import(candidate.startsWith('/') ? pathToFileURL(candidate).href : candidate)
+      if (typeof module.resolveIntegrationConfig === 'function') return module.resolveIntegrationConfig
+    } catch { /* try the next candidate */ }
+  }
+  return null
+}
+
+async function opsPlan(home, entry) {
+  if (!entry.usable) return null
+  try {
+    // Read-only normalization: the same options the preset row uses. A dsh-ops
+    // release without this export (or one that changed the option names) is
+    // reported as no plan rather than failing the companion inventory.
+    const resolveIntegrationConfig = await loadOpsResolver(home, entry)
+    if (resolveIntegrationConfig === null) return null
+    return summarizeOpsPlan(resolveIntegrationConfig({ ...OPENWRITE_OPS_OPTIONS }))
+  } catch { return null }
+}
+
+export async function companionSummary(home) {
+  try {
+    const companions = await detectCompanions(home)
+    const describe = entry => ({ installed: entry.installed, usable: entry.usable, version: entry.version, reason: entry.reason })
+    return {
+      host: companions.host,
+      dog: describe(companions.dog),
+      ops: { ...describe(companions.ops), plan: await opsPlan(home, companions.ops) },
+      freeModel: describe(companions.freeModel),
     }
+  } catch { return null }
+}
+
+/**
+ * The host's own default-model selection, read from the service the host
+ * exposes to plugins (`ctx.agentDefaultModel`).
+ *
+ * The API key is deliberately NOT part of this answer. The selection is a fact
+ * the author already sees in the host's own settings; the key is a secret that
+ * must never travel to a browser, and the host keeps it in its credentials
+ * service rather than in this selection at all.
+ *
+ * A host that does not compose the service, or one whose selection is not
+ * configured yet, answers `available: false` instead of throwing: the settings
+ * page shows "not configured", which is true, rather than failing to open.
+ */
+function hostModelSelection(ctx) {
+  const empty = { available: false, provider: '', model: '', reasoningEffort: '' }
+  let service
+  try { service = ctx.get('agentDefaultModel') } catch { return empty }
+  if (service === undefined || service === null) return empty
+  let selection
+  try { selection = service.currentSelection() } catch { return empty }
+  const provider = typeof selection?.provider === 'string' ? selection.provider : ''
+  const model = typeof selection?.model === 'string' ? selection.model : ''
+  const reasoningEffort = typeof selection?.reasoningEffort === 'string' ? selection.reasoningEffort : ''
+  // A selection with no provider or no model names no model: report it as
+  // unconfigured rather than as a selection of two empty strings.
+  return { available: provider !== '' && model !== '', provider, model, reasoningEffort }
+}
+
+/** Every non-hidden file of a tree, keyed by its path relative to the root. */
+async function listFiles(dir, prefix = '', found = new Map()) {
+  for (const entry of (await readdir(dir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
+    // Editor and OS noise is not an author edit: a `.DS_Store` must not make the
+    // next activation refuse to start.
+    if (entry.name.startsWith('.')) continue
+    const key = prefix + entry.name
+    const path = join(dir, entry.name)
+    if (entry.isDirectory()) await listFiles(path, key + '/', found)
+    else found.set(key, path)
+  }
+  return found
+}
+
+/**
+ * Digest of a managed preset directory, over the files the package ships only.
+ * A foreign file (the author's note, a skill they added, a dangling symlink) is
+ * not a modification: counting it would make one stray file brick the plugin.
+ */
+async function digestShipped(source, destination) {
+  const shipped = await listFiles(source)
+  const present = await listFiles(destination)
+  const hash = createHash('sha256')
+  for (const key of [...shipped.keys()].sort()) {
+    const path = present.get(key)
+    if (path === undefined) { hash.update(key + '\u0000missing'); continue }
+    hash.update(key)
+    try { hash.update(await readFile(path)) }
+    catch (error) { if (error.code !== 'ENOENT') hash.update(key + '\u0000unreadable') }
   }
-  await visit(dir)
   return hash.digest('hex')
 }
 
@@ -39,12 +138,13 @@ export async function apply(ctx) {
     const release = await lock(leases, { realpath: false, stale: 30_000, retries: { retries: 30, minTimeout: 100, maxTimeout: 500 } })
     try { return await operation() } finally { await release() }
   }
-  const expected = await digestTree(source)
   const marker = join(destination, '.openwrite-managed.json')
   await withLock(async () => {
     const existing = await readFile(marker, 'utf8').then(JSON.parse).catch(() => null)
-    if (existing && (existing.source !== expected || existing.tree !== await digestTree(destination))) {
-      throw new Error(`OpenWrite preset ${id} was modified; copy it to a custom preset before reinstalling this version`)
+    if (existing) {
+      if (existing.source !== await digestShipped(source, destination)) {
+        throw new Error(`OpenWrite preset ${id} was modified; copy it to a custom preset before reinstalling this version`)
+      }
     }
     if (!existing) {
       if (await lstat(destination).then(() => true).catch(error => { if (error.code === 'ENOENT') return false; throw error })) {
@@ -54,7 +154,8 @@ export async function apply(ctx) {
       await mkdir(staging, { recursive: true })
       try {
         await cp(source, staging, { recursive: true })
-        await writeFile(join(staging, '.openwrite-managed.json'), JSON.stringify({ source: expected, tree: expected, version }))
+        const digest = await digestShipped(source, staging)
+        await writeFile(join(staging, '.openwrite-managed.json'), JSON.stringify({ source: digest, tree: digest, version }))
         await rename(staging, destination)
       } finally { await rm(staging, { recursive: true, force: true }) }
     }
@@ -79,9 +180,16 @@ export async function apply(ctx) {
     if (typeof presetCtx.agentPresets.register !== 'function') return
     const definition = await presetDefinition(version, true)
     yield await presetCtx.agentPresets.register(definition)
-    const ids = new Set([...legacyPresetIds, id,
-      ...(await readdir(join(home, '.agent-presets'))).filter(name => /^openwrite-\d+-\d+-\d+(?:-[a-z0-9-]+)?$/.test(name)),
-    ])
+    const discovered = (await readdir(join(home, '.agent-presets')).catch(() => []))
+      .filter(name => /^openwrite-\d+-\d+-\d+(?:-[a-z0-9-]+)?$/.test(name))
+    // An alias keeps a session written by an older release resumable. Registering
+    // every released id instead floods the new-session selector with entries no
+    // session references, so the alias set follows the session store and only
+    // falls back to the durable list when that store cannot be read. This
+    // release's own identity is excluded: it is registered as the stable preset
+    // and its directory belongs to this plugin, so an alias for it is noise.
+    const referenced = await referencedPresetIds(home)
+    const ids = new Set([...(referenced ?? legacyPresetIds), ...discovered].filter(candidate => candidate !== id))
     for (const legacyId of ids) {
       // An author-supplied definition wins; readDocument checks presence without
       // waiting for host activation (list/resolve would deadlock startup).
@@ -90,8 +198,39 @@ export async function apply(ctx) {
         catch (error) { if (error?.code !== 'agent-preset/not-found') throw error }
       }
       yield await presetCtx.agentPresets.register({ ...definition, id: legacyId,
-        order: 1000, name: `${definition.name}（历史会话 ${legacyId}）`,
+        order: 1000, name: legacyAliasName(legacyId, definition.name),
       })
     }
   })
+  // Companion status for the workbench's companion section, and the host's own
+  // default-model selection, so OpenWrite's page in the host's settings dialog
+  // can show which model dsh itself would use. The companion route reports
+  // which implementation serves DoG and whether the optional integrations are
+  // live; it never changes what the preset mounts. The model route carries no
+  // key: the selection is a browser-visible fact, the key is not. Like every
+  // other /studio-panel/* route both sit behind the host's
+  // browser-authentication fence: without it any local process could read the
+  // host version, the companion inventory and the host's model selection.
+  ctx.inject(['webServer'], webCtx => webCtx.effect(() => {
+    webCtx.webServer.register({
+      kind: 'exact', path: '/studio-panel/companions', handler: async (req, res) => {
+        const respond = (code, data) => { res.writeHead(code, { 'content-type': 'application/json', 'cache-control': 'no-store' }); res.end(JSON.stringify(data)) }
+        const connection = webCtx.get('connection')
+        const rejection = connection ? connection.requestRejection({ headers: req.headers }) : 503
+        if (rejection !== undefined) { respond(rejection, { error: 'dsh browser authentication required', message: 'dsh browser authentication required', code: 'AUTHENTICATION_REQUIRED' }); return }
+        if (req.method !== 'GET') { respond(405, { error: 'Method not allowed', message: 'Method not allowed', code: 'METHOD_NOT_ALLOWED' }); return }
+        respond(200, await companionSummary(home) ?? { host: null, dog: { installed: false, usable: false, version: null, reason: null }, ops: { installed: false, usable: false, version: null, reason: null }, freeModel: { installed: false, usable: false, version: null, reason: null } })
+      },
+    }, 'openwrite: companion status')
+    webCtx.webServer.register({
+      kind: 'exact', path: '/studio-panel/host-model', handler: async (req, res) => {
+        const respond = (code, data) => { res.writeHead(code, { 'content-type': 'application/json', 'cache-control': 'no-store' }); res.end(JSON.stringify(data)) }
+        const connection = webCtx.get('connection')
+        const rejection = connection ? connection.requestRejection({ headers: req.headers }) : 503
+        if (rejection !== undefined) { respond(rejection, { error: 'dsh browser authentication required', message: 'dsh browser authentication required', code: 'AUTHENTICATION_REQUIRED' }); return }
+        if (req.method !== 'GET') { respond(405, { error: 'Method not allowed', message: 'Method not allowed', code: 'METHOD_NOT_ALLOWED' }); return }
+        respond(200, hostModelSelection(ctx))
+      },
+    }, 'openwrite: host model selection')
+  }))
 }

package/preset-definition.mjs

@@ -1,6 +1,11 @@
-import { readFile } from 'node:fs/promises'
+import { open, readFile, readdir, stat, mkdir, writeFile } from 'node:fs/promises'
+import { createHash } from 'node:crypto'
+import { zstdDecompressSync } from 'node:zlib'
+import { join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { load, Type, JSON_SCHEMA } from 'js-yaml'
+import { detectCompanions } from './companions.mjs'
+import { resolveDshHome } from '@deepseek-ai/dsh-home-paths'
 
 // Preserve Loader expressions; evaluating them here loses the preset's baseUrl
 // and entry-local realm. This is the host's entry-list !!js wire representation.
@@ -12,16 +17,150 @@ const schema = JSON_SCHEMA.extend(new Type('tag:yaml.org,2002:js', {
 export const stablePresetId = 'openwrite'
 
 // These released identities are durable session references, even after their
-// package-managed directories have been removed by older plugin versions.
-export const legacyPresetIds = Array.from({ length: 28 }, (_, i) => `openwrite-0-2-${i + 1}`)
+// package-managed directories have been removed by older plugin versions. They
+// are the safety net used when the session store cannot be read; the live alias
+// set follows the sessions that actually reference them (see below).
+/**
+ * Every released identity on the current `major.minor` line.
+ *
+ * Derived from the package version rather than a hardcoded count: `{ length: 29 }`
+ * could only ever express `0.2.x`, so a move to 0.3.0 or 1.0.0 structurally could
+ * not produce the new identity and the durable-resume safety net would silently
+ * omit it.
+ */
+const releaseVersion = JSON.parse(await readFile(new URL('package.json', import.meta.url), 'utf8')).version
+const releaseLine = /^(\d+)\.(\d+)\.(\d+)/.exec(String(releaseVersion || ''))
+export const legacyPresetIds = releaseLine === null
+  ? []
+  : Array.from({ length: Number(releaseLine[3]) }, (_, i) => `openwrite-${releaseLine[1]}-${releaseLine[2]}-${i + 1}`)
 
-export async function presetDefinition(version, modern = false) {
+/** One released versioned preset identity, including any pre-release suffix. */
+const versionedPresetId = /^openwrite-\d+-\d+-\d+(?:-[a-z0-9-]+)?$/
+
+/** Session log artifacts, in both encodings the host persistence backend writes. */
+const sessionLogSuffixes = ['.jsonl.zstd', '.jsonl']
+
+/** A session header is the first frame of its log; a bounded prefix reads it. */
+const headerPrefixBytes = 256 * 1024
+
+/**
+ * Name an alias after the release it restores. A bare id is an internal detail
+ * that leaves dozens of identically prefixed entries in the preset selector.
+ */
+export function legacyAliasName(id, name) {
+  if (!versionedPresetId.test(id)) return `${name}（历史会话 ${id}）`
+  return `${name}（旧版 ${id.replace(/^openwrite-/, '').replaceAll('-', '.')} · 仅用于恢复历史会话）`
+}
+
+async function collectSessionLogs(root) {
+  const logs = []
+  const walk = async directory => {
+    for (const entry of await readdir(directory, { withFileTypes: true })) {
+      const path = join(directory, entry.name)
+      if (entry.isDirectory()) await walk(path)
+      else if (sessionLogSuffixes.some(suffix => entry.name.endsWith(suffix))) logs.push(path)
+    }
+  }
+  await walk(root)
+  return logs
+}
+
+/**
+ * A digest over every log's identity, not just {count, newest mtime}: deleting
+ * one session and adding another in the same second keeps that pair unchanged
+ * and would serve a stale alias set (a missing id, a lingering one). Stats only,
+ * so this stays cheap enough to re-derive on every start.
+ */
+async function fingerprintLogs(logs) {
+  const hash = createHash('sha256')
+  const rows = []
+  for (const path of logs) {
+    let info
+    try { info = await stat(path) } catch { continue }
+    rows.push(`${path}\u0000${Math.round(info.mtimeMs)}\u0000${info.size}\n`)
+  }
+  rows.sort()
+  for (const row of rows) hash.update(row)
+  return { files: rows.length, digest: hash.digest('hex') }
+}
+
+/** The `agentPreset` a stored session header carries, or undefined when unreadable. */
+async function headerPresetId(path) {
+  const handle = await open(path, 'r')
+  try {
+    const buffer = Buffer.alloc(headerPrefixBytes)
+    const { bytesRead } = await handle.read(buffer, 0, headerPrefixBytes, 0)
+    const head = buffer.subarray(0, bytesRead)
+    // node:zlib decodes the leading frame and ignores the appended event frames.
+    const text = path.endsWith('.zstd') ? zstdDecompressSync(head).toString('utf8') : head.toString('utf8')
+    const header = JSON.parse(text.split('\n', 1)[0])
+    return typeof header?.agentPreset === 'string' ? header.agentPreset : undefined
+  } finally {
+    await handle.close()
+  }
+}
+
+/**
+ * The versioned preset ids stored sessions still reference. Registering every
+ * released id instead would fill the new-session selector with entries no
+ * session can resume, so the alias set is derived from the session store.
+ * Returns null when that store cannot be read at all, which keeps the durable
+ * alias list rather than silently dropping historical session resume.
+ */
+export async function referencedPresetIds(home) {
+  const root = join(home, 'sessions')
+  let logs
+  try {
+    logs = await collectSessionLogs(root)
+  } catch (error) {
+    if (error?.code !== 'ENOENT') return null
+    logs = []
+  }
+  // fingerprintLogs skips logs it cannot stat (a dangling symlink, or one the
+  // host prunes mid-scan); a walk that cannot even be listed is the only case
+  // that falls back to the durable list.
+  const fingerprint = await fingerprintLogs(logs).catch(() => null)
+  if (!fingerprint) return null
+  const cache = join(home, 'openwrite', 'preset-aliases.json')
+  const cached = await readFile(cache, 'utf8').then(JSON.parse).catch(() => null)
+  if (cached?.fingerprint?.files === fingerprint.files && cached.fingerprint.digest === fingerprint.digest) {
+    return new Set((cached.ids ?? []).filter(id => versionedPresetId.test(id)))
+  }
+  const ids = new Set()
+  for (const path of logs) {
+    const id = await headerPresetId(path).catch(() => undefined)
+    if (id && versionedPresetId.test(id)) ids.add(id)
+  }
+  await mkdir(join(home, 'openwrite'), { recursive: true }).catch(() => {})
+  await writeFile(cache, JSON.stringify({ fingerprint, ids: [...ids] }) + '\n').catch(() => {})
+  return ids
+}
+
+/**
+ * Mount dsh-ops into this preset when the companion is installed, its declared
+ * host range covers the running host, and it exposes the integration entry.
+ */
+async function adaptCompanions(plugins, options) {
+  if (plugins.some(row => row.id === 'openwrite-ops')) return
+  let companions = null
+  try {
+    companions = await detectCompanions(resolveDshHome(), options)
+  } catch { /* an unreadable home leaves the preset exactly as shipped */ }
+  if (!companions?.ops?.usable) return
+  plugins.push({ id: 'openwrite-ops', name: 'dsh-openwrite/ops-integration' })
+}
+
+export async function presetDefinition(version, modern = false, options = {}) {
   const baseUrl = new URL('./presets/openwrite/', import.meta.url)
   const plugins = load(await readFile(new URL('agent.cordis.yml', baseUrl), 'utf8'), { schema })
   const metadata = load(await readFile(new URL('preset.yml', baseUrl), 'utf8'))
   if (modern) {
     const adapt = rows => {
       for (const row of rows) {
+        // The workflow row is renamed for hosts that ship the PTC variant. This
+        // repo's node_modules carries an older host without that package, so the
+        // resolution gate treats it as expected-absent rather than failing (see
+        // scripts/preset-smoke.mjs).
         if (row.name === '@deepseek-ai/dsh-workflow-worker-thread') {
           row.name = '@deepseek-ai/dsh-workflow-ptc'
         }
@@ -33,5 +172,6 @@ export async function presetDefinition(version, modern = false) {
     }
     adapt(plugins)
   }
+  await adaptCompanions(plugins, options)
   return { ...metadata, id: stablePresetId, order: -1, plugins }
 }

package/presets/openwrite/agent.cordis.yml

@@ -20,7 +20,7 @@
       outlines and assets unless the author asks to translate them. Chinese skill instructions
       describe procedures; they do not require Chinese output. Translate their headings and help
       when presenting them. In English conversations, use English throughout the creative loop.
-      Writing tasks return a task_id immediately; poll novel_task_get until terminal and present
+      Writing tasks return a task_id immediately; poll novel_task(action="get") until terminal and present
       cancellation as requested until the task reports cancelled. Resume saved drafts via run_id_v2.
 
       你是 OpenWrite 创作 Agent，运行在 DeepSeek Harness（dsh）的统一 OpenWrite 预设中。
@@ -66,12 +66,12 @@
       → rereview 闭环。低质量、硬门禁失败或上下文不完整时先报告原因，不强行交付。
       修改已有正文、人物、世界、正典、伏笔或其他项目文档时，先用 novel_search / novel_status
       定位正式实体并读取最新版本。正文、正典和其他普通文档的每个独立修改分别调用
-      novel_document_change_plan(action="preview")；大纲、资产、创作重点、伏笔和写作目标的每个独立
-      修改分别调用 novel_structured_change_plan(action="preview")。向用户展示返回的 before/after 与来源版本；
+      novel_change_plan(action="document", step="preview")；大纲、资产、创作重点、伏笔和写作目标的每个独立
+      修改分别调用 novel_change_plan(action="structured", step="preview")。向用户展示返回的 before/after 与来源版本；
       只有用户明确确认后，才把原 preview_token 原样传给 action="apply", confirm=true，不得重新生成路径、
       锚点或内容。用户拒绝时用 action="reject"；源文件冲突时用 action="retry" 生成新预览；
       已应用项需要撤销时，只能把返回的 undo_preview_token 传给 action="undo", confirm=true。
-      novel_doc_write 是已获明确授权的完整文档写入兼容入口，不得用它绕过逐项预览。
+      novel_doc(action="write") 是已获明确授权的完整文档写入兼容入口，不得用它绕过逐项预览。
       完成写入后可用 novel_trace_list 核对来源、预算、模型调用、工具调用和领域变更。Trace 只保留摘要、
       revision 与用量，作品正文、提示原文、模型原文、凭据和推理内容不得写入 trace。
       普通讨论、分析和未确认建议不得写入资产。
@@ -81,9 +81,9 @@
       或阶段仍在大纲滚动期但用户明确要求“根据现在/当前大纲写下一章”、
       “就按这个大纲写”或等价表达，先向用户确认大纲范围，再执行章节预检与写作。
       用户要求修改大纲时，先用 novel_outline_read 定位结构，再用
-      novel_structured_change_plan(change_kind="outline") 对一个结构操作逐项预览和确认；不要用
-      novel_doc_write 绕过大纲门控，也不要整篇覆盖 src/outline.md。novel_outline_edit、
-      novel_asset_update、novel_focus、novel_foreshadowing 和 novel_writing_targets 仅在用户本轮已经
+      novel_change_plan(action="structured", step="preview", change_kind="outline") 对一个结构操作逐项预览和确认；不要用
+      novel_doc(action="write") 绕过大纲门控，也不要整篇覆盖 src/outline.md。novel_outline_edit、
+      novel_assets(action="update")、novel_focus、novel_foreshadowing 和 novel_writing_targets 仅在用户本轮已经
       明确授权对应的精确变更时作为直接写入兼容入口使用。
       用户要求删除已写正文或章节时，先向用户说明将删除的章节与影响并得到明确同意。
       单章使用 novel_chapter_delete；清理连续尾段时使用 novel_chapter_delete_batch，
@@ -335,5 +335,3 @@
 - id: openwrite-tools
   name: dsh-openwrite/tools
 
-- id: openwrite-dog-tools
-  name: dsh-openwrite/dog-tools

package/presets/openwrite/ops-integration.mjs

@@ -0,0 +1,28 @@
+// dsh-ops preset integration. The row that mounts this module is only added
+// when dsh-ops is installed, its declared host range covers the running host,
+// and it exposes `dsh-ops/integration`. The import is still defensive: a
+// companion that changed its entry between detection and load must degrade to
+// a no-op row rather than take the whole preset composition down.
+export const name = '@dsh-novel/openwrite-ops'
+
+export async function apply(ctx) {
+  let integration
+  try {
+    ({ integration } = await import('dsh-ops/integration'))
+  } catch {
+    ctx.effect(() => () => {}, 'openwrite-ops: dsh-ops integration unavailable')
+    return
+  }
+  // Bounded file tools plus progressive discovery for the OpenWrite preset.
+  // Official file tools stay available (`replaceOfficial: false`), no shell is
+  // published (`shell: false`), and the preset's own guidance is not replaced.
+  const plugin = integration({
+    preset: 'openwrite',
+    files: true,
+    discovery: true,
+    presentation: 'native',
+    replaceOfficial: false,
+    shell: false,
+  })
+  return plugin.apply(ctx)
+}

package/presets/openwrite/preset.yml

@@ -1,3 +1,4 @@
 name: OpenWrite 创作
 description: 长篇小说全流程 Agent：在同一会话中完成灵感收敛、人物/设定/大纲、正文写作、六域累加评审与修订交付，保留 37 项展开查询，按项目阶段自动切换规划与写作模式。
-order: 10
+# `order` is set by presetDefinition (the stable id leads the selector); a value
+# here would be silently overridden.

package/presets/openwrite/skills/canon/SKILL.md

@@ -9,9 +9,9 @@ Language: follow the author's current conversation language for responses and he
 
 接到已有 `novel_*`。人物、地点、世界观以 OpenWrite 资产为准。
 
-1. `novel_assets_list` 列出人物/世界资产（含名称与别名）。
-2. 指定实体用 `novel_asset_read`。
+1. `novel_assets(action="list"` 列出人物/世界资产（含名称与别名）。
+2. 指定实体用 `novel_assets(action="read", kind="character"|"world"|"progression", id=…)`。
 3. 按名称或别名找不到时 `novel_search`（scope 可 `assets`）。
 4. 关系与状态漂移用 `novel_continuity`。
 
-向作者报告规范名、别名、摘要。改设定走 `novel_structured_change_plan(change_kind="asset")`；普通讨论不得写入。
+向作者报告规范名、别名、摘要。改设定走 `novel_change_plan(action="structured"(change_kind="asset")`；普通讨论不得写入。

package/presets/openwrite/skills/delivery-artifact-query/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: delivery-artifact-query
+description: Query a chapter delivery record across manuscript, review, revision application, and re-review closure. Use after writing or reviewing a chapter, after revision actions, or when the user asks whether a chapter is truly ready to deliver.
+user-invocable: false
+---
+
+Language: follow the author's current conversation language for responses and help; preserve the manuscript language. Translate these instructions when presenting them.
+
+# 章节交付状态查询
+
+章节写作、评审和修订工具会直接返回交付状态，并把同一份记录落盘：
+`data/novels/{id}/data/dog/deliveries/{chapter}/dog-graph.json`。
+它覆盖六个阶段：`writing → review → revision → application → rereview → closure`。
+它不替代 OpenWrite 的写章、六域累加评审或修订服务。
+
+## 查询流程
+
+1. 从最近一次 `novel_write_chapter`、`novel_review_chapter`、`novel_revision`
+   或 `novel_task(action="get")` 结果里的 `dog_delivery` 读状态；需要完整阶段明细时再读
+   上面的 `dog-graph.json`（`stages` 里有每一阶段的 verdict 与 evidence）。
+2. 按 `closure` 的状态给结论（见下表），不要自行推断。
+3. 修订应用后必须重新调用 `novel_review_chapter`；只有复评对应当前正文 SHA 且门禁通过，
+   `closure` 才能成为 `closed`。
+
+## 状态解释
+
+- `review.missing`：正文存在但尚未评审。
+- `closure.review_failed`：当前正文已评审但未通过门禁，进入修订闭环。
+- `revision.proposal_pending`：提案已生成，等待作者确认应用或驳回。
+- `revision.applied_requires_rereview`：修订已写入正文，但不能视为问题已解决。
+- `closure.rereview_required`：必须对修订后的正文重新跑六域评审。
+- `closure.closed`：当前正文的最新评审通过，可以交付。
+
+`readyForDelivery=true` 等价于「当前正文 SHA 的最新复评通过且门禁通过」，
+可以直接作为交付结论；为 `false` 时说明上面某一项未满足。
+
+## 约束
+
+- 只查询 canonical manuscript/review/revision 文件，不直接修改它们。
+- 不因提案状态为 `applied` 就宣称问题关闭；必须以当前正文 SHA 对应的复评为准。
+- 记录缺失时回到 OpenWrite 流程重新评审，不要把上一次的结论说成最新。

package/presets/openwrite/skills/dialoguequality/SKILL.md

@@ -19,14 +19,15 @@ Language: follow the author's current conversation language for responses and he
 3. `data/style/composed.md` — 当前作品风格约束
 4. `src/outline.md` / canonical packet — 本章戏剧位置与章节目标
 
-如果需要完整判断某章对白是否失真，优先结合 `review_chapter` 或章节 packet，而不是只看几行台词。
+如果需要完整判断某章对白是否失真，优先结合 `novel_review_chapter` 或 `novel_chapter_work` 的章节 packet，而不是只看几行台词。
 
 ## 可用工具
 
 | 工具 | 说明 |
 |------|------|
-| `extract_dialogue_fingerprint` | 提取角色对白指纹 |
-| `review_chapter` | 对整章做审查，可发现台词失真、解释性对话、套路对白 |
+| `novel_manuscript_metrics(chapter_id=…)` | 章节可量化信号：字数、句长、对白占比等 |
+| `novel_review_chapter(chapter_id=…, domains=["prose","character"])` | 对整章做审查，可发现台词失真、解释性对话、套路对白 |
+| `novel_chapter_work(chapter_id=…)` | 章节工作 brief：戏剧位置、出场角色、章节目标 |
 
 ## 什么时候用
 
@@ -37,26 +38,24 @@ Language: follow the author's current conversation language for responses and he
 
 ## 工作方式
 
-### 1. 提取对白指纹
+### 1. 读取章节信号
 
-先定位章节和角色，再提取：
+先定位章节，再读可量化指标：
 
 ```text
 用户: 分析一下林月在第六章的对话风格
 
-AI:
-[COMMAND] extract_dialogue_fingerprint {
-  "chapter_id": "ch_006",
-  "character_names": ["林月"]
-}
+AI: 调用 novel_manuscript_metrics(chapter_id="ch_006")
 ```
 
-重点观察：
+重点观察返回里的：
 
-- `avg_sentence_length`：句长偏短还是偏长
-- `question_ratio`：疑问句比例
-- `common_bigrams`：高频词组
-- `speech_patterns`：口头禅、重复习惯、语气特征
+- 字数与对白占比：这一章是谁在说话
+- 句长相关指标：偏短还是偏长
+- 出场角色：林月是否真的有戏份
+
+没有工具会直接给出"对白指纹"；上面的指标加上正文摘录就是判断依据。
+需要整章判断时再调用 `novel_review_chapter(chapter_id="ch_006", domains=["prose","character"])`。
 
 ### 2. 结合角色档案复核
 
@@ -163,6 +162,6 @@ AI:
 
 ## 注意
 
-- `extract_dialogue_fingerprint` 适合看“说话指纹”
-- `review_chapter` 适合看“对白放在整章里是否成立”
+- `novel_manuscript_metrics` 提供可量化信号，判断"说话指纹"要靠它加上正文摘录
+- `novel_review_chapter` 适合看“对白放在整章里是否成立”
 - 真要改对白，必须结合人物文档和章节戏剧位置一起判断