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

package/src/backfill.mjs

@@ -0,0 +1,74 @@
+/**
+ * Historical backfill: select content events from the raw session snapshot,
+ * trim incomplete tool pairs at the edges, and build an archival segment.
+ * It never touches the live surface.
+ */
+import { estimateTextTokens, quoteEventText } from './threads.mjs';
+
+export const BACKFILL_TYPES = new Set(['user/message', 'assistant/message', 'tool/call', 'tool/result']);
+
+export function selectBackfillEvents(events, fromSeq, toSeq) {
+  const bySeq = new Map();
+  for (const event of Array.isArray(events) ? events : []) {
+    if (!BACKFILL_TYPES.has(event?.type)) continue;
+    const seq = Number(event?.seq);
+    if (!Number.isInteger(seq) || seq < fromSeq || seq > toSeq) continue;
+    bySeq.set(seq, event);
+  }
+  return [...bySeq.values()].sort((left, right) => Number(left.seq) - Number(right.seq));
+}
+
+/** Drop a leading result or a trailing call; the live hole boundaries are complete. */
+export function trimBackfillEvents(events) {
+  const list = Array.isArray(events) ? [...events] : [];
+  while (list.length > 0 && list[0]?.type === 'tool/result') list.shift();
+  while (list.length > 0 && list[list.length - 1]?.type === 'tool/call') list.pop();
+  return list;
+}
+
+export function buildBackfillSegment(events, {
+  sessionId,
+  why,
+  next,
+  residue,
+  tCoverage = 'T0',
+  now = new Date().toISOString(),
+} = {}) {
+  if (!Array.isArray(events) || events.length === 0) return null;
+  const fromSeq = Number(events[0].seq);
+  const toSeq = Number(events[events.length - 1].seq);
+  let tokens = 0;
+  for (const event of events) tokens += estimateTextTokens(quoteEventText(event));
+  const firstTime = Number(events[0]?.time);
+  const lastTime = Number(events[events.length - 1]?.time);
+  const spanStart = Number.isFinite(firstTime) ? new Date(firstTime).toISOString() : now;
+  const spanEnd = Number.isFinite(lastTime) ? new Date(lastTime).toISOString() : spanStart;
+  return {
+    fromSeq,
+    toSeq,
+    seqs: events.map((event) => Number(event.seq)),
+    count: events.length,
+    spanStart,
+    spanEnd,
+    minutes: Math.max(0, Number(((Date.parse(spanEnd) - Date.parse(spanStart)) / 60000).toFixed(1))),
+    tokens,
+    why,
+    next,
+    ...(residue === undefined ? {} : { residue }),
+    // `at` is content recency (when the conversation happened), not when the
+    // backfill was written. Keep the insertion clock separately.
+    at: spanEnd,
+    archivedAt: now,
+    archiveRef: `log:${sessionId}#seq=${fromSeq}-${toSeq}`,
+    tCoverage,
+  };
+}
+
+export function rangeOverlaps(existing, fromSeq, toSeq) {
+  return (Array.isArray(existing) ? existing : []).some((segment) => {
+    const a = Number(segment?.fromSeq);
+    const b = Number(segment?.toSeq);
+    if (!Number.isFinite(a) || !Number.isFinite(b)) return false;
+    return fromSeq <= b && toSeq >= a;
+  });
+}

package/src/backup.mjs

