@jjh32456/dsh-longlive 1.6.7 → 1.8.0

package/src/answer/query.js

@@ -0,0 +1,111 @@
+// answer/tool.js — `answer_audit`：只读查询生成后审计。
+//
+// 只在 answerGuard.enabled 时注册（tools/list 默认仍是 22 个基线工具），
+// 与 routerTools / d6Tools 一样由 registerTools 追加，绝不改变默认工具面。
+
+import { auditFilePath, auditMetrics, readAuditRows } from './audit.js';
+
+export const ANSWER_AUDIT_TOOL_NAME = 'answer_audit';
+
+/**
+ * @param {string|null} memoryRoot
+ * @returns {object} tool definition consumed by src/tools.js registerTools
+ */
+export function createAnswerTools(memoryRoot) {
+  const root = typeof memoryRoot === 'string' && memoryRoot.trim() !== '' ? memoryRoot.trim() : null;
+  return [{
+    name: ANSWER_AUDIT_TOOL_NAME,
+    description:
+      'Query the post-generation answer audit written by the 1.6.5 answer guard ' +
+      '(`<memoryRoot>/.longlive/answer-audit.jsonl`). One row per audited turn: whether a ' +
+      'history question was answered without a turn citation, whether the assistant claimed a ' +
+      'tool it never called, numbers/dates absent from context and tool results, and nonexistent ' +
+      'turn/card references. READ-ONLY: it never edits the assistant text or the session log. ' +
+      'Filters: sessionId, turn, verdict (clean|flagged), code (HISTORY_CLAIM_NO_CITATION, ' +
+      'ANSWERED_WITHOUT_EVIDENCE, FAKE_TOOL_CLAIM, UNGROUNDED_NUMBER, FAKE_TURN_REF, FAKE_CARD_REF), ' +
+      'since (ISO time). Default returns the newest 20 rows plus byVerdict/byCode counts.',
+    parameters: {
+      sessionId: {
+        type: 'string',
+        description: 'Only rows for this session id.',
+      },
+      turn: {
+        type: 'integer',
+        description: 'Only rows for this 1-based turn number.',
+      },
+      verdict: {
+        type: 'string',
+        enum: ['clean', 'flagged'],
+        description: 'Only rows with this verdict.',
+      },
+      code: {
+        type: 'string',
+        description: 'Only rows containing this flag code.',
+      },
+      since: {
+        type: 'string',
+        description: 'Only rows at or after this ISO timestamp.',
+      },
+      limit: {
+        type: 'integer',
+        description: 'Maximum rows returned (default 20, max 500).',
+      },
+      summary: {
+        type: 'boolean',
+        description: 'Default true: include byVerdict / byCode / metrics. false returns rows only.',
+      },
+    },
+    output: {
+      schema: { type: 'object', additionalProperties: true },
+      render: (_args, value) => (typeof value === 'string' ? value : JSON.stringify(value, null, 2)),
+    },
+    invoke: (args = {}) => answerAudit(args, { memoryRoot: root }),
+  }];
+}
+
+/**
+ * 工具实现（也直接给测试用）。永远不抛。
+ * @param {object} args
+ * @param {{memoryRoot?:string|null,limit?:number}} config
+ */
+export function answerAudit(args = {}, config = {}) {
+  const memoryRoot = typeof config.memoryRoot === 'string' && config.memoryRoot.trim() !== ''
+    ? config.memoryRoot.trim()
+    : null;
+  if (!memoryRoot) {
+    return {
+      ok: false,
+      code: 'E_NO_MEMORY_ROOT',
+      error: '没有可用的记忆根目录；审计文件位于 <memoryRoot>/.longlive/answer-audit.jsonl。',
+      path: '',
+    };
+  }
+  const limit = Number.isFinite(Number(args.limit))
+    ? Math.max(1, Math.min(500, Number(args.limit)))
+    : 20;
+  const read = readAuditRows(memoryRoot, {
+    limit,
+    sessionId: typeof args.sessionId === 'string' ? args.sessionId : undefined,
+    turn: Number.isFinite(Number(args.turn)) ? Number(args.turn) : undefined,
+    verdict: typeof args.verdict === 'string' ? args.verdict : undefined,
+    code: typeof args.code === 'string' ? args.code : undefined,
+    since: typeof args.since === 'string' ? args.since : undefined,
+  });
+  const base = {
+    ok: read.ok,
+    path: read.path || auditFilePath(memoryRoot),
+    total: read.total,
+    matched: read.matched,
+    corrupt: read.corrupt,
+    ...(read.error ? { note: read.error } : {}),
+    rows: read.rows,
+  };
+  if (args.summary === false) return base;
+  return {
+    ...base,
+    byVerdict: read.byVerdict,
+    byCode: read.byCode,
+    sessions: read.sessions,
+    metrics: auditMetrics(read.rows),
+  };
+}

package/src/answer/second-hop.mjs

