@aiwayds/dsh-topics-memory 0.20.0 → 0.22.0

package/src/ilog.ts

@@ -62,6 +62,24 @@ export interface InjectionRecord {
   slow?: SlowItem[]
 }
 
+/**
+ * One topic_open event (pointer-open log, v4 §4.3). Everything beyond
+ * `slug`/`at` is optional and late-added: older lines carry only the
+ * original pair, and every reader must tolerate the rest being absent.
+ */
+export interface OpenRecord {
+  slug: string
+  at: string
+  /** Session that issued the topic_open, when the host surface exposed one. */
+  sessionId?: string
+  /** Attribution: opened off an injected pointer, or off a topic_search hit. */
+  source?: 'pointer' | 'search'
+  /** Retrieval score of the matched injection hit (source='pointer' only). */
+  score?: number
+  /** open time − the matched injection record's at, in ms (source='pointer' only). */
+  sinceInjectionMs?: number
+}
+
 export interface AggregateStats {
   rounds: number
   injectedRounds: number
@@ -191,3 +209,274 @@ export function aggregateUsage(
   }
   return out
 }
+
+// ---------------------------------------------------------------------
+// Injection-vs-open metrics (v5) — open enrichment attribution + the
+// /topics stats panel aggregate. All pure: file I/O stays in store/service.
+// ---------------------------------------------------------------------
+
+/** How many tail injection records the cheap open attribution scans. */
+export const OPEN_ATTRIBUTION_TAIL = 50
+/** An injected pointer stays attributable for 48h (a work session's span). */
+export const OPEN_ATTRIBUTION_WINDOW_MS = 48 * 3_600_000
+
+/**
+ * Cheap source attribution for one open event: scan the injection tail
+ * (newest first) for a same-session record within the attribution window
+ * where the slug was truly delivered to the model's eyes. That is hits
+ * minus echoed/dropped (echo suppression and budget drops never rendered),
+ * PLUS slow-lane deliveries, PLUS deduped hits — dedup only blocks
+ * re-packing THIS round; the pointer rendered earlier in the same session
+ * and the model saw it (deliberately wider than renderedPointers: the panel
+ * denominator asks "did it render this round", attribution asks "did the
+ * model ever see it"). A fast-hit match carries that hit's score; a
+ * slow-only match carries none (slow pointers have no lexical score).
+ * Anything else (no session id, other session, expired, never rendered)
+ * is `search`.
+ */
+export function attributeOpen(
+  injections: readonly InjectionRecord[],
+  slug: string,
+  sessionId: string | undefined,
+  nowMs: number,
+): { source: 'pointer' | 'search'; score?: number; sinceInjectionMs?: number } {
+  if (sessionId === undefined) return { source: 'search' }
+  for (let i = injections.length - 1; i >= 0; i -= 1) {
+    const record = injections[i]
+    if (record.sessionId !== sessionId) continue
+    const atMs = Date.parse(record.at)
+    if (!Number.isFinite(atMs) || nowMs - atMs > OPEN_ATTRIBUTION_WINDOW_MS) continue
+    const sinceInjectionMs = Math.max(0, nowMs - atMs)
+    const suppressed = new Set<string>([...(record.echoed ?? []), ...(record.dropped ?? []).map((d) => d.slug)])
+    const hit = record.hits.find((h) => h.slug === slug && !suppressed.has(h.slug))
+    if (hit !== undefined) return { source: 'pointer', score: hit.score, sinceInjectionMs }
+    if ((record.slow ?? []).some((s) => s.slug === slug)) return { source: 'pointer', sinceInjectionMs }
+  }
+  return { source: 'search' }
+}
+
+/** Score bands for the open-rate-by-score cut of the stats panel. */
+export const SCORE_BANDS: readonly { label: string; lo: number; hi: number }[] = [
+  { label: '[0.3,0.5)', lo: 0.3, hi: 0.5 },
+  { label: '[0.5,1)', lo: 0.5, hi: 1 },
+  { label: '[1,2)', lo: 1, hi: 2 },
+  { label: '[2,5)', lo: 2, hi: 5 },
+  { label: '[5,∞)', lo: 5, hi: Number.POSITIVE_INFINITY },
+]
+
+/** Zero-open listing threshold: injections at or above this with zero opens. */
+export const ZERO_OPEN_MIN_INJECTIONS = 5
+/** Rolling window of the zero-open rule: only rendered injections inside it count. */
+export const ZERO_OPEN_WINDOW_DAYS = 30
+/** Injection-tail rows the decay read scans — a bound comfortably covering
+ *  the 30-day window at observed round volumes. */
+export const ZERO_OPEN_TAIL = 500
+
+/**
+ * Slugs that truly rendered in one round, in delivery order: raw hits minus
+ * the round's exclusions (deduped/echoed/dropped were never assembled), plus
+ * delivered slow pointers; a slug the fast lane already delivered counts
+ * once even when the slow lane also reports it delivered ("not packed
+ * twice"). Scores ride along from the fast hit only — slow pointers carry
+ * no lexical score. Shared by the stats panel and the zero-open rule.
+ */
+export function renderedPointers(record: InjectionRecord): { slug: string; score?: number }[] {
+  const excluded = new Set<string>([
+    ...(record.deduped ?? []),
+    ...(record.echoed ?? []),
+    ...(record.dropped ?? []).map((d) => d.slug),
+  ])
+  const seen = new Set<string>()
+  const out: { slug: string; score?: number }[] = []
+  for (const h of record.hits) {
+    if (excluded.has(h.slug) || seen.has(h.slug)) continue
+    seen.add(h.slug)
+    out.push({ slug: h.slug, score: h.score })
+  }
+  for (const s of record.slow ?? []) {
+    if (seen.has(s.slug)) continue
+    seen.add(s.slug)
+    out.push({ slug: s.slug })
+  }
+  return out
+}
+
+/**
+ * Zero-open slug set — the single shared 零打开高频 rule (v5): slugs whose
+ * truly-rendered pointer count within the rolling ZERO_OPEN_WINDOW_DAYS
+ * reaches ZERO_OPEN_MIN_INJECTIONS while the WHOLE open log has never
+ * recorded an open (wide scope — an open long after the last injection
+ * still disqualifies). Returns slug → windowed rendered-pointer count for
+ * the qualifying slugs; `/topics stats` (the panel's zero-open list) and
+ * the retrieval decay (`zeroOpenDecay`) both consume this one
+ * implementation. Records with unparsable `at` cannot prove window
+ * membership and are skipped (same tolerance as aggregateUsage).
+ */
+export function aggregateZeroOpen(
+  injections: readonly InjectionRecord[],
+  opens: readonly { slug: string }[],
+  nowMs: number,
+): Map<string, number> {
+  const cutoff = nowMs - ZERO_OPEN_WINDOW_DAYS * 86_400_000
+  const counts = new Map<string, number>()
+  for (const record of injections) {
+    const at = Date.parse(record.at)
+    if (!Number.isFinite(at) || at < cutoff) continue
+    for (const p of renderedPointers(record)) {
+      counts.set(p.slug, (counts.get(p.slug) ?? 0) + 1)
+    }
+  }
+  const opened = new Set(opens.map((o) => o.slug))
+  const out = new Map<string, number>()
+  for (const [slug, n] of counts) {
+    if (n >= ZERO_OPEN_MIN_INJECTIONS && !opened.has(slug)) out.set(slug, n)
+  }
+  return out
+}
+
+export interface OpenTopicRow {
+  slug: string
+  /** Truly rendered pointers for this slug (deduped/echoed/dropped excluded). */
+  injections: number
+  /** Opens attributed by slug over the whole open log (wide scope, by design). */
+  opens: number
+  openRate: number
+}
+
+export interface OpenBandRow {
+  label: string
+  /** Rendered fast pointers whose hit score falls in this band. */
+  pointers: number
+  /** Pointer-sourced opens whose attributed score falls in this band. */
+  opens: number
+  openRate: number
+}
+
+export interface OpenPanelStats {
+  /** Rendered pointer entries across the window: hits − deduped − echoed − dropped, plus slow pointers (same-slug fast+slow pairs counted once). */
+  pointerEntries: number
+  /** DISTINCT slugs from the window's rendered set with an in-window open
+   *  (search-sourced and never-rendered slugs excluded; one per slug). */
+  opensInWindow: number
+  openRate: number
+  topics: OpenTopicRow[]
+  zeroOpen: { slug: string; injections: number }[]
+  zeroOpenTotal: number
+  pointerOpens: number
+  searchOpens: number
+  /** False when no open record carries a source field (pre-enrichment data). */
+  hasSourceData: boolean
+  bands: OpenBandRow[]
+}
+
+/**
+ * Aggregate the injection-vs-open panel from the two JSONL windows. The
+ * per-topic/band denominators count only pointers that truly rendered
+ * (deduped/echoed/dropped excluded — same exclusion family as
+ * aggregateUsage); the header numerator counts only DISTINCT slugs from
+ * that rendered set with an open inside the injection window — a search
+ * open or an open of a never-rendered slug cannot enter, and repeat opens
+ * of the same slug count once, so the rate can no longer be pinned at
+ * 100% by repeated or off-scope opens. Opens per slug stay wide-scope
+ * (the model may open a topic long after its last injection). The
+ * zero-open list shares the decay's rule: rendered injections counted
+ * within the rolling 30-day window (anchored at the newest round), opens
+ * wide-scope.
+ */
+export function aggregateOpenPanel(
+  injections: readonly InjectionRecord[],
+  opens: readonly OpenRecord[],
+): OpenPanelStats {
+  // Numerator window: the earliest round represented in the denominator;
+  // the zero-open anchor is the newest round — the panel describes the log
+  // window it was fed, so a stale log still shows the topics that
+  // dominated it. The rendered-slug set below shares that window: only
+  // opens of slugs this window rendered can enter the numerator.
+  let windowStart = Number.POSITIVE_INFINITY
+  let windowEnd = Number.NEGATIVE_INFINITY
+  for (const r of injections) {
+    const atMs = Date.parse(r.at)
+    if (!Number.isFinite(atMs)) continue
+    if (atMs < windowStart) windowStart = atMs
+    if (atMs > windowEnd) windowEnd = atMs
+  }
+  const topicCounts = new Map<string, number>()
+  const bandPointers = new Array<number>(SCORE_BANDS.length).fill(0)
+  let pointerEntries = 0
+  const renderedSlugs = new Set<string>()
+  for (const r of injections) {
+    // renderedPointers keeps the entry/per-topic counts honest: excluded
+    // slugs never counted, a fast+slow pair for the same slug counted once.
+    for (const p of renderedPointers(r)) {
+      pointerEntries += 1
+      renderedSlugs.add(p.slug)
+      topicCounts.set(p.slug, (topicCounts.get(p.slug) ?? 0) + 1)
+      const score = p.score
+      if (score === undefined) continue
+      const bi = SCORE_BANDS.findIndex((b) => score >= b.lo && score < b.hi)
+      if (bi >= 0) bandPointers[bi] += 1
+    }
+  }
+  const opensBySlug = new Map<string, number>()
+  const bandOpens = new Array<number>(SCORE_BANDS.length).fill(0)
+  let pointerOpens = 0
+  let searchOpens = 0
+  let hasSourceData = false
+  // Numerator: DISTINCT slugs from the window's rendered set with an
+  // in-window open — search-sourced opens never count (the model found the
+  // topic by asking, not by following a rendered pointer), a never-rendered
+  // slug never counts, and repeat opens of the same slug count once.
+  const openedSlugsInWindow = new Set<string>()
+  for (const o of opens) {
+    opensBySlug.set(o.slug, (opensBySlug.get(o.slug) ?? 0) + 1)
+    if (o.source === 'pointer' || o.source === 'search') hasSourceData = true
+    if (o.source === 'pointer') pointerOpens += 1
+    else if (o.source === 'search') searchOpens += 1
+    if (o.source === 'pointer' && typeof o.score === 'number') {
+      const score = o.score
+      const bi = SCORE_BANDS.findIndex((b) => score >= b.lo && score < b.hi)
+      if (bi >= 0) bandOpens[bi] += 1
+    }
+    if (o.source === 'search') continue
+    const atMs = Date.parse(o.at)
+    // An open joins the windowed numerator unless it is provably older than
+    // the window's earliest round (unparsable stamps cannot prove either
+    // way) — and only when the window actually rendered its slug.
+    if (Number.isFinite(windowStart) && Number.isFinite(atMs) && atMs < windowStart) continue
+    if (!renderedSlugs.has(o.slug)) continue
+    openedSlugsInWindow.add(o.slug)
+  }
+  const opensInWindow = openedSlugsInWindow.size
+  const rate = (num: number, den: number): number => (den === 0 ? 0 : Math.min(1, num / den))
+  const topics: OpenTopicRow[] = [...topicCounts.entries()]
+    .map(([slug, injections]) => {
+      const opens = opensBySlug.get(slug) ?? 0
+      return { slug, injections, opens, openRate: rate(opens, injections) }
+    })
+    .sort((a, b) => b.injections - a.injections || a.slug.localeCompare(b.slug))
+  // Zero-open cut: the shared 30-day rule (aggregateZeroOpen), anchored at
+  // the newest round so window semantics match the decay's rolling window
+  // without growing a time-bomb dependency on the wall clock.
+  const zeroOpenCounts =
+    windowEnd === Number.NEGATIVE_INFINITY ? new Map<string, number>() : aggregateZeroOpen(injections, opens, windowEnd)
+  const zeroOpenAll = [...zeroOpenCounts.entries()]
+    .map(([slug, injections]) => ({ slug, injections }))
+    .sort((a, b) => b.injections - a.injections || a.slug.localeCompare(b.slug))
+  return {
+    pointerEntries,
+    opensInWindow,
+    openRate: rate(opensInWindow, pointerEntries),
+    topics: topics.slice(0, 10),
+    zeroOpen: zeroOpenAll.slice(0, 10).map((t) => ({ slug: t.slug, injections: t.injections })),
+    zeroOpenTotal: zeroOpenAll.length,
+    pointerOpens,
+    searchOpens,
+    hasSourceData,
+    bands: SCORE_BANDS.map((b, i) => ({
+      label: b.label,
+      pointers: bandPointers[i],
+      opens: bandOpens[i],
+      openRate: rate(bandOpens[i], bandPointers[i]),
+    })),
+  }
+}

