dsh-thesis 1.0.0

package/lib/paper/lib/review.js

@@ -0,0 +1,194 @@
+/**
+ * 章节确定性评审（thesis_review 的核心）。
+ *
+ * 六个可执行检查，全部基于真实文件内容，不做任何"感觉式"判断：
+ * 1. 字数：正文 CJK 字符数 vs 该章目标区间
+ * 2. 大纲：模板要求的全部小节标题是否齐全
+ * 3. 引用：文中引用编号是否都能对应 refs.bib 中的条目（顺序编码制）
+ * 4. 图表：图/表编号章号正确、序号从 1 连续
+ * 5. 未完成标记：待补/TODO/尖括号占位等残留
+ * 6. G2 清单：章节模板内嵌验收清单的勾选状态
+ *
+ * 语义质量（论证是否充分、逻辑是否连贯）由 AI 依据 thesis-writing 技能评审，
+ * 本工具只负责"可被机器证明"的部分——报告与清单一起构成 G2 验收依据。
+ */
+import { parseBibKeys } from "./bibtex.js";
+// ---------------------------------------------------------------------------
+// 各检查项
+// ---------------------------------------------------------------------------
+function cjkCount(text) {
+    return (text.match(/[\u4e00-\u9fff]/g) ?? []).length;
+}
+function parseWordRange(meta) {
+    const m = /(\d+)\s*[-–]\s*(\d+)/.exec(meta.words);
+    if (m === null)
+        return undefined;
+    return { min: Number(m[1]), max: Number(m[2]) };
+}
+function checkWordCount(text, meta) {
+    const range = parseWordRange(meta);
+    if (range === undefined)
+        return { check: '字数', ok: true, detail: `目标区间未定义（${meta.words}）` };
+    const count = cjkCount(text);
+    if (count < range.min) {
+        return { check: '字数', ok: false, detail: `${count} 字，低于目标 ${meta.words}（差 ${range.min - count} 字）` };
+    }
+    if (count > range.max) {
+        return { check: '字数', ok: false, detail: `${count} 字，超过目标 ${meta.words}（超 ${count - range.max} 字）` };
+    }
+    return { check: '字数', ok: true, detail: `${count} 字，符合目标 ${meta.words}` };
+}
+/** 从标题行提取小节编号（如 "## 1.1 研究背景" → "1.1"）。 */
+function headingNumbers(text) {
+    const numbers = new Set();
+    for (const line of text.split('\n')) {
+        const m = /^#{1,6}\s+(\d+(?:\.\d+)*)\s/.exec(line);
+        if (m?.[1] !== undefined)
+            numbers.add(m[1]);
+    }
+    return numbers;
+}
+function checkOutline(text, meta) {
+    const found = headingNumbers(text);
+    const missing = [];
+    for (const item of meta.outline) {
+        const m = /^(\d+(?:\.\d+)*)\s/.exec(item);
+        const number = m?.[1];
+        if (number !== undefined && !found.has(number))
+            missing.push(item);
+    }
+    if (missing.length === 0) {
+        return { check: '大纲', ok: true, detail: `${meta.outline.length} 个小节全部齐全` };
+    }
+    return { check: '大纲', ok: false, detail: `缺少小节：${missing.join('、')}` };
+}
+/** 解析正文引用标注 [1]、[2-4]、[1,3,5]，返回所有引用编号。 */
+function citedNumbers(text) {
+    const numbers = new Set();
+    for (const m of text.matchAll(/\[(\d+(?:[-,，]\d+)*)\]/g)) {
+        const token = m[1];
+        for (const part of token.split(/[,，]/)) {
+            const range = /^(\d+)-(\d+)$/.exec(part);
+            if (range !== null) {
+                const from = Number(range[1]);
+                const to = Number(range[2]);
+                for (let n = Math.min(from, to); n <= Math.max(from, to); n += 1)
+                    numbers.add(n);
+            }
+            else if (/^\d+$/.test(part)) {
+                numbers.add(Number(part));
+            }
+        }
+    }
+    return [...numbers].sort((a, b) => a - b);
+}
+function checkCitations(text, bibText, chapterNo) {
+    const cited = citedNumbers(text);
+    const bibCount = parseBibKeys(bibText).size;
+    if (cited.length === 0) {
+        // 绪论（1）与相关技术（2）必须引用；其余章允许无引用。
+        if (chapterNo === 1 || chapterNo === 2) {
+            return { check: '引用', ok: false, detail: `正文无任何引用标注。绪论与相关技术章必须引用文献（当前 refs.bib 共 ${bibCount} 条）` };
+        }
+        return { check: '引用', ok: true, detail: `本章无引用（第 ${chapterNo} 章允许；绪论与相关技术章才强制要求）` };
+    }
+    const max = cited[cited.length - 1];
+    if (max > bibCount) {
+        return { check: '引用', ok: false, detail: `引用编号 [${max}] 超出文献库（refs.bib 共 ${bibCount} 条）` };
+    }
+    return { check: '引用', ok: true, detail: `引用编号 ${cited.join('、')} 共 ${cited.length} 个，均在 refs.bib（${bibCount} 条）范围内` };
+}
+/** 图/表编号：第 n 章的编号必须是 n-k，k 从 1 连续，且不得出现其它章编号。 */
+export function checkNumberedObjects(text, chapterNo, kind) {
+    const pattern = kind === '图' ? /图\s*(\d+)[-–](\d+)/g : /表\s*(\d+)[-–](\d+)/g;
+    const numbers = new Set();
+    const wrongChapter = new Set();
+    for (const m of text.matchAll(pattern)) {
+        const chapter = Number(m[1]);
+        if (chapter === chapterNo) {
+            numbers.add(Number(m[2]));
+        }
+        else {
+            wrongChapter.add(`${kind} ${m[1]}-${m[2]}`);
+        }
+    }
+    const problems = [];
+    const list = [...numbers].sort((a, b) => a - b);
+    if (list.length === 0 && wrongChapter.size === 0) {
+        return { check: `${kind}编号`, ok: true, detail: `本章无${kind}（如后续添加，编号须为 ${kind} ${chapterNo}-1 起连续）` };
+    }
+    if (list.length > 0) {
+        const max = list[list.length - 1];
+        for (let n = 1; n <= max; n += 1) {
+            if (!numbers.has(n)) {
+                problems.push(`编号不连续：有 ${kind} ${chapterNo}-${max} 但缺 ${kind} ${chapterNo}-${n}`);
+                break;
+            }
+        }
+    }
+    if (wrongChapter.size > 0) {
+        problems.push(`出现其它章的编号：${[...wrongChapter].join('、')}（本章为第 ${chapterNo} 章）`);
+    }
+    if (problems.length > 0)
+        return { check: `${kind}编号`, ok: false, detail: problems.join('；') };
+    return { check: `${kind}编号`, ok: true, detail: `${list.map(n => `${kind} ${chapterNo}-${n}`).join('、')} 连续且章号正确` };
+}
+const PLACEHOLDER_RE = /（待补）|待补充|待写|TODO|TBD|FIXME|XXX|此处省略|<[^>]{2,}>|［待[^］]*］/g;
+function checkPlaceholders(text) {
+    const hits = [];
+    for (const m of text.matchAll(PLACEHOLDER_RE))
+        hits.push(m[0]);
+    if (hits.length === 0)
+        return { check: '未完成标记', ok: true, detail: '无待补/TODO 等残留' };
+    const samples = [...new Set(hits)].slice(0, 5).join('、');
+    return { check: '未完成标记', ok: false, detail: `${hits.length} 处残留：${samples}${hits.length > 5 ? ' 等' : ''}。完稿前必须清理` };
+}
+function checkG2Checklist(text, meta) {
+    const section = /##\s*本章 G2 验收清单([\s\S]*?)(?=\n## |\n# |$)/.exec(text);
+    const body = section?.[1] ?? '';
+    const unchecked = (body.match(/^\s*- \[ \]/gm) ?? []).length;
+    const checked = (body.match(/^\s*- \[x\]/gm) ?? []).length;
+    const total = meta.checklist.length;
+    if (body.trim() === '') {
+        return { check: 'G2 清单', ok: false, detail: `章节缺少"本章 G2 验收清单"一节（模板要求 ${total} 项）` };
+    }
+    if (unchecked > 0) {
+        return { check: 'G2 清单', ok: false, detail: `${unchecked}/${total} 项未勾选（已勾选 ${checked} 项）。逐项完成后勾选，再进入用户人工验收` };
+    }
+    return { check: 'G2 清单', ok: true, detail: `${total} 项全部勾选` };
+}
+export function reviewChapter(input) {
+    const findings = [
+        checkWordCount(input.chapterText, input.meta),
+        checkOutline(input.chapterText, input.meta),
+        checkCitations(input.chapterText, input.bibText, input.chapterNo),
+        checkNumberedObjects(input.chapterText, input.chapterNo, '图'),
+        checkNumberedObjects(input.chapterText, input.chapterNo, '表'),
+        checkPlaceholders(input.chapterText),
+        checkG2Checklist(input.chapterText, input.meta),
+    ];
+    return {
+        chapter: input.meta.file,
+        chapterNo: input.chapterNo,
+        title: input.meta.title,
+        findings,
+        allOk: findings.every(f => f.ok),
+    };
+}
+export function renderReviewReport(report) {
+    const lines = [];
+    lines.push(`# 章节评审报告：${report.chapter}（第 ${report.chapterNo} 章 ${report.title}）`);
+    lines.push('');
+    for (const f of report.findings) {
+        lines.push(`- ${f.ok ? '✓' : '✗'} ${f.check}：${f.detail}`);
+    }
+    const failed = report.findings.filter(f => !f.ok).length;
+    lines.push('');
+    if (failed === 0) {
+        lines.push('结论：全部确定性检查通过。接下来由 AI 依据 thesis-writing 技能做语义评审（论证/逻辑/去 AI 味），然后进入 G2 人工验收。');
+    }
+    else {
+        lines.push(`结论：${failed} 项检查未通过，先处理上述问题再复评（thesis_review 复跑）。处理完毕后进入 G2 人工验收：用户阅读→修改→签字，然后用 thesis_progress gate G2 pass。`);
+    }
+    return lines.join('\n');
+}

