@aiwayds/dsh-topics-memory 0.9.0 → 0.11.0

package/lib/service.js

@@ -15,6 +15,8 @@ import { aggregateStats, querySample } from "./ilog.js";
 import { fileHistory, fileAtRev } from "./git.js";
 export class TopicsService {
     cache = new Map();
+    /** mtime-keyed parse of the observations log, grouped by session. */
+    echoCache;
     store;
     getConfig;
     sync;
@@ -82,6 +84,60 @@ export class TopicsService {
     /** Drop the roster cache (tests, bulk external edits). */
     invalidate() {
         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) {
+        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;
+                    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();
     }
     /**
      * Full retrieval round: search → assemble → log (ADR 0006/0007). The
@@ -151,15 +207,19 @@ 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, sessionId, dedup, slow, slowExpired) {
         const cfg = this.cfg;
@@ -194,7 +254,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, {
@@ -206,13 +266,19 @@ 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 = [];
         const bySlug = new Map(roster.map((r) => [r.slug, r]));
         const entries = [];
         const unreadable = [];
         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
@@ -236,9 +302,21 @@ export class TopicsService {
                         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,
@@ -289,6 +367,8 @@ export class TopicsService {
             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' }))];
         }
@@ -328,7 +408,7 @@ export class TopicsService {
         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 };
     }
     /**
      * topic_open tool path (v4 §4.1): full conclusion / open questions /
@@ -336,8 +416,16 @@ 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, sessionId) {
-        const doc = await this.store.readTopic(slug).catch(() => undefined);
+    async openTopic(rawSlug, sessionId) {
+        // 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
@@ -345,17 +433,23 @@ export class TopicsService {
         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: 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()). */
     rosterSync() {

package/lib/sync.d.ts

@@ -32,7 +32,12 @@ export declare class Sync {
     private readonly urlFor;
     constructor(store: BundleStore, cfg: () => SyncConfig, token?: TokenResolver, urlFor?: UrlResolver);
     get active(): boolean;
-    /** 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.
+     */
     pull(): Promise<{
         ok: boolean;
         conflicted: string[];

package/lib/sync.js

@@ -35,7 +35,12 @@ export class Sync {
     get active() {
         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() {
         if (!this.active)
             return { ok: true, conflicted: [], message: 'local-only 模式，无同步' };
@@ -52,6 +57,23 @@ export class Sync {
             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$/, ''));
@@ -59,7 +81,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. */
     schedulePush() {

package/lib/tools.js

@@ -244,7 +244,20 @@ export function buildTopicTools(service) {
         },
         async execute(args) {
             const { entries } = await service.history(args.slug, args.limit ?? 20);
-            return { entries: entries.map((e) => ({ ...e, conclusion: e.conclusion })) };
+            // 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: e.hash,
+                        date: e.date,
+                        message: e.message,
+                    };
+                    if (typeof e.conclusion === 'string')
+                        entry.conclusion = e.conclusion;
+                    return [entry];
+                }),
+            };
         },
     });
     return [topicSave, topicOpen, topicSearch, topicObserve, topicHistory];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aiwayds/dsh-topics-memory",
-  "version": "0.9.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",
+  "version": "0.11.0",
+  "description": "dsh-plugin: quality-first topic memory for dsh — a topic keeps the starting question, conclusion, impact and dependencies, not the process; local-first git-traced OKF bundle, budgeted LLM-free injection",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/src/commands.ts

@@ -196,15 +196,23 @@ async function renderStats(service: TopicsService): Promise<string> {
     lines.push(`  慢道参与轮：${slowRounds}（快 ${(records.length - slowRounds)} / 慢或混合 ${slowRounds}${medianLag}）`)
   }
   // Pointer open rate (v4 §4.3): topic_open calls vs pointer entries injected.
+  // Echoed hits ride the retrieval but never became pointers — excluded here.
   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),
+      (acc, r) =>
+        acc +
+        r.hits.filter((h) => !(r.deduped ?? []).includes(h.slug) && !(r.echoed ?? []).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} 条注入指针）`)
   }
+  const echoedCount = records.reduce((acc, r) => acc + (r.echoed?.length ?? 0), 0)
+  if (echoedCount > 0) {
+    lines.push(`  回声抑制：${echoedCount} 次（本会话蒸馏出的 topic 不回注）`)
+  }
   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}`)