@@ -0,0 +1,80 @@
+/**
+ * session 冷备份（本机复制）。供引擎每轮调用：距上次 ≥ intervalMs 才真正复制。
+ *
+ * 注意：会话文件正在被追加写，复制可能拿到残缺末帧——所以复制后校验帧，
+ * 末帧解不开只记警告，不删备份。
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import zlib from 'node:zlib';
+
+const MAGIC = Buffer.from([0x28, 0xb5, 0x2f, 0xfd]);
+
+export function sessionFilePath({ home, sid }) {
+  if (!home || !sid) return null;
+  const root = path.join(home, '.dsh', 'sessions');
+  if (!fs.existsSync(root)) return null;
+  for (const dir of fs.readdirSync(root)) {
+    const candidate = path.join(root, dir, sid, 'session.v4.jsonl.zstd');
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+function frameOffsets(buf) {
+  const out = [];
+  let pos = -1;
+  while ((pos = buf.indexOf(MAGIC, pos + 1)) >= 0) out.push(pos);
+  return out;
+}
+
+export function verifySessionFile(file) {
+  const buf = fs.readFileSync(file);
+  const offsets = frameOffsets(buf);
+  if (offsets.length === 0) return { ok: false, reason: 'no-frame', bytes: buf.length };
+  let decoded = 0;
+  let textBytes = 0;
+  for (let i = 0; i < offsets.length; i++) {
+    const start = offsets[i];
+    const end = i + 1 < offsets.length ? offsets[i + 1] : buf.length;
+    try {
+      textBytes += zlib.zstdDecompressSync(buf.subarray(start, end)).toString('utf8').length;
+      decoded += 1;
+    } catch { /* 末帧可能残缺 */ }
+  }
+  return { ok: decoded > 0, bytes: buf.length, frames: offsets.length, decodedFrames: decoded, textBytes };
+}
+
+/**
+ * @returns {{skipped:true, reason:string} | {skipped:false, backup:string, check:object, removed:string[]}}
+ */
+export function maybeBackupSession({ home, sid, intervalMs = 15 * 60 * 1000, keep = 2, force = false, now = Date.now() } = {}) {
+  const src = sessionFilePath({ home, sid });
+  if (src === null) return { skipped: true, reason: 'no-session-file' };
+  const stateFile = path.join(home, '.dsh', 'continuity', 'backup-state.json');
+  let state = { lastAt: 0 };
+  try { state = JSON.parse(fs.readFileSync(stateFile, 'utf8')); } catch { state = { lastAt: 0 }; }
+  if (!force && now - Number(state.lastAt ?? 0) < intervalMs) {
+    return { skipped: true, reason: 'too-soon' };
+  }
+  const stamp = new Date(now).toISOString().replace(/[-:]/g, '').replace(/\.\d+Z$/, '').replace('T', 'T');
+  const destDir = path.join(home, '.dsh', 'archives', stamp);
+  fs.mkdirSync(destDir, { recursive: true });
+  const backup = path.join(destDir, 'session-' + String(sid).replace(/^session-/, '') + '.jsonl.zstd');
+  fs.copyFileSync(src, backup);
+  const check = verifySessionFile(backup);
+
+  const root = path.join(home, '.dsh', 'archives');
+  const mine = fs.readdirSync(root)
+    .map((name) => ({ name, full: path.join(root, name) }))
+    .filter((entry) => fs.existsSync(path.join(entry.full, 'session-' + String(sid).replace(/^session-/, '') + '.jsonl.zstd')))
+    .sort((left, right) => (left.name < right.name ? 1 : -1));
+  const removed = [];
+  for (const entry of mine.slice(keep)) {
+    fs.rmSync(entry.full, { recursive: true, force: true });
+    removed.push(entry.name);
+  }
+  fs.mkdirSync(path.dirname(stateFile), { recursive: true });
+  fs.writeFileSync(stateFile, JSON.stringify({ lastAt: now, lastFile: backup, check }, null, 2), 'utf8');
+  return { skipped: false, backup, check, removed };
+}

package/src/deadend.mjs