package/lib/paper/lib/zip.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 零依赖 ZIP 写入器（仅 STORE 无压缩），用于产出 .docx。
+ *
+ * .docx 是 ZIP 容器；Word/WPS 对 STORE（method 0）条目完全兼容。
+ * 条目名使用 UTF-8（general purpose flag bit 11），CRC32 自实现。
+ */
+export interface ZipEntry {
+    readonly name: string;
+    readonly data: Uint8Array;
+}
+export declare function crc32(data: Uint8Array): number;
+export declare function buildZip(entries: readonly ZipEntry[]): Uint8Array;
+/** 测试辅助：在 zip 字节里搜索给定条目名是否存在（字节级验证）。 */
+export declare function zipContainsName(zip: Uint8Array, name: string): boolean;

package/lib/paper/lib/zip.js

@@ -0,0 +1,124 @@
+/**
+ * 零依赖 ZIP 写入器（仅 STORE 无压缩），用于产出 .docx。
+ *
+ * .docx 是 ZIP 容器；Word/WPS 对 STORE（method 0）条目完全兼容。
+ * 条目名使用 UTF-8（general purpose flag bit 11），CRC32 自实现。
+ */
+// ---------------------------------------------------------------------------
+// CRC32（IEEE 802.3，多项式 0xEDB88320，表驱动）
+// ---------------------------------------------------------------------------
+const CRC_TABLE = (() => {
+    const table = new Uint32Array(256);
+    for (let n = 0; n < 256; n += 1) {
+        let c = n;
+        for (let k = 0; k < 8; k += 1) {
+            c = (c & 1) !== 0 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        }
+        table[n] = c >>> 0;
+    }
+    return table;
+})();
+export function crc32(data) {
+    let c = 0xffffffff;
+    for (const byte of data) {
+        c = CRC_TABLE[(c ^ byte) & 0xff] ^ (c >>> 8);
+    }
+    return (c ^ 0xffffffff) >>> 0;
+}
+// ---------------------------------------------------------------------------
+// 组装
+// ---------------------------------------------------------------------------
+const encoder = new TextEncoder();
+function u16le(value) {
+    const out = new Uint8Array(2);
+    out[0] = value & 0xff;
+    out[1] = (value >>> 8) & 0xff;
+    return out;
+}
+function u32le(value) {
+    const out = new Uint8Array(4);
+    out[0] = value & 0xff;
+    out[1] = (value >>> 8) & 0xff;
+    out[2] = (value >>> 16) & 0xff;
+    out[3] = (value >>> 24) & 0xff;
+    return out;
+}
+function concat(parts) {
+    const total = parts.reduce((sum, p) => sum + p.length, 0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const part of parts) {
+        out.set(part, offset);
+        offset += part.length;
+    }
+    return out;
+}
+export function buildZip(entries) {
+    const localParts = [];
+    const centralParts = [];
+    let offset = 0;
+    for (const entry of entries) {
+        const nameBytes = encoder.encode(entry.name);
+        const crc = crc32(entry.data);
+        const size = entry.data.length;
+        // 本地文件头
+        const local = concat([
+            u32le(0x04034b50),
+            u16le(20), // version needed
+            u16le(0x0800), // flags: UTF-8 名称
+            u16le(0), // method: STORE
+            u16le(0), u16le(0), // 时间/日期（0 合法）
+            u32le(crc),
+            u32le(size),
+            u32le(size),
+            u16le(nameBytes.length),
+            u16le(0), // extra 长度
+            nameBytes,
+            entry.data,
+        ]);
+        localParts.push(local);
+        // 中央目录项
+        const central = concat([
+            u32le(0x02014b50),
+            u16le(20), u16le(20), // 版本
+            u16le(0x0800),
+            u16le(0),
+            u16le(0), u16le(0),
+            u32le(crc),
+            u32le(size),
+            u32le(size),
+            u16le(nameBytes.length),
+            u16le(0), u16le(0), u16le(0), // extra/comment/disk/attrs
+            u16le(0), // internal attrs
+            u32le(0), // external attrs
+            u32le(offset),
+            nameBytes,
+        ]);
+        centralParts.push(central);
+        offset += local.length;
+    }
+    const centralDir = concat(centralParts);
+    const centralSize = centralDir.length;
+    const count = entries.length;
+    const eocd = concat([
+        u32le(0x06054b50),
+        u16le(0), u16le(0), // 磁盘号
+        u16le(count), u16le(count),
+        u32le(centralSize),
+        u32le(offset),
+        u16le(0), // comment 长度
+    ]);
+    return concat([...localParts, centralDir, eocd]);
+}
+/** 测试辅助：在 zip 字节里搜索给定条目名是否存在（字节级验证）。 */
+export function zipContainsName(zip, name) {
+    const needle = encoder.encode(name);
+    outer: for (let i = 0; i + needle.length <= zip.length; i += 1) {
+        for (let j = 0; j < needle.length; j += 1) {
+            if (zip[i + j] !== needle[j])
+                continue outer;
+        }
+        return true;
+    }
+    return false;
+}

