@aiwayds/dsh-topics-memory 0.8.1 → 0.9.0

package/lib/okf.d.ts

@@ -86,7 +86,25 @@ export declare function slugify(title: string): string;
 export declare function pathToSlug(path: string): string;
 /** `foo` → `topics/foo.md`. */
 export declare function slugToPath(slug: string): string;
-/** Bundle-relative paths of `depends` entries that point at topics. */
+/**
+ * Strip every `topics/` (or `topics:` — a colon form the wild has produced)
+ * prefix and `.md` suffix. The canonical depends entry carries exactly one
+ * of each, but bundles written by the save path that re-wrapped preserved
+ * values (fixed in the same release) can carry any number — idempotent by
+ * construction.
+ */
+export declare function unwrapTopicRef(raw: string): string;
+/**
+ * Canonical bundle-relative path for a `depends` entry, accepting every form
+ * the wild has produced: bare slug (`foo`), canonical path (`topics/foo.md`),
+ * multi-wrapped (`topics/topics/foo.md.md`). Idempotent. A value that still
+ * carries a path separator or scheme after unwrapping is not a bundle-internal
+ * topic reference and comes back as its unwrapped self (a dead edge for the
+ * graph, but never re-wrapped into a fake one); the empty string means the
+ * entry unwrapped to nothing and should be dropped by the caller.
+ */
+export declare function normalizeDependsEntry(raw: string): string;
+/** Topic slugs referenced by `depends`, tolerant of wrapped entries. */
 export declare function dependsSlugs(fm: {
     depends: readonly string[];
 }): string[];
@@ -111,7 +129,9 @@ export declare function normalizeLinkTarget(target: string): string | undefined;
  * Topic slugs referenced from a body: `[[wikilinks]]` (with optional
  * `#heading` / `|alias`) plus markdown links pointing at bundle paths.
  * These are the human-authored edges alongside `depends` — both feed the
- * retrieval graph walk and the backlinks index.
+ * retrieval graph walk and the backlinks index. Inline code and fenced
+ * code blocks are stripped first: topics that document link syntax would
+ * otherwise mint permanent phantom edges out of their own examples.
  */
 export declare function bodyLinkSlugs(body: string): string[];
 /** The conventional profile headings, for validators and tooling. */

package/lib/okf.js

