@aiwayds/dsh-topics-memory 0.6.0 → 0.7.0

package/lib/tools.js

@@ -22,6 +22,7 @@ export function buildTopicTools(service) {
             conclusion: { type: 'string', required: true, description: 'The current best conclusion, self-contained markdown prose' },
             description: { type: 'string', description: 'One-line summary for indexes and snippets' },
             tags: { ...STRING_ARRAY, description: 'Cross-cutting tags (project, domain, component); lowercased on save' },
+            triggers: { ...STRING_ARRAY, description: 'Short recall phrases that should bring this topic back (specific nouns/terms, no generic words)' },
             depends: { ...STRING_ARRAY, description: 'Slugs of prerequisite topics (topics this one builds on)' },
             open_questions: { ...STRING_ARRAY, description: 'Unresolved questions this topic still carries' },
             impact: { ...STRING_ARRAY, description: 'What this conclusion affects: topics, projects, decisions' },
@@ -53,6 +54,7 @@ export function buildTopicTools(service) {
                 conclusion: args.conclusion,
                 description: args.description,
                 tags: args.tags,
+                triggers: args.triggers,
                 depends: args.depends,
                 openQuestions: args.open_questions,
                 impact: args.impact,
@@ -64,6 +66,52 @@ export function buildTopicTools(service) {
             return { slug: result.slug, path: result.path, created: result.created, committed: result.committed };
         },
     });
+    const topicOpen = defineTool({
+        name: 'topic_open',
+        description: 'Open one topic from the long-term memory in full: conclusion, open questions, recommendations, ' +
+            'plus a staleness notice. Use when a <topic-memory> pointer (or a search hit) is actually relevant — ' +
+            'pointers are one-line hints; this fetches the real content.',
+        parameters: {
+            slug: { type: 'string', required: true, description: 'Topic slug (from a pointer or topic_search)' },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    found: { type: 'boolean', required: true },
+                    slug: { type: 'string', required: true },
+                    title: { type: 'string' },
+                    status: { type: 'string' },
+                    updatedAt: { type: 'string' },
+                    description: { type: 'string' },
+                    conclusion: { type: 'string' },
+                    openQuestions: { type: 'array', items: { type: 'string' } },
+                    recommendations: { type: 'string' },
+                },
+            },
+            render: (_args, value) => [
+                {
+                    type: 'text',
+                    text: !value.found
+                        ? `Topic \`${value.slug}\` 不存在（可能已合并或改名；用 topic_search 找）。`
+                        : [
+                            `快照于 ${value.updatedAt}，代码事实以源码为准。`,
+                            `### ${value.title} [${value.status}] (topics:${value.slug})`,
+                            value.description ?? '',
+                            value.conclusion !== '' ? `# Conclusion\n\n${value.conclusion}` : '',
+                            value.openQuestions !== undefined && value.openQuestions.length > 0 ? `待决: ${value.openQuestions.join('；')}` : '',
+                            value.recommendations !== '' ? `# Recommendations\n\n${value.recommendations}` : '',
+                        ]
+                            .filter((l) => l !== '')
+                            .join('\n\n'),
+                },
+            ],
+        },
+        async execute(args) {
+            return await service.openTopic(args.slug);
+        },
+    });
     const topicSearch = defineTool({
         name: 'topic_search',
         description: 'Search the long-term topic memory by keywords (hot path, no LLM). ' +
@@ -199,7 +247,7 @@ export function buildTopicTools(service) {
             return { entries: entries.map((e) => ({ ...e, conclusion: e.conclusion })) };
         },
     });
