dsh-convo-paper-plugin 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LiShaozheli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,67 @@
-# Temporary Holding Version
+# dsh-convo-paper-plugin
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+DeepSeek Harness 插件版：把对话整理成论文，并用确定性检索核验每一条引用。
+
+这是 [dsh-convo-paper](../README.md) 的宿主插件形态。核心逻辑与技能版完全一致（`dsh/lib/` 由 `lib/` 生成，`npm test` 会校验两份不漂移），区别在于它把自己注册进 DSH 的工具与命令系统：
+
+| 能力 | 说明 |
+| --- | --- |
+| `paper_extract` | 读会话日志，按说话人还原上下文，剔除系统注入 → `transcript.md` / `conversation.json` |
+| `paper_claims` | 提炼带出处的候选论点（id / 说话人 / 轮次 / 时间戳 / 建议章节）→ `claims.json` / `claims.md` |
+| `paper_build` | 组装论文骨架与证据对照表 → `paper-skeleton.md` / `evidence.md` |
+| `paper_verify_refs` | 四源核验引用（Crossref / DataCite / OpenAlex / arXiv），DOI 反查 + 标题相似度 |
+| `paper_run` | 一步跑完 extract → claims → build |
+| `/paper` | 斜杠命令，等价于 `paper_run` |
+
+## 安装
+
+插件需要装进 profile（不是拷文件夹）：
+
+```bash
+dsh plugin --profile desktop add github:LiShaozheli/dsh-convo-paper#path:/plugin
+```
+
+装完重启 DSH，`设置 → 插件` 里会出现 **convo-paper**，输入框输入 `/paper` 可用。
+
+也可以只在某个 profile 里试用：
+
+```bash
+dsh plugin --profile web add github:LiShaozheli/dsh-convo-paper#path:/plugin
+```
+
+## 与技能版的取舍
+
+| | 插件版 | 技能版 |
+| --- | --- | --- |
+| 出现在「已安装插件」 | ✅ | ❌（在技能列表/`@` 菜单里） |
+| 斜杠命令 `/paper` | ✅ | ❌ |
+| 原生工具，模型可直接调用 | ✅ | 读 `SKILL.md` 后手动跑 CLI |
+| 安装成本 | 需要 profile 与重启 | 拷一个目录即可 |
+| 依赖 | 无（不 import 任何 `@deepseek-ai/*` 值） | 无 |
+
+## 契约
+
+```js
+export const name = 'convo-paper'
+export const inject = ['tools']
+export function apply(ctx) { ctx.effect(() => ctx.tools.register({...}), 'label') }
+```
+
+- 工具用 `ctx.tools.register` 的普通对象定义（参数走 JSON Schema，输出走 `output.schema` + `render`），因此不依赖 `@deepseek-ai/dsh-tools` 的 `defineTool`，装到任何兼容 profile 都能跑。
+- 命令用 `ctx.commands.register`，且做了存在性判断——宿主没有 commands 服务时自动跳过，不影响工具。
+- 所有注册都包在 `ctx.effect(...)` 里，插件卸载时自动注销。
+
+## 验证
+
+```bash
+node test/plugin.test.mjs     # mock ctx：8 个用例，含真实会话日志端到端
+node scripts/sync-core.mjs --check
+```
+
+测试会在临时 `DSH_HOME` 里造一份多帧 zstd 会话日志，套上 mock ctx 走完 `paper_run`，断言产物与控制台摘要。
+
+## 已知边界
+
+- 保证引用的**存在性**，不保证**恰当性**。
+- 中文数据库（知网/万方）无开放 API，中文文献需人工确认。
+- 论点抽取是启发式的；操作密集型对话会提示素材不足，而不是硬写。

package/cordis.patch.yml

@@ -0,0 +1,6 @@
+# dsh-convo-paper-plugin bundle patch: one host row over the Web or Desktop
+# profile. The row name resolves from the profile's own node_modules, where
+# `dsh plugin --profile <profile> add <package>` installed this package.
+- insert:
+    - id: convo-paper
+      name: dsh-convo-paper-plugin