@@ -216,9 +216,47 @@ export function pathToSlug(path) {
 export function slugToPath(slug) {
     return `topics/${slug}.md`;
 }
-/** Bundle-relative paths of `depends` entries that point at topics. */
+/**
+ * Strip every `topics/` (or `topics:` — a colon form the wild has produced)
+ * prefix and `.md` suffix. The canonical depends entry carries exactly one
+ * of each, but bundles written by the save path that re-wrapped preserved
+ * values (fixed in the same release) can carry any number — idempotent by
+ * construction.
+ */
+export function unwrapTopicRef(raw) {
+    let t = raw.trim();
+    for (;;) {
+        if (t.startsWith('topics/'))
+            t = t.slice('topics/'.length);
+        else if (t.startsWith('topics:'))
+            t = t.slice('topics:'.length);
+        else
+            break;
+    }
+    while (t.endsWith('.md'))
+        t = t.slice(0, -3);
+    return t;
+}
+/**
+ * Canonical bundle-relative path for a `depends` entry, accepting every form
+ * the wild has produced: bare slug (`foo`), canonical path (`topics/foo.md`),
+ * multi-wrapped (`topics/topics/foo.md.md`). Idempotent. A value that still
+ * carries a path separator or scheme after unwrapping is not a bundle-internal
+ * topic reference and comes back as its unwrapped self (a dead edge for the
+ * graph, but never re-wrapped into a fake one); the empty string means the
+ * entry unwrapped to nothing and should be dropped by the caller.
+ */
+export function normalizeDependsEntry(raw) {
+    const t = unwrapTopicRef(raw);
+    if (t === '')
+        return '';
+    if (t.includes('/') || t.includes(':'))
+        return t;
+    return slugToPath(t);
+}
+/** Topic slugs referenced by `depends`, tolerant of wrapped entries. */
 export function dependsSlugs(fm) {
-    return fm.depends.map(pathToSlug);
+    return fm.depends.map(unwrapTopicRef);
 }
 /** Render the auto-generated OKF `index.md` (progressive disclosure, §Bundle). */
 export function renderIndex(entries) {
@@ -268,16 +306,21 @@ export function normalizeLinkTarget(target) {
  * Topic slugs referenced from a body: `[[wikilinks]]` (with optional
  * `#heading` / `|alias`) plus markdown links pointing at bundle paths.
  * These are the human-authored edges alongside `depends` — both feed the
- * retrieval graph walk and the backlinks index.
+ * retrieval graph walk and the backlinks index. Inline code and fenced
+ * code blocks are stripped first: topics that document link syntax would
+ * otherwise mint permanent phantom edges out of their own examples.
  */
 export function bodyLinkSlugs(body) {
     const out = new Set();
-    for (const m of body.matchAll(WIKILINK)) {
+    const prose = body
+        .replace(/```[\s\S]*?```/g, '')
+        .replace(/`[^`\n]*`/g, '');
+    for (const m of prose.matchAll(WIKILINK)) {
         const slug = normalizeLinkTarget(m[1]);
         if (slug !== undefined)
             out.add(slug);
     }
-    for (const m of body.matchAll(MD_LINK)) {
+    for (const m of prose.matchAll(MD_LINK)) {
         const slug = normalizeLinkTarget(m[1]);
         if (slug !== undefined)
             out.add(slug);

package/lib/service.js

@@ -446,7 +446,11 @@ export class TopicsService {
             type: 'Topic',
             title: input.title,
             tags: dedupeLower(input.tags ?? existing?.fm.tags ?? []),
-            depends: (input.depends ?? existing?.fm.depends ?? []).map(okf.slugToPath),
+            // normalizeDependsEntry, never bare slugToPath: the preserved-on-update
+            // fallback feeds already-canonical `topics/<slug>.md` entries back in,
+            // and wrapping those again stacked one layer per save (the double-wrap
+            // bug repaired on startup by BundleStore.repairDepends).
+            depends: dedupePaths((input.depends ?? existing?.fm.depends ?? []).map(okf.normalizeDependsEntry)),
             open_questions: input.openQuestions ?? existing?.fm.open_questions ?? [],
             impact: input.impact ?? existing?.fm.impact ?? [],
             status: input.status ?? existing?.fm.status ?? 'draft',
@@ -534,6 +538,17 @@ function dedupeLower(tags) {
     }
     return out;
 }
+function dedupePaths(paths) {
+    const seen = new Set();
+    const out = [];
+    for (const p of paths) {
+        if (p === '' || seen.has(p))
+            continue;
+        seen.add(p);
+        out.push(p);
+    }
+    return out;
+}
 function sanitizeTriggers(triggers) {
     const out = [];
     for (const t of triggers) {

package/lib/store.d.ts

@@ -66,7 +66,8 @@ export declare class BundleStore {
     /** Last distill-lane run outcome (diagnostics for /topics status and e2e). */
     writeDistillState(state: unknown): Promise<void>;
     readDistillState(): Promise<Record<string, unknown> | undefined>;
-    /** Create the directory skeleton, git repo, and initial index (idempotent). */
+    /** Create the directory skeleton, git repo, initial index, and repair
+     * wrapped depends entries left by older save paths (idempotent). */
     ensure(): Promise<void>;
     /** Repo initialized and not gitDisabled. */
     hasGit(): Promise<boolean>;
@@ -76,6 +77,16 @@ export declare class BundleStore {
     brokenTopics(): Promise<string[]>;
     readTopic(slug: string): Promise<okf.TopicDoc | undefined>;
     exists(slug: string): Promise<boolean>;
+    /**
+     * Upgrade repair for bundles written by the save path that stacked another
+     * `topics/….md` wrap onto preserved-on-update depends entries, leaving
+     * multi-wrapped references (`topics/topics/foo.md.md`) whose edges resolve
+     * to nothing. Unwraps in place behind the write queue, regenerates the
+     * derived files, and lands the result as one traceable commit; file
+     * rewrites happen even without git, the commit just doesn't. Idempotent —
+     * every clean startup re-scans and finds nothing to change.
+     */
+    private repairDepends;
     /** First free slug: `foo`, then `foo-2`, `foo-3`, … */
     uniqueSlug(base: string): Promise<string>;
     /**

package/lib/store.js

@@ -28,6 +28,20 @@ async function atomicWrite(file, content) {
     await writeFile(tmp, content, 'utf8');
     await rename(tmp, file);
 }
+function dedupePaths(paths) {
+    const seen = new Set();
+    const out = [];
+    for (const p of paths) {
+        if (p === '' || seen.has(p))
+            continue;
+        seen.add(p);
+        out.push(p);
+    }
+    return out;
+}
+function sameStrings(a, b) {
+    return a.length === b.length && a.every((v, i) => v === b[i]);
+}
 export class BundleStore {
     root;
     actor;
@@ -79,7 +93,8 @@ export class BundleStore {
             return undefined;
         }
     }
-    /** Create the directory skeleton, git repo, and initial index (idempotent). */
+    /** Create the directory skeleton, git repo, initial index, and repair
+     * wrapped depends entries left by older save paths (idempotent). */
     async ensure() {
         await mkdir(this.topicsDir(), { recursive: true });
         await mkdir(this.metaDir(), { recursive: true });
@@ -89,6 +104,7 @@ export class BundleStore {
         if (!(await existsSync(join(this.root, 'index.md')))) {
             await this.enqueue(() => this.regenerateIndex());
         }
+        await this.repairDepends();
     }
     /** Repo initialized and not gitDisabled. */
     async hasGit() {
@@ -170,6 +186,49 @@ export class BundleStore {
     async exists(slug) {
         return existsSync(this.topicPath(slug));
     }
+    /**
+     * Upgrade repair for bundles written by the save path that stacked another
+     * `topics/….md` wrap onto preserved-on-update depends entries, leaving
+     * multi-wrapped references (`topics/topics/foo.md.md`) whose edges resolve
+     * to nothing. Unwraps in place behind the write queue, regenerates the
+     * derived files, and lands the result as one traceable commit; file
+     * rewrites happen even without git, the commit just doesn't. Idempotent —
+     * every clean startup re-scans and finds nothing to change.
+     */
+    async repairDepends() {
+        await this.enqueue(async () => {
+            let files;
+            try {
+                files = await readdir(this.topicsDir());
+            }
+            catch {
+                return;
+            }
+            const changed = [];
+            for (const f of files) {
+                if (!f.endsWith('.md') || f === 'index.md')
+                    continue;
+                const file = join(this.topicsDir(), f);
+                let doc;
+                try {
+                    doc = okf.parseTopicDoc(await readFile(file, 'utf8'));
+                }
+                catch {
+                    continue; // broken files are status()'s business, not the repair's
+                }
+                const normalized = dedupePaths(doc.fm.depends.map(okf.normalizeDependsEntry));
+                if (sameStrings(normalized, doc.fm.depends))
+                    continue;
+                doc.fm.depends = normalized;
+                await atomicWrite(file, okf.serializeTopicDoc(doc));
+                changed.push(`topics/${f}`);
+            }
+            if (changed.length === 0)
+                return;
+            await this.regenerateIndex();
+            await this.commit([...changed, 'index.md'], `topics(migrate): repair wrapped depends entries in ${changed.length} topic file(s)`);
+        });
+    }
     /** First free slug: `foo`, then `foo-2`, `foo-3`, … */
     async uniqueSlug(base) {
         const clean = okf.slugify(base);
@@ -508,13 +567,19 @@ export class BundleStore {
     }
     async setConflicts(paths) {
         await this.enqueue(async () => {
-            if (paths.length === 0) {
+            // Only topic files belong here: a rebase can also conflict on meta
+            // sidecars (observations.jsonl is appended on both machines), and
+            // storing those leaked non-topic paths into the conflicts mark, where
+            // /topics status displayed them as if they were topics and the demote
+            // gate keyed on slugs that can never exist.
+            const topics = [...new Set(paths.filter((p) => /^topics\/.+\.md$/.test(p)))];
+            if (topics.length === 0) {
                 await atomicWrite(this.conflictsPath(), '[]\n');
             }
             else {
-                await atomicWrite(this.conflictsPath(), `${JSON.stringify([...paths], null, 2)}\n`);
+                await atomicWrite(this.conflictsPath(), `${JSON.stringify(topics, null, 2)}\n`);
             }
-            await this.commit(['meta/conflicts.json'], `topics(meta): mark ${paths.length} conflicted topic(s)`);
+            await this.commit(['meta/conflicts.json'], `topics(meta): mark ${topics.length} conflicted topic(s)`);
         });
     }
     // ------------------------------------------------------------------

package/lib/viz.js

@@ -9,6 +9,7 @@
  *
  * @module viz
  */
+import { unwrapTopicRef } from "./okf.js";
 /** Build the relationship graph: depends edges + body-link edges, no self-loops. */
 export function buildGraph(roster) {
     const bySlug = new Set(roster.map((r) => r.slug));
@@ -31,7 +32,9 @@ export function buildGraph(roster) {
     };
     for (const topic of roster) {
         for (const dep of topic.depends) {
-            const target = dep.replace(/^topics\//, '').replace(/\.md$/, '');
+            // unwrapTopicRef, not a single strip: pre-repair bundles can carry
+            // multi-wrapped depends entries, which would render a dead node here.
+            const target = unwrapTopicRef(dep);
             addEdge(topic.slug, target, 'depends');
         }
         for (const link of topic.links ?? [])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwayds/dsh-topics-memory",
-  "version": "0.8.1",
+  "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",
   "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/quality.test.mjs test/replay-gate.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 test/depends-repair.test.mjs",
     "smoke": "node scripts/smoke-boot.mjs"
   },
   "dependencies": {},

package/src/okf.ts

@@ -254,9 +254,43 @@ export function slugToPath(slug: string): string {
   return `topics/${slug}.md`
 }
 
-/** Bundle-relative paths of `depends` entries that point at topics. */
+/**
+ * Strip every `topics/` (or `topics:` — a colon form the wild has produced)
+ * prefix and `.md` suffix. The canonical depends entry carries exactly one
+ * of each, but bundles written by the save path that re-wrapped preserved
+ * values (fixed in the same release) can carry any number — idempotent by
+ * construction.
+ */
+export function unwrapTopicRef(raw: string): string {
+  let t = raw.trim()
+  for (;;) {
+    if (t.startsWith('topics/')) t = t.slice('topics/'.length)
+    else if (t.startsWith('topics:')) t = t.slice('topics:'.length)
+    else break
+  }
+  while (t.endsWith('.md')) t = t.slice(0, -3)
+  return t
+}
+
+/**
+ * Canonical bundle-relative path for a `depends` entry, accepting every form
+ * the wild has produced: bare slug (`foo`), canonical path (`topics/foo.md`),
+ * multi-wrapped (`topics/topics/foo.md.md`). Idempotent. A value that still
+ * carries a path separator or scheme after unwrapping is not a bundle-internal
+ * topic reference and comes back as its unwrapped self (a dead edge for the
+ * graph, but never re-wrapped into a fake one); the empty string means the
+ * entry unwrapped to nothing and should be dropped by the caller.
+ */
+export function normalizeDependsEntry(raw: string): string {
+  const t = unwrapTopicRef(raw)
+  if (t === '') return ''
+  if (t.includes('/') || t.includes(':')) return t
+  return slugToPath(t)
+}
+
+/** Topic slugs referenced by `depends`, tolerant of wrapped entries. */
 export function dependsSlugs(fm: { depends: readonly string[] }): string[] {
-  return fm.depends.map(pathToSlug)
+  return fm.depends.map(unwrapTopicRef)
 }
 
 export interface IndexEntry {
@@ -312,15 +346,20 @@ export function normalizeLinkTarget(target: string): string | undefined {
  * Topic slugs referenced from a body: `[[wikilinks]]` (with optional
  * `#heading` / `|alias`) plus markdown links pointing at bundle paths.
  * These are the human-authored edges alongside `depends` — both feed the
- * retrieval graph walk and the backlinks index.
+ * retrieval graph walk and the backlinks index. Inline code and fenced
+ * code blocks are stripped first: topics that document link syntax would
+ * otherwise mint permanent phantom edges out of their own examples.
  */
 export function bodyLinkSlugs(body: string): string[] {
   const out = new Set<string>()
-  for (const m of body.matchAll(WIKILINK)) {
+  const prose = body
+    .replace(/```[\s\S]*?```/g, '')
+    .replace(/`[^`\n]*`/g, '')
+  for (const m of prose.matchAll(WIKILINK)) {
     const slug = normalizeLinkTarget(m[1])
     if (slug !== undefined) out.add(slug)
   }
-  for (const m of body.matchAll(MD_LINK)) {
+  for (const m of prose.matchAll(MD_LINK)) {
     const slug = normalizeLinkTarget(m[1])
     if (slug !== undefined) out.add(slug)
   }

package/src/service.ts

@@ -484,7 +484,11 @@ export class TopicsService {
       type: 'Topic',
       title: input.title,
       tags: dedupeLower(input.tags ?? existing?.fm.tags ?? []),
-      depends: (input.depends ?? existing?.fm.depends ?? []).map(okf.slugToPath),
+      // normalizeDependsEntry, never bare slugToPath: the preserved-on-update
+      // fallback feeds already-canonical `topics/<slug>.md` entries back in,
+      // and wrapping those again stacked one layer per save (the double-wrap
+      // bug repaired on startup by BundleStore.repairDepends).
+      depends: dedupePaths((input.depends ?? existing?.fm.depends ?? []).map(okf.normalizeDependsEntry)),
       open_questions: input.openQuestions ?? existing?.fm.open_questions ?? [],
       impact: input.impact ?? existing?.fm.impact ?? [],
       status: input.status ?? existing?.fm.status ?? 'draft',
@@ -577,6 +581,17 @@ function dedupeLower(tags: string[]): string[] {
   return out
 }
 
+function dedupePaths(paths: string[]): string[] {
+  const seen = new Set<string>()
+  const out: string[] = []
+  for (const p of paths) {
+    if (p === '' || seen.has(p)) continue
+    seen.add(p)
+    out.push(p)
+  }
+  return out
+}
+
 function sanitizeTriggers(triggers: readonly string[]): string[] {
   const out: string[] = []
   for (const t of triggers) {

package/src/store.ts

@@ -77,6 +77,21 @@ async function atomicWrite(file: string, content: string): Promise<void> {
   await rename(tmp, file)
 }
 
+function dedupePaths(paths: readonly string[]): string[] {
+  const seen = new Set<string>()
+  const out: string[] = []
+  for (const p of paths) {
+    if (p === '' || seen.has(p)) continue
+    seen.add(p)
+    out.push(p)
+  }
+  return out
+}
+
+function sameStrings(a: readonly string[], b: readonly string[]): boolean {
+  return a.length === b.length && a.every((v, i) => v === b[i])
+}
+
 export interface BundleStoreOptions {
   /** Override the stamped actor (tests). Defaults to `agent:dsh-topics-memory@<host>`. */
   actor?: string
@@ -146,7 +161,8 @@ export class BundleStore {
     }
   }
 
-  /** Create the directory skeleton, git repo, and initial index (idempotent). */
+  /** Create the directory skeleton, git repo, initial index, and repair
+   * wrapped depends entries left by older save paths (idempotent). */
   async ensure(): Promise<void> {
     await mkdir(this.topicsDir(), { recursive: true })
     await mkdir(this.metaDir(), { recursive: true })
@@ -156,6 +172,7 @@ export class BundleStore {
     if (!(await existsSync(join(this.root, 'index.md')))) {
       await this.enqueue(() => this.regenerateIndex())
     }
+    await this.repairDepends()
   }
 
   /** Repo initialized and not gitDisabled. */
@@ -234,6 +251,45 @@ export class BundleStore {
     return existsSync(this.topicPath(slug))
   }
 
+  /**
+   * Upgrade repair for bundles written by the save path that stacked another
+   * `topics/….md` wrap onto preserved-on-update depends entries, leaving
+   * multi-wrapped references (`topics/topics/foo.md.md`) whose edges resolve
+   * to nothing. Unwraps in place behind the write queue, regenerates the
+   * derived files, and lands the result as one traceable commit; file
+   * rewrites happen even without git, the commit just doesn't. Idempotent —
+   * every clean startup re-scans and finds nothing to change.
+   */
+  private async repairDepends(): Promise<void> {
+    await this.enqueue(async () => {
+      let files: string[]
+      try {
+        files = await readdir(this.topicsDir())
+      } catch {
+        return
+      }
+      const changed: string[] = []
+      for (const f of files) {
+        if (!f.endsWith('.md') || f === 'index.md') continue
+        const file = join(this.topicsDir(), f)
+        let doc: okf.TopicDoc
+        try {
+          doc = okf.parseTopicDoc(await readFile(file, 'utf8'))
+        } catch {
+          continue // broken files are status()'s business, not the repair's
+        }
+        const normalized = dedupePaths(doc.fm.depends.map(okf.normalizeDependsEntry))
+        if (sameStrings(normalized, doc.fm.depends)) continue
+        doc.fm.depends = normalized
+        await atomicWrite(file, okf.serializeTopicDoc(doc))
+        changed.push(`topics/${f}`)
+      }
+      if (changed.length === 0) return
+      await this.regenerateIndex()
+      await this.commit([...changed, 'index.md'], `topics(migrate): repair wrapped depends entries in ${changed.length} topic file(s)`)
+    })
+  }
+
   /** First free slug: `foo`, then `foo-2`, `foo-3`, … */
   async uniqueSlug(base: string): Promise<string> {
     const clean = okf.slugify(base)
@@ -575,12 +631,18 @@ export class BundleStore {
 
   async setConflicts(paths: readonly string[]): Promise<void> {
     await this.enqueue(async () => {
-      if (paths.length === 0) {
+      // Only topic files belong here: a rebase can also conflict on meta
+      // sidecars (observations.jsonl is appended on both machines), and
+      // storing those leaked non-topic paths into the conflicts mark, where
+      // /topics status displayed them as if they were topics and the demote
+      // gate keyed on slugs that can never exist.
+      const topics = [...new Set(paths.filter((p) => /^topics\/.+\.md$/.test(p)))]
+      if (topics.length === 0) {
         await atomicWrite(this.conflictsPath(), '[]\n')
       } else {
-        await atomicWrite(this.conflictsPath(), `${JSON.stringify([...paths], null, 2)}\n`)
+        await atomicWrite(this.conflictsPath(), `${JSON.stringify(topics, null, 2)}\n`)
       }
-      await this.commit(['meta/conflicts.json'], `topics(meta): mark ${paths.length} conflicted topic(s)`)
+      await this.commit(['meta/conflicts.json'], `topics(meta): mark ${topics.length} conflicted topic(s)`)
     })
   }
 

package/src/viz.ts

@@ -11,6 +11,7 @@
  */
 
 import type { RetrievableTopic } from './retrieval.ts'
+import { unwrapTopicRef } from './okf.ts'
 
 export interface VizNode {
   id: string
@@ -51,7 +52,9 @@ export function buildGraph(roster: readonly RetrievableTopic[]): VizGraph {
   }
   for (const topic of roster) {
     for (const dep of topic.depends) {
-      const target = dep.replace(/^topics\//, '').replace(/\.md$/, '')
+      // unwrapTopicRef, not a single strip: pre-repair bundles can carry
+      // multi-wrapped depends entries, which would render a dead node here.
+      const target = unwrapTopicRef(dep)
       addEdge(topic.slug, target, 'depends')
     }
     for (const link of topic.links ?? []) addEdge(topic.slug, link, 'link')