package/lib/paper/register.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 论文工作区的工具与命令装配：台账、关卡、文献、评审、检查、构建、答辩素材。
+ *
+ * 纯业务逻辑在 `paper/tools/*.ts` 与 `paper/lib/*.ts`（零 cordis 依赖、可独立
+ * 测试）；本文件只做 `defineTool` / 命令注册的胶水。
+ *
+ * @module dsh-thesis/paper
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** 论文流水线装配所需的宿主侧输入。 */
+export interface PaperOptions {
+    /** 随包发布的技能目录绝对路径（`thesis_init` 复制到论文仓库 `.dsh/skills/`）。 */
+    readonly skillsDir: string;
+}
+/**
+ * 注册 11 个论文工具 + 5 个斜杠命令。
+ *
+ * 命令名只允许 `[a-z][a-z0-9_-]*`，故统一 `thesis-` 前缀。
+ */
+export declare function registerPaper(ctx: Context, options: PaperOptions): void;

package/lib/paper/register.js

@@ -0,0 +1,183 @@
+/**
+ * 论文工作区的工具与命令装配：台账、关卡、文献、评审、检查、构建、答辩素材。
+ *
+ * 纯业务逻辑在 `paper/tools/*.ts` 与 `paper/lib/*.ts`（零 cordis 依赖、可独立
+ * 测试）；本文件只做 `defineTool` / 命令注册的胶水。
+ *
+ * @module dsh-thesis/paper
+ */
+import { definePaperTool, sessionCwd, textOutput, writeBinary } from "../shared/index.js";
+import { buildCommand, checkCommand, decideCommand, litCommand, statusCommand } from "./commands.js";
+import { initSummary, runInit } from "./tools/init.js";
+import { runProgress } from "./tools/progress.js";
+import { runDecision } from "./tools/decision.js";
+import { runLitNote, runLitSave, runLitSearch } from "./tools/lit.js";
+import { runReview } from "./tools/review.js";
+import { buildSummary, runBuild } from "./tools/build.js";
+import { runCheck } from "./tools/check.js";
+import { runAiSelfcheckTool } from "./tools/aicheck.js";
+import { runDefensePrep } from "./tools/defense.js";
+import { LIT_SOURCES } from "./lib/lit-api.js";
+/**
+ * 注册 11 个论文工具 + 5 个斜杠命令。
+ *
+ * 命令名只允许 `[a-z][a-z0-9_-]*`，故统一 `thesis-` 前缀。
+ */
+export function registerPaper(ctx, options) {
+    ctx.tools.register(definePaperTool({
+        name: 'thesis_init',
+        description: '在指定绝对路径创建论文工作区：目录结构、进度台账、决定日志、时间线、七章论文模板、文献库骨架，并把 dsh-thesis 技能包写入 .dsh/skills/（项目级技能，随 git 版本化）。可选 git 初始化并首次提交。目标目录须为空或不存在；绝不覆盖已有文件。',
+        parameters: {
+            root: { type: 'string', required: true, description: '工作区根目录的绝对路径（空目录或不存在）' },
+            title: { type: 'string', description: '论文/课题标题，缺省为"本科毕业设计"（之后可改）' },
+            git: { type: 'boolean', description: '是否 git 初始化并首次提交，默认 true' },
+            force: { type: 'boolean', description: '目标目录非空时仍尝试写入，默认 false（安全第一）' },
+        },
+        output: textOutput(),
+        async execute(rawArgs, exec) {
+            const outcome = await runInit(ctx.fs, rawArgs, options.skillsDir, exec.signal);
+            return initSummary(outcome);
+        },
+    }));
+    ctx.tools.register(definePaperTool({
+        name: 'thesis_progress',
+        description: '读写论文进度台账（00-管理/进度台账.md）并强制执行人工关卡闸门：' +
+            'report 查看当前阶段/关卡/任务状态；update 推进任务状态（todo/doing/done，受阶段入口关卡约束）；' +
+            'gate 通过或重置人工关卡 G1（选题拍板）/G2（逐章验收，需 chapter）/G3（开题审阅）/G4（提交前自查），' +
+            '通过关卡前其关联任务必须先完成。',
+        parameters: {
+            action: { type: 'string', required: true, description: 'report | update | gate' },
+            task_id: { type: 'string', description: 'update 时必填：任务 ID（如 T1.1）' },
+            status: { type: 'string', description: 'update 时必填：todo | doing | done' },
+            note: { type: 'string', description: '可选备注（update 与 gate 均可用）' },
+            gate: { type: 'string', description: 'gate 时必填：G1 | G2 | G3 | G4' },
+            pass: { type: 'boolean', description: 'gate 时必填：true 通过，false 重置' },
+            chapter: { type: 'string', description: 'gate=G2 时必填：章节文件名，如 01-绪论' },
+        },
+        output: textOutput(),
+        async execute(rawArgs, exec) {
+            return await runProgress(ctx.fs, rawArgs, sessionCwd(exec), exec.signal);
+        },
+    }));
+    ctx.tools.register(definePaperTool({
+        name: 'thesis_decide',
+        description: '向决定日志（00-管理/决定日志.md）追加一条关键决定：内容、理由、备选方案。' +
+            '用于选题、技术选型、方案变更等所有「答辩时会被问到为什么」的决策，全程留痕。',
+        parameters: {
+            content: { type: 'string', required: true, description: '决定的实际内容' },
+            title: { type: 'string', description: '决定标题，缺省取 content 首行前 24 字' },
+            reason: { type: 'string', description: '做这个决定的理由（可选，强烈建议填写）' },
+            alternatives: { type: 'string', description: '考虑过的备选方案及弃用原因（可选，强烈建议填写）' },
+        },
+        output: textOutput(),
+        async execute(rawArgs, exec) {
+            return await runDecision(ctx.fs, rawArgs, sessionCwd(exec), exec.signal);
+        },
+    }));
+    ctx.tools.register(definePaperTool({
+        name: 'thesis_lit_search',
+        description: '从真实学术数据库检索文献（Semantic Scholar→DBLP→arXiv→Crossref 失败降级；source 可指定单一来源）。' +
+            '结果写入论文工作区的检索缓存与检索记录（审计留痕）。论文引用只能来自本工具的真实检索结果——这是零假文献红线。',
+        parameters: {
+            query: { type: 'string', required: true, description: '检索关键词（中英文均可，如 "attention is all you need"）' },
+            year_from: { type: 'number', description: '年份下限，如 2020' },
+            limit: { type: 'number', description: '返回条数上限，默认 10，最大 20' },
+            source: { type: 'string', description: `指定单一来源：${LIT_SOURCES.join(' | ')}；缺省 auto（降级链）` },
+        },
+        output: textOutput(),
+        async execute(rawArgs, exec) {
+            return await runLitSearch(ctx.fs, rawArgs, sessionCwd(exec), exec.signal, fetch);
+        },
+    }));
+    ctx.tools.register(definePaperTool({
+        name: 'thesis_lit_save',
+        description: '把 thesis_lit_search 检索到的文献（按缓存 id）收录进 02-文献/refs.bib，并写检索审计记录。' +
+            '只接受真实检索缓存中的 id；DOI 已在库中则自动跳过；bib key 冲突自动加后缀。',
+        parameters: {
+            ids: { type: 'array', items: { type: 'string' }, required: true, description: 'thesis_lit_search 返回的记录 id 列表' },
+        },
+        output: textOutput(),
+        async execute(rawArgs, exec) {
+            return await runLitSave(ctx.fs, rawArgs, sessionCwd(exec), exec.signal);
+        },
+    }));
+    ctx.tools.register(definePaperTool({
+        name: 'thesis_lit_note',
+        description: '为已检索/已收录的文献生成阅读笔记骨架（02-文献/笔记/<key>.md）：元数据、原始摘要、' +
+            '"这篇解决什么问题/方法要点/实验结论/与我课题的关系/可用引用句"五节模板。已有笔记不覆盖（force 除外）。',
+        parameters: {
+            ref: { type: 'string', required: true, description: '缓存记录 id 或 refs.bib 条目 key' },
+            force: { type: 'boolean', description: '笔记已存在时强制覆盖，默认 false' },
+        },
+        output: textOutput(),
+        async execute(rawArgs, exec) {
+            return await runLitNote(ctx.fs, rawArgs, sessionCwd(exec), exec.signal);
+        },
+    }));
+    ctx.tools.register(definePaperTool({
+        name: 'thesis_review',
+        description: '对论文单章做确定性评审（六项可机器验证的检查）：字数是否在目标区间、大纲小节是否齐全、' +
+            '引用编号是否都能对应 refs.bib 条目、图/表编号章号与连续性、待补/TODO 等未完成标记、' +
+            '章内 G2 验收清单勾选状态。语义质量（论证/逻辑）由 AI 依据 thesis-writing 技能另评；' +
+            '全部通过后进入 G2 人工验收（用户阅读→修改→签字，再 thesis_progress gate G2 pass）。',
+        parameters: {
+            chapter: { type: 'string', required: true, description: '章节文件名，如 01-绪论（可带 .md）' },
+        },
+        output: textOutput(),
+        async execute(rawArgs, exec) {
+            return await runReview(ctx.fs, rawArgs, sessionCwd(exec), exec.signal);
+        },
+    }));
+    ctx.tools.register(definePaperTool({
+        name: 'thesis_check',
+        description: '全文综合检查（五项）：引用双向一致（正文引用 ↔ refs.bib、编号连续、躺尸文献）、每章字数 vs 目标区间与全文合计、' +
+            '图/表编号章号与连续性、术语缩写定义先于使用、学校模板文件探测。报告写入 08-合规/引用检查报告/ 与 08-合规/格式检查报告/。',
+        parameters: {},
+        output: textOutput(),
+        async execute(_rawArgs, exec) {
+            return await runCheck(ctx.fs, sessionCwd(exec), exec.signal);
+        },
+    }));
+    ctx.tools.register(definePaperTool({
+        name: 'thesis_build',
+        description: '把已撰写章节（06-论文/章节/*.md）构建为论文.docx（可附 pdf）：优先 pandoc + 学校模板（06-论文/assets/学校模板/），' +
+            '无 pandoc 时用内置过渡引擎并显式标注。构建说明写入 06-论文/产出/构建说明.md。',
+        parameters: {
+            format: { type: 'string', description: 'docx（默认）| pdf | both' },
+            engine: { type: 'string', description: 'auto（默认，有 pandoc 用之）| pandoc | internal' },
+        },
+        output: textOutput(),
+        async execute(rawArgs, exec) {
+            const args = rawArgs;
+            const outcome = await runBuild(ctx.fs, args, sessionCwd(exec), exec.signal, writeBinary);
+            return buildSummary(outcome);
+        },
+    }));
+    ctx.tools.register(definePaperTool({
+        name: 'thesis_stylecheck',
+        description: '对已撰写章节做写作风格自查（六条确定性启发式）：模板套话、空洞结论句、自我暴露（错误级）、翻译腔、' +
+            '句式单一（连续同开头段落）、无锚点长段落。命中项附行号与改写建议；报告写入 08-合规/AI味自查报告.md。'
+            + '这是自查不是检测结论，最终以学校检测结果为准。',
+        parameters: {},
+        output: textOutput(),
+        async execute(_rawArgs, exec) {
+            return await runAiSelfcheckTool(ctx.fs, sessionCwd(exec), exec.signal);
+        },
+    }));
+    ctx.tools.register(definePaperTool({
+        name: 'thesis_defense',
+        description: '答辩准备：从工作区提取答辩素材（课题/各章概览/技术选型/关键决定/测试数据/git 工作量/文献数）写入 07-答辩/答辩素材.md，' +
+            '并生成六类必问预答辩问题库骨架（实现细节/技术选型/需求背景/工作量/数据可信/不足展望，附证据锚点）写入 07-答辩/预答辩问题库.md。' +
+            '具体问题由 AI 依据素材生成，模拟问答由用户完成（技能 thesis-defense）；「你的系统怎么实现的」这类问题用 defense_code_* 演练。',
+        parameters: {},
+        output: textOutput(),
+        async execute(_rawArgs, exec) {
+            return await runDefensePrep(ctx.fs, sessionCwd(exec), exec.signal);
+        },
+    }));
+    ctx.commands.register(statusCommand(ctx.fs));
+    ctx.commands.register(decideCommand(ctx.fs));
+    ctx.commands.register(litCommand(ctx.fs));
+    ctx.commands.register(checkCommand(ctx.fs));
+    ctx.commands.register(buildCommand(ctx.fs));
+}

