dsh-scrape 0.0.1 → 0.1.0

package/plugin.mjs

@@ -0,0 +1,197 @@
+/**
+ * dsh-scrape 的 host 半：往 DSH 里注册模型可调用的工具 `dsh_scrape`。
+ *
+ * 契约说明（照本机实测的宿主 0.2.2-rc.x）：
+ * - 只 import `node:` 内置与包内相对路径，**不 import `@deepseek-ai/*`**（否则会带第二份 cordis）；
+ * - 工具定义用「裸 JSON Schema ToolDefinition」注册，不需要 schemastery/zod，也没有编译步骤；
+ * - `apply(ctx, config)` 的 config 来自 cordis.patch.yml，可调默认超时/字节上限/限速，不写死在代码里。
+ */
+
+import { scrape, scrapeMany, VERSION, TOOL_NAME, DEFAULTS } from './lib/scrape.mjs'
+import { describeError } from './lib/errors.mjs'
+import { renderText } from './lib/format.mjs'
+
+/** cordis 插件名（= 包名；三处同名：包名 / patch 行 id / 这里）。 */
+export const name = 'dsh-scrape'
+
+/** 需要宿主提供的服务：工具注册表。 */
+export const inject = ['tools']
+
+/** 默认值；可被 cordis.patch.yml 的 config 覆盖。 */
+const CONFIG_DEFAULTS = {
+  timeoutMs: DEFAULTS.timeoutMs,
+  maxBytes: DEFAULTS.maxBytes,
+  maxUrls: DEFAULTS.maxUrls,
+  minIntervalMs: DEFAULTS.minIntervalMs,
+  maxChars: DEFAULTS.maxChars,
+  minChars: DEFAULTS.minChars,
+  robots: DEFAULTS.robots,
+  lineRefs: DEFAULTS.lineRefs,
+}
+
+/** 工具参数（宿主支持的 JSON Schema 子集）。 */
+const PARAMETERS = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    url: {
+      type: 'string',
+      description: '要抓的网页地址（http/https）。一次一页时用它。',
+    },
+    urls: {
+      type: 'array',
+      items: { type: 'string' },
+      description: '批量抓多个地址（最多 maxUrls 个；同域自动串行限速）。与 url 二选一。',
+    },
+    maxBytes: {
+      type: 'integer',
+      description: `响应体字节上限，默认 ${DEFAULTS.maxBytes}；超过会截断并在 warnings 里说明。`,
+    },
+    robots: {
+      type: 'boolean',
+      description: '是否遵守 robots.txt，默认 true。设 false 会抓取但仍记一条警告。',
+    },
+    timeoutMs: {
+      type: 'integer',
+      description: `单跳超时（毫秒），默认 ${DEFAULTS.timeoutMs}。`,
+    },
+    lineRefs: {
+      type: 'boolean',
+      description: "Markdown 里是否加 '<!-- L42 -->' 行号锚点，默认 true（便于引用与回溯）。",
+    },
+    maxChars: {
+      type: 'integer',
+      description: `返回的 Markdown 字符上限，默认 ${DEFAULTS.maxChars}；超出会截断并标注。`,
+    },
+    minChars: {
+      type: 'integer',
+      description: `「可信正文」的字数门槛，默认 ${DEFAULTS.minChars}；低于它会降低 confidence 并给 thin_content 警告。`,
+    },
+  },
+  required: [],
+}
+
+/** 返回值的 schema：只声明关键字段，保持开放以便演进。 */
+const OUTPUT_SCHEMA = {
+  type: 'object',
+  properties: {
+    tool: { type: 'string' },
+    version: { type: 'string' },
+    kind: { type: 'string' },
+    title: { type: 'string' },
+    markdown: { type: 'string' },
+    blocked: { description: '为 "robots" 时表示按 robots.txt 拒绝抓取' },
+    provenance: {
+      type: 'object',
+      properties: {
+        // 可为 null 的字段不声明 type：宿主只支持单一 type 字符串，声明了反而会把 null 判成非法
+        requestedUrl: { description: '调用方给的原始地址；本地 HTML 输入时为 null' },
+        finalUrl: { description: '跟随重定向后的最终地址' },
+        fetchedAt: { type: 'string', description: '抓取时刻（ISO 8601）' },
+        httpStatus: { description: 'HTTP 状态码；本地 HTML 输入时为 null' },
+        bytes: { type: 'integer', description: '响应体字节数' },
+        charset: { type: 'string', description: '实际用于解码的字符集' },
+        truncated: { type: 'boolean', description: '是否因 maxBytes 被截断' },
+        redirects: { type: 'array', items: { type: 'object' }, description: '每一跳重定向' },
+        robots: { description: 'robots.txt 的结论；robots:false 时为 null' },
+      },
+    },
+    removed: { type: 'object' },
+    content: {
+      type: 'object',
+      properties: {
+        chars: { type: 'integer' },
+        blocks: { type: 'integer' },
+        confidence: { type: 'number' },
+        method: { type: 'string' },
+        spaSuspected: { type: 'boolean' },
+      },
+    },
+    warnings: { type: 'array', items: { type: 'object' } },
+    notes: { type: 'array', items: { type: 'string' } },
+    limitations: { type: 'array', items: { type: 'string' } },
+    pages: { type: 'array', items: { type: 'object' } },
+    failures: { type: 'array', items: { type: 'object' } },
+  },
+  required: ['tool', 'version', 'kind'],
+}
+
+/**
+ * 组装工具定义（抽成函数，方便自检与单测直接拿到定义）。
+ * @param {object} [config] 插件配置
+ * @returns {object} ToolDefinition
+ */
+export function createToolDefinition(config = {}) {
+  const settings = { ...CONFIG_DEFAULTS, ...config }
+
+  return {
+    name: TOOL_NAME,
+    description:
+      '把网页变成干净、可引用、带行号的 Markdown：遵守 robots.txt、同域限速、跟随重定向、自动认字符集（GBK/Big5 不乱码）、按行去噪（script/style/nav/footer/cookie 条/分享按钮），并用密度法挑正文、给 confidence。输出 markdown 与 provenance（最终 URL / 抓取时间 / HTTP 状态 / 字节数），每条内容带 `<!-- L42 -->` 源行号锚点，便于引用回溯。**不执行 JavaScript**：疑似 SPA 会显式警告而不是返回空白。',
+    parameters: PARAMETERS,
+    output: {
+      schema: OUTPUT_SCHEMA,
+      render(_args, value) {
+        return [{ type: 'text', text: renderText(value, { detail: 'brief' }) }]
+      },
+      presentationMeta(_args, value) {
+        return {
+          chars: value.content?.chars ?? 0,
+          confidence: value.content?.confidence ?? 0,
+          spa: Boolean(value.content?.spaSuspected),
+          blocked: value.blocked ?? null,
+          warnings: value.warnings?.length ?? 0,
+        }
+      },
+    },
+    presentCall(args) {
+      const targetList = Array.isArray(args.urls) && args.urls.length > 0 ? `${args.urls.length} 个网址` : args.url ?? '(未给地址)'
+      return { card: 'generic', title: `抓取 ${targetList}`, kind: 'search', rawInput: args }
+    },
+    presentResult(args, result) {
+      if (result.isError || !result.meta) return undefined
+      const meta = result.meta
+      const status = meta.blocked ? `robots 禁止` : `${meta.chars} 字 · 置信度 ${meta.confidence}${meta.spa ? ' · 疑似 SPA' : ''}`
+      return {
+        card: 'generic',
+        title: `抓取 ${args.url ?? `${(args.urls ?? []).length} 个网址`} → ${status}`,
+        content: result.content,
+      }
+    },
+    async execute(args, exec) {
+      const options = {
+        timeoutMs: args.timeoutMs ?? settings.timeoutMs,
+        maxBytes: args.maxBytes ?? settings.maxBytes,
+        maxChars: args.maxChars ?? settings.maxChars,
+        minChars: args.minChars ?? settings.minChars,
+        maxUrls: settings.maxUrls,
+        minIntervalMs: settings.minIntervalMs,
+        robots: args.robots ?? settings.robots,
+        lineRefs: args.lineRefs ?? settings.lineRefs,
+        signal: exec?.signal,
+      }
+
+      try {
+        if (Array.isArray(args.urls) && args.urls.length > 0 && !args.url) {
+          return await scrapeMany(args.urls, options)
+        }
+        return await scrape({ url: args.url, urls: args.urls }, options)
+      } catch (error) {
+        const info = describeError(error)
+        // 抛出即可：工具管道会变成 isError，并把这段人话给模型看
+        throw new Error(`[${info.code}] ${info.message}${info.hint ? `\n→ ${info.hint}` : ''}`)
+      }
+    },
+  }
+}
+
+/**
+ * 插件激活：注册工具。
+ * @param {object} ctx cordis 上下文（需已注入 tools）
+ * @param {object} [config] 插件配置
+ * @returns {void}
+ */
+export function apply(ctx, config = {}) {
+  ctx.tools.register(createToolDefinition(config))
+  ctx.logger?.info?.(`dsh-scrape ${VERSION}: 已注册工具 ${TOOL_NAME}`)
+}

