@vellumai/assistant 0.7.0 → 0.7.2

package/src/memory/v2/injection.ts

@@ -6,15 +6,15 @@
 // Implements §5 of the design doc:
 //
 //   1. Hydrate prior activation state for the conversation.
-//   2. Read edges.json (the topology source of truth).
+//   2. Build the in-memory edge index from concept-page frontmatter.
 //   3. Select the per-turn candidate set (prior-state survivors ∪ ANN top-K).
 //   4. Compute own activation A_o over the candidates.
-//   5. Apply 2-hop spreading activation with neighborhood normalization → A.
+//   5. Apply 2-hop spreading activation along directed edges (incoming) → A.
 //   6. Pick top-K by activation; subtract everInjected to get the injection delta.
 //   7. If no new slugs, render nothing — caller leaves the prior cached
 //      attachments on prior user messages exactly as Anthropic prompt caching
 //      requires.
-//   8. Otherwise render a `<memory __injected>` block scoped to the *new* slugs
+//   8. Otherwise render a `<memory>` block scoped to the *new* slugs
 //      ordered by activation (descending) and persist the updated state +
 //      everInjected list (with `currentTurn` annotated) so future turns can
 //      append-inject cache-stably.
@@ -24,23 +24,30 @@
 // cached prefix bytes-identical across turns.
 
 import type { AssistantConfig } from "../../config/types.js";
+import { getLogger } from "../../util/logger.js";
 import { getWorkspaceDir } from "../../util/platform.js";
 import type { DrizzleDb } from "../db-connection.js";
+import {
+  type MemoryV2ConceptRowRecord,
+  type MemoryV2SkillRowRecord,
+  recordMemoryV2ActivationLog,
+} from "../memory-v2-activation-log-store.js";
 import {
   computeOwnActivation,
   computeSkillActivation,
   selectCandidates,
   selectInjections,
-  selectSkillCandidates,
   selectSkillInjections,
   spreadActivation,
 } from "./activation.js";
 import { hydrate, save } from "./activation-store.js";
-import { readEdges } from "./edges.js";
-import { readPage } from "./page-store.js";
-import { getSkillCapability } from "./skill-store.js";
+import { getEdgeIndex } from "./edge-index.js";
+import { readPage, renderPageContent } from "./page-store.js";
+import { getAllSkillIds, getSkillCapability } from "./skill-store.js";
 import type { ActivationState, EverInjectedEntry } from "./types.js";
 
+const log = getLogger("memory-v2-injection");
+
 // ---------------------------------------------------------------------------
 // Public types
 // ---------------------------------------------------------------------------
@@ -49,7 +56,7 @@ import type { ActivationState, EverInjectedEntry } from "./types.js";
  * Discriminator the wiring layer (`conversation-graph-memory.ts`) sets to
  * tell the v2 injector which call site is asking. Both modes currently share
  * the same block layout (mirroring v1 which also wraps both flows in
- * `<memory __injected>...</memory>`); the parameter exists so future tuning
+ * `<memory>...</memory>`); the parameter exists so future tuning
  * can shape the conversation-start block without touching the call site.
  */
 export type InjectMemoryV2Mode = "context-load" | "per-turn";