package/lib/paper/tools/aicheck.d.ts

@@ -0,0 +1,6 @@
+/**
+ * thesis_stylecheck：AI 味自查（六条启发式规则），
+ * 报告写入 08-合规/AI味自查报告.md（稳定文件名，每次重跑覆盖）。
+ */
+import type { FileSystem } from '@deepseek-ai/dsh-fs';
+export declare function runAiSelfcheckTool(fs: FileSystem, cwd: string | undefined, signal?: AbortSignal): Promise<string>;

package/lib/paper/tools/aicheck.js

@@ -0,0 +1,38 @@
+/**
+ * thesis_stylecheck：AI 味自查（六条启发式规则），
+ * 报告写入 08-合规/AI味自查报告.md（稳定文件名，每次重跑覆盖）。
+ */
+import * as nodePath from 'node:path';
+import { renderAiSelfcheck, runAiSelfcheck } from "../lib/aicheck.js";
+import { CHAPTER_META, isWrittenChapter } from "../lib/layout.js";
+import { findThesisRoot } from "../lib/project.js";
+export async function runAiSelfcheckTool(fs, cwd, signal) {
+    const root = await findThesisRoot(fs, cwd, signal);
+    if (root === null)
+        throw new Error('未找到论文工作区。请先在论文仓库目录内操作。');
+    const chapters = [];
+    const missing = [];
+    for (const [index, meta] of CHAPTER_META.entries()) {
+        let text;
+        try {
+            text = await fs.readText(await fs.resolve(nodePath.join(root, '06-论文/章节', `${meta.file}.md`), { signal }), signal);
+        }
+        catch {
+            text = undefined;
+        }
+        if (text === undefined || !isWrittenChapter(text, index + 1, meta)) {
+            missing.push(meta.file);
+            continue;
+        }
+        chapters.push({ name: meta.file, text });
+    }
+    const report = runAiSelfcheck(chapters);
+    const rendered = renderAiSelfcheck(report);
+    await fs.writeText(await fs.resolve(nodePath.join(root, '08-合规/AI味自查报告.md'), { signal }), rendered, undefined, signal);
+    return [
+        ...(missing.length > 0 ? [`⚠ 未撰写章节：${missing.join('、')}（不计入自查）。`, ''] : []),
+        rendered,
+        '',
+        '报告已写入：08-合规/AI味自查报告.md',
+    ].join('\n');
+}