package/scripts/check.mjs

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+/**
+ * 装机前自检（零依赖，`npm run check` 会调它）：
+ *  1) 包结构：name/version/type/main/exports/files/dsh.bundle 齐不齐
+ *  2) 语法：所有 .js/.mjs 过一遍 node --check
+ *  3) 命名四处同源：package.json / cordis.patch.yml / dsh-plugin.naming.json / 代码导出名
+ *  4) 真加载：用假 ctx 跑 apply()，确认注册出来的工具名是 dsh_scrape
+ *  5) 真 schema 校验：本机装了 DSH 就用宿主自己的 assertSupportedJsonSchema 验 schema
+ *  6) 红线：不许 import @deepseek-ai/*、不许有运行时依赖
+ *  7) README：必须有安装命令与版本号
+ *
+ * 只读：不写任何文件、不碰 ~/.dsh、不发网络请求。
+ */
+
+import { execFileSync } from 'node:child_process'
+import { existsSync, readFileSync, readdirSync } from 'node:fs'
+import { dirname, join, relative } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+import * as plugin from '../plugin.mjs'
+
+const root = join(dirname(fileURLToPath(import.meta.url)), '..')
+const problems = []
+const notes = []
+
+/**
+ * 记一条失败。
+ * @param {string} message 描述
+ * @returns {void}
+ */
+const fail = (message) => problems.push(message)
+
+/**
+ * 记一条通过/提示。
+ * @param {string} message 描述
+ * @returns {void}
+ */
+const note = (message) => notes.push(message)
+
+const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'))
+const naming = JSON.parse(readFileSync(join(root, 'dsh-plugin.naming.json'), 'utf8'))
+const patch = readFileSync(join(root, 'cordis.patch.yml'), 'utf8')
+
+// 1) 包结构
+for (const field of ['name', 'version', 'description', 'license', 'type', 'main']) {
+  if (!pkg[field]) fail(`package.json 缺字段 ${field}`)
+}
+if (pkg.type !== 'module') fail('package.json 的 type 必须是 module')
+if (pkg.version !== '0.1.0' && !process.argv.includes('--any-version')) {
+  fail(`版本应为 0.1.0，实际 ${pkg.version}`)
+}
+if (!pkg.dsh?.bundle?.patch) fail('package.json 缺 dsh.bundle.patch')
+if (!pkg.files?.includes('lib/')) fail('files 白名单必须包含 lib/')
+if (pkg.dependencies && Object.keys(pkg.dependencies).length > 0) fail('不允许有运行时依赖')
+if (!existsSync(join(root, pkg.main))) fail(`main 指向的文件不存在：${pkg.main}`)
+if (!existsSync(join(root, pkg.bin?.['dsh-scrape'] ?? 'lib/cli.js'))) fail('bin 指向的 CLI 不存在')
+
+// 2) 语法
+const targets = ['plugin.mjs', join('lib', 'cli.js'), ...listModules()]
+for (const target of targets) {
+  try {
+    execFileSync(process.execPath, ['--check', join(root, target)], { stdio: 'pipe' })
+  } catch (error) {
+    fail(`语法错误 ${target}: ${String(error.stderr ?? error.message).split('\n')[0]}`)
+  }
+}
+
+// 3) 命名四处同源
+if (!patch.includes(`id: ${pkg.name}`)) fail('cordis.patch.yml 的 id 必须等于包名')
+if (!patch.includes(`name: ${pkg.name}`)) fail('cordis.patch.yml 的 name 必须等于包名')
+if (naming.plugin?.packageName !== pkg.name) fail('naming.json 的 packageName 与 package.json 不一致')
+if (naming.names?.pluginNames?.[0] !== plugin.name) fail('naming.json 的 pluginNames 与代码导出名不一致')
+if (naming.names?.loaderIds?.[0] !== pkg.name) fail('naming.json 的 loaderIds 与包名不一致')
+
+// 4) 真加载
+const registered = []
+const fakeCtx = { tools: { register: (definition) => { registered.push(definition); return () => {} } }, logger: { info() {} } }
+try {
+  plugin.apply(fakeCtx, {})
+} catch (error) {
+  fail(`apply() 抛异常：${error instanceof Error ? error.message : String(error)}`)
+}
+if (registered.length !== 1) fail(`apply() 应注册 1 个工具，实际 ${registered.length}`)
+const tool = registered[0]
+if (!tool) fail('没有注册到任何工具')
+else {
+  if (tool.name !== 'dsh_scrape') fail(`工具名应为 dsh_scrape，实际 ${tool.name}`)
+  if (naming.names?.tools?.[0] !== tool.name) fail('naming.json 的 tools 与实际注册的工具名不一致')
+  if (tool.output === undefined || typeof tool.output.render !== 'function') fail('工具缺 output.render')
+  if (typeof tool.execute !== 'function') fail('工具缺 execute')
+  if (tool.parameters?.type !== 'object') fail('工具 parameters 必须是 object 根')
+  for (const key of ['url', 'urls', 'maxBytes', 'robots']) {
+    if (!tool.parameters?.properties?.[key]) fail(`工具参数缺 ${key}`)
+  }
+}
+
+// 5) 用宿主自己的 schema 校验（装了 DSH 才做）
+const hostRoot = join(process.env.HOME ?? '', '.local/lib/node_modules/@deepseek-ai/dsh')
+const hostTools = join(hostRoot, 'node_modules/@deepseek-ai/dsh-tools/lib/index.js')
+if (existsSync(hostTools)) {
+  try {
+    const host = await import(pathToFileURL(hostTools).href)
+    host.assertSupportedJsonSchema(tool.parameters)
+    host.assertSupportedJsonSchema(tool.output.schema)
+    note('宿主 assertSupportedJsonSchema：parameters 与 output.schema 均合法')
+  } catch (error) {
+    fail(`宿主 schema 校验不通过：${error instanceof Error ? error.message : String(error)}`)
+  }
+} else {
+  note('本机找不到 dsh-tools，跳过宿主 schema 校验')
+}
+
+// 5b) 用宿主的 yaml 解析器把 cordis.patch.yml 解出来，确认形状就是 loader 要的 insert 数组
+const hostYaml = join(hostRoot, 'node_modules/yaml/dist/index.js')
+if (existsSync(hostYaml)) {
+  try {
+    const yaml = await import(pathToFileURL(hostYaml).href)
+    const layers = yaml.parse(patch)
+    const row = Array.isArray(layers) ? layers[0]?.insert?.[0] : undefined
+    if (!row) fail('cordis.patch.yml 形状不对：应为 [{ insert: [{ id, name, config }] }]')
+    else {
+      if (row.id !== pkg.name) fail(`patch 行 id 应为 ${pkg.name}，实际 ${row.id}`)
+      if (row.name !== pkg.name) fail(`patch 行 name 应为 ${pkg.name}，实际 ${row.name}`)
+      if (typeof row.config !== 'object' || row.config === null) fail('patch 行缺 config')
+      note('宿主 yaml 解析 cordis.patch.yml：insert 行 id/name/config 均正确')
+    }
+  } catch (error) {
+    fail(`cordis.patch.yml 解析失败：${error instanceof Error ? error.message : String(error)}`)
+  }
+} else {
+  note('本机找不到 yaml 解析器，跳过 patch 校验')
+}
+
+// 6) 红线：不许 import 外部包
+for (const file of ['plugin.mjs', join('lib', 'cli.js'), ...listModules()]) {
+  const source = readFileSync(join(root, file), 'utf8')
+  if (/from\s+['"]@deepseek-ai\//.test(source)) fail(`${file} 不许 import @deepseek-ai/*（会带第二份 cordis）`)
+  for (const match of source.matchAll(/from\s+['"]([^'"]+)['"]/g)) {
+    const specifier = match[1]
+    if (!specifier.startsWith('node:') && !specifier.startsWith('./') && !specifier.startsWith('../')) {
+      fail(`${file} 引入了外部依赖 ${specifier}`)
+    }
+  }
+}
+
+// 7) README 硬要求
+const readme = readFileSync(join(root, 'README.md'), 'utf8')
+if (!/dsh plugin --profile \w+ add dsh-scrape/.test(readme)) fail('README 缺安装命令')
+if (!readme.includes(pkg.version)) fail(`README 里没有提到版本 ${pkg.version}`)
+if (!readme.includes('dsh_scrape')) fail('README 里没有提到工具名 dsh_scrape')
+
+/**
+ * 列出 lib 目录下所有 .mjs / .js。
+ * @returns {string[]} 相对路径
+ */
+function listModules() {
+  return readdirSync(join(root, 'lib'))
+    .filter((file) => file.endsWith('.mjs') || file.endsWith('.js'))
+    .map((file) => join('lib', file))
+}
+
+for (const message of notes) process.stdout.write(`✓ ${message}\n`)
+if (problems.length > 0) {
+  process.stderr.write(`\n✗ 自检未通过（${problems.length} 项）：\n`)
+  for (const problem of problems) process.stderr.write(`  - ${problem}\n`)
+  process.exitCode = 1
+} else {
+  process.stdout.write(`\n✓ dsh-scrape ${pkg.version} 自检通过（${targets.length} 个文件、工具 ${tool?.name ?? '(无)'}）\n`)
+  process.stdout.write(`  包根：${relative(process.cwd(), root) || '.'}\n`)
+}

package/scripts/verify-install.mjs

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+/**
+ * 装验：用**宿主自己的** cordis + SystemPrompt + ToolsService，把 **npm pack 出来的 tarball**
+ * 装进一个隔离目录并真注册、真执行、真渲染。
+ *
+ * 为什么不用 `dsh plugin add`：本机 Node 23 下 dsh CLI 静默空转（缺 `import.meta.main`），
+ * 走 CLI 只会得到「什么都没发生的成功」。所以这里直接走宿主的安装代码路径：
+ *   1) `npm pack` → 解包到 <tmp>/node_modules/dsh-scrape（离线的、和发布物一致的那份）
+ *   2) 用宿主 yaml 解析 cordis.patch.yml，取出 config（= 装上去以后宿主真正会用的配置）
+ *   3) new Context() → 真 SystemPrompt → 真 ToolsService → 我们的 apply(ctx, config)
+ *   4) 断言 dsh_scrape 出现在注册表、schema 通过宿主校验、execute 能抓能转、render 有内容
+ * 全程 `DSH_HOME` 指向临时目录，**不碰 ~/.dsh、不改任何配置**。
+ *
+ * 用法：
+ *   node scripts/verify-install.mjs                 # 自动找本机宿主安装
+ *   DSH_INSTALL=/path/to/@deepseek-ai/dsh node scripts/verify-install.mjs
+ *
+ * 退出码：0 通过 ｜ 1 失败 ｜ 3 本机找不到宿主（跳过，不算失败）
+ */
+
+import { pathToFileURL } from 'node:url'
+import { execFileSync } from 'node:child_process'
+import { createServer } from 'node:http'
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync } from 'node:fs'
+import { homedir, tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const packageRoot = join(dirname(fileURLToPath(import.meta.url)), '..')
+const problems = []
+
+/**
+ * 记一条失败。
+ * @param {string} message 描述
+ * @returns {void}
+ */
+const fail = (message) => problems.push(message)
+
+/**
+ * 找到本机 DSH 安装目录（含 node_modules/@deepseek-ai/* 的那一层）。
+ * @returns {string|null} 宿主安装根
+ */
+function findHostRoot() {
+  const candidates = [
+    process.env.DSH_INSTALL,
+    join(homedir(), '.local/lib/node_modules/@deepseek-ai/dsh'),
+    '/usr/local/lib/node_modules/@deepseek-ai/dsh',
+    '/opt/homebrew/lib/node_modules/@deepseek-ai/dsh',
+  ].filter(Boolean)
+  for (const candidate of candidates) {
+    if (existsSync(join(candidate, 'node_modules/@deepseek-ai/dsh-tools/lib/index.js'))) return candidate
+  }
+  return null
+}
+
+const hostRoot = findHostRoot()
+if (!hostRoot) {
+  process.stderr.write('! 本机找不到 DSH 安装（试过 DSH_INSTALL / ~/.local/lib/node_modules/@deepseek-ai/dsh），跳过装验\n')
+  process.exit(3)
+}
+
+const mods = join(hostRoot, 'node_modules/@deepseek-ai')
+const work = mkdtempSync(join(tmpdir(), 'dsh-scrape-install-'))
+const isolatedHome = join(work, 'home')
+mkdirSync(isolatedHome, { recursive: true })
+process.env.DSH_HOME = isolatedHome
+
+try {
+  // 1) 打包 + 解包（装的是发布物，不是工作区源码）
+  const packed = JSON.parse(execFileSync('npm', ['pack', '--json', '--pack-destination', work], { cwd: packageRoot, encoding: 'utf8' }))
+  const tarball = packed[0].filename
+  mkdirSync(join(work, 'node_modules'), { recursive: true })
+  execFileSync('tar', ['-xzf', join(work, tarball), '-C', work], { stdio: 'pipe' })
+  execFileSync('mv', [join(work, 'package'), join(work, 'node_modules', 'dsh-scrape')], { stdio: 'pipe' })
+  const installed = join(work, 'node_modules', 'dsh-scrape')
+
+  // 2) 宿主模块 + patch config
+  const { Context } = await import(pathToFileURL(join(mods, 'cordis/lib/index.js')).href)
+  const { SystemPrompt } = await import(pathToFileURL(join(mods, 'dsh-system-prompt/lib/index.js')).href)
+  const { ToolsService, assertSupportedJsonSchema } = await import(pathToFileURL(join(mods, 'dsh-tools/lib/index.js')).href)
+  const yaml = await import(pathToFileURL(join(hostRoot, 'node_modules/yaml/dist/index.js')).href)
+
+  const patch = yaml.parse(readFileSync(join(installed, 'cordis.patch.yml'), 'utf8'))
+  const row = Array.isArray(patch) ? patch[0]?.insert?.[0] : undefined
+  if (!row) fail('cordis.patch.yml 形状不对：应为 [{ insert: [{ id, name, config }] }]')
+  const plugin = await import(pathToFileURL(join(installed, 'plugin.mjs')).href)
+  const pkg = JSON.parse(readFileSync(join(installed, 'package.json'), 'utf8'))
+  if (row?.id !== pkg.name) fail(`patch 行 id (${row?.id}) 与包名 (${pkg.name}) 不一致`)
+
+  // 3) 真注册表
+  const ctx = new Context()
+  await ctx.plugin(SystemPrompt)
+  await ctx.plugin(ToolsService)
+  if (!ctx.tools) fail('宿主 ToolsService 没有激活（inject: systemPrompt）')
+
+  plugin.apply(ctx, row?.config ?? {})
+  const definition = ctx.tools.get('dsh_scrape')
+  if (!definition) fail('宿主注册表里没有 dsh_scrape')
+  else {
+    assertSupportedJsonSchema(definition.parameters)
+    assertSupportedJsonSchema(definition.output.schema)
+    const schemas = ctx.tools.schemas().map((schema) => schema.name)
+    if (!schemas.includes('dsh_scrape')) fail(`schemas() 里没有 dsh_scrape：${schemas.join(',')}`)
+  }
+
+  // 4) 真执行一次（本地服务，不联网）
+  const server = createServer((req, res) => {
+    if (req.url === '/robots.txt') { res.statusCode = 404; res.end('no robots'); return }
+    res.setHeader('content-type', 'text/html; charset=utf-8')
+    res.end(`<html><head><title>装验页面</title></head><body><main><article><h1>装验页面</h1>
+<p>${'这一段用来证明打包产物装进宿主注册表后真的能抓、能转、能带行号。'.repeat(8)}</p>
+<table><tr><th>项</th><th>值</th></tr><tr><td>引擎</td><td>dsh-scrape</td></tr></table>
+</article></main><footer>页脚噪音</footer></body></html>`)
+  })
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve))
+  const origin = `http://127.0.0.1:${server.address().port}`
+  try {
+    const result = await definition.execute({ url: `${origin}/post` }, {})
+    if (result.provenance.httpStatus !== 200) fail(`HTTP 状态不是 200：${result.provenance.httpStatus}`)
+    if (!result.markdown.includes('<!-- L')) fail('Markdown 里没有行号锚点')
+    if (!(result.removed.footer > 0)) fail('页脚没有被去噪')
+    if (!(result.content.confidence > 0.5)) fail(`置信度过低：${result.content.confidence}`)
+    const rendered = definition.output.render({ url: `${origin}/post` }, result)
+    if (rendered?.[0]?.text?.length < 200) fail('render 输出太短，模型看不到正文')
+    process.stdout.write(`  抓取：HTTP ${result.provenance.httpStatus} · ${result.content.chars} 字 · 置信度 ${result.content.confidence} · 去噪 ${result.removed.total} 字\n`)
+    process.stdout.write(`  渲染：${rendered[0].type} ${rendered[0].text.length} 字符\n`)
+  } finally {
+    server.close()
+  }
+} catch (error) {
+  fail(`装验抛异常：${error instanceof Error ? error.message : String(error)}`)
+} finally {
+  rmSync(work, { recursive: true, force: true })
+}
+
+if (problems.length > 0) {
+  process.stderr.write(`\n✗ 装验未通过（${problems.length} 项）：\n`)
+  for (const problem of problems) process.stderr.write(`  - ${problem}\n`)
+  process.exitCode = 1
+} else {
+  process.stdout.write('\n✓ 装验通过：宿主 cordis + SystemPrompt + ToolsService 真注册、真执行、真渲染（DSH_HOME 隔离）\n')
+  process.stdout.write(`  宿主：${hostRoot}\n`)
+}