package/dsh/index.js

@@ -0,0 +1,202 @@
+/**
+ * dsh-convo-paper-plugin — host half.
+ *
+ * Registers five tools and a `/paper` command on the DeepSeek Harness. Plain
+ * object definitions go through `ctx.tools.register` so the package depends on
+ * no `@deepseek-ai/*` value import and installs into any compatible profile.
+ */
+import { runExtract, runClaims, runBuild, runVerifyRefs, runAll } from './pipeline.mjs';
+
+export const name = 'convo-paper';
+export const inject = ['tools'];
+
+const LABEL = 'convo-paper';
+
+const SESSION_PARAM = {
+  type: 'string',
+  description: '会话 id（`latest` 表示最近一次会话，也可传 id 片段）。留空等于 latest。',
+};
+
+const CWD_PARAM = {
+  type: 'string',
+  description: '会话所属工作目录；用于在多个项目之间消歧。',
+};
+
+const OUT_PARAM = {
+  type: 'string',
+  description: '产物目录，默认写到会话的 cwd 下的 paper-work/。',
+};
+
+function text(value) {
+  return [{ type: 'text', text: String(value) }];
+}
+
+function summarize(result) {
+  if (!result || result.ok === false) {
+    return `失败：${result?.message || result?.code || 'unknown error'}`;
+  }
+  if (result.step === 'extract') {
+    const s = result.stats || {};
+    return `已抽取 ${result.sessionId}：${s.turns ?? 0} 轮 / 用户 ${s.userMessages ?? 0} 条 / AI ${s.assistantMessages ?? 0} 条，剔除系统注入 ${s.injectedMessages ?? 0} 条 → ${result.out}`;
+  }
+  if (result.step === 'claims') {
+    return `候选论点 ${result.candidateCount} 条（${Object.entries(result.bySection || {})
+      .map(([k, v]) => `${k}:${v}`)
+      .join('，')}）→ ${result.out}`;
+  }
+  if (result.step === 'build') {
+    return `骨架已生成：保留论点 ${result.keptClaims} 条，已核实文献 ${result.verifiedRefs} 条 → ${result.out}`;
+  }
+  if (result.step === 'verify-refs') {
+    return `核验 ${result.verdicts.length} 条：verified ${result.verified}｜possible ${result.possible}｜rejected ${result.rejected} → ${result.out}`;
+  }
+  if (result.step === 'run') {
+    return `${summarize(result.extracted)}\n${summarize(result.claims)}\n${summarize(result.built)}`;
+  }
+  return JSON.stringify(result);
+}
+
+function define(ctx, def) {
+  return ctx.effect(() => ctx.tools.register(def), `${LABEL} ${def.name}`);
+}
+
+export function apply(ctx) {
+  define(ctx, {
+    name: 'paper_extract',
+    description:
+      '读取一段 DSH 会话日志，按说话人还原上下文（用户说了什么 / AI 答了什么），剔除运行时上下文等系统注入，输出 transcript.md 与 conversation.json。做"把对话整理成论文"的第一步。',
+    parameters: {
+      type: 'object',
+      properties: { session: SESSION_PARAM, cwd: CWD_PARAM, out: OUT_PARAM, includeTools: { type: 'boolean', description: '是否在 transcript 中附上工具调用摘要' } },
+      additionalProperties: false,
+    },
+    output: { schema: { type: 'object' }, render: (_a, v) => text(summarize(v)) },
+    async execute(args = {}) {
+      return runExtract(args);
+    },
+    presentCall: (args = {}) => ({
+      card: 'generic',
+      title: '抽取对话上下文',
+      kind: 'read',
+      rawInput: String(args.session || 'latest'),
+    }),
+  });
+
+  define(ctx, {
+    name: 'paper_claims',
+    description:
+      '从已抽取的对话中提炼带出处的候选论点（观点/结论/创意），每条含 id、说话人、轮次、时间戳、建议章节，输出 claims.json 与 claims.md，供人工判定 keep/merge/drop。',
+    parameters: {
+      type: 'object',
+      properties: {
+        out: OUT_PARAM,
+        session: SESSION_PARAM,
+        cwd: CWD_PARAM,
+        perTurn: { type: 'number', description: '每轮最多保留多少条候选句，默认 6' },
+      },
+      additionalProperties: false,
+    },
+    output: { schema: { type: 'object' }, render: (_a, v) => text(summarize(v)) },
+    async execute(args = {}) {
+      return runClaims(args);
+    },
+    presentCall: () => ({ card: 'generic', title: '提炼候选论点', kind: 'read' }),
+  });
+
+  define(ctx, {
+    name: 'paper_build',
+    description:
+      '把保留的论点与已核实文献组装成论文骨架：摘要、六节正文、参考文献，并生成 evidence.md 证据对照表（论点→出处→支撑文献）。',
+    parameters: {
+      type: 'object',
+      properties: { out: OUT_PARAM, cwd: CWD_PARAM, title: { type: 'string', description: '论文标题；缺省用会话标题' } },
+      additionalProperties: false,
+    },
+    output: { schema: { type: 'object' }, render: (_a, v) => text(summarize(v)) },
+    async execute(args = {}) {
+      return runBuild(args);
+    },
+    presentCall: () => ({ card: 'generic', title: '生成论文骨架', kind: 'edit' }),
+  });
+
+  define(ctx, {
+    name: 'paper_verify_refs',
+    description:
+      '逐条核验参考文献：Crossref / DataCite / OpenAlex / arXiv 四源检索，DOI 反查 + 标题相似度判定。只有 verified 的条目允许进入正文，possible 需人工核对，rejected 必须丢弃。输入 [{id, claimId, title, doi}]。',
+    parameters: {
+      type: 'object',
+      properties: {
+        refs: {
+          type: 'array',
+          description: '待核验条目，title 必填，doi 强烈建议',
+          items: {
+            type: 'object',
+            properties: {
+              id: { type: 'string' },
+              claimId: { type: 'string', description: '这条文献支撑哪个论点（C001…）' },
+              title: { type: 'string' },
+              doi: { type: 'string' },
+              year: { type: 'number' },
+            },
+            required: ['title'],
+            additionalProperties: false,
+          },
+        },
+        out: OUT_PARAM,
+        cwd: CWD_PARAM,
+      },
+      required: ['refs'],
+      additionalProperties: false,
+    },
+    output: { schema: { type: 'object' }, render: (_a, v) => text(summarize(v)) },
+    async execute(args = {}) {
+      return runVerifyRefs(args);
+    },
+    presentCall: (args = {}) => ({
+      card: 'generic',
+      title: '核验参考文献',
+      kind: 'read',
+      rawInput: `${Array.isArray(args.refs) ? args.refs.length : 0} 条`,
+    }),
+  });
+
+  define(ctx, {
+    name: 'paper_run',
+    description: '一步完成 paper_extract → paper_claims → paper_build，产出可编辑的论文骨架。需要核验文献时再单独调用 paper_verify_refs。',
+    parameters: {
+      type: 'object',
+      properties: { session: SESSION_PARAM, cwd: CWD_PARAM, out: OUT_PARAM, includeTools: { type: 'boolean' }, perTurn: { type: 'number' } },
+      additionalProperties: false,
+    },
+    output: { schema: { type: 'object' }, render: (_a, v) => text(summarize(v)) },
+    async execute(args = {}) {
+      return runAll(args);
+    },
+    presentCall: (args = {}) => ({ card: 'generic', title: '对话转论文', kind: 'edit', rawInput: String(args.session || 'latest') }),
+  });
+
+  if (ctx.commands && typeof ctx.commands.register === 'function') {
+    ctx.effect(
+      () =>
+        ctx.commands.register({
+          name: 'paper',
+          description: '把当前（或指定）会话整理成论文骨架',
+          input: { hint: '[latest|<会话id>] [--out <目录>]' },
+          handler: async (invocation) => {
+            try {
+              const raw = String(invocation?.args ?? invocation?.input ?? invocation?.text ?? '').trim();
+              const parts = raw.split(/\s+/).filter(Boolean);
+              const session = parts[0] && parts[0] !== '--out' ? parts[0] : 'latest';
+              const outIdx = parts.indexOf('--out');
+              const out = outIdx >= 0 ? parts[outIdx + 1] : undefined;
+              const result = await runAll({ session, out });
+              return { kind: 'text', text: summarize(result) };
+            } catch (error) {
+              return { kind: 'error', text: error instanceof Error ? error.message : String(error) };
+            }
+          },
+        }),
+      `${LABEL} /paper command`,
+    );
+  }
+}