@@ -81,10 +88,11 @@ export interface InjectMemoryV2BlockParams {
 
 export interface InjectMemoryV2BlockResult {
   /**
-   * Rendered `<memory __injected>` block, ready to prepend to the current
-   * user message — or `null` when nothing new is eligible for injection.
-   * `null` is the cache-stable default: the caller adds nothing to the new
-   * user message and prior attachments stay byte-identical.
+   * Inner content for the `<memory>` block, ready for the caller to wrap
+   * exactly once at injection time — or `null` when nothing new is eligible
+   * for injection. `null` is the cache-stable default: the caller adds
+   * nothing to the new user message and prior attachments stay
+   * byte-identical.
    */
   block: string | null;
   /**
@@ -127,12 +135,14 @@ export async function injectMemoryV2Block(
   // with an effective empty prior state so the first turn can still inject.
   const priorState = await hydrate(database, conversationId);
 
-  // (2) Topology. `readEdges` returns the canonical empty index when the
-  // file is missing (fresh workspace pre-consolidation).
-  const edgesIdx = await readEdges(workspaceDir);
+  // (2) Topology. `getEdgeIndex` walks concept-page frontmatter and caches
+  // the result module-locally; an empty workspace yields an empty index.
+  const edgeIndex = await getEdgeIndex(workspaceDir);
 
   // (3) Candidate set: prior-state survivors above epsilon ∪ ANN top-50.
-  const candidates = await selectCandidates({
+  // `selectCandidates` also returns `fromPrior` / `fromAnn` provenance sets so
+  // telemetry can attribute each candidate back to its source.
+  const { candidates, fromPrior, fromAnn } = await selectCandidates({
     priorState,
     userText: userMessage,
     assistantText: assistantMessage,
@@ -141,46 +151,51 @@ export async function injectMemoryV2Block(
   });
 
   // (4) Own activation: A_o = d·prev + c_user·sim_u + c_a·sim_a + c_now·sim_n.
-  const ownActivation = await computeOwnActivation({
-    candidates,
-    priorState,
-    userText: userMessage,
-    assistantText: assistantMessage,
-    nowText,
-    config,
-  });
+  const { activation: ownActivation, breakdown: ownBreakdown } =
+    await computeOwnActivation({
+      candidates,
+      priorState,
+      userText: userMessage,
+      assistantText: assistantMessage,
+      nowText,
+      config,
+    });
 
   // (5) Spreading activation across the edge graph (k, hops from config).
   const { k, hops, top_k, epsilon } = config.memory.v2;
-  const finalActivation = spreadActivation(ownActivation, edgesIdx, k, hops);
+  const { final: finalActivation, contribution: spreadContribution } =
+    spreadActivation(ownActivation, edgeIndex, k, hops);
 
-  // (6) Pick top-K by activation; subtract everInjected for the injection delta.
+  // (6) Pick top-K by activation. Per-turn turns subtract everInjected for the
+  // injection delta (cache-stable append-only); context-load renders the
+  // entire top-K because it's a fresh load (turn 1 / post-compaction) where
+  // prior cached attachments don't exist or have been thrown away. The user
+  // message gets a complete top-K dump alongside the static
+  // essentials/threads/recent block, then per-turn turns just add deltas.
+  const mode = params.mode ?? "per-turn";
   const priorEverInjected: readonly EverInjectedEntry[] =
     priorState?.everInjected ?? [];
-  const { toInject } = selectInjections({
+  const { topNow, toInject } = selectInjections({
     A: finalActivation,
     priorEverInjected,
     topK: top_k,
   });
+  const slugsToRender = mode === "context-load" ? topNow : toInject;
 
   // (6b) Skill pipeline — a sibling pipeline to the concept-page one above.
-  // Skills are stateless: no decay carry-over, no spread, no `everInjected`
-  // dedup. The top-K relevant skills are re-presented every turn so the
-  // agent can drop and pick them up freely.
-  const skillCandidates = await selectSkillCandidates({
-    userText: userMessage,
-    assistantText: assistantMessage,
-    nowText,
-    config,
-    topK: config.memory.v2.top_k_skills,
-  });
-  const skillActivation = await computeSkillActivation({
-    candidates: skillCandidates,
-    userText: userMessage,
-    assistantText: assistantMessage,
-    nowText,
-    config,
-  });
+  // Skills are stateless (no decay, no spread, no `everInjected` dedup) and
+  // the catalog is small, so every known skill is scored every turn. The
+  // top-K injection slate is re-presented every turn so the agent can drop
+  // and pick skills up freely; the inspector renders the full ranked list.
+  const skillCandidates = new Set(getAllSkillIds());
+  const { activation: skillActivation, breakdown: skillBreakdown } =
+    await computeSkillActivation({
+      candidates: skillCandidates,
+      userText: userMessage,
+      assistantText: assistantMessage,
+      nowText,
+      config,
+    });
   const { topNow: topSkillIds } = selectSkillInjections({
     A: skillActivation,
     topK: config.memory.v2.top_k_skills,
@@ -195,14 +210,20 @@ export async function injectMemoryV2Block(
     if (value > epsilon) nextState[slug] = value;
   }
 
-  // Append the freshly injected slugs to everInjected (with their turn) so
-  // future turns can subtract them. We append rather than reset so that
-  // compaction-driven eviction (`evictCompactedTurns`) is the only path that
-  // can re-enable a previously-injected slug. Skills do NOT enter
-  // `everInjected` — they are stateless and re-presented every turn.
+  // Mark every rendered slug as ever-injected so future per-turn deltas don't
+  // re-attach the same content. On context-load this is the full top-K (we
+  // just rendered all of them); on per-turn it's just the newly added slugs.
+  // We append rather than reset so that compaction-driven eviction
+  // (`evictCompactedTurns`) is the only path that can re-enable a previously-
+  // injected slug. Skills do NOT enter `everInjected` — they are stateless
+  // and re-presented every turn.
+  const everInjectedSet = new Set(priorEverInjected.map((entry) => entry.slug));
+  const newlyInjected = slugsToRender.filter(
+    (slug) => !everInjectedSet.has(slug),
+  );
   const nextEverInjected: EverInjectedEntry[] = [
     ...priorEverInjected,
-    ...toInject.map((slug) => ({ slug, turn: currentTurn })),
+    ...newlyInjected.map((slug) => ({ slug, turn: currentTurn })),
   ];
 
   const nextActivationState: ActivationState = {
@@ -215,78 +236,212 @@ export async function injectMemoryV2Block(
 
   await save(database, conversationId, nextActivationState);
 
-  // (7) Cache-stable empty path: nothing new since the last turn AND no
-  // ranked skills to surface.
-  if (toInject.length === 0 && topSkillIds.length === 0) {
-    return { block: null, toInject: [] };
+  // Render before recording telemetry so the activation log can mark slugs
+  // whose backing file is gone — those are no-op renders that would otherwise
+  // be indistinguishable from successful "injected" rows in the log.
+  // `renderInjectionBlock` itself short-circuits on empty inputs.
+  const { block, missingSlugs } = await renderInjectionBlock(
+    workspaceDir,
+    slugsToRender,
+    topSkillIds,
+  );
+  const missingSlugSet = new Set(missingSlugs);
+  if (missingSlugs.length > 0) {
+    log.warn(
+      {
+        conversationId,
+        turn: currentTurn,
+        missingSlugs,
+        renderedCount: slugsToRender.length - missingSlugs.length,
+      },
+      "Memory v2 injection skipped slugs whose page was missing on disk — Qdrant index may be stale; consider reembed",
+    );
   }
 
-  // (8) Render. `toInject` is already activation-descending (selectInjections
-  // returns it as a filter of the sorted `topNow`), so it doubles as our
-  // render order. Prior slugs sit unchanged on prior user messages. Skills
-  // are appended after concept-page sections under the same header.
-  const block = await renderInjectionBlock(workspaceDir, toInject, topSkillIds);
+  // Record per-turn activation telemetry. Failures are warn-logged and never
+  // block memory injection.
+  const toInjectSet = new Set(toInject);
+  const renderedSet = new Set(slugsToRender);
+  const topSkillIdSet = new Set(topSkillIds);
+  const conceptRows: MemoryV2ConceptRowRecord[] = [...candidates].map(
+    (slug) => {
+      const breakdown = ownBreakdown.get(slug);
+      const inPrior = fromPrior.has(slug);
+      const inAnn = fromAnn.has(slug);
+      // Status reflects what was rendered for *this* turn:
+      //   - context-load: cache was wiped (turn 1 / post-compaction), so
+      //     `slugsToRender = topNow` and every rendered slug is freshly
+      //     injected on this turn. `in_context` is unreachable because there
+      //     is no prior cached attachment for the inspector to point at.
+      //   - per-turn: cached attachments from prior turns are still on the
+      //     user message, so prior-everInjected slugs are `in_context` and
+      //     the delta (`toInject`) is `injected`.
+      // `page_missing` overrides any "would-have-been-injected" status when
+      // `readPage` returned null for the slug — telemetry surfaces stale
+      // ANN/edge entries instead of silently masquerading as a successful
+      // injection.
+      let status: MemoryV2ConceptRowRecord["status"];
+      if (mode === "context-load") {
+        status = renderedSet.has(slug) ? "injected" : "not_injected";
+      } else if (everInjectedSet.has(slug)) {
+        status = "in_context";
+      } else if (toInjectSet.has(slug)) {
+        status = "injected";
+      } else {
+        status = "not_injected";
+      }
+      if (status === "injected" && missingSlugSet.has(slug)) {
+        status = "page_missing";
+      }
+      return {
+        slug,
+        finalActivation: finalActivation.get(slug) ?? 0,
+        ownActivation: ownActivation.get(slug) ?? 0,
+        priorActivation: breakdown?.priorContribution ?? 0,
+        simUser: breakdown?.simUser ?? 0,
+        simAssistant: breakdown?.simAssistant ?? 0,
+        simNow: breakdown?.simNow ?? 0,
+        spreadContribution: spreadContribution.get(slug) ?? 0,
+        source:
+          inPrior && inAnn ? "both" : inPrior ? "prior_state" : "ann_top50",
+        status,
+      };
+    },
+  );
+  conceptRows.sort((a, b) => b.finalActivation - a.finalActivation);
 
-  return { block, toInject };
+  const skillRows: MemoryV2SkillRowRecord[] = [...skillCandidates].map((id) => {
+    const breakdown = skillBreakdown.get(id);
+    return {
+      id,
+      activation: skillActivation.get(id) ?? 0,
+      simUser: breakdown?.simUser ?? 0,
+      simAssistant: breakdown?.simAssistant ?? 0,
+      simNow: breakdown?.simNow ?? 0,
+      status: topSkillIdSet.has(id) ? "injected" : "not_injected",
+    };
+  });
+  skillRows.sort((a, b) => b.activation - a.activation);
+
+  const v2Cfg = config.memory.v2;
+  try {
+    recordMemoryV2ActivationLog({
+      conversationId,
+      turn: currentTurn,
+      mode,
+      concepts: conceptRows,
+      skills: skillRows,
+      config: {
+        d: v2Cfg.d,
+        c_user: v2Cfg.c_user,
+        c_assistant: v2Cfg.c_assistant,
+        c_now: v2Cfg.c_now,
+        k: v2Cfg.k,
+        hops: v2Cfg.hops,
+        top_k: v2Cfg.top_k,
+        top_k_skills: v2Cfg.top_k_skills,
+        epsilon: v2Cfg.epsilon,
+      },
+    });
+  } catch (err) {
+    log.warn(
+      { err, conversationId, turn: currentTurn },
+      "Failed to record memory v2 activation telemetry — continuing",
+    );
+  }
+
+  return { block, toInject: newlyInjected };
 }
 
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
 
+interface RenderInjectionBlockResult {
+  /**
+   * Inner content for the `<memory>` block (concept-page sections + optional
+   * skills suffix), or `null` when both the concept-page list and the skill
+   * list collapse to empty after cache misses (no on-disk pages, no
+   * resolvable skill ids). Returned unwrapped so the caller can wrap it
+   * exactly once at injection time, matching v1's contract: callers that
+   * cache the value (`lastInjectedBlock`) or persist it (`memoryInjectedBlock`
+   * in message metadata) re-wrap on use, and storing the wrapped form here
+   * caused a double wrap on reinject after compaction and on rehydrate from
+   * DB.
+   */
+  block: string | null;
+  /**
+   * Slugs that `readPage` returned null for. Surfaced so the caller can
+   * mark them in the activation log (`status: "page_missing"`) and emit
+   * a warning — silent drops here previously masked stale Qdrant /
+   * edge-index entries that pointed at pages no longer on disk.
+   */
+  missingSlugs: string[];
+}
+
 /**
- * Render the `<memory __injected>` block for a list of slugs and a list of
- * ranked skill ids.
+ * Render the inner content of the `<memory>` block for a list of slugs and
+ * a list of ranked skill ids. The caller wraps the result in
+ * `<memory>...</memory>` exactly once at injection time.
  *
  * Concept pages are read in parallel via `readPage`. Pages whose file has
  * gone missing between selection and render (e.g. consolidation deleted
- * them) are silently dropped — the activation state still records them in
- * `everInjected` so we don't keep re-attempting on every turn.
+ * them, folder reorg renamed the slug) are dropped from the rendered
+ * block but reported back via `missingSlugs` so callers can surface the
+ * divergence.
  *
  * Skill ids are looked up via `getSkillCapability`. Ids that the cache no
  * longer knows (e.g. uninstalled mid-run) are silently dropped, mirroring
  * the missing-pages behavior.
  *
  * The block shape is the §5 layout from the design doc, with an optional
- * trailing skills subsection:
+ * trailing skills subsection. Each concept-page section reproduces the page
+ * as it lives on disk — frontmatter (`edges`, `ref_files`) plus body — so
+ * the agent sees the page's edges and any referenced media paths alongside
+ * the prose:
  *
- *   <memory __injected>
- *   ## What I Remember Right Now
  *   ### <slug-1>
+ *   ---
+ *   edges:
+ *     - <neighbor-slug>
+ *   ref_files:
+ *     - <path/to/asset>
+ *   ---
  *   <body-1>
  *
  *   ### <slug-2>
+ *   ---
+ *   edges: []
+ *   ref_files: []
+ *   ---
  *   <body-2>
  *
  *   ### Skills You Can Use
  *   - <skill-1 content>
  *   - <skill-2 content>
- *   </memory>
- *
- * The same `## What I Remember Right Now` header wraps the block whether
- * the skills section is alone, the concept-page sections are alone, or
- * both are present — keeping the renderer one shape.
- *
- * Returns `null` when both lists collapse to empty after cache misses so
- * the caller can fall through to its empty-block path instead of attaching
- * a header with no contents.
  */
 async function renderInjectionBlock(
   workspaceDir: string,
   slugs: string[],
   skillIds: string[],
-): Promise<string | null> {
+): Promise<RenderInjectionBlockResult> {
   const pages = await Promise.all(
     slugs.map(async (slug) => {
       const page = await readPage(workspaceDir, slug);
-      return page ? { slug, body: page.body.trim() } : null;
+      return { slug, page };
     }),
   );
 
   const sections: string[] = [];
-  for (const entry of pages) {
-    if (!entry || entry.body.length === 0) continue;
-    sections.push(`### ${entry.slug}\n${entry.body}`);
+  const missingSlugs: string[] = [];
+  for (const { slug, page } of pages) {
+    if (!page) {
+      missingSlugs.push(slug);
+      continue;
+    }
+    const content = renderPageContent(page).trim();
+    if (content.length === 0) continue;
+    sections.push(`### ${slug}\n${content}`);
   }
 
   // v2's skills collection is skills-only, so the activation suffix always applies.
@@ -300,8 +455,10 @@ async function renderInjectionBlock(
     sections.push(`### Skills You Can Use\n${skillLines.join("\n")}`);
   }
 
-  if (sections.length === 0) return null;
+  if (sections.length === 0) return { block: null, missingSlugs };
 
-  const inner = `## What I Remember Right Now\n\n${sections.join("\n\n")}`;
-  return `<memory __injected>\n${inner}\n</memory>`;
+  return {
+    block: sections.join("\n\n"),
+    missingSlugs,
+  };
 }

package/src/memory/v2/migration.ts

@@ -5,9 +5,9 @@
  * synthesizes a concept page per cluster via the configured LLM, promotes
  * high-significance nodes to `essentials.md` / active follow-ups to
  * `threads.md` / low-significance episodes to `archive/migrated-<date>.md`,
- * collapses v1 weighted directional edges into the v2 unweighted-undirected
- * `memory/edges.json`, and enqueues `embed_concept_page` jobs for each new
- * page. A sentinel file at `memory/.v2-state/.migration-complete-v1-to-v2`
+ * preserves v1 weighted directional edges as outgoing-edge entries on each
+ * source page's frontmatter, and enqueues `embed_concept_page` jobs for each
+ * new page. A sentinel file at `memory/.v2-state/.migration-complete-v1-to-v2`
  * gates re-runs — `force: true` is required to overwrite.
  *
  * The migration is structured as a sequence of small helpers — `gatherV1State`,
@@ -31,9 +31,8 @@ import type { Provider } from "../../providers/types.js";
 import { getLogger } from "../../util/logger.js";
 import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
 import { enqueueMemoryJob } from "../jobs-store.js";
-import { writeEdges } from "./edges.js";
 import { slugify, writePage } from "./page-store.js";
-import type { ConceptPage, EdgesIndex } from "./types.js";
+import type { ConceptPage } from "./types.js";
 
 const log = getLogger("memory-v2-migration");
 
@@ -56,7 +55,6 @@ export interface MigrationResult {
   threadsLines: number;
   archiveLines: number;
   embedsEnqueued: number;
-  rebuildEdgesJobId: string;
   sentinelWritten: boolean;
 }
 
@@ -86,8 +84,9 @@ export interface V1Item {
 }
 
 /**
- * v1 weighted directional edge — collapsed in stage 5 into v2's unweighted
- * undirected canonical pairs.
+ * v1 weighted directional edge. v2 preserves direction (an edge A→B in v1
+ * becomes an outgoing-edge entry on A's page in v2), so the migration just
+ * has to map node ids to slugs and group by source.
  */
 export interface V1Edge {
   sourceNodeId: string;
@@ -409,31 +408,38 @@ function formatPromotionLine(item: V1Item): string {
 }
 
 // ---------------------------------------------------------------------------
-// Stage 5 — Collapse v1 edges into v2 edges.json
+// Stage 5 — Map v1 edges to per-page outgoing edges
 // ---------------------------------------------------------------------------
 
 /**
- * Map every v1 graph-node id to a v2 concept-page slug, then rewrite v1
- * edges as canonical v2 tuples. Edges with either endpoint missing from
- * `slugMap` are dropped silently — those endpoints didn't survive
- * synthesis (e.g. their cluster produced no usable page).
+ * Map every v1 graph-node id to a v2 concept-page slug and group v1 edges by
+ * source slug. Edges with either endpoint missing from `slugMap` are dropped
+ * silently — those endpoints didn't survive synthesis (e.g. their cluster
+ * produced no usable page). Self-loops are dropped; duplicate `(source, target)`
+ * pairs collapse via the `Set<string>`.
  *
- * The returned `EdgesIndex` is canonicalized + deduped by `writeEdges`'s
- * own write-time normalization, so callers can pass it straight through.
+ * The returned map keys are source slugs and the values are sets of target
+ * slugs — i.e. each entry is a page's outgoing-edge list. The runner writes
+ * these into the source page's frontmatter.
  */
 export function collapseEdges(
   v1Edges: V1Edge[],
   slugMap: Map<string, string>,
-): EdgesIndex {
-  const tuples: [string, string][] = [];
+): Map<string, Set<string>> {
+  const outgoing = new Map<string, Set<string>>();
   for (const edge of v1Edges) {
-    const a = slugMap.get(edge.sourceNodeId);
-    const b = slugMap.get(edge.targetNodeId);
-    if (!a || !b) continue;
-    if (a === b) continue;
-    tuples.push([a, b]);
+    const from = slugMap.get(edge.sourceNodeId);
+    const to = slugMap.get(edge.targetNodeId);
+    if (!from || !to) continue;
+    if (from === to) continue;
+    let targets = outgoing.get(from);
+    if (!targets) {
+      targets = new Set<string>();
+      outgoing.set(from, targets);
+    }
+    targets.add(to);
   }
-  return { version: 1, edges: tuples };
+  return outgoing;
 }
 
 // ---------------------------------------------------------------------------
@@ -476,8 +482,8 @@ export interface RunMemoryV2MigrationParams {
  * Re-runs are gated by the sentinel file
  * `memory/.v2-state/.migration-complete-v1-to-v2`. Without `force: true`, a
  * second invocation throws `MigrationAlreadyAppliedError` without mutating
- * anything; with `force: true`, the migration overwrites pages and
- * `edges.json` and re-appends to the prose files.
+ * anything; with `force: true`, the migration overwrites pages and re-appends
+ * to the prose files.
  */
 export class MigrationAlreadyAppliedError extends Error {
   constructor() {
@@ -548,41 +554,46 @@ export async function runMemoryV2Migration(
     }
   }
 
+  // Resolve outgoing edges per source slug, then attach them to each page's
+  // frontmatter before writing. The page is the source of truth for its own
+  // outgoing edges — there is no separate edges-index file.
+  const outgoingBySource = collapseEdges(v1Edges, slugMap);
+  const finalizedPages: ConceptPage[] = pages.map((page) => {
+    const targets = outgoingBySource.get(page.slug);
+    if (!targets || targets.size === 0) return page;
+    return {
+      ...page,
+      frontmatter: {
+        ...page.frontmatter,
+        edges: [...targets].sort(),
+      },
+    };
+  });
+
   // Page writes hit different filenames so they're safe to fan out.
-  await Promise.all(pages.map((page) => writePage(workspaceDir, page)));
+  await Promise.all(
+    finalizedPages.map((page) => writePage(workspaceDir, page)),
+  );
 
   const promotions = derivePromotions(items);
   await appendPromotions(workspaceDir, promotions);
 
-  const edgesIdx = collapseEdges(v1Edges, slugMap);
-  await writeEdges(workspaceDir, edgesIdx);
-
-  const embedsEnqueued = enqueueEmbeds(pages.map((p) => p.slug));
-
-  // Page bodies are written with empty `edges:` frontmatter (the schema is a
-  // derived view of `edges.json`). Without this enqueue the frontmatter would
-  // stay empty until the next consolidation run, but consolidation bails on an
-  // empty buffer — so a freshly-migrated workspace can sit indefinitely with
-  // out-of-date frontmatter. The rebuild-edges job propagates `edges.json` into
-  // every page's frontmatter and is idempotent, so pairing it with the
-  // migration is safe even when nothing else has run yet.
-  const rebuildEdgesJobId = enqueueMemoryJob("memory_v2_rebuild_edges", {});
+  const embedsEnqueued = enqueueEmbeds(finalizedPages.map((p) => p.slug));
 
   await writeSentinel(workspaceDir);
 
-  // Re-read after writeEdges so the count reflects post-canonicalization
-  // dedup (collapseEdges can produce duplicate tuples when v1 had multiple
-  // weighted edges between the same pair).
-  const finalEdges = await readPersistedEdgeCount(workspaceDir);
+  let edgesWritten = 0;
+  for (const targets of outgoingBySource.values()) {
+    edgesWritten += targets.size;
+  }
 
   return {
-    pagesCreated: pages.length,
-    edgesWritten: finalEdges,
+    pagesCreated: finalizedPages.length,
+    edgesWritten,
     essentialsLines: promotions.essentials.length,
     threadsLines: promotions.threads.length,
     archiveLines: promotions.archive.length,
     embedsEnqueued,
-    rebuildEdgesJobId,
     sentinelWritten: true,
   };
 }
@@ -634,21 +645,3 @@ async function writeSentinel(workspaceDir: string): Promise<void> {
   await mkdir(join(workspaceDir, "memory", ".v2-state"), { recursive: true });
   await writeFile(sentinelPath, `${new Date().toISOString()}\n`, "utf-8");
 }
-
-/**
- * Read `memory/edges.json` after writing and return the edge count. Used
- * only to populate the result summary — the file has already been
- * canonicalized by `writeEdges`, so this is just a count, not validation.
- */
-async function readPersistedEdgeCount(workspaceDir: string): Promise<number> {
-  try {
-    const raw = await readFile(
-      join(workspaceDir, "memory", "edges.json"),
-      "utf-8",
-    );
-    const parsed = JSON.parse(raw) as { edges?: unknown[] };
-    return Array.isArray(parsed.edges) ? parsed.edges.length : 0;
-  } catch {
-    return 0;
-  }
-}