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

package/src/tag-detect.mjs

@@ -0,0 +1,42 @@
+/**
+ * Find a TAG declaration in an assistant message.
+ *
+ * The gate accepts the first non-empty, non-fenced line OR the last five
+ * non-empty, non-fenced lines. Last-five wins when both contain a TAG, which
+ * keeps the old "末尾优先" behavior. Fenced examples are never declarations.
+ */
+export function tagDeclarationCandidates(text, { tailLimit = 5 } = {}) {
+  const rawLines = String(text ?? '').split('\n');
+  const fenced = [];
+  let inFence = false;
+  for (const line of rawLines) {
+    if (/^\s*```/.test(line)) {
+      inFence = !inFence;
+      fenced.push(true);
+      continue;
+    }
+    fenced.push(inFence);
+  }
+
+  const candidates = [];
+  const tailIndexes = new Set();
+  for (let i = rawLines.length - 1; i >= 0; i -= 1) {
+    const line = rawLines[i].trim();
+    if (line.length === 0 || fenced[i]) continue;
+    candidates.push(line);
+    tailIndexes.add(i);
+    if (candidates.length >= tailLimit) break;
+  }
+
+  for (let i = 0; i < rawLines.length; i += 1) {
+    const line = rawLines[i].trim();
+    if (line.length === 0 || fenced[i]) continue;
+    if (!tailIndexes.has(i)) candidates.push(line);
+    break;
+  }
+  return candidates;
+}
+
+export function findTagDeclaration(text) {
+  return tagDeclarationCandidates(text).find((line) => /^TAG\s*[:：]/i.test(line)) ?? null;
+}

package/src/tag-maintenance.mjs

@@ -0,0 +1,285 @@
+/**
+ * Deterministic tag maintenance (0.8.57).
+ *
+ * No model calls. The only semantic-looking step is a conservative merge:
+ * it requires run containment, keyword/label overlap, a higher-use target and
+ * a clear margin. Everything else is data hygiene.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { copyFile, mkdir } from 'node:fs/promises';
+import { continuityHome, readTags, updateTags, writeTagsMd } from './tags-store.mjs';
+import { canonicalTagId, normalizeTags, renderTagsMd } from './tags.mjs';
+
+function readTurnUse(home) {
+  const use = new Map();
+  try {
+    const text = fs.readFileSync(path.join(home, 'turn-tags.jsonl'), 'utf8');
+    for (const line of text.split(/\r?\n/)) {
+      if (!line.trim()) continue;
+      try {
+        const row = JSON.parse(line);
+        if (typeof row?.tag !== 'string') continue;
+        const current = use.get(row.tag) ?? { count: 0, lastTurn: 0 };
+        current.count += 1;
+        current.lastTurn = Math.max(current.lastTurn, Number(row.turn) || 0);
+        use.set(row.tag, current);
+      } catch { /* skip malformed row */ }
+    }
+  } catch { /* no turn tags yet */ }
+  return use;
+}
+
+function tagRuns(state) {
+  const runs = new Map();
+  for (const [start, end, id] of state.runs ?? []) {
+    if (typeof id !== 'string') continue;
+    if (!runs.has(id)) runs.set(id, []);
+    runs.get(id).push([start, end]);
+  }
+  return runs;
+}
+
+function hasAnySeq(state, id, runs) {
+  if ((runs.get(id) ?? []).length > 0) return true;
+  if (Object.values(state.overrides ?? {}).includes(id)) return true;
+  return Object.values(state.memberships ?? {}).some((ids) => Array.isArray(ids) && ids.includes(id));
+}
+
+function nextNumericAlias(state) {
+  let max = 0;
+  for (const entry of Object.values(state.tags ?? {})) {
+    const match = /^T(\d+)$/.exec(String(entry?.alias ?? ''));
+    if (match) max = Math.max(max, Number(match[1]));
+  }
+  return max + 1;
+}
+
+function runsInside(sourceRuns, targetRuns) {
+  if (sourceRuns.length === 0 || targetRuns.length === 0) return false;
+  const strict = sourceRuns.every(([s, e]) => targetRuns.some(([ts, te]) => s >= ts && e <= te));
+  if (strict) return true;
+  const start = Math.min(...targetRuns.map(([s]) => s));
+  const end = Math.max(...targetRuns.map(([, e]) => e));
+  return sourceRuns.every(([s, e]) => s >= start && e <= end);
+}
+
+function keywordScore(source, target) {
+  const keys = target.keywords.map((k) => k.toLowerCase());
+  let score = 0;
+  for (const raw of source.keywords.map((k) => k.toLowerCase())) {
+    if (keys.includes(raw)) score += 2;
+    else if (keys.some((k) => k.includes(raw) || raw.includes(k))) score += 1;
+  }
+  return score;
+}
+
+function score(source, target, runs) {
+  let value = 0;
+  const reasons = [];
+  if (runsInside(runs.get(source.id) ?? [], runs.get(target.id) ?? [])) {
+    value += 3;
+    reasons.push('run-contained');
+  }
+  const kw = keywordScore(source, target);
+  if (kw > 0) {
+    value += kw;
+    reasons.push(`kw:${kw}`);
+  }
+  const sl = source.label.toLowerCase();
+  const tl = target.label.toLowerCase();
+  if (sl.includes(tl) || tl.includes(sl)) {
+    value += 2;
+    reasons.push('label-contains');
+  }
+  return { value, reasons };
+}
+
+export function planMaintenance(stateInput, use, nowTurn = 0) {
+  const state = normalizeTags(stateInput);
+  const runs = tagRuns(state);
+  const rows = Object.entries(state.tags ?? {})
+    .filter(([id, entry]) => id !== 'T0' && entry?.lifecycle !== 'merged' && entry?.lifecycle !== 'archived')
+    .map(([id, entry]) => ({
+      id,
+      label: String(entry?.label ?? id),
+      alias: String(entry?.alias ?? ''),
+      keywords: Array.isArray(entry?.keywords) ? entry.keywords.map(String) : [],
+      use: use.get(id)?.count ?? 0,
+      lastTurn: use.get(id)?.lastTurn ?? 0,
+      lifecycle: entry?.lifecycle,
+      runs: runs.get(id) ?? [],
+    }));
+
+  const expired = nowTurn > 0
+    ? rows.filter((row) => row.lifecycle === 'provisional' && row.use <= 1 && nowTurn - row.lastTurn > 20)
+    : [];
+  const expiredIds = new Set(expired.map((row) => row.id));
+  const ghosts = rows.filter((row) => !expiredIds.has(row.id) && row.use === 0 && !hasAnySeq(state, row.id, runs));
+  const active = rows.filter((row) => !expiredIds.has(row.id) && (row.use > 0 || hasAnySeq(state, row.id, runs)));
+
+  active.sort((a, b) => b.use - a.use || a.id.localeCompare(b.id));
+  let alias = nextNumericAlias(state);
+  const aliasFixes = [];
+  for (const row of active) {
+    if (/^T\d+$/.test(row.alias)) continue;
+    row.newAlias = `T${alias}`;
+    alias += 1;
+    aliasFixes.push(row);
+  }
+
+  const byId = new Map(active.map((row) => [row.id, row]));
+  const merges = [];
+  const orphans = [];
+  for (const source of active.filter((row) => row.use <= 10 && row.runs.length <= 3)) {
+    const ranked = active
+      .filter((row) => row.id !== source.id && row.use > source.use)
+      .map((row) => ({ target: row, ...score(source, row, runs) }))
+      .sort((a, b) => b.value - a.value || b.target.use - a.target.use);
+    const top = ranked[0] ?? null;
+    const second = ranked[1] ?? null;
+    const margin = top ? top.value - (second?.value ?? 0) : 0;
+    if (top !== null && top.value >= 4 && margin >= 1) {
+      merges.push({ source, target: top.target, score: top.value, reasons: top.reasons });
+    } else {
+      orphans.push({ source, top, margin });
+    }
+  }
+
+  return { state, rows, ghosts, expired, active, aliasFixes, merges, orphans, byId };
+}
+
+export async function applyMaintenance(plan) {
+  const state = structuredClone(plan.state);
+  const runUse = new Map(plan.rows.map((row) => [row.id, row.use]));
+
+  for (const ghost of plan.ghosts) {
+    if (state.tags[ghost.id] === undefined) continue;
+    state.tags[ghost.id].lifecycle = 'archived';
+    state.tags[ghost.id].useCount = 0;
+  }
+  for (const expired of plan.expired) {
+    const entry = state.tags[expired.id];
+    if (entry === undefined) continue;
+    entry.lifecycle = 'archived';
+    entry.mergedInto = 'T0';
+    entry.useCount = runUse.get(expired.id) ?? 0;
+  }
+  for (const fix of plan.aliasFixes) {
+    const entry = state.tags[fix.id];
+    if (entry === undefined) continue;
+    const old = String(entry.alias ?? '').trim();
+    if (old.length > 0) entry.legacyAliases = [...new Set([...(entry.legacyAliases ?? []), old])];
+    entry.alias = fix.newAlias;
+  }
+  for (const merge of plan.merges) {
+    const source = state.tags[merge.source.id];
+    const target = state.tags[merge.target.id];
+    if (source === undefined || target === undefined) continue;
+    source.lifecycle = 'merged';
+    source.mergedInto = merge.target.id;
+    source.useCount = runUse.get(source.id) ?? source.useCount ?? 0;
+    target.mergedFrom = [...new Set([...(target.mergedFrom ?? []), source.id])];
+    target.useCount = (target.useCount ?? runUse.get(target.id) ?? 0) + (runUse.get(source.id) ?? 0);
+  }
+  const mergedInto = new Map([
+    ...plan.merges.map((merge) => [merge.source.id, merge.target.id]),
+    ...plan.expired.map((row) => [row.id, 'T0']),
+  ]);
+  state.runs = (state.runs ?? [])
+    .map(([start, end, id]) => [start, end, mergedInto.get(id) ?? id])
+    .map(([start, end, id]) => [`${start}-${end}-${id}`, [start, end, id]])
+    .filter(([key], index, list) => list.findIndex(([other]) => other === key) === index)
+    .map(([, run]) => run)
+    .sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+  for (const [seq, id] of Object.entries(state.overrides ?? {})) {
+    state.overrides[seq] = mergedInto.get(id) ?? id;
+  }
+  for (const [seq, ids] of Object.entries(state.memberships ?? {})) {
+    state.memberships[seq] = [...new Set(ids.map((id) => mergedInto.get(id) ?? id))];
+  }
+  for (const row of plan.active) {
+    const entry = state.tags[row.id];
+    if (entry === undefined) continue;
+    entry.useCount = runUse.get(row.id) ?? 0;
+    if (entry.lifecycle === undefined) entry.lifecycle = 'active';
+    if (entry.lifecycle === 'provisional' && (entry.useCount ?? 0) >= 2) entry.lifecycle = 'active';
+  }
+  state.updatedAt = new Date().toISOString();
+  return normalizeTags(state);
+}
+
+function verify(plan, next) {
+  const problems = [];
+  const nextRuns = tagRuns(next);
+  for (const merge of plan.merges) {
+    const targetId = canonicalTagId(next, merge.target.id);
+    const covered = (merge.source.runs ?? []).every(([s, e]) => (nextRuns.get(targetId) ?? [])
+      .some(([ts, te]) => s >= ts && e <= te));
+    if (!covered) problems.push(`seq-not-covered:${merge.source.id}->${targetId}`);
+  }
+  for (const expired of plan.expired) {
+    const covered = (expired.runs ?? []).every(([s, e]) => (nextRuns.get('T0') ?? [])
+      .some(([ts, te]) => s >= ts && e <= te));
+    if (!covered) problems.push(`expired-seq-not-covered:${expired.id}`);
+  }
+  for (const row of plan.active) {
+    const entry = next.tags[row.id];
+    if (entry?.mergedInto !== undefined && next.tags[entry.mergedInto] === undefined) {
+      problems.push(`missing-merge-target:${row.id}->${entry.mergedInto}`);
+    }
+  }
+  return problems;
+}
+
+export async function runMaintenance({ home = continuityHome(), mode = 'manual', dryRun = false } = {}) {
+  const read = await readTags(home);
+  const use = readTurnUse(home);
+  const nowTurn = [...use.values()].reduce((max, item) => Math.max(max, item.lastTurn), 0);
+  const plan = planMaintenance(read.state, use, nowTurn);
+  const changed = plan.ghosts.length + plan.expired.length + plan.aliasFixes.length + plan.merges.length;
+  const result = {
+    mode,
+    dryRun,
+    total: plan.rows.length,
+    active: plan.active.length,
+    ghosts: plan.ghosts.length,
+    expired: plan.expired.length,
+    aliasFixes: plan.aliasFixes.length,
+    merged: plan.merges.length,
+    orphans: plan.orphans.length,
+    changed,
+    healthy: true,
+    problems: [],
+    merges: plan.merges.map((merge) => ({
+      source: merge.source.id,
+      target: merge.target.id,
+      score: merge.score,
+      reasons: merge.reasons,
+    })),
+  };
+  if (changed === 0) {
+    result.final = plan.rows.length;
+    return result;
+  }
+  if (dryRun) {
+    result.final = plan.rows.length - plan.ghosts.length - plan.expired.length - plan.merges.length;
+    return result;
+  }
+
+  const dir = home;
+  await mkdir(dir, { recursive: true });
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const backup = path.join(dir, `tags.json.bak-maintenance-${stamp}`);
+  try { await copyFile(path.join(dir, 'tags.json'), backup); } catch { /* first run */ }
+
+  const next = await applyMaintenance(plan);
+  result.problems = verify(plan, next);
+  result.healthy = result.problems.length === 0;
+  await updateTags(() => next, home);
+  await writeTagsMd(renderTagsMd(next, { maxSeq: 0 }), home);
+  result.final = Object.entries(next.tags).filter(([id, entry]) => id !== 'T0'
+    && entry?.lifecycle !== 'merged' && entry?.lifecycle !== 'archived').length;
+  result.backup = backup;
+  return result;
+}

package/src/tag-reject.mjs

@@ -0,0 +1,73 @@
+/**
+ * One-shot display state for a rejected TAG.
+ *
+ * The first pre-step that sees a rejection renders it and writes `shown:true`;
+ * the next pre-step removes the file without rendering again. A second rejection
+ * for the same turn does not reset `shown`, so one turn cannot spam the header.
+ */
+import { readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+
+export const TAG_REJECT_FILE = 'tag-reject.json';
+
+function read(file) {
+  try {
+    const value = JSON.parse(readFileSync(file, 'utf8'));
+    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Record the rejection, preserving an existing display for the same turn. */
+export function recordTagReject({ file, turn, token, kind, reason, now = Date.now() }) {
+  const previous = read(file);
+  const sameTurnShown = previous !== null && Number(previous.turn) === Number(turn) && previous.shown === true;
+  const next = {
+    at: new Date(now).toISOString(),
+    turn,
+    token,
+    kind,
+    reason,
+    shown: sameTurnShown,
+  };
+  if (sameTurnShown) next.shownAt = previous.shownAt ?? previous.at ?? null;
+  writeFileSync(file, JSON.stringify(next, null, 2), 'utf8');
+  return next;
+}
+
+/** The exact header format the instance already reads. */
+export function renderTagRejectHeader(reject) {
+  return '\n[打标·退回] 第 ' + String(reject.turn ?? '?') + ' 轮没有记下标签：你写的是「' + String(reject.token ?? '?') + '」——'
+    + String(reject.reason ?? reject.kind ?? '被拒') + '。'
+    + '\n  修法：node ~/.dsh/continuity/turnmap.mjs set --turn ' + String(reject.turn ?? '?') + ' --tag <Tx>'
+    + '（写别名，或写一个表里没有的新词；引号里的词按字面处理）';
+}
+
+/**
+ * Render at most once, then delete on the following consumption.
+ * If the rejected turn already has a tag, the notice is stale: delete without
+ * rendering. Returns `{action:'none'|'shown'|'deleted', text, reject?, reason?}`.
+ */
+export function consumeTagReject({ file, isResolved = () => false, now = Date.now() }) {
+  const reject = read(file);
+  if (reject === null) {
+    try { unlinkSync(file); } catch { /* nothing to remove */ }
+    return { action: 'none', text: '' };
+  }
+  if (isResolved(Number(reject.turn))) {
+    try { unlinkSync(file); } catch { /* next pre-step retries */ }
+    return { action: 'deleted', text: '', reason: 'resolved' };
+  }
+  if (reject.shown === true) {
+    try { unlinkSync(file); } catch { /* next pre-step retries */ }
+    return { action: 'deleted', text: '' };
+  }
+  const text = renderTagRejectHeader(reject);
+  const next = {
+    ...reject,
+    shown: true,
+    shownAt: new Date(now).toISOString(),
+  };
+  try { writeFileSync(file, JSON.stringify(next, null, 2), 'utf8'); } catch { /* display still valid */ }
+  return { action: 'shown', text, reject: next };
+}

package/src/tags-store.mjs

@@ -0,0 +1,94 @@
+/**
+ * Durable Continuity tag sidecar (~/.dsh/continuity/tags.json).
+ *
+ * Missing is a valid empty state (all T0). Corrupt JSON also falls back to the
+ * empty state instead of throwing; callers record one warning. Writes are
+ * serialized and atomic. Raw session events are never touched.
+ */
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import { emptyTags, normalizeTags } from './tags.mjs';
+
+let writeQueue = Promise.resolve();
+
+export function continuityHome() {
+  const override = process.env.DSH_CONTINUITY_HOME;
+  return override !== undefined && override.length > 0
+    ? override
+    : join(homedir(), '.dsh', 'continuity');
+}
+
+export function tagsFile(home = continuityHome()) {
+  return join(home, 'tags.json');
+}
+
+export function tagsMdFile(home = continuityHome()) {
+  return join(home, 'tags.md');
+}
+
+/** Write the generated tags.md view (never read back by the plugin). */
+export async function writeTagsMd(text, home = continuityHome()) {
+  const dir = home;
+  await mkdir(dir, { recursive: true });
+  const file = tagsMdFile(home);
+  const temp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    await writeFile(temp, String(text ?? ''), 'utf8');
+    await rename(temp, file);
+  } catch (error) {
+    try { await unlink(temp); } catch { /* best effort */ }
+    throw new Error(`continuity: cannot write ${file}: ${error?.message ?? error}`);
+  }
+}
+
+/**
+ * @returns {Promise<{state: object, missing: boolean, corrupt: boolean, error: string|null}>}
+ */
+export async function readTags(home = continuityHome()) {
+  try {
+    const raw = await readFile(tagsFile(home), 'utf8');
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (error) {
+      return { state: emptyTags(), missing: false, corrupt: true, error: error?.message ?? String(error) };
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      return { state: emptyTags(), missing: false, corrupt: true, error: 'tags.json must contain an object' };
+    }
+    return { state: normalizeTags(parsed), missing: false, corrupt: false, error: null };
+  } catch (error) {
+    if (error?.code === 'ENOENT') return { state: emptyTags(), missing: true, corrupt: false, error: null };
+    return { state: emptyTags(), missing: false, corrupt: true, error: error?.message ?? String(error) };
+  }
+}
+
+async function writeTags(state, home = continuityHome()) {
+  const dir = home;
+  await mkdir(dir, { recursive: true });
+  const file = tagsFile(home);
+  const temp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    await writeFile(temp, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+    await rename(temp, file);
+  } catch (error) {
+    try { await unlink(temp); } catch { /* best effort */ }
+    throw new Error(`continuity: cannot write ${file}: ${error?.message ?? error}`);
+  }
+}
+
+/** Serialized read-modify-write. The mutator receives a normalized copy. */
+export async function updateTags(mutate, home = continuityHome()) {
+  const operation = writeQueue.then(async () => {
+    const read = await readTags(home);
+    const working = structuredClone(read.state);
+    const next = await mutate(working);
+    const value = next !== null && next !== undefined && typeof next === 'object' ? next : working;
+    const normalized = normalizeTags({ ...value, updatedAt: new Date().toISOString() });
+    await writeTags(normalized, home);
+    return { state: normalized, recovered: read.missing || read.corrupt, readError: read.error };
+  });
+  writeQueue = operation.catch(() => {});
+  return operation;
+}