@yeaft/webchat-agent 0.1.916 → 0.1.917

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.916",
+  "version": "0.1.917",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",
@@ -36,7 +36,7 @@
   "files": [
     "**/*.js",
     "yeaft/templates/**/*.md",
-    "yeaft/dream-v2/prompts/**/*.md"
+    "yeaft/dream/prompts/**/*.md"
   ],
   "license": "MIT",
   "author": "Yeaft",

package/yeaft/conversation/persist.js

@@ -320,18 +320,6 @@ export function parseMessage(raw) {
       case 'threadId': msg.threadId = value; break;
       case 'sourceThreadId': msg.sourceThreadId = value; break;
       case 'sessionId': msg.sessionId = value; break;
-      // Legacy alias: pre-rename messages stamped `groupId:` (PR #881
-      // groups → sessions sweep). Without this case, files in
-      // ~/.yeaft/conversation/messages/*.md from before the rename
-      // parse with msg.sessionId undefined and #loadSessionHotMessages'
-      // `.filter(m => m?.sessionId)` drops every row — LLM replay sees
-      // an empty history. `if (!msg.sessionId)` keeps new-key precedence
-      // for hand-edited files that carry both keys. See
-      // migrate/sessions-v1.js — that pass moved directories but did
-      // NOT rewrite per-message frontmatter, which is why this alias
-      // has to live forever (or until a frontmatter-rewrite migration
-      // lands and the legacy dir is empty).
-      case 'groupId': if (!msg.sessionId) msg.sessionId = value; break;
       case 'chatId': msg.chatId = value; break;
       case 'speakerVpId': msg.speakerVpId = value; break;
       case 'attachmentsB64':

package/yeaft/{dream-v2 → dream}/apply.js

@@ -1,5 +1,5 @@
 /**
- * dream-v2/apply.js.
+ * dream/apply.js.
  *
  * Execute one merged-target action: either UPDATE an existing scope's
  * memory.md/summary.md, or CREATE a new one (currently topic-only).
@@ -21,7 +21,7 @@
 import { promises as fsp } from 'fs';
 import { join, dirname } from 'path';
 
-import { writeMemory, writeSummary, readMemory, readSummary } from '../memory/store-v2.js';
+import { writeMemory, writeSummary, readMemory, readSummary } from '../memory/store.js';
 import { withDreamMarker } from './state.js';
 import { batchSourcesForApply, needsBatchedApply, truncateMessage } from './segment.js';
 import { snapshotScope } from './snapshot.js';
@@ -111,7 +111,7 @@ function renderSourceBlocks(sources, language) {
 
 /**
  * Translate `target` like 'group/g-eng' or 'topic/sci/phys' to a Scope
- * understood by store-v2. Throws if the path is malformed.
+ * understood by store. Throws if the path is malformed.
  *
  * @param {string} target
  * @returns {{ kind: string, id?: string, path?: string[] }}

package/yeaft/{dream-v2 → dream}/limits.js

@@ -1,5 +1,5 @@
 /**
- * dream-v2/limits.js constants.
+ * dream/limits.js constants.
  *
  * Centralised so tests and runtime share one source of truth. Exposed
  * as both named exports and a `DEFAULT_LIMITS` object for `runDream()`

package/yeaft/{dream-v2 → dream}/merge.js

@@ -1,5 +1,5 @@
 /**
- * dream-v2/merge.js.
+ * dream/merge.js.
  *
  * Pure-code stage between Triage and Apply.
  *

package/yeaft/{dream-v2 → dream}/prompts/index.js

@@ -1,5 +1,5 @@
 /**
- * dream-v2/prompts/index.js — load + render the four dream prompts.
+ * dream/prompts/index.js — load + render the four dream prompts.
  *
  * Prompts live as `.md` files in this directory. We read once and cache.
  * Rendering is plain `{{name}}` substitution; no nested logic, no escaping —

package/yeaft/{dream-v2 → dream}/runner.js

@@ -1,5 +1,5 @@
 /**
- * dream-v2/runner.js.
+ * dream/runner.js.
  *
  * Orchestrates one full dream pass:
  *
@@ -41,7 +41,7 @@
 import { existsSync } from 'fs';
 import { join } from 'path';
 
-import { listScopes, readSummary } from '../memory/store-v2.js';
+import { listScopes, readSummary } from '../memory/store.js';
 import {
   DEFAULT_LIMITS,
 } from './limits.js';

package/yeaft/{dream-v2 → dream}/schedule.js

@@ -1,5 +1,5 @@
 /**
- * dream-v2/schedule.js.
+ * dream/schedule.js.
  *
  * Three trigger paths:
  *

package/yeaft/{dream-v2 → dream}/segment.js

@@ -1,5 +1,5 @@
 /**
- * dream-v2/segment.js.
+ * dream/segment.js.
  *
  * Three independent length-control concerns, kept pure so they can be
  * unit-tested without touching disk or any LLM:

package/yeaft/{dream-v2 → dream}/session-wiring.js

@@ -1,7 +1,7 @@
 /**
- * dream-v2/session-wiring.js wire-up for session.js.
+ * dream/session-wiring.js wire-up for session.js.
  *
- * Bridges the framework-agnostic `runDream` orchestrator (dream-v2/runner.js)
+ * Bridges the framework-agnostic `runDream` orchestrator (dream/runner.js)
  * to the live yeaft session: groups store, conversation log, LLM adapter,
  * and the engine's progress event sink.
  *
@@ -137,7 +137,7 @@ function makeLlm(session) {
     const adapter = session.adapter;
     const model = session.config?.fastModelId || session.config?.model;
     if (!adapter || typeof adapter.call !== 'function') {
-      throw new Error(`dream-v2: no adapter.call available (pass=${pass})`);
+      throw new Error(`dream: no adapter.call available (pass=${pass})`);
     }
 
     // Bug 2: emit loop event so the debug panel shows dream LLM API calls.
@@ -304,7 +304,7 @@ export function createV2DreamScheduler(session) {
       // Best-effort console for debug builds.
       if (session.config?.debug) {
         // eslint-disable-next-line no-console
-        console.log('[dream-v2]', stampedEvt);
+        console.log('[dream]', stampedEvt);
       }
     } catch { /* never let progress reporting kill the run */ }
   };