package/dsh/lib/build.mjs

@@ -0,0 +1,137 @@
+// Vendored copy of lib/build.mjs — edit lib/ and run `node scripts/sync-core.mjs`.
+/**
+ * Assemble the paper scaffold: sections, claim slots, citation slots, and the
+ * evidence table that traces every claim back to a turn and a speaker.
+ *
+ * It intentionally stops at the skeleton. Prose is written by the model under
+ * SKILL.md, because a template-filled document is not a paper.
+ */
+
+export const SECTIONS = [
+  { key: '1', title: '引言', hint: '问题从哪里来：用户提出的是什么困扰，为什么值得写成文章' },
+  { key: '2', title: '相关工作', hint: '外部文献对照；每条引用必须来自 refs.verified' },
+  { key: '3', title: '核心观点与框架', hint: '对话中真正有创意的判断、类比、框架' },
+  { key: '4', title: '论证与证据', hint: '支撑上述观点的推理链、案例、反例、数据' },
+  { key: '5', title: '讨论与局限', hint: '边界条件、反方意见、尚未验证的假设' },
+  { key: '6', title: '结论与展望', hint: '收敛成可检验的结论与下一步工作' },
+];
+
+function pickSection(c) {
+  const m = String(c.section || '').match(/^\s*(\d)/);
+  if (m && SECTIONS.some((s) => s.key === m[1])) return m[1];
+  return c.role === 'user' ? '1' : '3';
+}
+
+export function buildSkeleton({ conversation, claims, refs = [], title }) {
+  const kept = claims.filter((c) => c.status !== 'drop');
+  const groups = new Map(SECTIONS.map((s) => [s.key, []]));
+  for (const c of kept) groups.get(pickSection(c)).push(c);
+
+  const verified = refs.filter((r) => r.verdict === 'verified');
+  const possible = refs.filter((r) => r.verdict === 'possible');
+  const citeIndex = new Map();
+  verified.forEach((r, i) => citeIndex.set(r.id || r.record.doi || r.record.title, i + 1));
+
+  const docTitle = title || conversation.meta.title || '未命名论文';
+  const out = [];
+  out.push(`# ${docTitle}`);
+  out.push('');
+  out.push('> 骨架由 convo-paper 生成：括号内是写作指令，`[Cn]` 是可引用的观点锚点，`[n]` 是对应参考文献。');
+  out.push('');
+  out.push('## 摘要');
+  out.push('');
+  out.push('（用 200–300 字写：问题、方法、核心观点、结论。不要出现“本文借助 AI 对话”这类元叙述。）');
+  out.push('');
+  out.push('**关键词**：（3–5 个）');
+  out.push('');
+
+  for (const s of SECTIONS) {
+    out.push(`## ${s.key} ${s.title}`);
+    out.push('');
+    out.push(`<!-- 写作提示：${s.hint} -->`);
+    out.push('');
+    const list = groups.get(s.key) || [];
+    if (!list.length) {
+      out.push('（本节暂无对话素材：需要补充外部文献或由作者补写。）');
+      out.push('');
+      continue;
+    }
+    list.forEach((c, i) => {
+      const cite = c.citeId && citeIndex.has(c.citeId) ? ` [${citeIndex.get(c.citeId)}]` : '';
+      out.push(`${i + 1}. **[${c.id}]**（第${c.turn}轮·${c.role === 'user' ? '用户' : 'AI'}）${c.text}${cite}`);
+    });
+    out.push('');
+  }
+
+  out.push('## 参考文献');
+  out.push('');
+  if (!verified.length) {
+    out.push('（尚无已核实文献。先跑 `convo-paper refs verify`，只有 verdict=verified 的记录才能写进来。）');
+  } else {
+    verified.forEach((r, i) => out.push(r.gbt7714.replace(/^\[\d+\]\s*/, `[${i + 1}] `)));
+  }
+  if (possible.length) {
+    out.push('');
+    out.push('<!-- 待人工核对（匹配度不足，暂不列入正式参考文献）：');
+    for (const r of possible) out.push(`  - ${r.record.title}（相似度 ${r.similarity}）${r.record.doi || ''}`);
+    out.push('-->');
+  }
+  out.push('');
+  return out.join('\n');
+}
+
+export function buildEvidenceTable({ conversation, claims, refs = [] }) {
+  const out = [];
+  out.push('# 证据对照表');
+  out.push('');
+  out.push('每一条进入正文的判断，都必须能在这张表里找到出处。审稿人问“这个结论哪来的”，答案在这里。');
+  out.push('');
+  out.push('| 观点 | 说话人 | 轮次 | 原文摘要 | 支撑文献 | 状态 |');
+  out.push('| --- | --- | --- | --- | --- | --- |');
+  for (const c of claims) {
+    const short = c.text.replace(/\|/g, '\\|').slice(0, 60);
+    const refsForClaim = refs.filter((r) => r.claimId === c.id && r.verdict === 'verified');
+    const refText = refsForClaim.length
+      ? refsForClaim.map((r) => (r.record.doi ? `doi:${r.record.doi}` : r.record.title.slice(0, 30))).join('；')
+      : '—';
+    out.push(`| ${c.id} | ${c.role === 'user' ? '用户' : 'AI'} | ${c.turn} | ${short} | ${refText} | ${c.status || 'candidate'} |`);
+  }
+  out.push('');
+  out.push('## 未被引用的对话结论');
+  out.push('');
+  const unused = claims.filter((c) => !refs.some((r) => r.claimId === c.id));
+  if (!unused.length) out.push('（无）');
+  else for (const c of unused) out.push(`- ${c.id} ${c.text.slice(0, 80)}`);
+  out.push('');
+  return out.join('\n');
+}
+
+export function buildBibliography(refs) {
+  const verified = refs.filter((r) => r.verdict === 'verified');
+  const possible = refs.filter((r) => r.verdict === 'possible');
+  const rejected = refs.filter((r) => r.verdict === 'rejected');
+  const out = [];
+  out.push('# 参考文献（GB/T 7714）');
+  out.push('');
+  out.push(`已核实 ${verified.length} 条 / 待核对 ${possible.length} 条 / 已拒绝 ${rejected.length} 条。`);
+  out.push('');
+  verified.forEach((r, i) => out.push(r.gbt7714.replace(/^\[\d+\]\s*/, `[${i + 1}] `)));
+  if (possible.length) {
+    out.push('');
+    out.push('## 待人工核对（不得直接引用）');
+    out.push('');
+    for (const r of possible) {
+      out.push(`- 输入：${r.input.title}`);
+      out.push(`  候选：${r.record.title}（${r.record.venue || '—'}, ${r.record.year || '—'}）相似度 ${r.similarity}`);
+      if (r.record.doi) out.push(`  DOI：${r.record.doi}`);
+    }
+  }
+  if (rejected.length) {
+    out.push('');
+    out.push('## 已拒绝（查无此文，模型可能编造）');
+    out.push('');
+    for (const r of rejected) out.push(`- ${r.input.title || '(空)'} —— ${r.reason}`);
+  }
+  out.push('');
+  return out.join('\n');
+}