package/lib/paper/tools/build.d.ts

@@ -0,0 +1,27 @@
+/**
+ * thesis_build：产出论文 docx（+ 可选 pdf）。
+ *
+ * 引擎选择：
+ * - pandoc 存在时优先（--reference-doc 使用学校模板）；
+ * - 无 pandoc 时使用内置零依赖转换器（lib/docx.ts），并在构建说明中
+ *   显式标注"内置过渡引擎，非学校模板排版"。
+ *
+ * 二进制例外（文档化）：ctx.fs 无二进制写入能力，docx/pdf 字节由本工具
+ * 通过 node:fs 直接写入论文仓库 06-论文/产出/ 目录。文本工作全部走 ctx.fs。
+ */
+import type { FileSystem } from '@deepseek-ai/dsh-fs';
+export interface BuildArgs {
+    format?: 'docx' | 'pdf' | 'both';
+    engine?: 'auto' | 'pandoc' | 'internal';
+}
+export type WriteBinary = (absPath: string, data: Uint8Array) => Promise<void>;
+export interface BuildOutcome {
+    readonly docxPath: string;
+    readonly pdfPath?: string;
+    readonly engine: 'pandoc' | 'internal';
+    readonly template: string | undefined;
+    readonly chapters: readonly string[];
+    readonly missing: readonly string[];
+}
+export declare function runBuild(fs: FileSystem, args: BuildArgs, cwd: string | undefined, signal: AbortSignal | undefined, writeBinary: WriteBinary): Promise<BuildOutcome>;
+export declare function buildSummary(outcome: BuildOutcome): string;