@theseus-whale/dsh-continuity 0.0.0-stage → 4.12.2

package/src/skills.mjs

@@ -0,0 +1,111 @@
+/**
+ * Skill preload: maps the active thread to skill files and builds the block
+ * appended to the per-turn continuity message.
+ *
+ * Defaults: ~/.dsh/continuity/skills (override with DSH_SKILLS_DIR).
+ *   index.json   { skills: [{ name, file, aliases, threads }], byKeyword }
+ *   <name>.md    body with YAML frontmatter
+ *
+ * Matching is deterministic: a thread matches by thread id or tag alias.
+ * No model, no heuristics.
+ */
+import { readFile, stat as statFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { continuityHome } from './threads-store.mjs';
+
+export function skillsDir() {
+  const override = process.env.DSH_SKILLS_DIR;
+  return override !== undefined && override.length > 0
+    ? override
+    : join(continuityHome(), 'skills');
+}
+
+let cache = { index: null, bodies: new Map() };
+
+export async function readSkillsIndex() {
+  const file = join(skillsDir(), 'index.json');
+  try {
+    const raw = await readFile(file, 'utf8');
+    const parsed = JSON.parse(raw);
+    return {
+      skills: Array.isArray(parsed?.skills) ? parsed.skills : [],
+      byKeyword: parsed?.byKeyword ?? {},
+    };
+  } catch {
+    return { skills: [], byKeyword: {} };
+  }
+}
+
+/** Skills whose `threads` contain any of the given ids/aliases. */
+export function skillsForThreads(index, ids) {
+  const set = new Set(ids.filter((x) => typeof x === 'string' && x.length > 0));
+  return index.skills.filter((s) => Array.isArray(s.threads) && s.threads.some((t) => set.has(t)));
+}
+
+/** Skills matched by keywords that appear in the given text (byKeyword: word -> file). */
+export function skillsForKeywords(index, text) {
+  const hay = String(text ?? '');
+  if (hay.length === 0) return [];
+  const out = [];
+  const seen = new Set();
+  for (const [word, file] of Object.entries(index.byKeyword ?? {})) {
+    if (!word || typeof file !== 'string') continue;
+    if (!hay.includes(word)) continue;
+    const entry = index.skills.find((candidate) => candidate.file === file || candidate.name === file);
+    if (!entry || seen.has(entry.name)) continue;
+    seen.add(entry.name);
+    out.push(entry);
+  }
+  return out;
+}
+
+export function stripFrontmatter(raw) {
+  // 去 BOM：PowerShell 写文件可能带 BOM，会让 frontmatter 判不出来。
+  const text = String(raw ?? '').replace(/^\uFEFF/, '');
+  if (!text.startsWith('---')) return text;
+  const end = text.indexOf('\n---', 3);
+  if (end < 0) return text;
+  return text.slice(end + 4).replace(/^\s*/, '');
+}
+
+/** Read bodies (cached); truncate by a rough 4-chars-per-token budget. */
+export async function buildSkillsBlock(entries, options = {}) {
+  const maxTokens = Number.isInteger(options.maxTokens) ? options.maxTokens : 3000;
+  if (entries.length === 0) return '';
+  const parts = [];
+  let budget = Math.max(200, maxTokens) * 4;
+  for (const entry of entries) {
+    const file = join(skillsDir(), entry.file);
+    // 缓存带 mtime/size 校验：技能文件改了，下一轮就用新正文，不必重启。
+    let stat = null;
+    try { stat = await statFile(file); } catch { stat = null; }
+    let cached = cache.bodies.get(file);
+    if (cached !== undefined && stat !== null && (cached.mtimeMs !== stat.mtimeMs || cached.size !== stat.size)) {
+      cached = undefined;
+      cache.bodies.delete(file);
+    }
+    let body = cached?.body;
+    if (body === undefined) {
+      try {
+        body = stripFrontmatter(await readFile(file, 'utf8')).trim();
+      } catch {
+        body = '';
+      }
+      cache.bodies.set(file, { body, mtimeMs: stat?.mtimeMs ?? 0, size: stat?.size ?? 0 });
+    }
+    if (!body) continue;
+    if (budget - body.length < 0) {
+      parts.push('…（预算不足，余下技能未载入）');
+      break;
+    }
+    parts.push(body);
+    budget -= body.length;
+  }
+  if (parts.length === 0) return '';
+  const header = '[技能正文] 本次按线头与关键词自动载入，切换线头或关键词变化后自动换下。';
+  return header + '\n\n' + parts.join('\n\n---\n\n');
+}
+
+export function clearSkillsCache() {
+  cache = { index: null, bodies: new Map() };
+}

package/src/split-range.mjs

@@ -0,0 +1,115 @@
+/**
+ * 把“待保存区间”按轮标签切成话题段（纯函数，可单测）。
+ *
+ * 规则：
+ *   1. 每轮一个标签（T0 视为无归属）；
+ *   2. 相邻同标签合并；T0 段并入前一段（没有前一段就并入后一段）；
+ *   3. 小于 minTurns 的段并入相邻段（避免切出一堆碎段）；
+ *   4. 只按 seq 区间切，不跨轮切。
+ *
+ * @returns {Array<{tag:string, fromSeq:number, toSeq:number, turns:number}>}
+ */
+export function planSplits({ turns = [], tagOf = new Map(), fromSeq = 0, toSeq = Infinity, minTurns = 2 } = {}) {
+  const items = [];
+  for (const info of Array.isArray(turns) ? turns : []) {
+    const seqs = (info?.seqs ?? []).filter((seq) => Number.isInteger(Number(seq)) && Number(seq) >= fromSeq && Number(seq) <= toSeq);
+    if (seqs.length === 0) continue;
+    const tag = String(tagOf.get(Number(info.turn)) ?? 'T0');
+    items.push({ turn: Number(info.turn), tag, from: Math.min(...seqs.map(Number)), to: Math.max(...seqs.map(Number)) });
+  }
+  items.sort((left, right) => left.from - right.from);
+  if (items.length === 0) return [];
+
+  // 1) 同标签相邻合并（T0 先不合并）
+  const runs = [];
+  for (const item of items) {
+    const last = runs.at(-1);
+    if (last !== undefined && last.tag === item.tag && item.tag !== 'T0') { last.to = Math.max(last.to, item.to); last.turns += 1; continue; }
+    runs.push({ tag: item.tag, from: item.from, to: item.to, turns: 1 });
+  }
+
+  // 2) T0 并入邻段
+  const merged = [];
+  for (let index = 0; index < runs.length; index += 1) {
+    const run = runs[index];
+    if (run.tag !== 'T0') { merged.push(run); continue; }
+    const prev = merged.at(-1);
+    if (prev !== undefined) { prev.to = Math.max(prev.to, run.to); prev.turns += run.turns; continue; }
+    const next = runs.slice(index + 1).find((row) => row.tag !== 'T0');
+    if (next === undefined) continue;
+    next.from = Math.min(next.from, run.from);
+    next.turns += run.turns;
+  }
+
+  // 3) 小段并入邻段（优先前）
+  const out = [];
+  for (const run of merged) {
+    const prev = out.at(-1);
+    if (prev !== undefined && run.turns < minTurns) { prev.to = Math.max(prev.to, run.to); prev.turns += run.turns; continue; }
+    out.push({ ...run });
+  }
+  if (out.length > 1 && out[0].turns < minTurns) {
+    out[1] = { ...out[1], from: Math.min(out[0].from, out[1].from), turns: out[0].turns + out[1].turns };
+    out.shift();
+  }
+
+  // 4) 相邻同标签再合并一次
+  const final = [];
+  for (const run of out) {
+    const last = final.at(-1);
+    if (last !== undefined && last.tag === run.tag) { last.to = Math.max(last.to, run.to); last.turns += run.turns; continue; }
+    final.push(run);
+  }
+  return final.map((run) => ({ tag: run.tag, fromSeq: run.from, toSeq: run.to, turns: run.turns }));
+}
+
+/**
+ * 把区间内的轮按标签切成连续块（不合并、不筛选）。
+ * 相邻同标签 = 一块；标签一变就断开。
+ *
+ * @returns {Array<{tag:string, fromSeq:number, toSeq:number, turns:number}>}
+ */
+export function blocksByTag({ events = [], tagOf = new Map(), fromSeq = 0, toSeq = Infinity } = {}) {
+  const byTurn = new Map();
+  for (const event of Array.isArray(events) ? events : []) {
+    if (event?.type !== 'user/message' && event?.type !== 'assistant/message') continue;
+    // user/message 没有 data.turn（结构性事实）；调用方可以先用 attributeTurnSeqs 把轮号
+    // 填到 event.turn 上。只认 data.turn 会把用户原话排除在折叠边界之外——那正是
+    // “想找原话却折不进去”的根源（2026-10-30 实测：块起点落在 assistant 而不是 user）。
+    const turn = Number(event?.data?.turn ?? event?.turn);
+    const seq = Number(event?.seq);
+    if (!Number.isInteger(turn) || !Number.isInteger(seq)) continue;
+    if (seq < fromSeq || seq > toSeq) continue;
+    const entry = byTurn.get(turn) ?? { turn, seqs: [], tag: String(tagOf.get(turn) ?? 'T0') };
+    entry.seqs.push(seq);
+    byTurn.set(turn, entry);
+  }
+  const ordered = [...byTurn.values()].sort((left, right) => Math.min(...left.seqs) - Math.min(...right.seqs));
+  const blocks = [];
+  for (const entry of ordered) {
+    const last = blocks.at(-1);
+    if (last !== undefined && last.tag === entry.tag) last.turns.push(entry);
+    else blocks.push({ tag: entry.tag, turns: [entry] });
+  }
+  return blocks.map((block) => ({
+    tag: block.tag,
+    fromSeq: Math.min(...block.turns.flatMap((entry) => entry.seqs)),
+    toSeq: Math.max(...block.turns.flatMap((entry) => entry.seqs)),
+    turns: block.turns.length,
+  }));
+}
+
+/**
+ * save 的机械分段：只取「属于 target 的连续轮块」。
+ * 相邻同标签的轮合成一块；标签一变就断开——所以不会跨过别的标签去折。
+ *
+ * 这是 save() 折叠范围的唯一依据：切到 T2 时，T4 的块被折、T2 的块原地留着。
+ *
+ * @returns {Array<{fromSeq:number, toSeq:number, turns:number}>}
+ */
+export function runsForThread({ events = [], tagOf = new Map(), fromSeq = 0, toSeq = Infinity, target = '' } = {}) {
+  if (String(target).length === 0) return [];
+  return blocksByTag({ events, tagOf, fromSeq, toSeq })
+    .filter((block) => block.tag === String(target))
+    .map((block) => ({ fromSeq: block.fromSeq, toSeq: block.toSeq, turns: block.turns }));
+}

package/src/state.mjs

@@ -0,0 +1,198 @@
+/**
+ * Process-local state shared by the Host panel row and the compaction engine.
+ *
+ * The panel's HTTP route and the engine are two rows of one installed package,
+ * so they resolve the same file URL and therefore the same module instance.
+ * This is a diagnostic cache only: the session log remains the source of truth
+ * for anything the model saw.
+ */
+import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const continuityDir = () => join(process.env.USERPROFILE ?? process.env.HOME ?? '.', '.dsh', 'continuity');
+
+/** Recompute the merged view from passes.jsonl plus the pre-pass folds sidecar.
+ *  Each session gets its own sessions/<id>/dropped-ranges.json; sequence spaces
+ *  from different sessions must never be merged together. */
+export function rebuildDroppedRanges(sessionId = null) {
+  try {
+    const dir = continuityDir();
+    let passes = [];
+    try {
+      passes = readFileSync(join(dir, 'passes.jsonl'), 'utf8')
+        .split(/\r?\n/).filter(Boolean).map((line) => {
+          try { return JSON.parse(line.replace(/^\uFEFF/, '')); } catch { return null; }
+        }).filter(Boolean);
+    } catch { /* no new pass log yet; folds may still cover history */ }
+    let foldSessions = {};
+    try {
+      const parsed = JSON.parse(readFileSync(join(dir, 'folds.json'), 'utf8').replace(/^\uFEFF/, ''));
+      foldSessions = parsed?.sessions ?? {};
+    } catch { /* old install may have no folds sidecar */ }
+
+    const passesBySession = new Map();
+    for (const row of passes) {
+      const id = row?.sessionId;
+      if (typeof id !== 'string' || id === '') continue;
+      if (!passesBySession.has(id)) passesBySession.set(id, []);
+      passesBySession.get(id).push(row);
+    }
+    const ids = sessionId
+      ? [String(sessionId)]
+      : [...new Set([...passesBySession.keys(), ...Object.keys(foldSessions)])];
+    for (const id of ids) {
+      const sessionPasses = passesBySession.get(id) ?? [];
+      const sessionFolds = Array.isArray(foldSessions?.[id]?.folds) ? foldSessions[id].folds : [];
+      const entries = [
+        ...sessionPasses.map((row) => ({ from: row.start, to: row.end, at: row.at, source: 'pass' })),
+        ...sessionFolds.map((row) => ({ from: row.from, to: row.to, at: row.at, source: 'fold' })),
+      ];
+      const ranges = entries
+        .map((row) => [Number(row.from), Number(row.to)])
+        .filter(([start, end]) => Number.isFinite(start) && Number.isFinite(end) && start <= end)
+        .sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+      const merged = [];
+      for (const [start, end] of ranges) {
+        const last = merged.at(-1);
+        if (last && start <= last[1] + 1) last[1] = Math.max(last[1], end);
+        else merged.push([start, end]);
+      }
+      const totalSeqs = merged.reduce((sum, [start, end]) => sum + (end - start + 1), 0);
+      const times = entries.map((row) => row.at).filter((at) => typeof at === 'string' && at).sort();
+      const sessionDir = join(dir, 'sessions', id);
+      mkdirSync(sessionDir, { recursive: true });
+      writeFileSync(join(sessionDir, 'dropped-ranges.json'), `${JSON.stringify({
+        updatedAt: new Date().toISOString(),
+        sessionId: id,
+        ranges: merged,
+        totalSeqs,
+        passes: sessionPasses.length,
+        folds: sessionFolds.length,
+        coverageFrom: times[0] ?? null,
+        coverageNote: 'passes.jsonl is complete after 4.9.80; earlier ranges come from folds.json with no token counts',
+      }, null, 2)}\n`, 'utf8');
+    }
+  } catch { /* diagnostics must never block compaction */ }
+}
+
+/** Append-only pass receipt for independent post-hoc verification. */
+export function appendPassLog(pass) {
+  try {
+    const home = process.env.USERPROFILE ?? process.env.HOME ?? '.';
+    const dir = join(home, '.dsh', 'continuity');
+    mkdirSync(dir, { recursive: true });
+    const at = Number.isFinite(pass?.at) ? pass.at : Date.now();
+    appendFileSync(join(dir, 'passes.jsonl'), `${JSON.stringify({
+      ...pass,
+      at: new Date(at).toISOString(),
+      atMs: at,
+    })}\n`, 'utf8');
+    rebuildDroppedRanges(pass?.sessionId ?? null);
+  } catch { /* diagnostics must never block compaction */ }
+}
+
+/** @typedef {{ at: number, mountedAt: number, policy: object, provenance: object, compactionBasic: object, base: object }} EngineState */
+/** @typedef {{ at: number, sessionId?: string, start?: number, end?: number, count?: number, tokens?: number, budget?: number, reason?: string, estTokens?: number, windowTokens?: number, afterTokens?: number, afterSurfaceTokens?: number, afterBaselineTokens?: number, rebloatTokens?: number }} PassRecord */
+/** @typedef {{ at: number, sessionId: string, estTokens: number, windowTokens: number, surfaceTokens: number, baselineTokens: number }} ContextRecord */
+/** @typedef {{ at: number, sessionId?: string, count: number, tokens: number, chars: number, reason: string }} PreviewRecord */
+
+export const continuityState = {
+  /** @type {EngineState | null} */
+  engine: null,
+  /** The session id the mounted engine has actually served. @type {string|null} */
+  engineSession: null,
+  /** @type {PassRecord[]} newest first */
+  passes: [],
+  /** @type {ContextRecord | null} */
+  context: null,
+  /** @type {PreviewRecord[]} newest first */
+  previews: [],
+  /** @type {{ at: number, message: string, key?: string } | null} */
+  lastError: null,
+  /** @type {{ at: number, name: string, scope: string } | null} */
+  sessionLogTool: null,
+  /** @type {{ at: number, name: string, scope: string } | null} */
+  threadsTool: null,
+  /** @type {{ at: number, active: string|null, count: number, rules: boolean } | null} */
+  threads: null,
+};
+
+/** Record that the preset-scoped `session_log` tool registered. */
+export function markSessionLogTool({ name, scope }) {
+  continuityState.sessionLogTool = { at: Date.now(), name, scope };
+}
+
+/** Record that the preset-scoped `continuity` tool registered. */
+export function markThreadsTool({ name, scope }) {
+  continuityState.threadsTool = { at: Date.now(), name, scope };
+}
+
+/** Remember which session the mounted Continuity engine is serving. */
+export function markEngineSession(sessionId) {
+  const id = typeof sessionId === 'string' ? sessionId : '';
+  if (id.length > 0) continuityState.engineSession = id;
+}
+
+/** Record the thread injection snapshot for the panel (read-only diagnostic). */
+export function markThreadsSnapshot({ activeId, count, rules }) {
+  continuityState.threads = {
+    at: Date.now(),
+    active: activeId ?? null,
+    count: Number.isFinite(count) ? count : 0,
+    rules: Boolean(rules),
+  };
+}
+
+/** Record that the engine row mounted, with the policy it resolved. */
+export function markEngine({ policy, provenance, compactionBasic, base, instance }) {
+  continuityState.engine = {
+    at: Date.now(),
+    mountedAt: Date.now(),
+    policy,
+    provenance,
+    compactionBasic,
+    base: base ?? {},
+  };
+  // The panel metadata above is not callable; keep the real engine separately
+  // so index.apply can route agent/turn-stopping to onTurnStopping.
+  continuityState.engineInstance = instance ?? null;
+}
+
+/** Remember one completed compaction pass for the panel. */
+export function recordPass(pass) {
+  const record = { at: Date.now(), ...pass };
+  continuityState.passes.unshift(record);
+  if (continuityState.passes.length > 24) continuityState.passes.length = 24;
+  appendPassLog(record);
+}
+
+/** Remember the latest measured context shape (used by stats tail output). */
+export function recordContext(context) {
+  continuityState.context = { at: Date.now(), ...context };
+}
+
+/** Remember one landed batch of old-tool-result previews. */
+export function recordPreview(preview) {
+  continuityState.previews.unshift({ at: Date.now(), ...preview });
+  if (continuityState.previews.length > 24) continuityState.previews.length = 24;
+}
+
+/** Remember the last non-fatal measurement or compaction failure. */
+export function recordError(message, key) {
+  continuityState.lastError = { at: Date.now(), message: String(message), ...(key === undefined ? {} : { key }) };
+}
+
+export function resetState() {
+  continuityState.engine = null;
+  continuityState.engineInstance = null;
+  continuityState.engineSession = null;
+  continuityState.passes = [];
+  continuityState.context = null;
+  continuityState.previews = [];
+  continuityState.lastError = null;
+  continuityState.sessionLogTool = null;
+  continuityState.threadsTool = null;
+  continuityState.threads = null;
+}
+
+export default continuityState;

package/src/t0.mjs

@@ -0,0 +1,149 @@
+/**
+ * T0 闸的纯逻辑：算“即将折叠的区间里还有多少条未决”。
+ *
+ * 口径（与 T0-POLICY.md 一致）：
+ *  - 只看**可见文本**：用户全文 + 助手非 reasoning 部分（reasoning 是草稿，不算记忆）；
+ *  - 注入噪音（[线]/[候选]/runtime…）不计；
+ *  - 有标签 = 已定；`t0-decisions.jsonl` 里 `as:"t0"` = 显式判定的 T0；其余 = 未决。
+ */
+import { tagsAtSeq } from './tags.mjs';
+
+export const NOISE_RE = /^(\[线\]|\[标签\]|\[习惯|\[技能|\[归位|\[回查|\[痕迹|\[接手|\[候选|\[新标签|\[归拢|\[学习|\[分叉|\[存\?|\[回正|\[放|\[暂停\]|\[打标|\[话题\?|\[基础规则|\[存活\]|<system-reminder>|<workspace|This is an automatically generated checkpoint|Current runtime context|Time sampled)/;
+
+/** 可见文本：用户全文；助手只取非 reasoning 部分。 */
+export function visibleText(event) {
+  const msg = event?.data?.message;
+  const parts = msg?.content;
+  if (Array.isArray(parts)) {
+    return parts
+      .filter((part) => part?.type !== 'reasoning')
+      .map((part) => part?.text ?? '')
+      .join('\n')
+      .trim();
+  }
+  const direct = event?.data?.content;
+  if (typeof direct === 'string') return direct.trim();
+  if (Array.isArray(direct)) {
+    return direct
+      .filter((part) => part?.type !== 'reasoning')
+      .map((part) => part?.text ?? '')
+      .join('\n')
+      .trim();
+  }
+  return '';
+}
+
+/**
+ * @returns {{ content:number, tagged:number, t0Decided:number, undecided:Array<{seq:number,type:string,head:string}> }}
+ */
+export function contentUndecided({ events = [], tagsDoc = null, decisions = [], turnTagRows = [], fromSeq = 0, toSeq = Infinity } = {}) {
+  // 轮标签：调用方一直传 turnTagRows，但函数签名没接——于是在这里抛 ReferenceError，
+  // 又被 save 的 catch 吞掉，四道闸集体静默失效（2026-10-29 反向验收抓到：97 轮无标签也存了）。
+  const taggedTurns = new Set();
+  for (const row of Array.isArray(turnTagRows) ? turnTagRows : []) {
+    const turn = Number(row?.turn);
+    if (Number.isInteger(turn)) taggedTurns.add(turn);
+  }
+  const decided = new Set();
+  const explicitT0 = new Set();
+  for (const row of Array.isArray(decisions) ? decisions : []) {
+    const seqs = Array.isArray(row?.seqs) ? row.seqs : [row?.seq];
+    for (const raw of seqs) {
+      const seq = Number(raw);
+      if (!Number.isInteger(seq)) continue;
+      decided.add(seq);
+      if (row?.as === 't0') explicitT0.add(seq);
+    }
+  }
+
+  let content = 0;
+  let tagged = 0;
+  let t0Decided = 0;
+  let noTurn = 0;
+  const undecided = [];
+  for (const event of Array.isArray(events) ? events : []) {
+    if (event?.type !== 'user/message' && event?.type !== 'assistant/message') continue;
+    const seq = Number(event?.seq);
+    if (!Number.isInteger(seq) || seq < fromSeq || seq > toSeq) continue;
+    const text = visibleText(event);
+    if (text.length === 0) continue;
+    if (NOISE_RE.test(text)) continue;
+    const source = event?.data?.message?.source ?? event?.data?.source;
+    if (source?.peer === true) continue;
+    if (typeof source?.kind === 'string' && source.kind !== 'user') continue;
+    // Host 可能把 source 的额外字段洗掉，只留 kind:"user"；投递前缀不参与内容计数。
+    if (/^\[(?:创|闸|peer|gate)(?:\]|·)/.test(text)) continue;
+    content += 1;
+    const tags = tagsDoc === null ? [] : [...tagsAtSeq(tagsDoc, seq)].filter((tag) => tag !== 'T0');
+    if (tags.length > 0) { tagged += 1; continue; }
+    if (explicitT0.has(seq)) { t0Decided += 1; continue; }
+    if (decided.has(seq)) { tagged += 1; continue; } // 已判给某标签（memberships 可能尚未写入）
+    const turnNumber = Number(event?.data?.turn);
+    if (Number.isInteger(turnNumber) && taggedTurns.has(turnNumber)) { tagged += 1; continue; } // 轮标签已判
+    // 没有轮号 ≠ 不用判：归属靠 run 区间（[from,to,tagId]），run 不需要轮号。
+    // 之前这里写「无轮号 → 跳过」，等于把 37 条真实用户消息当成不用管（2026-10-30 用户纠正）。
+    if (!Number.isInteger(turnNumber)) noTurn += 1;
+    undecided.push({ seq, type: event.type, head: text.replace(/\s+/g, ' ').slice(0, 60) });
+  }
+  return { content, tagged, t0Decided, noTurn, undecided };
+}
+
+
+/**
+ * 这次折叠覆盖到、但还没有轮标签的轮。
+ * @returns {Array<{turn:number, seq:number}>}
+ */
+export function untaggedTurnList({ events = [], turnTagRows = [], fromSeq = 0, toSeq = Infinity } = {}) {
+  const tagged = new Set();
+  for (const row of Array.isArray(turnTagRows) ? turnTagRows : []) {
+    const turn = Number(row?.turn);
+    if (Number.isInteger(turn)) tagged.add(turn);
+  }
+  const out = new Map();
+  for (const event of Array.isArray(events) ? events : []) {
+    if (event?.type !== 'user/message' && event?.type !== 'assistant/message') continue;
+    const turn = Number(event?.data?.turn);
+    const seq = Number(event?.seq);
+    if (!Number.isInteger(turn) || !Number.isInteger(seq)) continue;
+    if (seq < fromSeq || seq > toSeq) continue;
+    if (tagged.has(turn)) continue;
+    if (!out.has(turn)) out.set(turn, { turn, seq });
+  }
+  return [...out.values()];
+}
+
+
+/**
+ * 全局轮标签缺口：已结束的轮里，有多少轮还没有标签。
+ * 这是“机制是否漏打”的判据——缺口大就不是没轮到，是漏了。
+ *
+ * @returns {{settled:number, tagged:number, missing:Array<{turn:number, hasUserText:boolean}>}}
+ */
+export function turnTagGap({ events = [], turnTagRows = [], boundaryTurn = Infinity } = {}) {
+  const tagged = new Set();
+  for (const row of Array.isArray(turnTagRows) ? turnTagRows : []) {
+    const turn = Number(row?.turn);
+    if (Number.isInteger(turn)) tagged.add(turn);
+  }
+  const withMessages = new Map();
+  let maxTurn = 0;
+  for (const event of Array.isArray(events) ? events : []) {
+    if (event?.type !== 'user/message' && event?.type !== 'assistant/message') continue;
+    const turn = Number(event?.data?.turn);
+    if (!Number.isInteger(turn)) continue;
+    if (turn > maxTurn) maxTurn = turn;
+    const entry = withMessages.get(turn) ?? { turn, hasUserText: false };
+    if (event.type === 'user/message') entry.hasUserText = true;
+    withMessages.set(turn, entry);
+  }
+  const settledBoundary = Math.min(Number.isFinite(boundaryTurn) ? boundaryTurn : Infinity, maxTurn - 1);
+  const missing = [];
+  let settled = 0;
+  for (const entry of withMessages.values()) {
+    if (entry.turn > settledBoundary) continue;
+    settled += 1;
+    if (!tagged.has(entry.turn)) missing.push({ turn: entry.turn, hasUserText: entry.hasUserText });
+  }
+  missing.sort((left, right) => left.turn - right.turn);
+  return { settled, tagged: settled - missing.length, missing };
+}

package/src/tag-confirm.mjs

@@ -0,0 +1,78 @@
+/**
+ * New-tag policy for the strict `TAG: NEW:<word>` interface.
+ *
+ * An unknown word without NEW: is not a tag request; it is a typo or an
+ * attempt to let the model confirm itself. The gate must reject it.
+ */
+
+/** Split only on em/en dash; ASCII hyphen is part of F-35 / COVID-19. */
+export function tagTokenFromDeclaration(declaration) {
+  return String(declaration ?? '')
+    .replace(/^TAG\s*[:：]\s*/i, '')
+    .split(/[—–]/)[0]
+    .trim();
+}
+
+/** Return the explicit NEW: word (quotes stripped), or null. */
+export function splitNewToken(token) {
+  const key = String(token ?? '').trim();
+  const hit = /^NEW\s*[:：]\s*(.+)$/i.exec(key);
+  return hit === null ? null : tagWordFromToken(hit[1]);
+}
+
+/** Strip wrapping quotes so evidence/near-label use the word itself. */
+export function tagWordFromToken(token) {
+  const key = String(token ?? '').trim();
+  const wrap = /^["“「'‘](.*)["”」'’]$/.exec(key);
+  return wrap !== null ? wrap[1].trim() : key;
+}
+
+function isTagLine(line) {
+  return /^\s*TAG\s*[:：]/i.test(line);
+}
+
+/**
+ * The word must appear in the user's message or the assistant body, not only
+ * in the TAG line or in the gate question itself.
+ */
+export function hasWordEvidence({ userText = '', assistantText = '', word = '' } = {}) {
+  const needle = String(word ?? '').trim().toLowerCase();
+  if (needle.length === 0) return false;
+  const visible = (text) => String(text ?? '')
+    .split(/\r?\n/)
+    .filter((line) => !isTagLine(line) && !/^\s*\[(?:闸|gate|peer)/.test(line))
+    .join('\n')
+    .toLowerCase();
+  return visible(userText).includes(needle) || visible(assistantText).includes(needle);
+}
+
+/** Levenshtein distance, used only for near-duplicate label names. */
+export function editDistance(a, b) {
+  const left = String(a ?? '');
+  const right = String(b ?? '');
+  if (left === right) return 0;
+  if (left.length === 0) return right.length;
+  if (right.length === 0) return left.length;
+  let prev = Array.from({ length: right.length + 1 }, (_, index) => index);
+  for (let i = 1; i <= left.length; i += 1) {
+    const next = [i];
+    for (let j = 1; j <= right.length; j += 1) {
+      const cost = left[i - 1] === right[j - 1] ? 0 : 1;
+      next[j] = Math.min(prev[j] + 1, next[j - 1] + 1, prev[j - 1] + cost);
+    }
+    prev = next;
+  }
+  return prev[right.length];
+}
+
+/** Return the first existing label within edit distance 1, or null. */
+export function findNearLabel(labels, word) {
+  const target = String(word ?? '').trim();
+  if (target.length === 0) return null;
+  for (const item of Array.isArray(labels) ? labels : []) {
+    const label = String(item?.label ?? '').trim();
+    if (label.length === 0 || label === target) continue;
+    if (editDistance(target, label) <= 1) return item;
+  }
+  return null;
+}