@aiwayds/dsh-topics-memory 0.9.0 → 0.11.0

package/src/quality.ts

@@ -36,6 +36,8 @@ export const SAMPLED_EVERY = 3
 const RING_CHARS = 6000
 /** Candidate band size fed to the rerank. */
 const CANDIDATE_LIMIT = 6
+/** Over-fetch before the exclude filter, so excluded slugs don't thin the band. */
+const CANDIDATE_OVERFETCH = 6
 
 export const QUERY_BUILD_PROMPT = [
   '你是检索查询构建器。输入是最近几轮对话。任务：判断「模型此刻需要什么背景知识」，输出一个用于关键词检索的 query。',
@@ -70,6 +72,14 @@ export type ConsumeResult = { pending: PendingInjection } | { expired: 'ttl' | '
 export interface DispatchInput {
   ring: readonly RingEntry[]
   turnId: number
+  /**
+   * Slugs the session already carries — injected earlier this session or
+   * distilled from its own turns (echo). The candidate band drops them
+   * BEFORE the rerank: a pick the fast-lane dedup would silently swallow at
+   * consumption is a wasted aux call and a dead pending (2026-09 audit: 2 of
+   * the first 3 slow-lane outcomes died exactly this way).
+   */
+  exclude?: ReadonlySet<string>
 }
 
 /** Race `p` against a timeout; `onTimeout` fires so callers can abort upstream work. */
@@ -233,13 +243,16 @@ export class SlowLane {
       // candidates = threshold passers + the near-miss band beneath them.
       const band = searchTopics(query, roster, {
         threshold: this.service.cfg.matchThreshold,
-        topK: CANDIDATE_LIMIT,
+        topK: CANDIDATE_LIMIT + CANDIDATE_OVERFETCH,
         tagBoost: this.service.cfg.tagBoost,
         graphDepth: 0,
         recencyWindowDays: this.service.cfg.recencyWindowDays,
         structuralGate: false,
       })
-      const candidates = [...band.hits, ...band.nearMisses].slice(0, CANDIDATE_LIMIT)
+      const exclude = input.exclude
+      const candidates = [...band.hits, ...band.nearMisses]
+        .filter((c) => !exclude?.has(c.slug))
+        .slice(0, CANDIDATE_LIMIT)
       if (candidates.length === 0) return
       const bySlug = new Map(roster.map((r) => [r.slug, r]))
       const payload = candidates.flatMap((c) => {

package/src/service.ts

@@ -48,6 +48,8 @@ export interface SlowDelivery {
 
 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
   readonly store: BundleStore
   private readonly getConfig: () => TopicsConfigValue
   readonly sync?: Sync
@@ -116,6 +118,55 @@ export class TopicsService {
   /** Drop the roster cache (tests, bulk external edits). */
   invalidate(): void {
     this.cache.clear()
+    this.echoCache = undefined
+  }
+
+  /**
+   * Slugs distilled from THIS session's own turns — the echo set (2026-09
+   * audit finding #3: a topic distilled from in-session knowledge injected
+   * back into the same session is a lagging echo of what the model already
+   * said, occasionally stale enough to contradict the newer in-session
+   * conclusion). Provenance is durable in the observations log: each line
+   * carries `sessionId` and, once distilled, `distilledInto`. Sync read on
+   * the injection hot path, mtime-cached like the roster.
+   */
+  echoSlugsSync(sessionId: string): Set<string> {
+    const file = join(this.store.metaDir(), 'observations.jsonl')
+    let st
+    try {
+      st = statSync(file)
+    } catch {
+      return new Set()
+    }
+    let bySession = this.echoCache
+    if (bySession === undefined || bySession.mtimeMs !== st.mtimeMs || bySession.size !== st.size) {
+      bySession = { mtimeMs: st.mtimeMs, size: st.size, bySession: new Map() }
+      try {
+        const lines = readFileSync(file, 'utf8').split('\n')
+        for (const line of lines) {
+          if (line.trim() === '') continue
+          let obs: { sessionId?: unknown; distilled?: unknown; distilledInto?: unknown }
+          try {
+            obs = JSON.parse(line)
+          } catch {
+            continue // torn tail line
+          }
+          if (obs.distilled !== true || typeof obs.sessionId !== 'string' || !Array.isArray(obs.distilledInto)) continue
+          let set = bySession.bySession.get(obs.sessionId)
+          if (set === undefined) {
+            set = new Set()
+            bySession.bySession.set(obs.sessionId, set)
+          }
+          for (const slug of obs.distilledInto) {
+            if (typeof slug === 'string' && slug !== '') set.add(okf.slugify(slug))
+          }
+        }
+      } catch {
+        return new Set() // unreadable log: fail open (no suppression)
+      }
+      this.echoCache = bySession
+    }
+    return bySession.bySession.get(sessionId) ?? new Set()
   }
 
   /**
@@ -183,17 +234,21 @@ export class TopicsService {
    *
    * `dedup.exclude` (session-level injection dedup) filters hits AND slow
    * picks before assembly; excluded slugs are reported back as `deduped`
-   * (and logged as `record.deduped`), never packed. `included` mirrors the
-   * fast pointers that entered the context and `slowIncluded` the slow ones
-   * — only these may be marked as injected by the caller; budget-dropped
-   * slugs stay injectable later.
+   * (and logged as `record.deduped`), never packed. `dedup.echo` (蒸馏回声,
+   * v4 audit) filters the same way but reports separately as `echoed` /
+   * `record.echoed`: slugs distilled from THIS session's own turns.
+   * `included` mirrors the fast pointers that entered the context and
+   * `slowIncluded` the slow ones — only these may be marked as injected by
+   * the caller; budget-dropped slugs stay injectable later.
    *
    * `slow` (v4 §4.2) carries the consumed pending when one exists: picks are
    * packed after the fast pointers under the same budget, take log-only
    * shadow re-gate verdicts against the CURRENT query (B3: record, never
-   * block), and fill the record's lane field family.
+   * block), and fill the record's lane field family. A pick the fast lane
+   * already delivers THIS round is counted as slow-delivered (it entered the
+   * context) but not packed twice.
    */
-  retrieveSync(query: string, sessionId?: string, dedup?: { exclude?: ReadonlySet<string> }, slow?: SlowDelivery, slowExpired?: 'ttl' | 'turn-lag'): { text: string; outcome: SearchOutcome; deduped: string[]; included: string[]; slowIncluded: string[] } {
+  retrieveSync(query: string, sessionId?: string, dedup?: { exclude?: ReadonlySet<string>; echo?: ReadonlySet<string> }, slow?: SlowDelivery, slowExpired?: 'ttl' | 'turn-lag'): { text: string; outcome: SearchOutcome; deduped: string[]; echoed: string[]; included: string[]; slowIncluded: string[] } {
     const cfg = this.cfg
     const roster = this.rosterSync()
     const empty: SearchOutcome = { hits: [], nearMisses: [], rosterSize: roster.length }
@@ -224,7 +279,7 @@ export class TopicsService {
         }
         void this.store.appendInjectionRecord(trace).catch(() => undefined)
       }
-      return { text: '', outcome: empty, deduped: [], included: [], slowIncluded: [] }
+      return { text: '', outcome: empty, deduped: [], echoed: [], included: [], slowIncluded: [] }
     }
     const conflicts = this.store.getConflictsSync()
     const outcome = searchTopics(query, roster, {
@@ -236,12 +291,18 @@ export class TopicsService {
       conflicts,
     })
     const exclude = dedup?.exclude
+    const echo = dedup?.echo
     const deduped = exclude === undefined ? [] : outcome.hits.filter((h) => exclude.has(h.slug)).map((h) => h.slug)
+    const echoed: string[] = []
     const bySlug = new Map(roster.map((r) => [r.slug, r]))
     const entries: DigestInput[] = []
     const unreadable: string[] = []
     for (const hit of outcome.hits) {
       if (exclude?.has(hit.slug)) continue
+      if (echo?.has(hit.slug)) {
+        echoed.push(hit.slug)
+        continue
+      }
       const doc = this.readDocSync(hit.slug)
       if (doc === undefined) {
         // The hit has no readable doc — without this accounting it used to
@@ -264,8 +325,19 @@ export class TopicsService {
           if (!deduped.includes(item.slug)) deduped.push(item.slug)
           continue
         }
+        if (echo?.has(item.slug)) {
+          if (!echoed.includes(item.slug)) echoed.push(item.slug)
+          continue
+        }
         const meta = bySlug.get(item.slug)
         if (meta === undefined) continue // vanished between production and consumption
+        if (entries.some((e) => e.slug === item.slug)) {
+          // The fast lane delivers the same slug THIS round — the content
+          // enters the context exactly once (never packed twice), and the
+          // pick still counts as delivered for the lane bookkeeping.
+          slowDelivered.push({ slug: item.slug, why: item.why })
+          continue
+        }
         const verdict = scoreTopic(queryTokens, meta, {
           threshold: cfg.matchThreshold,
           topK: cfg.topK,
@@ -313,6 +385,7 @@ export class TopicsService {
     }
     if (sessionId !== undefined) record.sessionId = sessionId
     if (deduped.length > 0) record.deduped = deduped
+    if (echoed.length > 0) record.echoed = echoed
     if (unreadable.length > 0) {
       record.dropped = [...(record.dropped ?? []), ...unreadable.map((slug) => ({ slug, reason: 'doc-unreadable' }))]
     }
@@ -347,7 +420,7 @@ export class TopicsService {
     if (slowExpired !== undefined && injection.text === '') record.lane = 'slow'
     if (injection.dropped.length > 0) record.dropped = [...(record.dropped ?? []), ...injection.dropped]
     void this.store.appendInjectionRecord(record).catch(() => undefined)
-    return { text: injection.text, outcome, deduped, included: injection.included, slowIncluded }
+    return { text: injection.text, outcome, deduped, echoed, included: injection.included, slowIncluded }
   }
 
   /**
@@ -356,7 +429,7 @@ export class TopicsService {
    * the store stamps it on every write, so it IS the last-updated instant).
    * Logs an open record for the pointer-open-rate stat.
    */
-  async openTopic(slug: string, sessionId?: string): Promise<{
+  async openTopic(rawSlug: string, sessionId?: string): Promise<{
     found: boolean
     slug: string
     title?: string
@@ -367,24 +440,47 @@ export class TopicsService {
     openQuestions?: string[]
     recommendations?: string
   }> {
-    const doc = await this.store.readTopic(slug).catch(() => undefined)
+    // Pointers render slugs as `(topics:<slug>)` and models copy that whole
+    // token back as the argument — unwrap every `topics:`/`topics/` wrap the
+    // same way the depends edges do (audit ⑨: the wrapped form read as a
+    // missing topic). Then CANONICALIZE with the save path's own slugify:
+    // unwrap alone is case-preserving, and on a case-sensitive filesystem
+    // (Linux bundles) an uppercase-carrying argument would miss the file the
+    // save path wrote under its folded slug (CI-caught, v0.11.0 round 1).
+    const slug = okf.slugify(okf.unwrapTopicRef(rawSlug))
+    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.
     await this.store
       .appendOpenRecord({ slug, at: new Date().toISOString(), ...(sessionId !== undefined ? { sessionId } : {}) })
       .catch(() => undefined)
-    return {
+    // Optional fields are OMITTED, never present-as-undefined: the host's
+    // tool-output validation rejects any object carrying an undefined-valued
+    // key as non-lossless JSON (INVALID_TOOL_OUTPUT; audit ②⑦ — topics
+    // without a description made every open of them fail).
+    const found: {
+      found: boolean
+      slug: string
+      title: string
+      status: okf.TopicStatus
+      updatedAt: string
+      description?: string
+      conclusion: string
+      openQuestions: string[]
+      recommendations: string
+    } = {
       found: true,
       slug,
       title: doc.fm.title,
       status: doc.fm.status,
       updatedAt: doc.fm.generated.at,
-      description: doc.fm.description,
       conclusion: okf.sectionOf(doc.body, okf.CONCLUSION_HEADING) ?? '',
       openQuestions: doc.fm.open_questions,
       recommendations: okf.sectionOf(doc.body, okf.RECOMMENDATIONS_HEADING) ?? '',
     }
+    if (doc.fm.description !== undefined) found.description = doc.fm.description
+    return found
   }
 
   /** Sync roster read (same mtime cache as roster()). */

package/src/sync.ts

@@ -51,7 +51,12 @@ export class Sync {
     return this.cfg().repo !== ''
   }
 
-  /** Session start (or `/topics sync pull`): rebase onto remote, mark conflicts. */
+  /**
+   * Session start (or `/topics sync pull`): rebase onto remote, mark
+   * conflicts, then replay any push the previous session's local-only exit
+   * deferred. The replay is best-effort — a failure just marks lastError and
+   * the debounced flush (or the next boot's pull) retries.
+   */
   async pull(): Promise<{ ok: boolean; conflicted: string[]; message: string }> {
     if (!this.active) return { ok: true, conflicted: [], message: 'local-only 模式，无同步' }
     const token = await this.safeToken()
@@ -66,6 +71,21 @@ export class Sync {
       // A successful rebase clears previous conflict marks.
       const prior = await this.store.getConflicts()
       if (prior.size > 0) await this.store.setConflicts([])
+      // Deferred-push replay: the previous exit committed locally only, so a
+      // successful rebase here is the moment the backlog lands on the remote.
+      try {
+        if ((await gitmod.unpushedCount(this.store.root)) > 0) {
+          const pushed = await gitmod.push(this.store.root, token)
+          if (pushed.ok) {
+            this.lastPushAt = new Date().toISOString()
+            this.lastError = ''
+          } else {
+            this.lastError = pushed.output.slice(-500)
+          }
+        }
+      } catch {
+        // pull must stay best-effort for the session-start caller
+      }
       return { ok: true, conflicted: [], message: '已与远端同步' }
     }
     const conflictedSlugs = outcome.conflicted.map((p) => p.replace(/^topics\//, '').replace(/\.md$/, ''))
@@ -73,7 +93,14 @@ export class Sync {
       await this.store.setConflicts(outcome.conflicted)
     }
     this.lastError = outcome.output.slice(-500)
-    return { ok: false, conflicted: conflictedSlugs, message: `rebase 冲突：${conflictedSlugs.join('、') || '未知路径'}（已标记降权，待手工解决）` }
+    // A rebase can fail without producing conflicted paths (identity missing,
+    // fetch failure, corrupt state) — surface the git output tail instead of
+    // the misleading 「未知路径」 so a headless failure is diagnosable.
+    if (conflictedSlugs.length === 0) {
+      const tail = outcome.output.trim().split('\n').slice(-3).join('；').slice(-200)
+      return { ok: false, conflicted: [], message: `rebase 失败（无冲突文件）：${tail !== '' ? tail : 'git 无输出'}` }
+    }
+    return { ok: false, conflicted: conflictedSlugs, message: `rebase 冲突：${conflictedSlugs.join('、')}（已标记降权，待手工解决）` }
   }
 
   /** Called after every write-through commit — schedules the debounced push. */

package/src/tools.ts

@@ -261,7 +261,19 @@ export function buildTopicTools(service: TopicsService) {
     },
     async execute(args) {
       const { entries } = await service.history(args.slug, args.limit ?? 20)
-      return { entries: entries.map((e) => ({ ...e, conclusion: e.conclusion as string | undefined })) }
+      // conclusion is omitted, never present-as-undefined — the host rejects
+      // undefined-valued keys as non-lossless JSON (INVALID_TOOL_OUTPUT).
+      return {
+        entries: entries.flatMap((e) => {
+          const entry: { hash: string; date: string; message: string; conclusion?: string } = {
+            hash: e.hash,
+            date: e.date,
+            message: e.message,
+          }
+          if (typeof e.conclusion === 'string') entry.conclusion = e.conclusion
+          return [entry]
+        }),
+      }
     },
   })