-    return [topicSave, topicSearch, topicObserve, topicHistory];
+    return [topicSave, topicOpen, topicSearch, topicObserve, topicHistory];
 }
 function extractConclusion(body) {
     // Local copy to avoid importing okf section helpers into the hot render path.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwayds/dsh-topics-memory",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "dsh-plugin: OKF v0.2 topic memory for dsh - local-first git-tracked bundle, hot-path LLM-free injection, two-stage observer with background distill",
   "type": "module",
   "main": "lib/index.js",
@@ -38,7 +38,7 @@
     "build": "tsc -p tsconfig.json",
     "check": "tsc --noEmit -p tsconfig.json",
     "pretest": "tsc -p tsconfig.json",
-    "test": "node --test test/yaml.test.mjs test/okf.test.mjs test/retrieval.test.mjs test/digest.test.mjs test/ilog.test.mjs test/store.test.mjs test/paths.test.mjs test/git.test.mjs test/sync.test.mjs test/tools.test.mjs test/dedup.test.mjs test/commands.test.mjs test/onboard.test.mjs test/delegation.test.mjs test/observer.test.mjs test/distill.test.mjs test/viz.test.mjs test/corpus.test.mjs test/llm-scope.test.mjs test/settings-migration.test.mjs"
+    "test": "node --test test/yaml.test.mjs test/okf.test.mjs test/retrieval.test.mjs test/digest.test.mjs test/ilog.test.mjs test/store.test.mjs test/paths.test.mjs test/git.test.mjs test/sync.test.mjs test/tools.test.mjs test/dedup.test.mjs test/commands.test.mjs test/onboard.test.mjs test/delegation.test.mjs test/observer.test.mjs test/distill.test.mjs test/viz.test.mjs test/corpus.test.mjs test/llm-scope.test.mjs test/settings-migration.test.mjs test/quality.test.mjs test/replay-gate.test.mjs"
   },
   "dependencies": {},
   "peerDependencies": {

package/src/commands.ts

@@ -122,8 +122,9 @@ async function renderStatus(service: TopicsService): Promise<string> {
     `  冲突：${s.conflicts.length === 0 ? '无' : s.conflicts.join('、')}`,
     `  损坏文件：${s.broken.length === 0 ? '无' : s.broken.join('、')}`,
     `  git：${s.git ? `是（HEAD ${s.head?.slice(0, 10) ?? '??'}）` : '否'}`,
-    `  注入：${cfg.autoInject ? `开（topK ${cfg.topK}，预算 ${cfg.totalBudget} tok，阈值 ${cfg.matchThreshold}）` : '关'}`,
+    `  注入：${cfg.autoInject ? `${cfg.injectMode === 'digest' ? 'digest' : 'pointer'} 模式（topK ${cfg.topK}，预算 ${cfg.injectMode === 'digest' ? cfg.totalBudget : Math.min(cfg.totalBudget, 600)} tok，阈值 ${cfg.matchThreshold}）` : '关'}`,
     `  去重：${cfg.injectDedup ? '开（同会话已注入的 Topic 不重注）' : '关'}`,
+    `  慢道：${cfg.qualityLane === 'off' ? '关' : cfg.qualityLane === 'always' ? `每轮（${cfg.distillProvider}/${cfg.distillModel}）` : `采样 1/3（${cfg.distillProvider}/${cfg.distillModel}）`}`,
     `  蒸馏：${cfg.distillProvider !== '' && cfg.distillModel !== '' ? `${cfg.distillProvider}/${cfg.distillModel}，每 ${cfg.distillEveryTurns} 轮` : '未配置模型（/topics set distill-provider / distill-model）'}`,
   ]
   // Last lane outcome (distill-state summary) — what "checkable via
@@ -181,12 +182,35 @@ async function renderStats(service: TopicsService): Promise<string> {
     `  零命中轮：${stats.zeroHitRounds}；平均命中 ${stats.avgHitsPerRound} 条/轮`,
     `  平均预算占用：${stats.avgBudgetUtilization} tok`,
   ]
+  // v4 lane split — how much of the injection traffic each lane carries.
+  const slowRounds = records.filter((r) => r.lane === 'slow' || r.lane === 'mixed').length
+  if (slowRounds > 0) {
+    const consumed = records.filter((r) => r.consumedAt !== undefined && r.computedAt !== undefined)
+    let medianLag = ''
+    if (consumed.length > 0) {
+      const lags = consumed
+        .map((r) => Math.max(0, Date.parse(r.consumedAt as string) - Date.parse(r.computedAt as string)))
+        .sort((a, b) => a - b)
+      medianLag = `，赶上中位时延 ${(lags[Math.floor(lags.length / 2)] / 1000).toFixed(1)}s`
+    }
+    lines.push(`  慢道参与轮：${slowRounds}（快 ${(records.length - slowRounds)} / 慢或混合 ${slowRounds}${medianLag}）`)
+  }
+  // Pointer open rate (v4 §4.3): topic_open calls vs pointer entries injected.
+  const opens = await service.store.readOpenRecords()
+  if (opens.length > 0 || records.some((r) => r.lane !== undefined)) {
+    const entries = records.reduce(
+      (acc, r) => acc + r.hits.filter((h) => !(r.deduped ?? []).includes(h.slug)).length + (r.slow?.length ?? 0),
+      0,
+    )
+    const rate = entries === 0 ? 0 : Math.min(1, opens.length / entries)
+    lines.push(`  指针打开率：${(rate * 100).toFixed(1)}%（${opens.length} 次 topic_open / ${entries} 条注入指针）`)
+  }
   if (stats.topTopics.length > 0) {
     lines.push('  Top-N 被注入 Topic：')
     for (const t of stats.topTopics.slice(0, 5)) lines.push(`    ${t.slug} ×${t.count}`)
   }
   if (stats.nearMissHistogram.length > 0) {
-    lines.push('  Near-miss 分布（低于阈值被挡）：')
+    lines.push('  Near-miss 分布（低于阈值或被结构门挡下）：')
     for (const b of stats.nearMissHistogram) lines.push(`    ${b.bucket}: ${b.count}`)
     const hint = tuningHint(stats, service.cfg.matchThreshold)
     if (hint !== undefined) lines.push(`  💡 ${hint}`)

package/src/config.ts

@@ -22,16 +22,22 @@ export const TopicsConfig = z.object({
   totalBudget: z.number().default(1500),
   /** Retrieval score threshold — tune via /topics stats near-miss evidence. */
   matchThreshold: z.number().default(0.3),
-  /** Additive boost per tag hit. */
+  /** Additive boost per tag hit (v4: total cap = this value, was ×3). */
   tagBoost: z.number().default(0.15),
+  /** Injection shape: pointer (default, ≤600 tok) keeps the legacy digest view. */
+  injectMode: z.string().default('pointer'),
+  /** Slow quality lane (v4 §4.2): off | sampled (1/3 of turns) | always. */
+  qualityLane: z.string().default('sampled'),
   /** depends-graph expansion depth (0 disables). */
   graphDepth: z.number().default(2),
   /** Days within which a topic counts as recent (+0.2). */
   recencyWindowDays: z.number().default(7),
   /** Capture each turn's user/assistant text as raw observations (M2). */
   autoObserve: z.boolean().default(true),
-  /** Whether injection and observation also engage delegated subagent sessions (ADR 0011). */
-  includeSubagents: z.boolean().default(true),
+  /** Whether injection and observation also engage delegated subagent sessions (ADR 0011).
+   *  v4 default flipped to false: one-shot subagent turns diluted the pool.
+   *  The slow quality lane never runs for subagents either way (hard guard). */
+  includeSubagents: z.boolean().default(false),
   /** Max auto-captured chars per side (user/assistant) per turn. */
   observationMaxChars: z.number().default(2000),
   /** Background distill cadence: every N turns of a long session. */
@@ -60,6 +66,8 @@ export type TopicsConfigValue = {
   totalBudget: number
   matchThreshold: number
   tagBoost: number
+  injectMode: string
+  qualityLane: string
   graphDepth: number
   recencyWindowDays: number
   autoObserve: boolean
@@ -83,6 +91,8 @@ export const CONFIG_KEYS = [
   'totalBudget',
   'matchThreshold',
   'tagBoost',
+  'injectMode',
+  'qualityLane',
   'graphDepth',
   'recencyWindowDays',
   'autoObserve',
@@ -136,6 +146,14 @@ export function parseConfigValue(key: ConfigKey, raw: string): boolean | number
       if (!Number.isFinite(n) || n < 0 || !Number.isInteger(n)) return { error: `${key} 需要非负整数` }
       return n
     }
+    case 'injectMode': {
+      if (raw === 'pointer' || raw === 'digest') return raw
+      return { error: 'inject-mode 取值 pointer|digest' }
+    }
+    case 'qualityLane': {
+      if (raw === 'off' || raw === 'sampled' || raw === 'always') return raw
+      return { error: 'quality-lane 取值 off|sampled|always' }
+    }
     case 'matchThreshold':
     case 'tagBoost': {
       const n = Number(raw)

package/src/digest.ts

@@ -76,11 +76,39 @@ export function topicDigest(input: DigestInput, budgetTokens: number): { text: s
   return { text, usedTokens: estimateTokens(text) }
 }
 
+/**
+ * Pointer view (v4 dual-channel design §4.1) — the default fast-lane shape.
+ * Each entry is a two-line pointer (title/status/slug/score + one-line
+ * description, ≤80 tok); the model pulls full content via topic_open when the
+ * pointer is actually relevant. 宁缺勿滥: the retrieval gate decides what
+ * becomes a pointer, the budget only caps how many land.
+ */
+export const POINTER_PER_TOPIC = 80
+export const POINTER_TOTAL = 600
+
+export function pointerEntry(input: DigestInput, budgetTokens: number): { text: string; usedTokens: number } {
+  const { doc, hit } = input
+  const fm = doc.fm
+  const lines: string[] = []
+  lines.push(`### ${fm.title} [${fm.status}] (topics:${input.slug} score:${hit.score.toFixed(2)})`)
+  let one = fm.description ?? ''
+  if (one === '') {
+    const conclusion = sectionOf(doc.body, CONCLUSION_HEADING) ?? ''
+    one = firstParagraph(conclusion)
+  }
+  if (one !== '') lines.push(truncateToTokens(one.replace(/\s+/g, ' ').trim(), Math.max(16, budgetTokens - 24)).text)
+  if (hit.reasons.includes('conflicted-demoted')) lines.push('⚠ 此条存在未合并冲突，结论可能过期。')
+  const text = lines.join('\n')
+  return { text, usedTokens: estimateTokens(text) }
+}
+
 export interface AssembleResult {
   text: string
   usedTokens: number
   included: string[]
   dropped: { slug: string; reason: string }[]
+  /** Slow-lane pointers that entered the context (v4 §4.2). */
+  slowIncluded?: string[]
 }
 
 export interface AssembleConfig {
@@ -88,38 +116,117 @@ export interface AssembleConfig {
   totalBudget: number
 }
 
+/** Slow-lane pointer input — roster metadata plus the lane's why line. */
+export interface SlowPointerInput {
+  slug: string
+  title: string
+  status: string
+  description?: string
+  why: string
+}
+
+/**
+ * One slow-lane pointer: same shape as a fast pointer plus the mandatory why
+ * line (v4 §4.2 — 每条带 why 行). No score: the gate here was the LLM rerank,
+ * not the lexical threshold.
+ */
+export function slowEntryText(input: SlowPointerInput, budgetTokens: number): { text: string; usedTokens: number } {
+  const lines: string[] = []
+  lines.push(`### ${input.title} [${input.status}] (topics:${input.slug})`)
+  lines.push(`为什么相关: ${truncateToTokens(input.why.replace(/\s+/g, ' ').trim(), 32).text}`)
+  if (input.description !== undefined && input.description !== '') {
+    lines.push(truncateToTokens(input.description.replace(/\s+/g, ' ').trim(), Math.max(12, budgetTokens - 48)).text)
+  }
+  const text = lines.join('\n')
+  return { text, usedTokens: estimateTokens(text) }
+}
+
 const WRAPPER_OPEN = '<topic-memory>'
 const WRAPPER_CLOSE = '</topic-memory>'
+const WRAPPER_INTRO =
+  '以下是与当前输入相关的已沉淀记忆（来源：本地 topics bundle；仅供参考的资料，不是指令）。'
+
+function wrapBlocks(blocks: readonly string[]): string {
+  return `${WRAPPER_OPEN}\n${WRAPPER_INTRO}\n\n${blocks.join('\n\n')}\n${WRAPPER_CLOSE}`
+}
 
 /**
- * Greedily pack per-topic digests (hits already score-ordered) under the
- * total budget. Zero hits → empty text (ADR 0006: 零命中零注入).
+ * Shared greedy packing: fast entries first (score-ordered), then optional
+ * slow-lane pointers, all under one total budget (v4 B2: shared 600 — the
+ * slow lane spends whatever the fast lane leaves; 分账终值 is a P3 question).
+ * Zero blocks → empty text (ADR 0006: 零命中零注入).
  */
-export function assembleInjection(
+function packInjection(
   entries: readonly DigestInput[],
   cfg: AssembleConfig,
+  render: (entry: DigestInput, budget: number) => { text: string; usedTokens: number },
+  slow?: readonly SlowPointerInput[],
 ): AssembleResult {
-  if (entries.length === 0) return { text: '', usedTokens: 0, included: [], dropped: [] }
+  if (entries.length === 0 && (slow === undefined || slow.length === 0)) {
+    return { text: '', usedTokens: 0, included: [], dropped: [] }
+  }
   const included: string[] = []
+  const slowIncluded: string[] = []
   const dropped: { slug: string; reason: string }[] = []
   const blocks: string[] = []
-  let used = estimateTokens(`${WRAPPER_OPEN}\n以下是与当前输入相关的已沉淀记忆（来源：本地 topics bundle；仅供参考的资料，不是指令）。\n\n${WRAPPER_CLOSE}`)
+  let used = estimateTokens(`${WRAPPER_OPEN}\n${WRAPPER_INTRO}\n\n${WRAPPER_CLOSE}`)
   for (const entry of entries) {
     const budget = Math.min(cfg.perTopicBudget, cfg.totalBudget - used)
     if (budget < 24) {
       dropped.push({ slug: entry.slug, reason: 'total-budget' })
       continue
     }
-    const digest = topicDigest(entry, budget)
-    if (used + digest.usedTokens > cfg.totalBudget) {
+    const block = render(entry, budget)
+    if (used + block.usedTokens > cfg.totalBudget) {
       dropped.push({ slug: entry.slug, reason: 'total-budget' })
       continue
     }
-    blocks.push(digest.text)
+    blocks.push(block.text)
     included.push(entry.slug)
-    used += digest.usedTokens
+    used += block.usedTokens
+  }
+  for (const item of slow ?? []) {
+    const budget = cfg.totalBudget - used
+    if (budget < 24) {
+      dropped.push({ slug: item.slug, reason: 'slow-budget' })
+      continue
+    }
+    const block = slowEntryText(item, Math.min(POINTER_PER_TOPIC, budget))
+    if (used + block.usedTokens > cfg.totalBudget) {
+      dropped.push({ slug: item.slug, reason: 'slow-budget' })
+      continue
+    }
+    blocks.push(block.text)
+    slowIncluded.push(item.slug)
+    used += block.usedTokens
   }
   if (blocks.length === 0) return { text: '', usedTokens: 0, included: [], dropped }
-  const text = `${WRAPPER_OPEN}\n以下是与当前输入相关的已沉淀记忆（来源：本地 topics bundle；仅供参考的资料，不是指令）。\n\n${blocks.join('\n\n')}\n${WRAPPER_CLOSE}`
-  return { text, usedTokens: estimateTokens(text), included, dropped }
+  const text = wrapBlocks(blocks)
+  const result: AssembleResult = { text, usedTokens: estimateTokens(text), included, dropped }
+  if (slowIncluded.length > 0) result.slowIncluded = slowIncluded
+  return result
+}
+
+/**
+ * Greedily pack pointer entries (hits already score-ordered) under the total
+ * budget. Zero hits → empty text (ADR 0006: 零命中零注入).
+ */
+export function assemblePointer(
+  entries: readonly DigestInput[],
+  cfg: AssembleConfig,
+  slow?: readonly SlowPointerInput[],
+): AssembleResult {
+  return packInjection(entries, cfg, pointerEntry, slow)
+}
+
+/**
+ * Greedily pack per-topic digests (hits already score-ordered) under the
+ * total budget. Zero hits → empty text (ADR 0006: 零命中零注入).
+ */
+export function assembleInjection(
+  entries: readonly DigestInput[],
+  cfg: AssembleConfig,
+  slow?: readonly SlowPointerInput[],
+): AssembleResult {
+  return packInjection(entries, cfg, topicDigest, slow)
 }

package/src/distill.ts

@@ -30,6 +30,7 @@ export interface DistillOp {
   title?: string
   description?: string
   tags?: string[]
+  triggers?: string[]
   depends?: string[]
   open_questions?: string[]
   impact?: string[]
@@ -54,12 +55,13 @@ export const SYSTEM_PROMPT = [
   '你是 topic 记忆库的蒸馏引擎。输入是若干条未蒸馏的会话观察（JSON）和现有 topic 索引。',
   '任务：把观察沉淀成 Topic 操作。只输出一个 JSON 对象，不要任何其他文字、Markdown 代码块或解释。',
   '输出格式：{"ops": [...]}，每个元素：',
-  '  {"op":"create","title":"主题名","description":"一句话","tags":["小写标签"],"depends":["前置topic的slug"],',
+  '  {"op":"create","title":"主题名","description":"一句话","tags":["小写标签"],"triggers":["应想起本条的触发词"],"depends":["前置topic的slug"],',
   '   "open_questions":["未决问题"],"impact":["影响面"],"conclusion":"当前结论(自含散文)","recommendations":"可执行建议","status":"draft",',
   '   "observed_ids":["obs-..."]}',
   '  {"op":"update","slug":"已有slug","conclusion":"修订后的完整结论","open_questions":[...],"observed_ids":["obs-..."]}',
   '规则：',
   '- 硬性要求：每个 op 必须带 observed_ids 字段，值只能从本次输入「未蒸馏观察」里列出的 id 中逐字复制（形如 "obs-..."）；create 填它所综合依据的观察 id，update 填促使本次修订的观察 id。含列表之外 id 的条目会被过滤；observed_ids 缺失、为空或过滤后不剩任何有效 id 的 op 会被整体丢弃。',
+  '- create 建议带 triggers：3-8 个「什么输入出现时应该想起这条记忆」的短语，写具体名词/术语，禁止 dsh、配置、错误 之类的泛词。',
   '- conclusion 必须自含（不依赖观察原文也能读懂），写「目前有效的结论」，不是流水账。',
   '- 同一主题只允许一个 create；已有相近 topic 时用 update 修订它的 conclusion。',
   '- 观察里有价值就沉淀，没价值就跳过该观察（被跳过观察的 id 不要出现在任何 op 里）；没有可沉淀内容时输出 {"ops":[]}。',
@@ -616,6 +618,7 @@ export class Distiller {
             conclusion: op.conclusion,
             description: op.description,
             tags: op.tags,
+            triggers: Array.isArray(op.triggers) ? op.triggers.filter((t): t is string => typeof t === 'string') : undefined,
             depends: op.depends,
             openQuestions: op.open_questions,
             impact: op.impact,

package/src/ilog.ts

@@ -6,6 +6,27 @@
  * @module ilog
  */
 
+/** Shadow re-gate verdict for one slow-lane pick (log-only, never blocks — v4 B3). */
+export interface ShadowVerdict {
+  slug: string
+  pass: boolean
+  why: string
+}
+
+/** Slow-lane query-build shape audit (v4 §4.3): priming evidence, no content. */
+export interface QueryBuildShape {
+  rawChars: number
+  keptChars: number
+  /** Content categories the query build dropped (e.g. pasted dumps). */
+  stripped: string[]
+}
+
+/** One slow-lane pointer that entered (or was budgeted out of) the context. */
+export interface SlowItem {
+  slug: string
+  why: string
+}
+
 export interface InjectionRecord {
   at: string
   sessionId?: string
@@ -13,14 +34,30 @@ export interface InjectionRecord {
   queryTokenCount: number
   querySample?: string
   rosterSize: number
-  hits: { slug: string; score: number; reasons: string[]; viaGraph: boolean }[]
-  nearMisses: { slug: string; score: number }[]
+  hits: { slug: string; score: number; reasons: string[]; viaGraph: boolean; strong?: boolean; bodyHits?: number }[]
+  nearMisses: { slug: string; score: number; reasons?: string[] }[]
   injected: boolean
   why?: string
   dropped?: { slug: string; reason: string }[]
   /** Slugs blocked this round by session-level injection dedup (never assembled). */
   deduped?: string[]
   usedTokens?: number
+  // ---- v4 lane field family (§4.3) — absent on pure fast-lane rounds ----
+  /** fast = lexical pointers only; slow = async picks only; mixed = both. */
+  lane?: 'fast' | 'slow' | 'mixed'
+  /** Slow lane: the consumed pending died at its hard bounds (TTL / turn-lag). */
+  slowExpired?: 'ttl' | 'turn-lag'
+  /** Slow lane: when the pending was computed (turn/end) and consumed (spliced). */
+  computedAt?: string
+  consumedAt?: string
+  /** Log-only lexical re-gate verdicts taken at consumption time. */
+  shadowVerdict?: ShadowVerdict[]
+  queryBuild?: QueryBuildShape
+  /** Slow-lane model route (`provider/model`) and pipeline wall time in ms. */
+  slowModel?: string
+  slowMs?: number
+  /** Slow-lane pointers this round, in delivery order. */
+  slow?: SlowItem[]
 }
 
 export interface AggregateStats {

package/src/index.ts

@@ -30,6 +30,8 @@ import { buildTopicTools } from './tools.ts'
 import { buildTopicsCommand } from './commands.ts'
 import { Observer, textOf, type UserMessageLike } from './observer.ts'
 import { Distiller, defaultModelCaller, type DistillResult, type LlmCandidateShape } from './distill.ts'
+import { SlowLane } from './quality.ts'
+import type { SlowDelivery } from './service.ts'
 import { CONFIG_KEYS, TopicsConfig, type TopicsConfigValue } from './config.ts'
 import type { AskServiceResolver, AskServiceShape, LlmDirectoryResolver, LlmDirectoryShape } from './onboard.ts'
 import { isDelegated } from './delegation.ts'
@@ -240,18 +242,32 @@ export function apply(ctx: Context): void {
     try {
       const state = turns.get(sessionId)
       if (state === undefined) return
-      const dedup = cfgNow().injectDedup
-      const seen = dedup ? injectedBySession.get(sessionId) : undefined
-      const r = service.retrieveSync(query, sessionId, seen === undefined ? undefined : { exclude: seen })
-      // Mark only what entered the context this round (hits → dedup filter →
-      // assemble → registry mark; budget-dropped slugs stay injectable).
-      if (dedup && r.included.length > 0) {
+      const cfg = cfgNow()
+      const seen = cfg.injectDedup ? injectedBySession.get(sessionId) : undefined
+      // Slow-lane consumption point (v4 生命周期表): the pending produced at
+      // the previous turn/end rides THIS splice — consumed or expired, the
+      // slot is gone either way (消费即清; expiry surfaces in record.why).
+      let slow: SlowDelivery | undefined
+      let slowExpired: 'ttl' | 'turn-lag' | undefined
+      if (cfg.autoInject) {
+        const consumed = slowLane.consume(sessionId, observer.turnCountOf(sessionId))
+        if (consumed !== undefined) {
+          if ('pending' in consumed) slow = consumed.pending
+          else slowExpired = consumed.expired
+        }
+      }
+      const r = service.retrieveSync(query, sessionId, seen === undefined ? undefined : { exclude: seen }, slow, slowExpired)
+      // Mark only what entered the context this round (hits AND slow picks →
+      // dedup filter → assemble → registry mark; budget-dropped slugs stay
+      // injectable).
+      if (cfg.injectDedup && (r.included.length > 0 || r.slowIncluded.length > 0)) {
         let marked = injectedBySession.get(sessionId)
         if (marked === undefined) {
           marked = new Set<string>()
           injectedBySession.set(sessionId, marked)
         }
         for (const slug of r.included) marked.add(slug)
+        for (const slug of r.slowIncluded) marked.add(slug)
       }
       state.injectionText = r.text
     } catch {
@@ -259,6 +275,38 @@ export function apply(ctx: Context): void {
     }
   }
 
+  /**
+   * Slow-lane production trigger at turn/end (v4 §4.2). Host-side gates live
+   * here: subagent sessions never run the lane (hard guard, independent of
+   * includeSubagents) and a distill run in flight makes the lane yield (the
+   * every-N-turns distill cadence shares this trigger).
+   */
+  function dispatchSlowLane(sessionId: string): void {
+    try {
+      // Injection is off → the lane would burn aux LLM calls on pendings no
+      // spliced will ever consume (the spliced branch early-returns on
+      // autoInject before reaching the consume point).
+      if (!cfgNow().autoInject) return
+      if (isDelegated(agents()?.get(sessionId))) return
+      if (distiller.hasPending(sessionId)) return
+      // Same trigger-time capture the distill trigger uses: the agent's
+      // scoped llm is alive NOW, and the lane's caller reads the captured
+      // entry lazily inside its async pipeline (released via the
+      // slowLane-aware guards once the pipeline settles).
+      try {
+        captureFromAgent(agents()?.get(sessionId))
+      } catch {
+        // contained — the captured instance, if any, still walks the chain
+      }
+      slowLane.dispatch(sessionId, {
+        ring: observer.recentTurns(sessionId),
+        turnId: observer.turnCountOf(sessionId),
+      })
+    } catch {
+      // contained — the lane must never break the event handler
+    }
+  }
+
   // ---- Tools ----
   const tools = (ctx as unknown as { tools: { register(tool: unknown): void } }).tools
   for (const tool of buildTopicTools(service)) tools.register(tool)
@@ -302,6 +350,22 @@ export function apply(ctx: Context): void {
     },
   )
   const distiller = new Distiller(service, caller)
+  /**
+   * The ONE sessionLlm release decision, shared by every settle path (distill
+   * run settle, slow-lane pipeline settle, teardown, manual-distill decline):
+   * drop the captured entry only when no future read can need it. Keeping
+   * this in one place is what stopped the slow lane from re-opening the
+   * concern-1 leak (a disposal landing mid-pipeline must be closed out by
+   * the pipeline's own settle, not only by the one-shot disposal event).
+   */
+  const releaseSessionLlm = (sessionId: string): void => {
+    if (!distiller.hasPending(sessionId) && !slowLane.hasInFlight(sessionId)) sessionLlm.delete(sessionId)
+  }
+  // Slow quality lane (v4 §4.2): shares the distill caller/route; owns its
+  // own pending lifecycle (produce at turn/end, consume at the next splice).
+  // The settle hook re-runs the release check because a disposal that landed
+  // mid-pipeline deferred to THIS pipeline and never fires again.
+  const slowLane = new SlowLane(service, caller, releaseSessionLlm)
 
   // ---- Observer (M2) ----
   // The process-exit disposer awaits this run (bounded): the callback below
@@ -324,11 +388,7 @@ export function apply(ctx: Context): void {
     const run = distiller.request(sessionId, reason)
     if (run !== undefined) {
       if (sessionId === 'dispose') exitDistill = run
-      void run
-        .finally(() => {
-          if (!distiller.hasPending(sessionId)) sessionLlm.delete(sessionId)
-        })
-        .catch(() => undefined)
+      void run.finally(() => releaseSessionLlm(sessionId)).catch(() => undefined)
     }
   })
 
@@ -405,8 +465,15 @@ export function apply(ctx: Context): void {
         // Restore/resume boundary: the persisted context is being replayed — a
         // fresh process has no dedup registry, so allow re-injection.
         injectedBySession.delete(sessionId)
+        slowLane.clear(sessionId)
       }
       observer.onSessionEvent(sessionId, event.type, event.data)
+      // AFTER the observer processed the turn (turnCount already bumped, so
+      // the pending stamps the correct turn id; the every-N distill trigger
+      // has already claimed its cadence slot — the lane yields to it inside
+      // dispatchSlowLane). The turns-map lifecycle above never touches the
+      // lane's pending map — the two coexist by design (v4 生命周期表).
+      if (event.type === 'turn/end') dispatchSlowLane(sessionId)
     }) as never,
   )
 
@@ -432,11 +499,12 @@ export function apply(ctx: Context): void {
       captureFromAgent((subject as { agent?: unknown }).agent)
       observer.onSessionEvent(sessionId, name, undefined)
       injectedBySession.delete(sessionId)
+      slowLane.clear(sessionId)
       // A teardown-triggered run (session-end distill) reads the payload
       // capture lazily: drop the entry here only when no run can still read
-      // it. A pending run removes it on settle; a session that ends without
-      // any run must not leak its capture (long-running host process).
-      if (!distiller.hasPending(sessionId)) sessionLlm.delete(sessionId)
+      // it. The slow lane's in-flight pipeline reads it too (shared caller);
+      // its settle hook re-runs this check when the pipeline finishes.
+      releaseSessionLlm(sessionId)
     }) as never)
   }
 
@@ -536,14 +604,12 @@ export function apply(ctx: Context): void {
         // capture above may have (re)armed the session's llm entry; with no
         // run pending to consume-and-release it, drop it here — a declined
         // request leaves no settle hook behind.
-        if (!distiller.hasPending(sessionId)) sessionLlm.delete(sessionId)
+        releaseSessionLlm(sessionId)
         return distiller.configured
           ? { ok: false, reason: 'in-flight', created: [], updated: [], marked: 0 }
           : { ok: false, reason: 'no-model', created: [], updated: [], marked: 0 }
       }
-      return run.finally(() => {
-        if (!distiller.hasPending(sessionId)) sessionLlm.delete(sessionId)
-      })
+      return run.finally(() => releaseSessionLlm(sessionId))
     }
     cmdCtx.effect(() => commands.register(buildTopicsCommand(service, mutate as never, resolveAsk, resolveLlm, manualDistill)), 'topics: /topics')
   })
@@ -559,10 +625,12 @@ const DEFAULTS: TopicsConfigValue = {
   totalBudget: 1500,
   matchThreshold: 0.3,
   tagBoost: 0.15,
+  injectMode: 'pointer',
+  qualityLane: 'sampled',
   graphDepth: 2,
   recencyWindowDays: 7,
   autoObserve: true,
-  includeSubagents: true,
+  includeSubagents: false,
   observationMaxChars: 2000,
   distillEveryTurns: 5,
   distillOnSessionEnd: true,