dsh-thesis 1.0.0

package/lib/dedup/similarity.d.ts

@@ -0,0 +1,169 @@
+/**
+ * 降重的核心度量：字符 n-gram 指纹（shingle）、倒排索引候选剪枝、
+ * 包含率/杰卡德/最长公共子串（含起止偏移）。全部为纯函数、无随机。
+ *
+ * 口径说明（必须如实写进报告）：
+ * - 指纹：归一化后按**字符**滑动窗口取 n 元组（`n = options.shingle`，
+ *   中文 4 字、拉丁按 4 字符近似词），相同的 shingle 用稳定哈希比较。
+ * - `containment`：本段 shingle 出现在对方中的比例 —— 回答"这段有多少是抄来的"；
+ *   `jaccard`：双方 shingle 的交集/并集 —— 对长文档更保守。
+ * - 命中定位：最长公共子串（归一化字符坐标），并回溯到原文偏移。
+ * - 本模块**不是**知网/维普类系统：它只在给定语料内做字符串重合度估算，
+ *   不能给出学校检测系统的重复率，也不接入任何收费库。
+ *
+ * @module dsh-thesis/dedup
+ */
+import type { NormalizedText, Segment } from './normalize.ts';
+/** 带指纹的归一化文本（`chars` 是归一化字符数，索引用 `starts` 定位）。 */
+export interface FingerprintedText {
+    readonly text: string;
+    readonly chars: number;
+    /** shingle 哈希集合。 */
+    readonly shingles: ReadonlySet<number>;
+    /** 第 i 个 shingle 在归一化字符坐标中的起点。 */
+    readonly starts: readonly number[];
+}
+export interface ScoreOptions {
+    /** shingle 窗口（字符数）。 */
+    readonly shingle: number;
+    /** 命中片段的最短长度（归一化字符数），缺省 `2 × shingle`。 */
+    readonly minRun?: number;
+    /** 最多返回多少条命中片段（按长度降序），缺省 5。 */
+    readonly maxSpans?: number;
+}
+/** 一条命中的连续片段（坐标是归一化字符坐标，`aStart`/`bStart` 对应各自文本）。 */
+export interface MatchSpan {
+    readonly length: number;
+    readonly aStart: number;
+    readonly aEnd: number;
+    readonly bStart: number;
+    readonly bEnd: number;
+}
+export interface CompareResult {
+    /** 综合得分：取 `containment`（本次实现保证 `score === containment`）。 */
+    readonly score: number;
+    readonly containment: number;
+    readonly jaccard: number;
+    /** 最长公共子串长度（归一化字符数）。 */
+    readonly longestRun: number;
+    readonly spans: readonly MatchSpan[];
+}
+/** 语料侧指纹计数（正文字符数口径，与段落长度无关）。 */
+export interface CorpusDoc {
+    readonly id: string;
+    readonly label: string;
+    readonly shingle: FingerprintedText;
+    /** 全局语料文档序号（用于倒排索引）。 */
+    readonly index: number;
+}
+export interface CorpusIndex {
+    readonly docs: readonly CorpusDoc[];
+    /** shingle 哈希 → 语料文档序号列表。 */
+    readonly inverted: ReadonlyMap<number, readonly number[]>;
+}
+export interface CorpusHit {
+    readonly id: string;
+    readonly label: string;
+    readonly score: number;
+    readonly containment: number;
+    readonly jaccard: number;
+    readonly longestRun: number;
+    readonly spans: readonly CorpusSpan[];
+}
+/** 命中片段 + 回溯到原文的片段文本与行号。 */
+export interface CorpusSpan {
+    readonly length: number;
+    /** 本段原文中的片段（自 `segment.text` 切出）。 */
+    readonly text: string;
+    /** 片段在 `segment.text` 中的起止偏移（`[start, end)`）。 */
+    readonly start: number;
+    readonly end: number;
+    readonly lineStart: number;
+    readonly lineEnd: number;
+}
+export interface RiskItem {
+    readonly segment: Segment;
+    readonly best: CorpusHit;
+    /** 该段的全部候选命中（按得分降序，含 best）。 */
+    readonly hits: readonly CorpusHit[];
+}
+export interface ScanOptions extends ScoreOptions {
+    /** 判定高风险的包含率阈值。 */
+    readonly threshold: number;
+}
+export interface ScanResult {
+    readonly items: readonly RiskItem[];
+    /** 参与比对的正文段落数。 */
+    readonly paragraphCount: number;
+    /** 参与比对段落的归一化字符总数（加权重复率的分母）。 */
+    readonly totalChars: number;
+    readonly corpusCount: number;
+    /** 有任一非零命中的段落数。 */
+    readonly matchedCount: number;
+    readonly high: number;
+    readonly medium: number;
+    readonly low: number;
+}
+/**
+ * 稳定 32 位哈希（FNV-1a 变体）。自行实现而不依赖 node:crypto，
+ * 保证"同一输入 → 同一哈希"，跨语言/跨版本可复现。
+ */
+export declare function hashShingle(text: string): number;
+/**
+ * 对**已归一化**的文本取字符 n-gram 指纹。
+ * 文本短于窗口时退化为「整串一个 shingle」，使 `containment` 仍有定义。
+ */
+export declare function fingerprintText(doc: NormalizedText, shingle: number): FingerprintedText;
+/** 段落 → 指纹。 */
+export declare function fingerprintSegment(segment: Segment, shingle: number): FingerprintedText;
+/** 原始文本 → 指纹（内部先归一化，便于直接比较任意字符串）。 */
+export declare function fingerprintOf(text: string, shingle: number): FingerprintedText;
+/** 两个集合的交集大小（迭代较小者）。 */
+export declare function intersectionSize(a: ReadonlySet<number>, b: ReadonlySet<number>): number;
+/** 用语料建立倒排索引：shingle → 语料文档序号列表。 */
+export declare function buildIndex(docs: readonly CorpusDoc[]): CorpusIndex;
+/**
+ * 找出全部足够长的公共片段（按长度降序，去掉被更长片段覆盖的短片段）。
+ * 同长度片段按 (aStart, bStart) 稳定排序，保证可复现。
+ */
+export declare function matchSpans(a: FingerprintedText, b: FingerprintedText, options: {
+    shingle: number;
+    minRun?: number;
+    maxSpans?: number;
+}): MatchSpan[];
+/** 比较两份指纹：包含率、杰卡德、最长公共子串与命中片段。 */
+export declare function compareFingerprints(a: FingerprintedText, b: FingerprintedText, options: {
+    shingle: number;
+    minRun?: number;
+    maxSpans?: number;
+}): CompareResult;
+/**
+ * 比较两段文本。返回 `{ score, containment, jaccard, longestRun, spans }`；
+ * `spans` 的坐标是**归一化字符坐标**，调用方可配合 `offsetsFor` 回到原文。
+ */
+export declare function compareText(a: string, b: string, options: ScoreOptions): CompareResult;
+/** 可选的两两朴素比对（结果必须与倒排索引一致，供等价性测试与排查使用）。 */
+export type CandidateMode = 'index' | 'all';
+export interface ScanInput {
+    readonly segments: readonly Segment[];
+    readonly corpus: readonly {
+        readonly id: string;
+        readonly label: string;
+        readonly text: string;
+    }[];
+    readonly options: ScanOptions;
+    /** 候选策略：index（默认，倒排剪枝）| all（与全语料两两比对）。 */
+    readonly candidateMode?: CandidateMode;
+}
+/**
+ * 扫描正文段落：每段给出最佳命中（来源 id、得分、命中片段偏移与文本）。
+ *
+ * 候选剪枝：先用倒排索引筛出与本段有任何共同 shingle 的语料文档；
+ * 没有任何共同 shingle 的文档，其 `containment` 必然为 0（本段没有被它覆盖），
+ * 因此不会被选为最佳命中 —— 这正是剪枝不改变结果的原因。
+ *
+ * **自比屏蔽**：语料文档 id 与本段 `file` 相同的一律跳过。默认语料含各章正文
+ * （正文互查），若不跳过，段落与它所在的那一章必然 100% 重合——那是"自己跟
+ * 自己比"，不是重复。判断按文件路径做，两种候选策略下行为一致。
+ */
+export declare function scan(input: ScanInput): ScanResult;