@@ -0,0 +1,101 @@
+// src/answer/second-hop.mjs — B4：证据包字段覆盖不足 → 第二跳补读（最多 1 跳）
+//
+// §11.6-B4：证据包「字段覆盖检查」不足 → 补读第二跳（最多 1 跳）。
+// 断言口径：构造缺 when 的证据 → 触发第二跳。本模块不猜内容：第二跳只放宽
+// 证据检索阈值/条数并回读相邻轮，字段仍缺则如实返回 missingFieldsAfter。
+
+export const SECOND_HOP_SCHEMA = 'second-hop/v1';
+export const DEFAULT_REQUIRED_FIELDS = Object.freeze(['when']);
+
+const WHEN_PATTERNS = [
+  /\d{4}[-/年]\d{1,2}[-/月]\d{1,2}/u,
+  /\d{4}[-/年]\d{1,2}月?/u,
+  /今天|今日|昨天|昨日|前天|明天|后天|上周|本周|上周[一二三四五六日天]|周[一二三四五六日天]/u,
+  /\d{1,2}\s*月\s*\d{1,2}\s*日/u,
+  /\d{1,2}[:：]\d{2}/u,
+  /刚才|刚刚|之前|上次|上次那回/u,
+];
+
+/** Check which required dimensions the evidence text covers. */
+export function evidenceFieldCoverage(items, { requiredFields = DEFAULT_REQUIRED_FIELDS } = {}) {
+  const text = (Array.isArray(items) ? items : [])
+    .map((item) => [item?.user, item?.assistant].filter(Boolean).join('\n'))
+    .join('\n');
+  const present = {
+    when: WHEN_PATTERNS.some((pattern) => pattern.test(text)),
+    what: text.trim() !== '',
+    who: /[\u3400-\u9fffA-Za-z]{2,}/u.test(text),
+  };
+  const missingFields = (Array.isArray(requiredFields) ? requiredFields : DEFAULT_REQUIRED_FIELDS)
+    .filter((field) => present[field] !== true);
+  return { requiredFields: [...requiredFields], present, missingFields, covered: missingFields.length === 0 };
+}
+
+function turnNumbers(items) {
+  return (Array.isArray(items) ? items : []).map((item) => Number(item?.turn)).filter(Number.isFinite);
+}
+
+/**
+ * First hop + at most one second hop. `retrieve` is injected (pure/testable seam).
+ * Returns the first-hop result extended with `items` (first + added second-hop turns)
+ * and a `secondHop` receipt. Never exceeds one extra hop.
+ */
+export function retrieveEvidenceWithSecondHop({
+  turns = [],
+  question = '',
+  currentTurn = 0,
+  maxItems = 3,
+  minScore = 1.8,
+  retrieve,
+  requiredFields = DEFAULT_REQUIRED_FIELDS,
+  relaxFactor = 0.6,
+  maxHop = 1,
+} = {}) {
+  if (typeof retrieve !== 'function') throw new Error('E_SECOND_HOP_RETRIEVE: retrieve function required');
+  const first = retrieve({ turns, question, currentTurn, maxItems, minScore });
+  const coverageFirst = evidenceFieldCoverage(first?.items, { requiredFields });
+  if (coverageFirst.covered || maxHop < 1) {
+    return {
+      ...first,
+      secondHop: {
+        schema: SECOND_HOP_SCHEMA,
+        triggered: false,
+        reason: coverageFirst.covered ? 'covered' : 'max-hop',
+        missingFieldsFirst: coverageFirst.missingFields,
+        addedTurns: [],
+        missingFieldsAfter: coverageFirst.missingFields,
+        hop: 1,
+        maxHop,
+      },
+    };
+  }
+  const relaxedMinScore = Math.max(0, Number(minScore) * Number(relaxFactor));
+  const second = retrieve({
+    turns,
+    question,
+    currentTurn,
+    maxItems: Math.max(1, Number(maxItems) + 2),
+    minScore: relaxedMinScore,
+  });
+  const firstTurns = new Set(turnNumbers(first?.items));
+  const added = (Array.isArray(second?.items) ? second.items : []).filter((item) => !firstTurns.has(Number(item?.turn)));
+  const combined = [...(Array.isArray(first?.items) ? first.items : []), ...added].slice(0, Math.max(1, Number(maxItems) + 2));
+  const coverageAfter = evidenceFieldCoverage(combined, { requiredFields });
+  return {
+    ...first,
+    items: combined,
+    zeroHit: combined.length === 0,
+    secondHop: {
+      schema: SECOND_HOP_SCHEMA,
+      triggered: true,
+      reason: 'field-coverage',
+      missingFieldsFirst: coverageFirst.missingFields,
+      addedTurns: added.map((item) => Number(item.turn)).filter(Number.isFinite),
+      missingFieldsAfter: coverageAfter.missingFields,
+      filled: coverageAfter.covered,
+      hop: 2,
+      maxHop,
+      relaxedMinScore,
+    },
+  };
+}

package/src/auto-truncate.js

@@ -55,7 +55,7 @@ import {
 // `autoTruncate: {}` cannot cut a session by accident; `mode:'request'` also
 // requires enabled:true, and the runner additionally needs the watchdog.
 export const AUTO_TRUNCATE_DEFAULTS = Object.freeze({
-  enabled: false,
+  enabled: true,
   mode: 'dryrun',
   tokensThreshold: 300_000,
   minTurns: 12,