package/src/retrieval.ts

@@ -49,12 +49,26 @@ export interface RetrievalConfig {
   usageBoost: number
   /** Usage signals per slug (hits/opens in the window); absent map = no boost. */
   usage?: ReadonlyMap<string, { hits: number; opens: number }>
+  /**
+   * Zero-open decay (v5, default off — config `zeroOpenDecay`): halve the
+   * score of slugs on the zero-open list (≥5 rendered injections in the
+   * rolling 30 days, zero opens ever) at score-finalization time, BEFORE
+   * the threshold cut — a decayed candidate that drops below the threshold
+   * lands in nearMisses with the `zero-open-decay` reason, so the log
+   * shows why it stopped injecting. Absent/off = zero behavior change.
+   */
+  zeroOpenDecay?: boolean
+  /** Zero-open slugs for this round (service-built from the ilog tail). */
+  zeroOpenSlugs?: ReadonlySet<string>
 }
 
 /** Hard cap for the usage bonus — below threshold 0.3 so usage can never
  *  carry a candidate across the gate on its own (ADR 0015). */
 export const USAGE_BOOST_CAP = 0.2
 
+/** Score multiplier for zero-open slugs when zeroOpenDecay is on (v5). */
+export const ZERO_OPEN_DECAY_FACTOR = 0.5
+
 export const DEFAULT_RETRIEVAL: RetrievalConfig = {
   threshold: 0.3,
   topK: 4,
@@ -224,6 +238,14 @@ export function scoreTopic(
     score *= 0.3
     reasons.push('conflicted-demoted')
   }
+  // Zero-open decay (v5): same demotion family as conflicts — applied to
+  // the content score BEFORE gateScore is taken, so the threshold cut and
+  // the near-miss band both see the halved score; recency still rides
+  // outside it as the ranking tiebreaker.
+  if (cfg.zeroOpenDecay === true && cfg.zeroOpenSlugs?.has(topic.slug) === true) {
+    score *= ZERO_OPEN_DECAY_FACTOR
+    reasons.push('zero-open-decay')
+  }
   const gateScore = score
   score += recencyBonus
   const bodySet = new Set([...description, ...conclusion])

package/src/service.ts

@@ -10,11 +10,11 @@ import { readFile, stat } from 'node:fs/promises'
 import { readdirSync, readFileSync, statSync } from 'node:fs'
 import { join } from 'node:path'
 import * as okf from './okf.ts'
-import { searchTopics, scoreTopic, passesGate, tokenize, type RetrievableTopic, type SearchOutcome } from './retrieval.ts'
+import { searchTopics, scoreTopic, passesGate, tokenize, type RetrievableTopic, type RetrievalConfig, type SearchOutcome } from './retrieval.ts'
 import { assembleInjection, assemblePointer, POINTER_PER_TOPIC, POINTER_TOTAL, type AssembleResult, type DigestInput, type SlowPointerInput } from './digest.ts'
 import type { BundleStore, Observation, SaveResult } from './store.ts'
 import type { TopicsConfigValue } from './config.ts'
-import { aggregateStats, querySample, aggregateUsage, USAGE_WINDOW_DAYS, type AggregateStats, type InjectionRecord, type QueryBuildShape, type ShadowVerdict, type SlowItem, type UsageSignal } from './ilog.ts'
+import { aggregateStats, querySample, aggregateUsage, aggregateZeroOpen, ZERO_OPEN_TAIL, USAGE_WINDOW_DAYS, attributeOpen, OPEN_ATTRIBUTION_TAIL, type AggregateStats, type InjectionRecord, type OpenRecord, type QueryBuildShape, type ShadowVerdict, type SlowItem, type UsageSignal } from './ilog.ts'
 import { fileHistory, fileAtRev } from './git.ts'
 import type { Sync } from './sync.ts'
 
@@ -25,6 +25,37 @@ interface CacheEntry {
   slug: string
 }
 
+/** Tolerant JSONL line read: undefined = unreadable file. Unlike an empty
+ *  array, undefined tells the caller to fail open AND skip caching — a
+ *  successful stat paired with a failed read must not freeze an empty
+ *  snapshot into the cache until the next append. */
+function readLogLinesSync(file: string): string[] | undefined {
+  try {
+    return readFileSync(file, 'utf8').split('\n')
+  } catch {
+    return undefined
+  }
+}
+
+/** Parse already-split lines back-to-front, keeping the last `tail` parsed
+ *  records in order: blanks and torn JSON lines are skipped (and never
+ *  consume tail budget), so a torn tail line cannot crowd out a good one.
+ *  Shared by the usage/zero-open cache — one tail parse feeds both. */
+function parseJsonlLinesSync<T>(lines: readonly string[], tail = Number.POSITIVE_INFINITY): T[] {
+  const out: T[] = []
+  for (let i = lines.length - 1; i >= 0 && out.length < tail; i -= 1) {
+    const line = lines[i]
+    if (line.trim() === '') continue
+    try {
+      out.push(JSON.parse(line) as T)
+    } catch {
+      continue // torn tail line
+    }
+  }
+  out.reverse()
+  return out
+}
+
 export interface RetrieveOutcome {
   outcome: SearchOutcome
   injection: AssembleResult
@@ -50,13 +81,22 @@ export class TopicsService {
   private cache = new Map<string, CacheEntry>()
   /** mtime-keyed parse of the observations log, grouped by session. */
   private echoCache: { mtimeMs: number; size: number; bySession: Map<string, Set<string>> } | undefined
-  private usageCache: {
-    injMs: number
-    injSize: number
-    opensMs: number
-    opensSize: number
-    signals: Map<string, UsageSignal>
-  } | undefined
+  /** Single shared cache over the two feedback JSONL logs (S2): the key is
+   *  the (mtime,size) quartet of injections.jsonl + opens.jsonl, one read
+   *  and one tail parse feed BOTH aggregates — usageSignalsSync and
+   *  zeroOpenSlugsSync used to each keep a full-parse cache of their own.
+   *  Invalidation stays append-driven: the store only ever appends, so any
+   *  write moves mtime+size. Never populated when a read failed (N1). */
+  private logSignalsCache:
+    | {
+        injMs: number
+        injSize: number
+        opensMs: number
+        opensSize: number
+        signals: Map<string, UsageSignal>
+        zeroOpenSlugs: ReadonlySet<string>
+      }
+    | undefined
   readonly store: BundleStore
   private readonly getConfig: () => TopicsConfigValue
   readonly sync?: Sync
@@ -131,7 +171,7 @@ export class TopicsService {
   invalidate(): void {
     this.cache.clear()
     this.echoCache = undefined
-    this.usageCache = undefined
+    this.logSignalsCache = undefined
   }
 
   /**
@@ -186,10 +226,36 @@ export class TopicsService {
    * Usage signals (ADR 0015): mtime-cached aggregate over the injection log
    * and the opens log, rolling USAGE_WINDOW_DAYS. Synchronous like
    * echoSlugsSync — the retrieval hot path is sync — and cheap when warm:
-   * a fresh cache costs two stat() calls. Unreadable logs fail open to an
+   * a fresh cache costs two stat() calls, one read of each log, and feeds
+   * the zero-open set from the same parse. Unreadable logs fail open to an
    * empty map (no boost), never an error.
    */
   usageSignalsSync(): Map<string, UsageSignal> {
+    return this.logSignalsSync().signals
+  }
+
+  /**
+   * Zero-open slug set for the decay (v5): the shared aggregateZeroOpen
+   * rule over the injection tail and the whole opens log (compacted, so a
+   * full read stays small). Shares one cache and one parse with
+   * usageSignalsSync; unreadable logs fail open to an empty set (no
+   * decay), never an error. Only called when zeroOpenDecay is on.
+   */
+  zeroOpenSlugsSync(): ReadonlySet<string> {
+    return this.logSignalsSync().zeroOpenSlugs
+  }
+
+  /**
+   * The one shared feedback-log read behind both signals: stat both files
+   * (mtime+size quartet key), parse the injections TAIL only
+   * (ZERO_OPEN_TAIL rounds comfortably cover both 30-day windows) and the
+   * opens log whole (the zero-open rule is whole-history), then feed the
+   * two pure aggregates from that single parse. A failed read still fails
+   * open to empty inputs but NEVER populates the cache (N1) — otherwise a
+   * stat-success/read-failure race would freeze an empty snapshot until
+   * the next append.
+   */
+  private logSignalsSync(): { signals: Map<string, UsageSignal>; zeroOpenSlugs: ReadonlySet<string> } {
     const injFile = join(this.store.metaDir(), 'injections.jsonl')
     const opensFile = join(this.store.metaDir(), 'opens.jsonl')
     const statOf = (file: string): { mtimeMs: number; size: number } => {
@@ -202,7 +268,7 @@ export class TopicsService {
     }
     const injSt = statOf(injFile)
     const opensSt = statOf(opensFile)
-    const cached = this.usageCache
+    const cached = this.logSignalsCache
     if (
       cached !== undefined &&
       cached.injMs === injSt.mtimeMs &&
@@ -210,38 +276,38 @@ export class TopicsService {
       cached.opensMs === opensSt.mtimeMs &&
       cached.opensSize === opensSt.size
     ) {
-      return cached.signals
+      return cached
     }
-    const parseLines = <T>(file: string): T[] => {
-      const out: T[] = []
-      try {
-        for (const line of readFileSync(file, 'utf8').split('\n')) {
-          if (line.trim() === '') continue
-          try {
-            out.push(JSON.parse(line) as T)
-          } catch {
-            continue // torn tail line
-          }
-        }
-      } catch {
-        // unreadable log: contribute nothing
+    const injLines = readLogLinesSync(injFile)
+    const opensLines = readLogLinesSync(opensFile)
+    const injections = parseJsonlLinesSync<InjectionRecord>(injLines ?? [], ZERO_OPEN_TAIL)
+    const opens = parseJsonlLinesSync<OpenRecord>(opensLines ?? [])
+    const now = Date.now()
+    const signals = aggregateUsage(injections, opens, USAGE_WINDOW_DAYS, now)
+    const zeroOpenSlugs: ReadonlySet<string> = new Set(aggregateZeroOpen(injections, opens, now).keys())
+    if (injLines !== undefined && opensLines !== undefined) {
+      this.logSignalsCache = {
+        injMs: injSt.mtimeMs,
+        injSize: injSt.size,
+        opensMs: opensSt.mtimeMs,
+        opensSize: opensSt.size,
+        signals,
+        zeroOpenSlugs,
       }
-      return out
-    }
-    const signals = aggregateUsage(
-      parseLines(injFile),
-      parseLines(opensFile),
-      USAGE_WINDOW_DAYS,
-      Date.now(),
-    )
-    this.usageCache = {
-      injMs: injSt.mtimeMs,
-      injSize: injSt.size,
-      opensMs: opensSt.mtimeMs,
-      opensSize: opensSt.size,
-      signals,
     }
-    return signals
+    return { signals, zeroOpenSlugs }
+  }
+
+  /**
+   * zeroOpenDecay fields for scoring calls: empty when the gate is off —
+   * no file reads, zero behavior change — and the shared mtime-cached set
+   * when on. Spread into every searchTopics/scoreTopic cfg that already
+   * carries the usage signals (injection paths + explicit topic_search;
+   * the slow lane's recall band stays untouched, mirroring usageBoost).
+   */
+  private zeroOpenCfg(): Pick<RetrievalConfig, 'zeroOpenDecay' | 'zeroOpenSlugs'> {
+    if (this.cfg.zeroOpenDecay !== true) return {}
+    return { zeroOpenDecay: true, zeroOpenSlugs: this.zeroOpenSlugsSync() }
   }
 
   /**
@@ -269,6 +335,7 @@ export class TopicsService {
       conflicts,
       usageBoost: cfg.usageBoost,
       usage: this.usageSignalsSync(),
+      ...this.zeroOpenCfg(),
     })
     const bySlug = new Map(roster.map((r) => [r.slug, r]))
     const entries: DigestInput[] = []
@@ -368,6 +435,7 @@ export class TopicsService {
       conflicts,
       usageBoost: cfg.usageBoost,
       usage: this.usageSignalsSync(),
+      ...this.zeroOpenCfg(),
     })
     const exclude = dedup?.exclude
     const echo = dedup?.echo
@@ -427,6 +495,7 @@ export class TopicsService {
           structuralGate: true,
           usageBoost: cfg.usageBoost,
           usage: this.usageSignalsSync(),
+          ...this.zeroOpenCfg(),
         })
         shadow.push({
           slug: item.slug,
@@ -532,9 +601,14 @@ export class TopicsService {
     const doc = slug === '' ? undefined : await this.store.readTopic(slug).catch(() => undefined)
     if (doc === undefined) return { found: false, slug }
     // Awaited (tool path, not hot): a settled write makes the pointer-open
-    // stat reliable; a failed log write must not fail the tool.
+    // stat reliable; a failed log write must not fail the tool. Source
+    // attribution rides the same write: a cheap injections-tail scan decides
+    // pointer vs search and, for pointers, carries the hit score and the
+    // open→injection lag (ilog.attributeOpen).
+    const at = new Date().toISOString()
+    const attribution = await this.attributeOpen(slug, sessionId, Date.parse(at))
     await this.store
-      .appendOpenRecord({ slug, at: new Date().toISOString(), ...(sessionId !== undefined ? { sessionId } : {}) })
+      .appendOpenRecord({ slug, at, ...(sessionId !== undefined ? { sessionId } : {}), ...attribution })
       .catch(() => undefined)
     // Optional fields are OMITTED, never present-as-undefined: the host's
     // tool-output validation rejects any object carrying an undefined-valued
@@ -564,6 +638,18 @@ export class TopicsService {
     return found
   }
 
+  /**
+   * Resolve the open's source attribution: the injections tail (bounded by
+   * OPEN_ATTRIBUTION_TAIL) scanned for a same-session hit within the
+   * attribution window. Read failures degrade to 'search' — attribution is
+   * telemetry, never a blocker.
+   */
+  private async attributeOpen(slug: string, sessionId: string | undefined, nowMs: number): Promise<{ source: 'pointer' | 'search'; score?: number; sinceInjectionMs?: number }> {
+    if (sessionId === undefined) return { source: 'search' }
+    const tail = await this.store.readInjectionRecords(OPEN_ATTRIBUTION_TAIL).catch(() => [])
+    return attributeOpen(tail, slug, sessionId, nowMs)
+  }
+
   /** Sync roster read (same mtime cache as roster()). */
   rosterSync(): RetrievableTopic[] {
     let files: string[]
@@ -706,6 +792,7 @@ export class TopicsService {
       conflicts: await this.store.getConflicts(),
       usageBoost: cfg.usageBoost,
       usage: this.usageSignalsSync(),
+      ...this.zeroOpenCfg(),
     })
   }
 

package/src/store.ts

@@ -26,7 +26,7 @@ import { randomUUID } from 'node:crypto'
 import * as okf from './okf.ts'
 import * as gitmod from './git.ts'
 import { actorFor } from './paths.ts'
-import type { InjectionRecord } from './ilog.ts'
+import type { InjectionRecord, OpenRecord } from './ilog.ts'
 
 export interface TopicMeta {
   slug: string
@@ -612,14 +612,15 @@ export class BundleStore {
 
   // ------------------------------------------------------------------
   // Pointer-open log (v4 §4.3) — one line per topic_open call; feeds the
-  // 「指针打开率」 stat. Features only (slug/time), never conversation text.
+  // 「指针打开率」 stat. Features only (slug/time + attribution), never
+  // conversation text.
   // ------------------------------------------------------------------
 
   private opensPath(): string {
     return join(this.metaDir(), 'opens.jsonl')
   }
 
-  async appendOpenRecord(record: { slug: string; at: string; sessionId?: string }): Promise<void> {
+  async appendOpenRecord(record: OpenRecord): Promise<void> {
     await mkdir(this.metaDir(), { recursive: true })
     await appendFile(this.opensPath(), `${JSON.stringify(record)}\n`, 'utf8')
     await this.compactOpensIfNeeded()
@@ -638,22 +639,27 @@ export class BundleStore {
     await atomicWrite(file, lines.slice(-Math.max(1, Math.floor(lines.length / 4))).map((l) => `${l}\n`).join(''))
   }
 
-  /** Opens in the recent window; tolerant of a torn tail like the other JSONLs. */
-  async readOpenRecords(limit = 2000): Promise<{ slug: string; at: string; sessionId?: string }[]> {
+  /** Opens in the recent window; tolerant of a torn tail like the other JSONLs.
+   *  Enrichment fields (sessionId/source/score/sinceInjectionMs) are optional:
+   *  pre-enrichment lines carry only slug/at and read back without them. */
+  async readOpenRecords(limit = 2000): Promise<OpenRecord[]> {
     let raw: string
     try {
       raw = await readFile(this.opensPath(), 'utf8')
     } catch {
       return []
     }
-    const out: { slug: string; at: string; sessionId?: string }[] = []
+    const out: OpenRecord[] = []
     for (const line of raw.split('\n')) {
       if (line.trim() === '') continue
       try {
-        const parsed = JSON.parse(line) as { slug?: unknown; at?: unknown; sessionId?: unknown }
+        const parsed = JSON.parse(line) as { slug?: unknown; at?: unknown; sessionId?: unknown; source?: unknown; score?: unknown; sinceInjectionMs?: unknown }
         if (typeof parsed.slug === 'string' && typeof parsed.at === 'string') {
-          const rec: { slug: string; at: string; sessionId?: string } = { slug: parsed.slug, at: parsed.at }
+          const rec: OpenRecord = { slug: parsed.slug, at: parsed.at }
           if (typeof parsed.sessionId === 'string') rec.sessionId = parsed.sessionId
+          if (parsed.source === 'pointer' || parsed.source === 'search') rec.source = parsed.source
+          if (typeof parsed.score === 'number') rec.score = parsed.score
+          if (typeof parsed.sinceInjectionMs === 'number') rec.sinceInjectionMs = parsed.sinceInjectionMs
           out.push(rec)
         }
       } catch {