@@ -232,13 +240,25 @@ export function tuningHint(stats: ReturnType<typeof aggregateStats>, threshold:
 async function renderList(service: TopicsService): Promise<string> {
   const metas = await service.store.listTopics()
   if (metas.length === 0) return 'Bundle 里还没有 Topic —— 在会话里让我记点什么，或 /topics set 配置好蒸馏。'
-  const lines = [`共 ${metas.length} 个 Topic：`]
-  for (const m of metas.sort((a, b) => a.slug.localeCompare(b.slug))) {
-    lines.push(`  ${m.slug}  [${m.status}] ${m.title}${m.tags.length > 0 ? `  #${m.tags.join(' #')}` : ''}`)
+  metas.sort((a, b) => a.slug.localeCompare(b.slug))
+  const lines = [
+    `共 ${metas.length} 个 Topic：`,
+    '',
+    '| Slug | 标题 | 状态 | 标签 | 更新 |',
+    '| --- | --- | --- | --- | --- |',
+  ]
+  for (const m of metas) {
+    const tags = m.tags.length > 0 ? m.tags.map((t) => `#${cell(t)}`).join(' ') : '—'
+    lines.push(`| \`${cell(m.slug)}\` | ${cell(m.title)} | ${m.status} | ${tags} | ${cell(m.generatedAt.slice(0, 10))} |`)
   }
   return lines.join('\n')
 }
 
+/** One markdown table cell: pipes escaped, whitespace flattened. */
+function cell(text: string): string {
+  return text.replace(/\|/g, '\\|').replace(/\s*\n\s*/g, ' ')
+}
+
 async function renderShow(service: TopicsService, slug: string | undefined): Promise<CommandResult> {
   if (slug === undefined || slug === '') return fail('用法：/topics show <slug>')
   const doc = await service.store.readTopic(slug)

package/src/config.ts

@@ -14,6 +14,11 @@ export const TopicsConfig = z.object({
   autoInject: z.boolean().default(true),
   /** Skip re-injecting topics already injected earlier in the same session. */
   injectDedup: z.boolean().default(true),
+  /** Skip re-injecting topics distilled from the CURRENT session's own turns
+   *  (蒸馏回声): the conversation already carries that knowledge, so a
+   *  pointer is a stale echo at best (2026-09 audit: 3 of 6 useless rounds).
+   *  Provenance rides the observations log (sessionId → distilledInto). */
+  suppressEcho: z.boolean().default(true),
   /** Max topics injected per round (ADR 0006: ≤4). */
   topK: z.number().default(4),
   /** Per-topic digest budget in tokens. */
@@ -61,6 +66,7 @@ export type TopicsConfigValue = {
   repo: string
   autoInject: boolean
   injectDedup: boolean
+  suppressEcho: boolean
   topK: number
   perTopicBudget: number
   totalBudget: number
@@ -86,6 +92,7 @@ export const CONFIG_KEYS = [
   'repo',
   'autoInject',
   'injectDedup',
+  'suppressEcho',
   'topK',
   'perTopicBudget',
   'totalBudget',
@@ -125,6 +132,7 @@ export function parseConfigValue(key: ConfigKey, raw: string): boolean | number
     }
     case 'autoInject':
     case 'injectDedup':
+    case 'suppressEcho':
     case 'autoObserve':
     case 'distillOnSessionEnd':
     case 'includeSubagents': {

package/src/distill.ts

@@ -161,8 +161,10 @@ export class Distiller {
    * caller can hook post-run cleanup — the per-session llm capture in
    * index.ts must live exactly as long as a run that may read it. `manual`
    * is the /topics distill trigger: same lane, same in-flight guard.
+   * `boot-replay` is the session-start backlog drain: a previous exit's
+   * skipped (or killed-mid-run) distill replays here.
    */
-  request(sessionId: string, reason: 'every-n' | 'session-end' | 'manual'): Promise<DistillResult> | undefined {
+  request(sessionId: string, reason: 'every-n' | 'session-end' | 'manual' | 'boot-replay'): Promise<DistillResult> | undefined {
     if (!this.configured) return undefined
     if (this.inFlight.has(sessionId)) return undefined
     const run = this.run(sessionId).finally(() => this.inFlight.delete(sessionId))

package/src/git.ts

@@ -152,10 +152,13 @@ export interface PullOutcome {
  * `pull --rebase` with conflict containment: on conflict we abort the rebase
  * (ADR 0003 — no automatic smart merging) and report the conflicted paths so
  * the caller can mark those topics. Remote and branch are explicit — the
- * bundle never depends on upstream tracking config.
+ * bundle never depends on upstream tracking config. IDENTITY rides along:
+ * a rebase REPLAYS local commits, which requires a committer identity, and
+ * a fresh machine (CI, new host) may have none — without this the pull
+ * fails with an empty conflicted list on every session start.
  */
 export async function pullRebase(cwd: string, token?: string, remote = 'origin', branch = 'main'): Promise<PullOutcome> {
-  const r = await runGit(['pull', '--rebase', '--autostash', remote, branch], { cwd, token, mayFail: true, timeoutMs: 60_000 }).catch((e) => {
+  const r = await runGit([...IDENTITY, 'pull', '--rebase', '--autostash', remote, branch], { cwd, token, mayFail: true, timeoutMs: 60_000 }).catch((e) => {
     return { code: -1, stdout: '', stderr: String(e instanceof Error ? e.message : e) } satisfies GitResult
   })
   if (r.code === 0) return { ok: true, conflicted: [], output: r.stdout + r.stderr }

package/src/ilog.ts

@@ -41,6 +41,8 @@ export interface InjectionRecord {
   dropped?: { slug: string; reason: string }[]
   /** Slugs blocked this round by session-level injection dedup (never assembled). */
   deduped?: string[]
+  /** Slugs blocked this round as 蒸馏回声 (distilled from this session's own turns). */
+  echoed?: 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. */
@@ -88,12 +90,14 @@ export function aggregateStats(records: readonly InjectionRecord[]): AggregateSt
       budgetSamples += 1
       budgetSum += r.usedTokens
     }
-    // topTopics feeds 「Top-N 被注入 Topic」— deduped hits were NOT injected,
-    // so they must not inflate the per-slug injection counts. Retrieval-shape
-    // metrics above (hits/rounds, zero-hit rounds) keep counting raw hits.
+    // topTopics feeds 「Top-N 被注入 Topic」— deduped/echoed hits were NOT
+    // injected, so they must not inflate the per-slug injection counts.
+    // Retrieval-shape metrics above (hits/rounds, zero-hit rounds) keep
+    // counting raw hits.
     const deduped = r.deduped === undefined ? undefined : new Set(r.deduped)
+    const echoed = r.echoed === undefined ? undefined : new Set(r.echoed)
     for (const h of r.hits) {
-      if (deduped?.has(h.slug)) continue
+      if (deduped?.has(h.slug) || echoed?.has(h.slug)) continue
       topicCounts.set(h.slug, (topicCounts.get(h.slug) ?? 0) + 1)
     }
     for (const nm of r.nearMisses) {

package/src/index.ts

@@ -39,13 +39,13 @@ import { isDelegated } from './delegation.ts'
 export const name = 'dsh-topics-memory'
 
 /**
- * Bounded wait for the process-exit distill. Session teardown is the last
- * distill trigger, but the disposer used to fire it fire-and-forget — process
- * exit always won the race and the run died unwritten. The disposer now waits
- * for the run, capped so a pathological (hanging) model call can never wedge
- * the host's exit.
+ * Bounded wait for the process-exit meta commit. The exit path is
+ * local-only: no pull/push, no model call — the deferred push rides the
+ * next boot's pull and the skipped exit distill is replayed there. The
+ * window only bounds the local `git commit` against a pathological stall
+ * (a wedged index.lock, a hung filesystem), which should never fire.
  */
-export const EXIT_DISTILL_TIMEOUT_MS = 90_000
+export const EXIT_COMMIT_TIMEOUT_MS = 10_000
 
 /**
  * Resolve when `p` settles (rejection swallowed) or after `ms`, whichever
@@ -244,6 +244,7 @@ export function apply(ctx: Context): void {
       if (state === undefined) return
       const cfg = cfgNow()
       const seen = cfg.injectDedup ? injectedBySession.get(sessionId) : undefined
+      const echo = cfg.suppressEcho ? service.echoSlugsSync(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).
@@ -256,7 +257,7 @@ export function apply(ctx: Context): void {
           else slowExpired = consumed.expired
         }
       }
-      const r = service.retrieveSync(query, sessionId, seen === undefined ? undefined : { exclude: seen }, slow, slowExpired)
+      const r = service.retrieveSync(query, sessionId, seen === undefined && echo === undefined ? undefined : { exclude: seen, echo }, slow, slowExpired)
       // Mark only what entered the context this round (hits AND slow picks →
       // dedup filter → assemble → registry mark; budget-dropped slugs stay
       // injectable).
@@ -301,6 +302,18 @@ export function apply(ctx: Context): void {
       slowLane.dispatch(sessionId, {
         ring: observer.recentTurns(sessionId),
         turnId: observer.turnCountOf(sessionId),
+        // The lane must not spend its rerank on slugs this session already
+        // carries (injected earlier / distilled from its own turns) — such a
+        // pick is silently swallowed at consumption and the pending dies.
+        exclude: (() => {
+          const seen = injectedBySession.get(sessionId)
+          const echo = cfgNow().suppressEcho ? service.echoSlugsSync(sessionId) : undefined
+          if (seen === undefined || seen.size === 0) return echo
+          if (echo === undefined || echo.size === 0) return seen
+          const merged = new Set(seen)
+          for (const slug of echo) merged.add(slug)
+          return merged
+        })(),
       })
     } catch {
       // contained — the lane must never break the event handler
@@ -368,10 +381,10 @@ export function apply(ctx: Context): void {
   const slowLane = new SlowLane(service, caller, releaseSessionLlm)
 
   // ---- Observer (M2) ----
-  // The process-exit disposer awaits this run (bounded): the callback below
-  // records it synchronously when the fake 'dispose' session's end trigger
-  // fires, so the disposer can wait for the last distill to land.
-  let exitDistill: Promise<DistillResult> | undefined
+  // Trigger runs are fire-and-forget everywhere now — including the exit
+  // one. Observations are write-through on disk, so a run the process exits
+  // under is never lost work: its input is still undistilled and the next
+  // boot's replay distills it.
   const observer = new Observer(service, (sessionId, reason) => {
     // Trigger-time capture: the agent is still registered here, so its scoped
     // ctx can hand over the llm instance whose adapters are live.
@@ -387,7 +400,6 @@ export function apply(ctx: Context): void {
     // and its own settle hook does the release.
     const run = distiller.request(sessionId, reason)
     if (run !== undefined) {
-      if (sessionId === 'dispose') exitDistill = run
       void run.finally(() => releaseSessionLlm(sessionId)).catch(() => undefined)
     }
   })
@@ -508,13 +520,37 @@ export function apply(ctx: Context): void {
     }) as never)
   }
 
-  // ---- Sync lifecycle: pull on session start, flush on dispose ----
+  // ---- Sync lifecycle: pull on session start, local commit on dispose ----
   ctx.on('session/event' as never, ((session: { id: unknown }, event: SessionEvent) => {
     if (event.type === 'agent/session-start') {
       void sync
         .pull()
         .catch(() => undefined)
         .finally(() => store.ensure().catch(() => undefined))
+        .then(() => {
+          // Boot replay: the observations JSONL is the durable distill queue.
+          // Whatever the previous exit skipped (local-only exit since the
+          // no-network exit commit) or a killed run left unmarked is still
+          // undistilled here. Empty pool and no-model are cheap no-ops inside
+          // the distiller; the per-session dedup guards double runs.
+          void store
+            .undistilledObservations(1)
+            .then((pending) => {
+              if (pending.length === 0) return
+              // Same trigger-time capture the observer callback does: the
+              // replay run's caller resolves candidates lazily and a fresh
+              // session has no prior capture to lean on.
+              try {
+                captureFromAgent(agents()?.get(session.id) as unknown)
+              } catch {
+                // contained — the run below fails with the readable
+                // no-adapter detail instead
+              }
+              const run = distiller.request(String(session.id), 'boot-replay')
+              if (run !== undefined) void run.catch(() => undefined)
+            })
+            .catch(() => undefined)
+        })
     }
   }) as never)
 
@@ -522,27 +558,24 @@ export function apply(ctx: Context): void {
     () => {
       void store.ensure().catch(() => undefined)
       // Async disposer: cordis awaits it during unload (Disposable may be
-      // async), so the exit distill gets its bounded window before the
-      // process goes away instead of always losing the exit race.
+      // async). The exit path is local-only — one git commit of the meta
+      // sidecars (observations / injection log / distill state), no pull, no
+      // push, no model call. The deferred push rides the next boot's pull
+      // (sync.pull replays it) and the skipped exit distill is replayed
+      // there too; both only ever needed the on-disk state, which the commit
+      // below makes durable before the process goes away.
       return () => {
         // A real session's session-end run (agent/disposed trigger, moments
         // earlier) may still be in flight — and the fake-'dispose' run would
         // feed the SAME global pool head to the model a second time (double
         // evaluation, double GC attempts). Skip the exit trigger while any
-        // run is pending; the bounded wait below then simply has nothing
-        // extra to await.
+        // run is pending; its capture is already write-through on disk.
         if (!distiller.hasAnyPending()) {
           observer.onSessionEvent('dispose', 'agent/disposed', undefined)
         }
         sync.dispose()
-        // The exit flush (final meta commit + ledger flush) rides the SAME
-        // bounded window as the exit distill — fire-and-forget here loses the
-        // exit race that window was built to win.
-        const exitFlush = sync.commitMeta().then(() => sync.flush()).catch(() => undefined)
-        return settleBounded(
-          exitDistill === undefined ? exitFlush : Promise.allSettled([exitDistill, exitFlush]),
-          EXIT_DISTILL_TIMEOUT_MS,
-        )
+        const exitFlush = sync.commitMeta().catch(() => undefined)
+        return settleBounded(exitFlush, EXIT_COMMIT_TIMEOUT_MS)
       }
     },
     'topics: lifecycle',
@@ -626,6 +659,7 @@ const DEFAULTS: TopicsConfigValue = {
   repo: '',
   autoInject: true,
   injectDedup: true,
+  suppressEcho: true,
   topK: 4,
   perTopicBudget: 300,
   totalBudget: 1500,