@@ -473,7 +473,7 @@ export async function bootInitEmptyGroups(args) {
   if (empty.length === 0) return out;
   if (args.config?.debug) {
     // eslint-disable-next-line no-console
-    console.log(`[dream-v2] boot init: triggering empty-AMS dream for ${empty.length} group(s):`, empty);
+    console.log(`[dream] boot init: triggering empty-AMS dream for ${empty.length} group(s):`, empty);
   }
   // Fire-and-forget; the scheduler swallows its own failures.
   Promise.resolve(args.dreamScheduler.triggerDreamForScopes(empty)).catch(() => {});
@@ -554,7 +554,7 @@ export async function bootCatchUpStaleDream(args) {
 
   if (args.config?.debug) {
     // eslint-disable-next-line no-console
-    console.log(`[dream-v2] boot catch-up: stale (lastDreamAt=${out.lastDreamAt}, ageMs=${out.ageMs}); firing one non-manual tick.`);
+    console.log(`[dream] boot catch-up: stale (lastDreamAt=${out.lastDreamAt}, ageMs=${out.ageMs}); firing one non-manual tick.`);
   }
 
   // Non-manual: MIN_NEW_PER_GROUP still applies. Use the public

package/yeaft/{dream-v2 → dream}/snapshot.js

@@ -1,5 +1,5 @@
 /**
- * dream-v2/snapshot.js.
+ * dream/snapshot.js.
  *
  * Pre-Apply backup of memory.md + summary.md to
  * `~/.yeaft/memory/.dream-bak/<ts>/<scope-path>/`. The runner takes a

package/yeaft/{dream-v2 → dream}/state.js

@@ -1,5 +1,5 @@
 /**
- * dream-v2/state.js.
+ * dream/state.js.
  *
  * Three pieces of state, tracked separately:
  *
@@ -115,7 +115,7 @@ function parseGroupState(raw) {
 
 // ─── per-scope dream error sink ────────────────────────────────
 //
-// Why: dream-v2 silently swallowed exceptions at the triage / apply
+// Why: dream silently swallowed exceptions at the triage / apply
 // catch sites — the only sink was `trace.event('dream_progress', evt)`
 // and a `config.debug`-gated `console.log` in `session-wiring.js`. With
 // `debug=false` (the default), there was no on-disk evidence that a
@@ -130,7 +130,7 @@ function parseGroupState(raw) {
 
 /**
  * Resolve a memoryRoot + scope-string to the scope directory.
- * The scope string is the same shape dream-v2 already uses internally:
+ * The scope string is the same shape dream already uses internally:
  * `'user'`, `'vp/<vpId>'`, `'group/<sessionId>'`, `'feature/<id>'`, etc.
  *
  * Pure path-join; does NOT create the directory. The writer creates it.

package/yeaft/{dream-v2 → dream}/triage.js

@@ -1,5 +1,5 @@
 /**
- * dream-v2/triage.js.
+ * dream/triage.js.
  *
  * Decide, for one group's diff, which scopes should be touched by Apply.
  * The decision is two-staged on purpose:
@@ -35,7 +35,7 @@
  * below.)
  */
 
-import { isValidTopic } from '../memory/store-v2.js';
+import { isValidTopic } from '../memory/store.js';
 import { truncateMessage } from './segment.js';
 import { render } from './prompts/index.js';
 

package/yeaft/engine.js

@@ -28,7 +28,7 @@ import { runCompact as runCompactOrchestrator } from './compact/orchestrator.js'
 import { evaluateCompactTriggers } from './compact/triggers.js';
 import { archiveTurn } from './archive/turn-archive.js';
 import { archiveToolResults } from './archive/tool-results.js';
-import { readSummary as readScopeSummary } from './memory/store-v2.js';
+import { readSummary as readScopeSummary } from './memory/store.js';
 import { runAdjust } from './memory/adjust.js';
 import { isVpSeedBackfillStub } from './memory/seed-backfill.js';
 import { runStopHooks } from './stop-hooks.js';
@@ -261,7 +261,7 @@ export function buildResidentEntries(args) {
   // session-qualified. The legacy bare `vp/<id>` scope was a structural
   // bug — `summaries.vp` is actually loaded from `group/<sessionId>/vp/<id>/summary.md`
   // (see #loadLayerASummaries, kind:'group-vp'), so labelling it `vp/<id>`
-  // in the Resident layer (a) collides with the ACL regex in store-v2
+  // in the Resident layer (a) collides with the ACL regex in store
   // (which only recognises `<root>/<sid>/vp/...`) and (b) makes the same
   // VP persona leak across DIFFERENT sessions whenever the AMS rehydrates
   // by id rather than by full scope path. The session-qualified form

package/yeaft/history-compact.js

@@ -150,7 +150,7 @@ export const DEFAULT_MESSAGE_TOKEN_BUDGET = 32768;
 
 /**
  * Estimate the token weight of a single message including role overhead
- * and any tool-call structure. Mirrors `dream-v2/segment.js` approach: a
+ * and any tool-call structure. Mirrors `dream/segment.js` approach: a
  * couple of tokens per message for role/wrapping plus the body.
  *
  * @param {{role:string, content?:string, toolCalls?:Array, toolCallId?:string}} m

package/yeaft/init.js

@@ -8,10 +8,11 @@
 import { existsSync, mkdirSync, writeFileSync, accessSync, constants } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
-// NOTE: migrateSessionsV1 is called at the end of initYeaftDir() to collapse
-// any legacy groups/ + chats/ + memory/{group,chat}/ data into the unified
-// sessions/ layout. Idempotent via sentinel file.
-import { migrateSessionsV1 } from './migrate/sessions-v1.js';
+// NOTE: migrateSessions runs at the end of initYeaftDir(). It collapses
+// legacy groups/ + chats/ + memory/{group,chat}/ into the unified sessions/
+// layout AND rewrites pre-rename per-message frontmatter (groupId → sessionId).
+// Idempotent via the `.yeaft-migration.done` sentinel file.
+import { migrateSessions } from './migrate/sessions.js';
 
 /**
  * Check if an error is a permission error (EACCES or EPERM).
@@ -215,27 +216,20 @@ export function initYeaftDir(dir) {
     created.push(mcpExamplePath);
   }
 
-  // NOTE: sessions-v1 migration (collapse groups/ + chats/ → sessions/) is
-  // intentionally NOT wired here yet — Phase 1 ships the session-store +
-  // migration script + scope vocab as foundation only. Activating the
-  // migration before the runtime reads from sessions/ would move data out
-  // from under the live group/chat code paths. Phase 2 flips the runtime
-  // and then hooks `migrateSessionsV1(root)` here.
-
-  // NOTE: sessions-v1 migration runs at end. Fire-and-log: keep
-  // initYeaftDir() sync so existing callers don't break. The migration is
-  // idempotent (sentinel file) so a partial run on crash is safe.
-  Promise.resolve()
-    .then(() => migrateSessionsV1(root))
-    .then((res) => {
-      if (res && res.migrated) {
-        console.log(`[yeaft] session migration complete (${res.moved} dirs moved${res.warnings?.length ? `, ${res.warnings.length} warnings` : ''})`);
-        if (res.warnings?.length) for (const w of res.warnings) console.warn(`[yeaft] migration: ${w}`);
-      }
-    })
-    .catch((err) => {
-      console.warn(`[yeaft] session migration failed (continuing): ${err?.message || err}`);
-    });
+  // NOTE: sessions migration runs synchronously here. It MUST complete before
+  // any LLM request fires, because step 7 (per-message frontmatter rewrite)
+  // is what lets the persist.js parser drop the legacy `groupId:` row alias.
+  // Idempotent (sentinel file) so re-running on a fully-migrated dir is a
+  // no-op; on a partial-crash dir, each step is independently resumable.
+  try {
+    const res = migrateSessions(root);
+    if (res && res.migrated) {
+      console.log(`[yeaft] session migration complete (${res.moved} dirs moved, ${res.frontmatterRewrites} messages rewritten${res.warnings?.length ? `, ${res.warnings.length} warnings` : ''})`);
+      if (res.warnings?.length) for (const w of res.warnings) console.warn(`[yeaft] migration: ${w}`);
+    }
+  } catch (err) {
+    console.warn(`[yeaft] session migration failed (continuing): ${err?.message || err}`);
+  }
 
   return { dir: root, created, writable, warnings };
 }

package/yeaft/memory/adjust.js

@@ -28,7 +28,7 @@
  */
 
 import { approxTokens } from './budget.js';
-import { isVpForeign } from './store-v2.js';
+import { isVpForeign } from './store.js';
 
 /**
  * @typedef {object} AdjustTriggerInput

package/yeaft/memory/ams.js

@@ -17,7 +17,7 @@
  */
 
 import { approxTokens, packWithinBudget } from './budget.js';
-import { isVpForeign } from './store-v2.js';
+import { isVpForeign } from './store.js';
 
 const RECENT_DEFAULT_CAPACITY = 64;
 

package/yeaft/memory/preflow.js

@@ -17,7 +17,7 @@
 
 import { extractKeywords } from './keywords.js';
 import { approxTokens } from './budget.js';
-import { isVpForeign } from './store-v2.js';
+import { isVpForeign } from './store.js';
 
 /**
  * @typedef {object} PreflowOptions

package/yeaft/memory/seed-backfill.js

@@ -18,7 +18,7 @@
  *     of truth for own-VP identity; surfacing the stub in Section 6 would
  *     dup the same `# Name / Role` text. New seed paths (vp-crud.js,
  *     group-crud.js, seed-default.js) use `seedSummaryIfMissingSync` from
- *     store-v2.js to write directly to the correct scope dir.
+ *     store.js to write directly to the correct scope dir.
  *
  *   - `archiveLegacyScopes(root)`: one-shot migration that moves the truly
  *     dead top-level `vp/`, `feature/`, `topic/` dirs to `.legacy/`. Per

package/yeaft/memory/{store-v2.js → store.js}

@@ -1,5 +1,5 @@
 /**
- * memory/store-v2.js — per-scope memory.md + summary.md (Layer-A storage).
+ * memory/store.js — per-scope memory.md + summary.md (Layer-A storage).
  *
  * One pair of files per scope. No shards, no entries/, no index.md, no
  * index.json. The five scope kinds — user, vp, group, feature, topic — share
@@ -34,7 +34,7 @@
  * What this module deliberately does NOT do:
  *   - No frontmatter parsing. memory.md and summary.md are pure markdown;
  *     the dream-state metadata block lives at the file's tail and is read
- *     by `dream-v2/state.js`, not here.
+ *     by `dream/state.js`, not here.
  *   - No LLM calls, no extraction, no summarisation. Pure I/O.
  *
  * Reference: agent/yeaft/memory/DESIGN-H2-AMS.md.

package/yeaft/migrate/sessions.js

@@ -0,0 +1,485 @@
+/**
+ * migrate/sessions.js — One-shot migration that consolidates legacy on-disk
+ * layouts into the current `sessions/`-based shape.
+ *
+ * Idempotent. Marks completion with `<yeaftDir>/.yeaft-migration.done`.
+ * Synchronous: callers (notably initYeaftDir) rely on the migration
+ * completing before the engine reads any conversation rows.
+ *
+ * Steps:
+ *   0. Snapshot conversation directories into
+ *      `<yeaftDir>/.legacy-backup-<YYYYMMDD>/` so the in-place rewrites
+ *      below have a recovery point. Skipped if today's backup exists.
+ *   1. ~/.yeaft/groups/<g>/         → ~/.yeaft/sessions/<g>/
+ *      group.json → meta.json with shape:
+ *        { id, vpIds: roster, displayName: name, workDir, createdAt,
+ *          lastTurnAt: null, archivedAt? }
+ *   2. ~/.yeaft/chats/<c>/          → ~/.yeaft/sessions/<c>/
+ *      chat.json → meta.json with vpIds: [vpId]
+ *   3. ~/.yeaft/memory/group/<g>/   → ~/.yeaft/memory/session/<g>/
+ *   4. ~/.yeaft/memory/chat/<c>/    → ~/.yeaft/memory/session/<c>/
+ *      Rewrites front-matter `scope:` fields from group/<id> / chat/<id>
+ *      → session/<id>.
+ *   5. ~/.yeaft/memory/groups/<g>/ams.json → ~/.yeaft/memory/sessions/<g>/ams.json
+ *   6. SQLite FTS index `memory_segments.scope` rows: rewrite group/* / chat/*
+ *      → session/*.
+ *   7. Per-message frontmatter: rewrite `groupId: X` → `sessionId: X` in every
+ *      `*.md` under `conversation/messages|cold/` and
+ *      `sessions/<id>/conversation/messages|cold/`. This is what closes the
+ *      loop on PR #881's rename — without it, the parser would have to carry
+ *      a permanent `groupId` alias.
+ *
+ * Collision policy: if `sessions/<x>` already exists, log + skip (we assume
+ * a prior partial run already moved it). If both groups/<x> and chats/<x>
+ * exist with the same id, bail loudly — that shouldn't happen because
+ * group ids are `grp_*` and chat ids are `chat_*`.
+ */
+
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from 'fs';
+import { join } from 'path';
+import { openSegmentIndex } from '../memory/index-db.js';
+
+const SENTINEL = '.yeaft-migration.done';
+const SENTINEL_VERSION = 2;
+
+/**
+ * Run the sessions migration. No-op when sentinel exists.
+ *
+ * Synchronous: the per-message frontmatter rewrite (step 7) MUST finish
+ * before any conversation row is loaded, otherwise the parser would drop
+ * legacy `groupId:` rows. Keeping this synchronous lets initYeaftDir stay
+ * synchronous too — its 5+ callers all expect that.
+ *
+ * @param {string} yeaftDir
+ * @returns {{ migrated: boolean, moved: number, frontmatterRewrites: number, warnings: string[] }}
+ */
+export function migrateSessions(yeaftDir) {
+  const warnings = [];
+  if (!yeaftDir || !existsSync(yeaftDir)) {
+    return { migrated: false, moved: 0, frontmatterRewrites: 0, warnings: ['yeaftDir missing'] };
+  }
+  const sentinel = join(yeaftDir, SENTINEL);
+  if (existsSync(sentinel)) {
+    // Version-aware: ignore a sentinel from an older schema. Future v3
+    // migrations can run on v2-completed trees because they read what
+    // we wrote and decide for themselves whether to re-execute.
+    let v = 0;
+    try { v = JSON.parse(readFileSync(sentinel, 'utf8'))?.version ?? 0; } catch { /* corrupt sentinel — treat as 0 */ }
+    if (v >= SENTINEL_VERSION) {
+      return { migrated: false, moved: 0, frontmatterRewrites: 0, warnings: [] };
+    }
+  }
+
+  // Step 0 — backup conversation dirs before any in-place rewrite.
+  // Only operates on the conversation tree (the only thing step 7 touches
+  // in-place); directory renames in steps 1–5 don't need a backup because
+  // they're reversible by moving the directory back.
+  const backupRoot = join(yeaftDir, `.legacy-backup-${ymdLocal(new Date())}`);
+  backupConversationTrees(yeaftDir, backupRoot, warnings);
+
+  const sessionsRoot = join(yeaftDir, 'sessions');
+  const groupsRoot = join(yeaftDir, 'groups');
+  const chatsRoot = join(yeaftDir, 'chats');
+  const memoryRoot = join(yeaftDir, 'memory');
+  const memSessionRoot = join(memoryRoot, 'session');
+  const memSessionsAmsRoot = join(memoryRoot, 'sessions');
+
+  if (!existsSync(sessionsRoot)) mkdirSync(sessionsRoot, { recursive: true });
+  if (!existsSync(memSessionRoot)) mkdirSync(memSessionRoot, { recursive: true });
+  if (!existsSync(memSessionsAmsRoot)) mkdirSync(memSessionsAmsRoot, { recursive: true });
+
+  // ID collision check
+  const groupIds = listDirs(groupsRoot);
+  const chatIds = listDirs(chatsRoot);
+  const overlap = groupIds.filter((id) => chatIds.includes(id));
+  if (overlap.length > 0) {
+    throw new Error(`sessions migration: id collision between groups/ and chats/: ${overlap.join(',')}`);
+  }
+
+  let moved = 0;
+
+  // Reconcile any half-migrated sessions/<id>/ from a prior crash:
+  // a leftover group.json/chat.json with no meta.json means the rename
+  // succeeded but the rewrite didn't. Repair before moving on so the
+  // session is usable post-migration.
+  for (const id of listDirs(sessionsRoot)) {
+    const dst = join(sessionsRoot, id);
+    if (existsSync(join(dst, 'meta.json'))) continue;
+    if (existsSync(join(dst, 'group.json'))) {
+      rewriteGroupMetaToSessionMeta(dst, warnings);
+      warnings.push(`reconciled partial migration at sessions/${id}`);
+    } else if (existsSync(join(dst, 'chat.json'))) {
+      rewriteChatMetaToSessionMeta(dst, warnings);
+      warnings.push(`reconciled partial migration at sessions/${id}`);
+    }
+  }
+
+  // 1. groups/<g>/ → sessions/<g>/
+  for (const id of groupIds) {
+    const src = join(groupsRoot, id);
+    const dst = join(sessionsRoot, id);
+    if (existsSync(dst)) {
+      // Partial-run reconcile: if meta.json wasn't written yet, retry the
+      // rewrite from the leftover group.json at the destination. Avoids
+      // permanently broken sessions when the prior run crashed between
+      // renameSync and rewriteGroupMetaToSessionMeta.
+      if (!existsSync(join(dst, 'meta.json')) && existsSync(join(dst, 'group.json'))) {
+        rewriteGroupMetaToSessionMeta(dst, warnings);
+        warnings.push(`reconciled partial migration at sessions/${id}`);
+      } else {
+        warnings.push(`sessions/${id} already exists; skipping groups/${id}`);
+      }
+      continue;
+    }
+    renameSync(src, dst);
+    rewriteGroupMetaToSessionMeta(dst, warnings);
+    moved++;
+  }
+
+  // 2. chats/<c>/ → sessions/<c>/
+  for (const id of chatIds) {
+    const src = join(chatsRoot, id);
+    const dst = join(sessionsRoot, id);
+    if (existsSync(dst)) {
+      if (!existsSync(join(dst, 'meta.json')) && existsSync(join(dst, 'chat.json'))) {
+        rewriteChatMetaToSessionMeta(dst, warnings);
+        warnings.push(`reconciled partial migration at sessions/${id}`);
+      } else {
+        warnings.push(`sessions/${id} already exists; skipping chats/${id}`);
+      }
+      continue;
+    }
+    renameSync(src, dst);
+    rewriteChatMetaToSessionMeta(dst, warnings);
+    moved++;
+  }
+
+  // 3+4. memory/{group,chat}/<id>/ → memory/session/<id>/
+  for (const family of ['group', 'chat']) {
+    const root = join(memoryRoot, family);
+    if (!existsSync(root)) continue;
+    for (const id of listDirs(root)) {
+      const src = join(root, id);
+      const dst = join(memSessionRoot, id);
+      if (existsSync(dst)) {
+        warnings.push(`memory/session/${id} already exists; skipping memory/${family}/${id}`);
+        continue;
+      }
+      renameSync(src, dst);
+      rewriteSegmentScopes(dst, family, id, warnings);
+    }
+  }
+
+  // 5. memory/groups/<g>/ams.json → memory/sessions/<g>/ams.json
+  const amsGroupRoot = join(memoryRoot, 'groups');
+  if (existsSync(amsGroupRoot)) {
+    for (const id of listDirs(amsGroupRoot)) {
+      const srcDir = join(amsGroupRoot, id);
+      const dstDir = join(memSessionsAmsRoot, id);
+      if (existsSync(dstDir)) {
+        warnings.push(`memory/sessions/${id} already exists; skipping memory/groups/${id}`);
+        continue;
+      }
+      renameSync(srcDir, dstDir);
+    }
+  }
+  const amsChatRoot = join(memoryRoot, 'chats');
+  if (existsSync(amsChatRoot)) {
+    for (const id of listDirs(amsChatRoot)) {
+      const srcDir = join(amsChatRoot, id);
+      const dstDir = join(memSessionsAmsRoot, id);
+      if (existsSync(dstDir)) {
+        warnings.push(`memory/sessions/${id} already exists; skipping memory/chats/${id}`);
+        continue;
+      }
+      renameSync(srcDir, dstDir);
+    }
+  }
+
+  // 6. Rewrite SQLite FTS index scope strings via the shared index-db module
+  //    (which already handles ABI loading). Idempotent: WHERE clause skips
+  //    already-rewritten rows. Synchronous: better-sqlite3 has no async API.
+  rewriteFtsScopes(memoryRoot, warnings);
+
+  // 7. Per-message frontmatter rewrite. Walks both the legacy flat
+  //    conversation directory and every per-session conversation directory
+  //    so that any pre-rename row still on disk gets the new key shape.
+  const frontmatterRewrites = rewriteAllMessageFrontmatter(yeaftDir, warnings);
+
+  // 8. Sentinel — version 2 = this consolidated migration (covers what the
+  //    old `.session-migration-v1.done` sentinel covered plus the frontmatter
+  //    rewrite).
+  writeFileSync(sentinel, JSON.stringify({
+    version: SENTINEL_VERSION,
+    migratedAt: new Date().toISOString(),
+    moved,
+    frontmatterRewrites,
+    warnings,
+  }, null, 2), 'utf8');
+
+  return { migrated: true, moved, frontmatterRewrites, warnings };
+}
+
+/** YYYYMMDD in local time. */
+function ymdLocal(d) {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, '0');
+  const day = String(d.getDate()).padStart(2, '0');
+  return `${y}${m}${day}`;
+}
+
+/**
+ * Snapshot the conversation trees so step 7's in-place frontmatter rewrite
+ * is reversible. Only the dirs step 7 touches get backed up — directory
+ * renames in steps 1–5 are reversible by moving the directory back.
+ *
+ * Skips per-source-dir if the destination already exists (resume safety).
+ */
+function backupConversationTrees(yeaftDir, backupRoot, warnings) {
+  const sources = [
+    join(yeaftDir, 'conversation'),
+    join(yeaftDir, 'chat'),
+    join(yeaftDir, 'sessions'),
+    // Step 1/2 move groups/<g>/ and chats/<c>/ into sessions/<x>/, and
+    // step 7 then rewrites *.md inside the moved trees. Without backing
+    // these up at step 0, a regex bug would silently destroy the only
+    // copy of pre-rename conversation messages.
+    join(yeaftDir, 'groups'),
+    join(yeaftDir, 'chats'),
+  ];
+  for (const src of sources) {
+    if (!existsSync(src)) continue;
+    const rel = src.slice(yeaftDir.length + 1);
+    const dst = join(backupRoot, rel);
+    if (existsSync(dst)) continue; // resume / second run today
+    try {
+      mkdirSync(dst, { recursive: true });
+      cpSync(src, dst, { recursive: true });
+    } catch (err) {
+      warnings.push(`backup ${src} → ${dst} failed: ${err.message}`);
+    }
+  }
+}
+
+function rewriteFtsScopes(memoryRoot, warnings) {
+  const dbPath = join(memoryRoot, 'index.db');
+  if (!existsSync(dbPath)) return;
+  // Best-effort: index-db.js is the single ABI-load site, so we route through
+  // it. Errors here are non-fatal — the FTS index can be rebuilt at runtime.
+  let idx;
+  try {
+    idx = openSegmentIndex(dbPath);
+  } catch (err) {
+    warnings.push(`FTS rewrite skipped: ${err.message}`);
+    return;
+  }
+  try {
+    const db = idx._db;
+    db.exec('BEGIN');
+    db.exec("UPDATE memory_segments SET scope = REPLACE(scope, 'group/', 'session/') WHERE scope LIKE 'group/%'");
+    db.exec("UPDATE memory_segments SET scope = REPLACE(scope, 'chat/', 'session/') WHERE scope LIKE 'chat/%'");
+    db.exec('COMMIT');
+  } catch (err) {
+    try { idx._db.exec('ROLLBACK'); } catch { /* ignore */ }
+    warnings.push(`FTS scope rewrite failed: ${err.message}`);
+  } finally {
+    try { idx.close(); } catch { /* ignore */ }
+  }
+}
+
+/**
+ * Rewrite `groupId: X` → `sessionId: X` in every message frontmatter under
+ * the known conversation directories. Returns the number of files mutated.
+ *
+ * Idempotent: a second run finds nothing to rewrite and returns 0.
+ */
+function rewriteAllMessageFrontmatter(yeaftDir, warnings) {
+  let count = 0;
+  const dirs = [];
+  // Legacy flat layout.
+  for (const sub of ['messages', 'cold']) {
+    const d = join(yeaftDir, 'conversation', sub);
+    if (existsSync(d)) dirs.push(d);
+  }
+  // Defensive: chat mode dir (empty in production today, but cheap to scan).
+  for (const sub of ['messages', 'cold']) {
+    const d = join(yeaftDir, 'chat', sub);
+    if (existsSync(d)) dirs.push(d);
+  }
+  // Per-session layout.
+  const sessionsRoot = join(yeaftDir, 'sessions');
+  if (existsSync(sessionsRoot)) {
+    for (const id of listDirs(sessionsRoot)) {
+      for (const sub of ['messages', 'cold']) {
+        const d = join(sessionsRoot, id, 'conversation', sub);
+        if (existsSync(d)) dirs.push(d);
+      }
+    }
+  }
+  for (const dir of dirs) {
+    count += rewriteFrontmatterInDir(dir, warnings);
+  }
+  return count;
+}
+
+/**
+ * Walk a single directory and rewrite any `.md` file whose YAML frontmatter
+ * carries `groupId:` but not `sessionId:`. If both keys are already present
+ * the redundant `groupId:` line is dropped. Atomic via tmp-then-rename.
+ *
+ * Returns the number of files mutated.
+ */
+function rewriteFrontmatterInDir(dir, warnings) {
+  let mutated = 0;
+  let entries;
+  try { entries = readdirSync(dir); } catch { return 0; }
+  for (const name of entries) {
+    if (!name.endsWith('.md')) continue;
+    const path = join(dir, name);
+    try {
+      const raw = readFileSync(path, 'utf8');
+      // Frontmatter must open with `---` (LF or CRLF) for us to touch it.
+      // Skip the legacy human-readable conv-XXXX.md transcript files (no
+      // frontmatter) — they're informational dumps, not parser inputs.
+      const openMatch = raw.match(/^---\r?\n/);
+      if (!openMatch) continue;
+      const openLen = openMatch[0].length;
+      // Find the closing `\n---` (allow CRLF before the close too).
+      const endIdx = raw.search(/\r?\n---/);
+      if (endIdx === -1 || endIdx < openLen) continue;
+      const fmBody = raw.slice(openLen, endIdx);
+      const after = raw.slice(endIdx);
+      // Detect line ending used by the file so we round-trip it.
+      const eol = raw.slice(0, openLen).includes('\r\n') ? '\r\n' : '\n';
+      const lines = fmBody.split(/\r?\n/);
+      const groupIdLineIdx = lines.findIndex((l) => /^groupId:\s*/.test(l));
+      if (groupIdLineIdx === -1) continue;
+      const hasSessionId = lines.some((l) => /^sessionId:\s*\S/.test(l));
+      const m = lines[groupIdLineIdx].match(/^groupId:\s*(.*?)\s*$/);
+      const value = m ? m[1] : '';
+      if (!hasSessionId && !value) {
+        // Pathological: `groupId:` with no value AND no existing sessionId.
+        // Don't manufacture `sessionId: ` — that would silently mint a
+        // useless row. Leave the file alone and log it so we can audit.
+        warnings.push(`frontmatter rewrite skipped (empty groupId, no sessionId): ${path}`);
+        continue;
+      }
+      let newLines;
+      if (hasSessionId) {
+        // Redundant — drop the groupId line.
+        newLines = lines.filter((_, i) => i !== groupIdLineIdx);
+      } else {
+        // Replace in place to preserve frontmatter ordering.
+        newLines = lines.slice();
+        newLines[groupIdLineIdx] = `sessionId: ${value}`;
+      }
+      const next = `---${eol}${newLines.join(eol)}${after}`;
+      // Collision-safe tmp name: pid + counter. Parallel migration runs
+      // shouldn't happen (sentinel gates everything) but the atomic-rename
+      // contract is cheap insurance.
+      const tmp = `${path}.tmp.${process.pid}`;
+      writeFileSync(tmp, next, 'utf8');
+      renameSync(tmp, path);
+      mutated++;
+    } catch (err) {
+      warnings.push(`frontmatter rewrite failed ${path}: ${err.message}`);
+    }
+  }
+  return mutated;
+}
+
+function listDirs(root) {
+  if (!root || !existsSync(root)) return [];
+  const out = [];
+  for (const name of readdirSync(root)) {
+    if (name.startsWith('.')) continue;
+    try {
+      if (statSync(join(root, name)).isDirectory()) out.push(name);
+    } catch { /* ignore */ }
+  }
+  return out;
+}
+
+function rewriteGroupMetaToSessionMeta(sessionDir, warnings) {
+  const oldPath = join(sessionDir, 'group.json');
+  const newPath = join(sessionDir, 'meta.json');
+  if (!existsSync(oldPath)) {
+    if (!existsSync(newPath)) warnings.push(`no group.json in ${sessionDir}`);
+    return;
+  }
+  try {
+    const raw = JSON.parse(readFileSync(oldPath, 'utf8'));
+    const meta = {
+      id: raw.id,
+      displayName: raw.name || raw.id,
+      vpIds: Array.isArray(raw.roster) && raw.roster.length > 0 ? raw.roster.slice() : ['omni'],
+      // Preserve defaultVpId so Phase 2 coordinator can resolve "which VP
+      // answers when no @-mention". Easy to keep now, hard to backfill later.
+      ...(raw.defaultVpId ? { defaultVpId: raw.defaultVpId } : {}),
+      workDir: typeof raw.workDir === 'string' ? raw.workDir : '',
+      createdAt: raw.createdAt || new Date().toISOString(),
+      lastTurnAt: null,
+    };
+    writeFileSync(newPath, JSON.stringify(meta, null, 2), 'utf8');
+    try { unlinkSync(oldPath); } catch { /* keep both if cannot delete */ }
+  } catch (err) {
+    warnings.push(`failed to rewrite ${oldPath}: ${err.message}`);
+  }
+}
+
+function rewriteChatMetaToSessionMeta(sessionDir, warnings) {
+  const oldPath = join(sessionDir, 'chat.json');
+  const newPath = join(sessionDir, 'meta.json');
+  if (!existsSync(oldPath)) {
+    if (!existsSync(newPath)) warnings.push(`no chat.json in ${sessionDir}`);
+    return;
+  }
+  try {
+    const raw = JSON.parse(readFileSync(oldPath, 'utf8'));
+    const meta = {
+      id: raw.id,
+      displayName: raw.displayName || raw.id,
+      vpIds: [raw.vpId || 'omni'],
+      workDir: typeof raw.workDir === 'string' ? raw.workDir : '',
+      createdAt: raw.createdAt || new Date().toISOString(),
+      lastTurnAt: raw.lastTurnAt || null,
+    };
+    writeFileSync(newPath, JSON.stringify(meta, null, 2), 'utf8');
+    try { unlinkSync(oldPath); } catch { /* */ }
+  } catch (err) {
+    warnings.push(`failed to rewrite ${oldPath}: ${err.message}`);
+  }
+}
+
+function rewriteSegmentScopes(sessionMemoryDir, oldFamily, id, warnings) {
+  const segDir = join(sessionMemoryDir, 'segments');
+  if (!existsSync(segDir)) return;
+  let entries;
+  try { entries = readdirSync(segDir); } catch { return; }
+  const re = new RegExp(`^(\\s*scope:\\s*)${oldFamily}/${escapeRe(id)}\\b`, 'gm');
+  for (const name of entries) {
+    if (!name.endsWith('.md')) continue;
+    const path = join(segDir, name);
+    try {
+      const src = readFileSync(path, 'utf8');
+      const next = src.replace(re, `$1session/${id}`);
+      if (next !== src) writeFileSync(path, next, 'utf8');
+    } catch (err) {
+      warnings.push(`segment rewrite failed ${path}: ${err.message}`);
+    }
+  }
+}
+
+function escapeRe(s) {
+  return String(s).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/yeaft/session.js

@@ -47,7 +47,7 @@ import { ensureDefaultSessionIfEmpty } from './sessions/session-crud.js';
 import { seedDefaultVps } from './vp/seed-defaults.js';
 import { topUpDefaultVps } from './vp/seed-topup.js';
 import { archiveLegacyScopes } from './memory/seed-backfill.js';
-import { createV2DreamScheduler, bootInitEmptyGroups, bootCatchUpStaleDream } from './dream-v2/session-wiring.js';
+import { createV2DreamScheduler, bootInitEmptyGroups, bootCatchUpStaleDream } from './dream/session-wiring.js';
 import { openSegmentIndex } from './memory/index-db.js';
 import { syncAll as syncSegmentIndex } from './memory/segment-sync.js';
 import { openAmsRegistry } from './memory/ams-registry.js';
@@ -204,7 +204,7 @@ export async function loadSession(options = {}) {
 
   // ─── 2.2 R6 → v2 auto-migration retired ───────────────
   //         The R6 shard layout is gone — memory writes go through
-  //         dream-v2 directly. Existing users have already migrated
+  //         dream directly. Existing users have already migrated
   //         (state file in ~/.yeaft/.memory-v2-migration.json).
 
   // ─── 2a. Permission pre-check ─────────────────────────
@@ -362,7 +362,7 @@ export async function loadSession(options = {}) {
     // — kind:'group-vp'). The backfill therefore generated orphan files
     // on every boot. See `memory/seed-backfill.js` for the historical
     // context. Real seeding happens at create time via
-    // `seedSummaryIfMissingSync` from `store-v2.js`, called by vp-crud /
+    // `seedSummaryIfMissingSync` from `store.js`, called by vp-crud /
     // group-crud / seed-default — those write to the correct scope dirs.
   }
 
@@ -468,7 +468,7 @@ export async function loadSession(options = {}) {
 
   // ─── 9a. Create dream scheduler ────────────
   // The legacy R6 dream-scheduler was retired alongside recall-r6;
-  // dream-v2 is the only active path (the `config.memoryV2` opt-out
+  // dream is the only active path (the `config.memoryV2` opt-out
   // flag was retired in task-710 — wiring is unconditional).
   // partialSession lets the v2 scheduler dereference adapter/config/
   // engine/trace lazily — safe because callers attach more fields

package/yeaft/sessions/seed-default.js

@@ -16,7 +16,7 @@ import { existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import { openSession, createSession, loadSessionMeta } from './session-store.js';
-import { seedSummaryIfMissingSync } from '../memory/store-v2.js';
+import { seedSummaryIfMissingSync } from '../memory/store.js';
 
 export const DEFAULT_SESSION_ID = 'grp_default';
 

package/yeaft/sessions/session-crud.js

@@ -52,7 +52,7 @@ import { addVp as rosterAdd, removeVp as rosterRemove, setDefaultVp } from './ro
 import { seedDefaultSession, DEFAULT_SESSION_ID } from './seed-default.js';
 import { nextSessionId, validateVpId, isReservedVpId } from './ids.js';
 import { scanVpLibrary, DEFAULT_VP_LIB_DIR } from '../vp/vp-store.js';
-import { seedSummaryIfMissingSync, removeScopeDirSync } from '../memory/store-v2.js';
+import { seedSummaryIfMissingSync, removeScopeDirSync } from '../memory/store.js';
 import { ensureSessionConfigFile, saveSessionConfig, loadSessionConfig } from './session-config.js';
 
 /**

package/yeaft/stop-hooks.js

@@ -9,7 +9,7 @@
  * entries-store extraction was retired in the H2-AMS rip.
  *
  * Dream V2 owns all background memory maintenance (scope summaries +
- * memory writes via dream-v2/session-wiring.js → createV2DreamScheduler).
+ * memory writes via dream/session-wiring.js → createV2DreamScheduler).
  *
  * Reference: yeaft-yeaft-core-systems.md §4.4
  */

package/yeaft/vp/vp-crud.js

@@ -29,7 +29,7 @@ import { STOCK_VP_IDS } from './stock-ids.js';
 /**
  * Default memory root used when callers don't pass `options.memoryRoot`.
  * Memory lives at `<root>/vp/<id>/{summary.md,memory.md,segments/…}` —
- * see `store-v2.scopeDir`. Production sites should thread the configured
+ * see `store.scopeDir`. Production sites should thread the configured
  * `<yeaftDir>/memory` through `options.memoryRoot` so a non-default yeaft
  * directory (e.g. tests, sandboxed CI) doesn't write under `~/.yeaft/`.
  */

package/yeaft/web-bridge.js

@@ -3519,7 +3519,7 @@ export async function handleYeaftDreamTrigger(msg = {}) {
   // otherwise auto-run events can be persisted under the clicked group.
   // The scheduler also short-circuits the underlying run for same-group,
   // and a different group's filter would have been silently dropped
-  // anyway (see dream-v2/schedule.js inflight reuse), so the user-facing
+  // anyway (see dream/schedule.js inflight reuse), so the user-facing
   // semantics are unchanged ("you already asked").
   if (sessionId && (inflightScopedDreamGroups.size > 0 || session.dreamScheduler.isRunning)) {
     const skippedResult = {

package/yeaft/migrate/sessions-v1.js

@@ -1,295 +0,0 @@
-/**
- * migrate/sessions-v1.js — One-shot migration: collapse groups/ + chats/ → sessions/
- *
- * Idempotent. Marks completion with a sentinel file
- * `<yeaftDir>/.session-migration-v1.done`.
- *
- * Migrates:
- *   1. ~/.yeaft/groups/<g>/         → ~/.yeaft/sessions/<g>/
- *      group.json → meta.json with shape:
- *        { id, vpIds: roster, displayName: name, workDir, createdAt,
- *          lastTurnAt: null, archivedAt? }
- *   2. ~/.yeaft/chats/<c>/          → ~/.yeaft/sessions/<c>/
- *      chat.json → meta.json with vpIds: [vpId]
- *   3. ~/.yeaft/memory/group/<g>/   → ~/.yeaft/memory/session/<g>/
- *   4. ~/.yeaft/memory/chat/<c>/    → ~/.yeaft/memory/session/<c>/
- *      Rewrites front-matter `scope:` fields from group/<id> / chat/<id>
- *      → session/<id>.
- *   5. ~/.yeaft/memory/groups/<g>/ams.json → ~/.yeaft/memory/sessions/<g>/ams.json
- *
- * Collision policy: if `sessions/<x>` already exists, log + skip (we assume
- * a prior partial run already moved it). If both groups/<x> and chats/<x>
- * exist with the same id, bail loudly — that shouldn't happen because
- * group ids are `grp_*` and chat ids are `chat_*`.
- */
-
-import {
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  renameSync,
-  statSync,
-  unlinkSync,
-  writeFileSync,
-} from 'fs';
-import { join } from 'path';
-
-const SENTINEL = '.session-migration-v1.done';
-
-/**
- * Run the v1 sessions migration. No-op when sentinel exists.
- *
- * @param {string} yeaftDir
- * @returns {{ migrated: boolean, moved: number, warnings: string[] }}
- */
-export async function migrateSessionsV1(yeaftDir) {
-  const warnings = [];
-  if (!yeaftDir || !existsSync(yeaftDir)) {
-    return { migrated: false, moved: 0, warnings: ['yeaftDir missing'] };
-  }
-  const sentinel = join(yeaftDir, SENTINEL);
-  if (existsSync(sentinel)) {
-    return { migrated: false, moved: 0, warnings: [] };
-  }
-
-  const sessionsRoot = join(yeaftDir, 'sessions');
-  const groupsRoot = join(yeaftDir, 'groups');
-  const chatsRoot = join(yeaftDir, 'chats');
-  const memoryRoot = join(yeaftDir, 'memory');
-  const memSessionRoot = join(memoryRoot, 'session');
-  const memSessionsAmsRoot = join(memoryRoot, 'sessions');
-
-  if (!existsSync(sessionsRoot)) mkdirSync(sessionsRoot, { recursive: true });
-  if (!existsSync(memSessionRoot)) mkdirSync(memSessionRoot, { recursive: true });
-  if (!existsSync(memSessionsAmsRoot)) mkdirSync(memSessionsAmsRoot, { recursive: true });
-
-  // ID collision check
-  const groupIds = listDirs(groupsRoot);
-  const chatIds = listDirs(chatsRoot);
-  const overlap = groupIds.filter((id) => chatIds.includes(id));
-  if (overlap.length > 0) {
-    throw new Error(`sessions migration: id collision between groups/ and chats/: ${overlap.join(',')}`);
-  }
-
-  let moved = 0;
-
-  // 0. Reconcile any half-migrated sessions/<id>/ from a prior crash:
-  // a leftover group.json/chat.json with no meta.json means the rename
-  // succeeded but the rewrite didn't. Repair before moving on so the
-  // session is usable post-migration.
-  for (const id of listDirs(sessionsRoot)) {
-    const dst = join(sessionsRoot, id);
-    if (existsSync(join(dst, 'meta.json'))) continue;
-    if (existsSync(join(dst, 'group.json'))) {
-      rewriteGroupMetaToSessionMeta(dst, warnings);
-      warnings.push(`reconciled partial migration at sessions/${id}`);
-    } else if (existsSync(join(dst, 'chat.json'))) {
-      rewriteChatMetaToSessionMeta(dst, warnings);
-      warnings.push(`reconciled partial migration at sessions/${id}`);
-    }
-  }
-
-  // 1. groups/<g>/ → sessions/<g>/
-  for (const id of groupIds) {
-    const src = join(groupsRoot, id);
-    const dst = join(sessionsRoot, id);
-    if (existsSync(dst)) {
-      // Partial-run reconcile: if meta.json wasn't written yet, retry the
-      // rewrite from the leftover group.json at the destination. Avoids
-      // permanently broken sessions when the prior run crashed between
-      // renameSync and rewriteGroupMetaToSessionMeta.
-      if (!existsSync(join(dst, 'meta.json')) && existsSync(join(dst, 'group.json'))) {
-        rewriteGroupMetaToSessionMeta(dst, warnings);
-        warnings.push(`reconciled partial migration at sessions/${id}`);
-      } else {
-        warnings.push(`sessions/${id} already exists; skipping groups/${id}`);
-      }
-      continue;
-    }
-    renameSync(src, dst);
-    rewriteGroupMetaToSessionMeta(dst, warnings);
-    moved++;
-  }
-
-  // 2. chats/<c>/ → sessions/<c>/
-  for (const id of chatIds) {
-    const src = join(chatsRoot, id);
-    const dst = join(sessionsRoot, id);
-    if (existsSync(dst)) {
-      if (!existsSync(join(dst, 'meta.json')) && existsSync(join(dst, 'chat.json'))) {
-        rewriteChatMetaToSessionMeta(dst, warnings);
-        warnings.push(`reconciled partial migration at sessions/${id}`);
-      } else {
-        warnings.push(`sessions/${id} already exists; skipping chats/${id}`);
-      }
-      continue;
-    }
-    renameSync(src, dst);
-    rewriteChatMetaToSessionMeta(dst, warnings);
-    moved++;
-  }
-
-  // 3+4. memory/{group,chat}/<id>/ → memory/session/<id>/
-  for (const family of ['group', 'chat']) {
-    const root = join(memoryRoot, family);
-    if (!existsSync(root)) continue;
-    for (const id of listDirs(root)) {
-      const src = join(root, id);
-      const dst = join(memSessionRoot, id);
-      if (existsSync(dst)) {
-        warnings.push(`memory/session/${id} already exists; skipping memory/${family}/${id}`);
-        continue;
-      }
-      renameSync(src, dst);
-      rewriteSegmentScopes(dst, family, id, warnings);
-    }
-  }
-
-  // 5. memory/groups/<g>/ams.json → memory/sessions/<g>/ams.json
-  const amsGroupRoot = join(memoryRoot, 'groups');
-  if (existsSync(amsGroupRoot)) {
-    for (const id of listDirs(amsGroupRoot)) {
-      const srcDir = join(amsGroupRoot, id);
-      const dstDir = join(memSessionsAmsRoot, id);
-      if (existsSync(dstDir)) {
-        warnings.push(`memory/sessions/${id} already exists; skipping memory/groups/${id}`);
-        continue;
-      }
-      renameSync(srcDir, dstDir);
-    }
-  }
-  const amsChatRoot = join(memoryRoot, 'chats');
-  if (existsSync(amsChatRoot)) {
-    for (const id of listDirs(amsChatRoot)) {
-      const srcDir = join(amsChatRoot, id);
-      const dstDir = join(memSessionsAmsRoot, id);
-      if (existsSync(dstDir)) {
-        warnings.push(`memory/sessions/${id} already exists; skipping memory/chats/${id}`);
-        continue;
-      }
-      renameSync(srcDir, dstDir);
-    }
-  }
-
-  // 6. Rewrite SQLite FTS index scope strings via the shared index-db
-  //    module (which already handles ABI loading). Idempotent: WHERE clause
-  //    skips already-rewritten rows.
-  try {
-    const dbPath = join(memoryRoot, 'index.db');
-    if (existsSync(dbPath)) {
-      const { openSegmentIndex } = await import('../memory/index-db.js');
-      const idx = openSegmentIndex(dbPath);
-      try {
-        const db = idx._db;
-        db.exec("BEGIN");
-        db.exec("UPDATE memory_segments SET scope = REPLACE(scope, 'group/', 'session/') WHERE scope LIKE 'group/%'");
-        db.exec("UPDATE memory_segments SET scope = REPLACE(scope, 'chat/', 'session/') WHERE scope LIKE 'chat/%'");
-        db.exec("COMMIT");
-      } catch (err) {
-        try { idx._db.exec("ROLLBACK"); } catch { /* ignore */ }
-        warnings.push(`FTS scope rewrite failed: ${err.message}`);
-      } finally {
-        try { idx.close(); } catch { /* ignore */ }
-      }
-    }
-  } catch (err) {
-    warnings.push(`FTS rewrite skipped: ${err.message}`);
-  }
-
-  // 7. sentinel
-  writeFileSync(sentinel, JSON.stringify({
-    version: 1,
-    migratedAt: new Date().toISOString(),
-    moved,
-    warnings,
-  }, null, 2), 'utf8');
-
-  return { migrated: true, moved, warnings };
-}
-
-function listDirs(root) {
-  if (!root || !existsSync(root)) return [];
-  const out = [];
-  for (const name of readdirSync(root)) {
-    if (name.startsWith('.')) continue;
-    try {
-      if (statSync(join(root, name)).isDirectory()) out.push(name);
-    } catch { /* ignore */ }
-  }
-  return out;
-}
-
-function rewriteGroupMetaToSessionMeta(sessionDir, warnings) {
-  const oldPath = join(sessionDir, 'group.json');
-  const newPath = join(sessionDir, 'meta.json');
-  if (!existsSync(oldPath)) {
-    if (!existsSync(newPath)) warnings.push(`no group.json in ${sessionDir}`);
-    return;
-  }
-  try {
-    const raw = JSON.parse(readFileSync(oldPath, 'utf8'));
-    const meta = {
-      id: raw.id,
-      displayName: raw.name || raw.id,
-      vpIds: Array.isArray(raw.roster) && raw.roster.length > 0 ? raw.roster.slice() : ['omni'],
-      // Preserve defaultVpId so Phase 2 coordinator can resolve "which VP
-      // answers when no @-mention". Easy to keep now, hard to backfill later.
-      ...(raw.defaultVpId ? { defaultVpId: raw.defaultVpId } : {}),
-      workDir: typeof raw.workDir === 'string' ? raw.workDir : '',
-      createdAt: raw.createdAt || new Date().toISOString(),
-      lastTurnAt: null,
-    };
-    writeFileSync(newPath, JSON.stringify(meta, null, 2), 'utf8');
-    try { unlinkSync(oldPath); } catch { /* keep both if cannot delete */ }
-  } catch (err) {
-    warnings.push(`failed to rewrite ${oldPath}: ${err.message}`);
-  }
-}
-
-function rewriteChatMetaToSessionMeta(sessionDir, warnings) {
-  const oldPath = join(sessionDir, 'chat.json');
-  const newPath = join(sessionDir, 'meta.json');
-  if (!existsSync(oldPath)) {
-    if (!existsSync(newPath)) warnings.push(`no chat.json in ${sessionDir}`);
-    return;
-  }
-  try {
-    const raw = JSON.parse(readFileSync(oldPath, 'utf8'));
-    const meta = {
-      id: raw.id,
-      displayName: raw.displayName || raw.id,
-      vpIds: [raw.vpId || 'omni'],
-      workDir: typeof raw.workDir === 'string' ? raw.workDir : '',
-      createdAt: raw.createdAt || new Date().toISOString(),
-      lastTurnAt: raw.lastTurnAt || null,
-    };
-    writeFileSync(newPath, JSON.stringify(meta, null, 2), 'utf8');
-    try { unlinkSync(oldPath); } catch { /* */ }
-  } catch (err) {
-    warnings.push(`failed to rewrite ${oldPath}: ${err.message}`);
-  }
-}
-
-function rewriteSegmentScopes(sessionMemoryDir, oldFamily, id, warnings) {
-  const segDir = join(sessionMemoryDir, 'segments');
-  if (!existsSync(segDir)) return;
-  let entries;
-  try { entries = readdirSync(segDir); } catch { return; }
-  const re = new RegExp(`^(\\s*scope:\\s*)${oldFamily}/${escapeRe(id)}\\b`, 'gm');
-  for (const name of entries) {
-    if (!name.endsWith('.md')) continue;
-    const path = join(segDir, name);
-    try {
-      const src = readFileSync(path, 'utf8');
-      const next = src.replace(re, `$1session/${id}`);
-      if (next !== src) writeFileSync(path, next, 'utf8');
-    } catch (err) {
-      warnings.push(`segment rewrite failed ${path}: ${err.message}`);
-    }
-  }
-}
-
-function escapeRe(s) {
-  return String(s).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}