@@ -0,0 +1,95 @@
+/**
+ * C7 死胡同症状检测（纯函数）。
+ *
+ * 两条可数症状 + 一条强制提问：
+ *   1. sameSpot   ：同一路径在窗口内被改 ≥ limit 次（“同处改三版”）
+ *   2. fixLoop    ：同一个错误签名在“改动之后”再次出现 ≥2 次（“每次都在补上一版的洞”）
+ *   3. noCriteria ：这一轮在改东西，但回复里没有判据/验收/测试（“说不清改完怎样”）
+ *
+ * 注意：它只报症状，不判“是不是死胡同”——那个判断仍归实例。
+ */
+
+export function pathFromArguments(name, argumentsText) {
+  if (typeof argumentsText !== 'string' || argumentsText.length === 0) return null;
+  if (name !== 'edit' && name !== 'write') return null;
+  try {
+    const parsed = JSON.parse(argumentsText);
+    const path = parsed?.file_path ?? parsed?.path;
+    return typeof path === 'string' && path.length > 0 ? path : null;
+  } catch {
+    const match = argumentsText.match(/"file_path"\s*:\s*"([^"]+)"/);
+    return match === null ? null : match[1];
+  }
+}
+
+/** 为将来多路径留接口；当前只有 edit/write 可靠，所以最多一个。 */
+export function pathsFromArguments(name, argumentsText) {
+  const single = pathFromArguments(name, argumentsText);
+  return single === null ? [] : [single];
+}
+
+export function detectDeadEnds({
+  toolCalls = [],
+  replies = [],
+  errors = [],
+  windowTurns = 8,
+  limit = 3,
+} = {}) {
+  const calls = Array.isArray(toolCalls) ? toolCalls : [];
+  const maxTurn = calls.reduce((max, call) => Math.max(max, Number(call?.turn) || 0), 0);
+  const recent = calls.filter((call) => (Number(call?.turn) || 0) > maxTurn - windowTurns);
+
+  // 1) 同处改三版
+  const byPath = new Map();
+  for (const call of recent) {
+    const paths = Array.isArray(call?.paths) ? call.paths : (typeof call?.path === 'string' ? [call.path] : []);
+    for (const path of paths) {
+      if (typeof path !== 'string' || path.length === 0) continue;
+      const entry = byPath.get(path) ?? { path, turns: new Set(), count: 0 };
+      entry.turns.add(Number(call?.turn) || 0);
+      entry.count += 1;
+      byPath.set(path, entry);
+    }
+  }
+  const sameSpot = [...byPath.values()]
+    .filter((entry) => entry.turns.size >= limit)
+    .map((entry) => ({ path: entry.path, turns: entry.turns.size, edits: entry.count }))
+    .sort((left, right) => right.turns - left.turns);
+
+  // 2) 修完仍同错：同一签名在改动之后又出现
+  const editedTurns = new Set(recent.map((call) => Number(call?.turn) || 0));
+  const bySig = new Map();
+  for (const error of Array.isArray(errors) ? errors : []) {
+    const sig = error?.sig;
+    if (typeof sig !== 'string' || sig.length === 0) continue;
+    const turn = Number(error?.turn) || 0;
+    if (!editedTurns.has(turn)) continue;
+    const entry = bySig.get(sig) ?? { sig, turns: new Set() };
+    entry.turns.add(turn);
+    bySig.set(sig, entry);
+  }
+  const fixLoop = [...bySig.values()]
+    .filter((entry) => entry.turns.size >= 2)
+    .map((entry) => ({ sig: entry.sig, turns: entry.turns.size }));
+
+  // 3) 说不清改完怎样
+  const lastReply = (Array.isArray(replies) ? replies : [])
+    .slice()
+    .sort((left, right) => (Number(left?.turn) || 0) - (Number(right?.turn) || 0))
+    .at(-1);
+  const text = typeof lastReply?.text === 'string' ? lastReply.text : '';
+  // 只在“真的动手改”的轮里才问判据：这一轮必须有 edit/write 调用。
+  // 否则讲哲学、讨论方案也会被误报（第一次上线就是这么翻车的）。
+  const lastTurn = Number(lastReply?.turn) || 0;
+  const touchedFiles = editedTurns.has(lastTurn);
+  const CHANGE_VERB = /(改成|修改|改一下|改代码|改文件|打补丁|patch\s*(一下|掉)?|调整成|重写)/;
+  const changesSomething = touchedFiles && CHANGE_VERB.test(text);
+  const hasCriteria = /判据|验收|测试|验证|证据|怎么算成功|标准/.test(text);
+  const noCriteria = changesSomething && !hasCriteria;
+
+  const symptoms = [];
+  if (sameSpot.length > 0) symptoms.push('同处改多版：' + sameSpot.slice(0, 2).map((entry) => entry.path + '（' + entry.turns + ' 轮）').join('、'));
+  if (fixLoop.length > 0) symptoms.push('改完仍同错：' + fixLoop.slice(0, 2).map((entry) => entry.sig).join('、'));
+  if (noCriteria) symptoms.push('这条改动缺验收标准');
+  return { sameSpot, fixLoop, noCriteria, symptoms };
+}

package/src/deleted-store.mjs

@@ -0,0 +1,35 @@
+/**
+ * Explicit-delete backups (~/.dsh/continuity/deleted/<id>-<ts>.json).
+ * Writes are atomic; nothing here deletes or restores automatically.
+ */
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { mkdir, rename, unlink, writeFile } from 'node:fs/promises';
+
+export function continuityHome() {
+  const override = process.env.DSH_CONTINUITY_HOME;
+  return override !== undefined && override.length > 0
+    ? override
+    : join(homedir(), '.dsh', 'continuity');
+}
+
+export function deletedDir() {
+  return join(continuityHome(), 'deleted');
+}
+
+export async function writeDeletedBackup(id, payload) {
+  const safe = String(id).replace(/[^a-zA-Z0-9._-]/g, '_');
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const dir = deletedDir();
+  await mkdir(dir, { recursive: true });
+  const file = join(dir, `${safe}-${stamp}.json`);
+  const temp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    await writeFile(temp, `${JSON.stringify(payload, 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}`);
+  }
+  return file;
+}