package/dsh/lib/claims.mjs

@@ -0,0 +1,170 @@
+// Vendored copy of lib/claims.mjs — edit lib/ and run `node scripts/sync-core.mjs`.
+/**
+ * Heuristic candidate extraction: which sentences carry a stance, a judgement,
+ * a conclusion, or an idea worth putting into a paper.
+ *
+ * This is deliberately conservative and cheap. The model curates the list
+ * afterwards (SKILL.md step 3) — the script's job is to make sure nothing is
+ * silently dropped, and to keep a stable id + provenance for every candidate.
+ */
+
+const CLAIM_MARKERS = [
+  // 判断 / 归因 / 结论
+  '因此', '所以', '可见', '说明', '本质上', '关键是', '关键在于', '我认为', '我的判断',
+  '结论', '核心是', '根本原因', '之所以', '这意味着', '换句话说', '值得注意', '说白了',
+  '更重要的是', '问题在于', '真正的', '应该是', '不应该', '建议', '必须', '不能',
+  '只能', '代价', '前提', '边界', '而不是', '反过来', '实际上', '误区', '容易', '风险',
+  // 英文
+  'therefore', 'thus', 'this means', 'the key', 'in my view', 'i think', 'suggests that',
+  'implies', 'we should', 'the problem is', 'root cause', 'trade-off', 'rather than',
+];
+
+const NOVELTY_MARKERS = [
+  // 创意 / 反直觉 / 框架 / 类比
+  '反直觉', '与直觉相反', '容易被忽略', '被低估', '重新定义', '换个角度', '打个比方',
+  '类比', '可以这样理解', '三个层次', '两层', '框架', '假设', '反例', '悖论', '张力',
+  'insight', 'reframe', 'framework', 'counterintuitive', 'analogy', 'novel', 'hypothesis',
+];
+
+const USER_INTENT_MARKERS = ['我想要', '我希望', '我担心', '困扰', '问题是', '我觉得', '能不能', '有没有'];
+
+const MD_LINK = /\[([^\]]*)\]\([^)]*\)/g;
+const MD_EMPH = /(\*\*|__|\*|_|`|~~)/g;
+
+/** Strip markdown scaffolding so the extracted sentence reads like prose. */
+export function cleanText(text) {
+  return String(text)
+    .replace(/```[\s\S]*?```/g, ' ')
+    .replace(/<[^>]+>/g, ' ')
+    .replace(MD_LINK, '$1')
+    .replace(MD_EMPH, '')
+    .replace(/^\s{0,3}#{1,6}\s+/gm, '')
+    .replace(/^\s{0,3}>\s?/gm, '')
+    .replace(/^\s*(?:[-*+]|\d+[.)])\s+/gm, '')
+    .replace(/\|/g, ' ')
+    .replace(/[ \t]+/g, ' ')
+    .trim();
+}
+
+function splitSentences(text) {
+  const cleaned = cleanText(text);
+  const chunks = cleaned.split(/(?<=[。！？!?；;])|\n+/);
+  return chunks
+    .map((s) => s.replace(/\s+/g, ' ').trim())
+    .filter((s) => s.length >= 14 && s.length <= 420)
+    .filter((s) => !/^(js|bash|json|text)?\s*$/i.test(s));
+}
+
+function score(sentence, pool) {
+  const lower = sentence.toLowerCase();
+  let hits = 0;
+  const matched = [];
+  for (const m of pool) {
+    if (lower.includes(m.toLowerCase())) {
+      hits += 1;
+      matched.push(m);
+    }
+  }
+  return { hits, matched };
+}
+
+export function extractClaims(conversation, { perTurn = 6 } = {}) {
+  const claims = [];
+  let n = 0;
+  const seen = new Set();
+  const add = (claim) => {
+    const key = claim.text.toLowerCase().replace(/\s+/g, '').slice(0, 120);
+    if (!key || seen.has(key)) return;
+    seen.add(key);
+    n += 1;
+    claims.push({ ...claim, id: `C${String(n).padStart(3, '0')}` });
+  };
+
+  for (const turn of conversation.turns) {
+    // 用户的原话就是论文的问题陈述，整段保留，不参与线索词筛选。
+    for (const u of turn.users) {
+      const text = cleanText(u.text).replace(/\s+/g, ' ').slice(0, 320);
+      if (text.length >= 8) {
+        add({
+          role: 'user',
+          turn: turn.turn,
+          at: u.at,
+          text,
+          claimScore: 0,
+          noveltyScore: 0,
+          markers: ['问题陈述'],
+          section: '1 引言',
+          kind: 'statement',
+          status: 'candidate',
+        });
+      }
+    }
+
+    const buckets = [
+      ...turn.assistant.map((a) => ({ role: 'assistant', text: a.text, at: a.at })),
+      ...turn.users.map((u) => ({ role: 'user', text: u.text, at: u.at })),
+    ];
+    for (const bucket of buckets) {
+      const scored = splitSentences(bucket.text).map((s) => {
+        const c = score(s, CLAIM_MARKERS);
+        const nv = score(s, NOVELTY_MARKERS);
+        const intent = bucket.role === 'user' ? score(s, USER_INTENT_MARKERS) : { hits: 0, matched: [] };
+        return {
+          text: s,
+          claimScore: c.hits,
+          claimMarkers: c.matched,
+          noveltyScore: nv.hits,
+          noveltyMarkers: nv.matched,
+          intentScore: intent.hits,
+          total: c.hits * 2 + nv.hits * 2 + intent.hits + Math.min(s.length, 120) / 200,
+        };
+      });
+      const picked = scored
+        .filter((s) => s.claimScore > 0 || s.noveltyScore > 0 || s.intentScore > 0)
+        .sort((a, b) => b.total - a.total)
+        .slice(0, perTurn);
+
+      for (const s of picked) {
+        add({
+          role: bucket.role,
+          turn: turn.turn,
+          at: bucket.at,
+          text: s.text,
+          claimScore: s.claimScore,
+          noveltyScore: s.noveltyScore,
+          markers: [...new Set([...s.claimMarkers, ...s.noveltyMarkers])],
+          section:
+            bucket.role === 'user'
+              ? '1 引言'
+              : s.noveltyScore > 0
+                ? '3 核心观点与框架'
+                : '4 论证与证据',
+          kind: 'sentence',
+          status: 'candidate',
+        });
+      }
+    }
+  }
+  return claims;
+}
+
+export function renderClaimsMarkdown(claims, conversation) {
+  const out = ['# 候选观点清单', ''];
+  out.push(`来源：${conversation.meta.title || '(未命名会话)'}｜候选 ${claims.length} 条`, '');
+  out.push('> 这些是脚本按线索词捞出的候选句。写论文前请逐条判定：保留 / 合并 / 删除，把结论写回 claims.json 的 status 字段。');
+  out.push('');
+  const bySection = new Map();
+  for (const c of claims) {
+    if (!bySection.has(c.section)) bySection.set(c.section, []);
+    bySection.get(c.section).push(c);
+  }
+  for (const [section, list] of bySection) {
+    out.push(`## ${section}`, '');
+    for (const c of list) {
+      out.push(`- **${c.id}**（第${c.turn}轮·${c.role === 'user' ? '用户' : 'AI'}，线索：${c.markers.join('/') || '—'}）`);
+      out.push(`  ${c.text}`);
+    }
+    out.push('');
+  }
+  return out.join('\n');
+}