package/lib/dedup/similarity.js

@@ -0,0 +1,323 @@
+/**
+ * 降重的核心度量：字符 n-gram 指纹（shingle）、倒排索引候选剪枝、
+ * 包含率/杰卡德/最长公共子串（含起止偏移）。全部为纯函数、无随机。
+ *
+ * 口径说明（必须如实写进报告）：
+ * - 指纹：归一化后按**字符**滑动窗口取 n 元组（`n = options.shingle`，
+ *   中文 4 字、拉丁按 4 字符近似词），相同的 shingle 用稳定哈希比较。
+ * - `containment`：本段 shingle 出现在对方中的比例 —— 回答"这段有多少是抄来的"；
+ *   `jaccard`：双方 shingle 的交集/并集 —— 对长文档更保守。
+ * - 命中定位：最长公共子串（归一化字符坐标），并回溯到原文偏移。
+ * - 本模块**不是**知网/维普类系统：它只在给定语料内做字符串重合度估算，
+ *   不能给出学校检测系统的重复率，也不接入任何收费库。
+ *
+ * @module dsh-thesis/dedup
+ */
+import { normalizeText, offsetsFor, sliceRaw } from "./normalize.js";
+// ---------------------------------------------------------------------------
+// 指纹
+// ---------------------------------------------------------------------------
+/**
+ * 稳定 32 位哈希（FNV-1a 变体）。自行实现而不依赖 node:crypto，
+ * 保证"同一输入 → 同一哈希"，跨语言/跨版本可复现。
+ */
+export function hashShingle(text) {
+    let hash = 0x811C9DC5;
+    for (let i = 0; i < text.length; i += 1) {
+        hash ^= text.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    return hash >>> 0;
+}
+/**
+ * 对**已归一化**的文本取字符 n-gram 指纹。
+ * 文本短于窗口时退化为「整串一个 shingle」，使 `containment` 仍有定义。
+ */
+export function fingerprintText(doc, shingle) {
+    const n = Math.max(1, Math.floor(shingle));
+    const chars = doc.chars.map(c => c.ch);
+    const shingles = new Set();
+    const starts = [];
+    if (chars.length === 0) {
+        return { text: doc.text, chars: 0, shingles, starts };
+    }
+    if (chars.length <= n) {
+        shingles.add(hashShingle(chars.join('')));
+        starts.push(0);
+        return { text: doc.text, chars: chars.length, shingles, starts };
+    }
+    for (let i = 0; i + n <= chars.length; i += 1) {
+        const shingleText = chars.slice(i, i + n).join('');
+        const hash = hashShingle(shingleText);
+        if (!shingles.has(hash)) {
+            shingles.add(hash);
+            starts.push(i);
+        }
+    }
+    return { text: doc.text, chars: chars.length, shingles, starts };
+}
+/** 段落 → 指纹。 */
+export function fingerprintSegment(segment, shingle) {
+    return fingerprintText(segment.doc, shingle);
+}
+/** 原始文本 → 指纹（内部先归一化，便于直接比较任意字符串）。 */
+export function fingerprintOf(text, shingle) {
+    return fingerprintText(normalizeText(text), shingle);
+}
+/** 两个集合的交集大小（迭代较小者）。 */
+export function intersectionSize(a, b) {
+    const [small, large] = a.size <= b.size ? [a, b] : [b, a];
+    let count = 0;
+    for (const value of small) {
+        if (large.has(value))
+            count += 1;
+    }
+    return count;
+}
+// ---------------------------------------------------------------------------
+// 倒排索引
+// ---------------------------------------------------------------------------
+/** 用语料建立倒排索引：shingle → 语料文档序号列表。 */
+export function buildIndex(docs) {
+    const inverted = new Map();
+    for (const doc of docs) {
+        for (const shingle of doc.shingle.shingles) {
+            const list = inverted.get(shingle);
+            if (list === undefined) {
+                inverted.set(shingle, [doc.index]);
+            }
+            else {
+                list.push(doc.index);
+            }
+        }
+    }
+    return { docs, inverted };
+}
+// ---------------------------------------------------------------------------
+// 度量
+// ---------------------------------------------------------------------------
+/**
+ * 从共同 shingle 出发向两侧扩展，求最长的连续公共子串（片段起点是区间起点）。
+ * 复杂度 O(片段长度)，用于把「有重合」细化成「抄了哪一段」。
+ */
+function expand(a, b, i, j) {
+    let aStart = i;
+    let bStart = j;
+    while (aStart > 0 && bStart > 0 && a[aStart - 1] === b[bStart - 1]) {
+        aStart -= 1;
+        bStart -= 1;
+    }
+    let length = 0;
+    let x = aStart;
+    let y = bStart;
+    while (x < a.length && y < b.length && a[x] === b[y]) {
+        x += 1;
+        y += 1;
+        length += 1;
+    }
+    return { length, aStart, bStart };
+}
+/**
+ * 找出全部足够长的公共片段（按长度降序，去掉被更长片段覆盖的短片段）。
+ * 同长度片段按 (aStart, bStart) 稳定排序，保证可复现。
+ */
+export function matchSpans(a, b, options) {
+    const minRun = Math.max(1, Math.floor(options.minRun ?? Math.max(2, options.shingle * 2)));
+    const maxSpans = Math.max(1, Math.floor(options.maxSpans ?? 5));
+    const aChars = a.text;
+    const bChars = b.text;
+    if (aChars.length === 0 || bChars.length === 0)
+        return [];
+    const seen = new Set();
+    const spans = [];
+    const narrow = a.shingles.size <= b.shingles.size ? a : b;
+    for (const start of narrow.starts) {
+        const probe = narrow.text.slice(start, start + Math.max(1, options.shingle));
+        const other = narrow === a ? b : a;
+        let from = 0;
+        for (;;) {
+            const at = other.text.indexOf(probe, from);
+            if (at < 0)
+                break;
+            const aIdx = narrow === a ? start : at;
+            const bIdx = narrow === a ? at : start;
+            const grown = expand(aChars, bChars, aIdx, bIdx);
+            from = at + 1;
+            if (grown.length < minRun)
+                continue;
+            const key = `${grown.aStart}:${grown.bStart}:${grown.length}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            spans.push({
+                length: grown.length,
+                aStart: grown.aStart,
+                aEnd: grown.aStart + grown.length,
+                bStart: grown.bStart,
+                bEnd: grown.bStart + grown.length,
+            });
+        }
+    }
+    spans.sort((x, y) => y.length - x.length || x.aStart - y.aStart || x.bStart - y.bStart);
+    const kept = [];
+    for (const span of spans) {
+        if (kept.length >= maxSpans)
+            break;
+        const covered = kept.some(k => k.aStart <= span.aStart && k.bStart <= span.bStart
+            && k.aStart + k.length >= span.aStart + span.length
+            && k.bStart + k.length >= span.bStart + span.length);
+        if (!covered)
+            kept.push(span);
+    }
+    return kept;
+}
+/** 比较两份指纹：包含率、杰卡德、最长公共子串与命中片段。 */
+export function compareFingerprints(a, b, options) {
+    const intersection = intersectionSize(a.shingles, b.shingles);
+    const containment = a.shingles.size === 0 ? 0 : intersection / a.shingles.size;
+    const union = a.shingles.size + b.shingles.size - intersection;
+    const jaccard = union === 0 ? 0 : intersection / union;
+    const spans = matchSpans(a, b, options);
+    const longestRun = spans.length > 0 ? spans[0].length : 0;
+    return { score: containment, containment, jaccard, longestRun, spans };
+}
+/**
+ * 比较两段文本。返回 `{ score, containment, jaccard, longestRun, spans }`；
+ * `spans` 的坐标是**归一化字符坐标**，调用方可配合 `offsetsFor` 回到原文。
+ */
+export function compareText(a, b, options) {
+    const fa = fingerprintOf(a, options.shingle);
+    const fb = fingerprintOf(b, options.shingle);
+    const scoreOptions = { shingle: options.shingle };
+    if (options.minRun !== undefined)
+        scoreOptions.minRun = options.minRun;
+    if (options.maxSpans !== undefined)
+        scoreOptions.maxSpans = options.maxSpans;
+    return compareFingerprints(fa, fb, scoreOptions);
+}
+function documentFor(text, shingle) {
+    return fingerprintOf(text, shingle);
+}
+function spansFor(segment, result) {
+    const spans = [];
+    for (const span of result.spans) {
+        const mapped = offsetsFor(segment.doc, span.aStart, span.aEnd);
+        if (mapped === null)
+            continue;
+        const text = sliceRaw(segment.text, mapped.start, mapped.end);
+        spans.push({
+            length: span.length,
+            text,
+            start: mapped.start,
+            end: mapped.end,
+            lineStart: lineAtSafe(segment, mapped.start),
+            lineEnd: lineAtSafe(segment, mapped.end),
+        });
+    }
+    return spans;
+}
+function lineAtSafe(segment, offset) {
+    const clamped = Math.max(0, Math.min(segment.text.length, offset));
+    let line = segment.lineStart;
+    for (let i = 0; i < clamped; i += 1) {
+        if (segment.text[i] === '\n')
+            line += 1;
+    }
+    return line;
+}
+/**
+ * 扫描正文段落：每段给出最佳命中（来源 id、得分、命中片段偏移与文本）。
+ *
+ * 候选剪枝：先用倒排索引筛出与本段有任何共同 shingle 的语料文档；
+ * 没有任何共同 shingle 的文档，其 `containment` 必然为 0（本段没有被它覆盖），
+ * 因此不会被选为最佳命中 —— 这正是剪枝不改变结果的原因。
+ *
+ * **自比屏蔽**：语料文档 id 与本段 `file` 相同的一律跳过。默认语料含各章正文
+ * （正文互查），若不跳过，段落与它所在的那一章必然 100% 重合——那是"自己跟
+ * 自己比"，不是重复。判断按文件路径做，两种候选策略下行为一致。
+ */
+export function scan(input) {
+    const options = input.options;
+    const corpusDocs = input.corpus.map((entry, index) => ({
+        id: entry.id,
+        label: entry.label,
+        shingle: documentFor(entry.text, options.shingle),
+        index,
+    }));
+    const corpusIndex = buildIndex(corpusDocs);
+    const items = [];
+    let high = 0;
+    let medium = 0;
+    let low = 0;
+    let matched = 0;
+    let totalChars = 0;
+    for (const segment of input.segments) {
+        totalChars += segment.doc.chars.length;
+        const target = fingerprintSegment(segment, options.shingle);
+        const candidates = candidateIds(target, corpusIndex, input.candidateMode ?? 'index');
+        const selfId = segment.file.replace(/\\/g, '/');
+        const hits = [];
+        for (const candidate of candidates) {
+            const doc = corpusDocs[candidate];
+            if (doc.id.replace(/\\/g, '/') === selfId)
+                continue;
+            const result = compareFingerprints(target, doc.shingle, {
+                shingle: options.shingle,
+                ...(options.minRun !== undefined ? { minRun: options.minRun } : {}),
+                ...(options.maxSpans !== undefined ? { maxSpans: options.maxSpans } : {}),
+            });
+            if (result.score <= 0)
+                continue;
+            hits.push({
+                id: doc.id,
+                label: doc.label,
+                score: result.score,
+                containment: result.containment,
+                jaccard: result.jaccard,
+                longestRun: result.longestRun,
+                spans: spansFor(segment, result),
+            });
+        }
+        hits.sort((x, y) => y.score - x.score || y.longestRun - x.longestRun || (x.id < y.id ? -1 : x.id > y.id ? 1 : 0));
+        const best = hits[0];
+        if (best === undefined) {
+            low += 1;
+            continue;
+        }
+        matched += 1;
+        if (best.score >= options.threshold)
+            high += 1;
+        else if (best.score >= options.threshold * 0.6)
+            medium += 1;
+        else
+            low += 1;
+        items.push({ segment, best, hits });
+    }
+    items.sort((x, y) => y.best.score - x.best.score
+        || y.best.longestRun - x.best.longestRun
+        || (x.segment.file < y.segment.file ? -1 : x.segment.file > y.segment.file ? 1 : 0)
+        || x.segment.lineStart - y.segment.lineStart);
+    return {
+        items,
+        paragraphCount: input.segments.length,
+        totalChars,
+        corpusCount: input.corpus.length,
+        matchedCount: matched,
+        high,
+        medium,
+        low,
+    };
+}
+function candidateIds(target, index, mode) {
+    if (mode === 'all')
+        return index.docs.map(doc => doc.index);
+    const ids = new Set();
+    for (const shingle of target.shingles) {
+        const list = index.inverted.get(shingle);
+        if (list === undefined)
+            continue;
+        for (const id of list)
+            ids.add(id);
+    }
+    return [...ids].sort((a, b) => a - b);
+}

package/lib/gates/dangerous.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 不可逆操作闸门：`tools/pre-execute` 监听。
+ *
+ * 当模型即将执行命中高危规则的工具调用（默认只查 bash：递归删除、强制推送、
+ * 数据库破坏语句、管道执行远程脚本等）时，以 ask 决策拦截——审批界面会把
+ * 两个问题（最坏结果能否接受？能否回滚？）呈现给用户。
+ *
+ * 这是唯一不可由模型代答、也不可被提示词绕过的闸门：不可逆操作必须由人当场
+ * 拍板。用户可以批准（想清楚了）或拒绝（拿到更安全的替代方案）。
+ *
+ * @module dsh-thesis/gates/dangerous
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { type GateOptions } from './writing-intent.ts';
+/**
+ * 安装高危操作闸门监听。
+ *
+ * 未命中的调用原样委托 `next()`；命中时不再调用 next（ask 决策直接返回，
+ * 由审批服务决定放行与否）。直接调用 `ctx.tools.execute()` 的无模型调用
+ * （exec.agent 缺失）不拦截。
+ */
+export declare function installDangerousGate(ctx: Context, config?: GateOptions): void;

package/lib/gates/dangerous.js

@@ -0,0 +1,47 @@
+/**
+ * 不可逆操作闸门：`tools/pre-execute` 监听。
+ *
+ * 当模型即将执行命中高危规则的工具调用（默认只查 bash：递归删除、强制推送、
+ * 数据库破坏语句、管道执行远程脚本等）时，以 ask 决策拦截——审批界面会把
+ * 两个问题（最坏结果能否接受？能否回滚？）呈现给用户。
+ *
+ * 这是唯一不可由模型代答、也不可被提示词绕过的闸门：不可逆操作必须由人当场
+ * 拍板。用户可以批准（想清楚了）或拒绝（拿到更安全的替代方案）。
+ *
+ * @module dsh-thesis/gates/dangerous
+ */
+import { excerpt } from "../shared/text.js";
+import { compileDestructiveRules, findDestructiveHit } from "./detect.js";
+import { destructiveAskReason } from "./messages.js";
+import { GATE_DEFAULTS } from "./writing-intent.js";
+/** 决策理由中引用的命令摘录长度上限。 */
+const COMMAND_EXCERPT_MAX = 200;
+/**
+ * 安装高危操作闸门监听。
+ *
+ * 未命中的调用原样委托 `next()`；命中时不再调用 next（ask 决策直接返回，
+ * 由审批服务决定放行与否）。直接调用 `ctx.tools.execute()` 的无模型调用
+ * （exec.agent 缺失）不拦截。
+ */
+export function installDangerousGate(ctx, config = {}) {
+    if (config.destructiveGate === false)
+        return;
+    const toolNames = config.destructiveToolNames ?? GATE_DEFAULTS.destructiveToolNames;
+    const rules = compileDestructiveRules(config.destructiveRules ?? GATE_DEFAULTS.destructiveRules, pattern => {
+        ctx.logger.warn(`dsh-thesis: 无效的 destructiveRules 正则已跳过: ${pattern}`);
+    });
+    ctx.on('tools/pre-execute', async (exec, next) => {
+        if (exec.agent === undefined)
+            return next();
+        if (!toolNames.includes(exec.name))
+            return next();
+        const args = exec.arguments;
+        const command = args !== undefined && typeof args.command === 'string' ? args.command : undefined;
+        if (command === undefined)
+            return next();
+        const hit = findDestructiveHit(command, rules);
+        if (hit === undefined)
+            return next();
+        return { kind: 'ask', reason: destructiveAskReason(hit.label, excerpt(command, COMMAND_EXCERPT_MAX)) };
+    });
+}

package/lib/gates/detect.d.ts

@@ -0,0 +1,54 @@
+/**
+ * 闸门的判定逻辑：正则预编译 + 命中判断。零 cordis 依赖，可独立单测。
+ *
+ * 三条设计原则（都来自真实返工，不是审美）：
+ * - **便宜**：只做启发式判断。误报的代价是模型多问一句，漏报的代价是整章按错误要求重写。
+ * - **面向人**：闸门只负责「发现问题」，问题由模型转述、由用户回答。
+ * - **有终止条件**：用户一句「直接写」即可绕开写作意图闸门；但**不可逆操作闸门不可绕过**——
+ *   删除、强制推送这类操作必须由人当场拍板。
+ *
+ * @module dsh-thesis/gates/detect
+ */
+import type { DestructiveRule } from './writing-intent.ts';
+/** 一条命中的高危命令规则：标签 + 命中的正则源。 */
+export interface DestructiveHit {
+    label: string;
+    pattern: string;
+}
+/** 一条已编译的高危规则：预编译后的正则随标签一并保留，避免每次调用重新编译。 */
+export interface CompiledDestructiveRule {
+    label: string;
+    pattern: string;
+    regex: RegExp;
+}
+/** 编译正则列表；无效模式跳过并上报，绝不把异常抛进 agent 循环。 */
+export declare function compilePatterns(patterns: string[], onInvalid: (pattern: string) => void): RegExp[];
+/**
+ * 编译「已含验收标准/约束」的标记：按正则源编译。
+ *
+ * `criteriaMarkers` 里既有字面标记（如「验收」），也有条件句式正则（如「如果…就」），
+ * 因此不做字面转义——字面标记本身不含正则元字符，直接当正则源编译即保持子串匹配语义。
+ */
+export declare function compileCriteriaMarkers(markers: string[], onInvalid: (marker: string) => void): RegExp[];
+/**
+ * 编译「授权绕过」标记：字面短语 + 否定防护。
+ *
+ * 中文标记加负向后顾，使「不要直接写」「别直接写」不再命中「直接写」；
+ * 纯拉丁标记用词边界包裹，避免「just write」命中「just write it later」这类子串误判。
+ */
+export declare function compileBypassMarkers(markers: string[], onInvalid: (marker: string) => void): RegExp[];
+/** 预编译高危命令规则：一次编译，后续检测直接复用。 */
+export declare function compileDestructiveRules(rules: DestructiveRule[], onInvalid: (pattern: string) => void): CompiledDestructiveRule[];
+/**
+ * 判断一段用户文本是否「有写作意图、但没带上验收标准」。
+ *
+ * @returns true = 应当触发写作意图闸门。
+ */
+export declare function isUnguardedWritingIntent(text: string, patterns: RegExp[], criteriaMarkers: RegExp[], bypassMarkers: RegExp[]): boolean;
+/**
+ * 在命令字符串中查找第一条命中的高危规则。
+ *
+ * @param rules 已由 {@link compileDestructiveRules} 预编译的规则。
+ * @returns 命中结果；无命中返回 undefined。
+ */
+export declare function findDestructiveHit(command: string, rules: CompiledDestructiveRule[]): DestructiveHit | undefined;