@yeaft/webchat-agent 1.0.348 → 1.0.350

package/yeaft/memory/segment-store.js

@@ -1,9 +1,10 @@
 /**
- * memory/segment-store.js — disk I/O for segment-formatted memory.md.
+ * memory/segment-store.js — disk I/O for segment evidence in memory.md.
  *
- * Bridges between the on-disk format (memory.md per scope, multiple
- * segment blocks) and the SQLite segment index. This layer handles
- * scope <-> file path mapping; the index layer is scope-agnostic.
+ * Bridges between the on-disk evidence format (memory.md per scope, multiple
+ * segment blocks) and the SQLite segment index. Canonical prompt-facing prose
+ * is stored separately in content.md. This layer handles scope <-> file path
+ * mapping; the index layer is scope-agnostic.
  *
  * Path conventions:
  *   ~/.yeaft/memory/user/memory.md
@@ -18,8 +19,10 @@ import {
   readFileSync, writeFileSync, existsSync, mkdirSync,
   readdirSync, statSync, renameSync,
 } from 'node:fs';
+import { createHash } from 'node:crypto';
 import { join, dirname, relative, sep } from 'node:path';
 import { stripDreamStateBlocks } from './prompt-cleanup.js';
+import { extractKeywords } from './keywords.js';
 import { parseSegments, serializeSegments } from './segment.js';
 
 /**
@@ -33,7 +36,9 @@ export function readScope(memoryRoot, scope) {
   const path = scopeFilePath(memoryRoot, scope);
   if (!existsSync(path)) return [];
   const text = readFileSync(path, 'utf8');
-  return parseSegments(stripDreamStateBlocks(text), { defaultScope: scope });
+  const stripped = stripDreamStateBlocks(text);
+  if (!stripped.trimStart().startsWith('---')) return [];
+  return parseSegments(stripped, { defaultScope: scope });
 }
 
 /**
@@ -56,7 +61,37 @@ export function writeScope(memoryRoot, scope, segments) {
 }
 
 /**
- * Walk the memory root and return all scopes that have a memory.md.
+ * Read canonical content as a derived FTS record. The stable id lets normal
+ * sync delete or update it without changing the segment schema. This record is
+ * a scope selector only; Engine always reloads prompt text from content.md.
+ *
+ * @param {string} memoryRoot
+ * @param {string} scope
+ * @returns {import('./segment.js').Segment|null}
+ */
+export function readCanonicalContentRecord(memoryRoot, scope) {
+  const path = join(memoryRoot, scope, 'content.md');
+  if (!existsSync(path)) return null;
+  const body = readFileSync(path, 'utf8').trim();
+  if (!body) return null;
+  const stat = statSync(path);
+  const timestamp = stat.mtime.toISOString();
+  const digest = createHash('sha256').update(scope).digest('hex').slice(0, 12);
+  return {
+    id: `content_${digest}`,
+    scope,
+    kind: 'context',
+    tags: ['canonical-content', ...extractKeywords(`${scope} ${body}`).slice(0, 128)],
+    sourceMessages: [],
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    body,
+  };
+}
+
+/**
+ * Walk the memory root and return all scopes that have evidence memory.md or
+ * canonical content.md. Either representation must be queryable.
  *
  * @param {string} memoryRoot
  * @returns {string[]}
@@ -74,10 +109,11 @@ function walk(root, dir, out) {
     let st;
     try { st = statSync(full); } catch { continue; }
     if (st.isDirectory()) {
+      if (entry.startsWith('.')) continue;
       walk(root, full, out);
-    } else if (entry === 'memory.md') {
+    } else if (entry === 'memory.md' || entry === 'content.md') {
       const rel = relative(root, dir).split(sep).join('/');
-      if (rel) out.push(rel);
+      if (rel && !out.includes(rel)) out.push(rel);
     }
   }
 }

package/yeaft/memory/segment-sync.js

@@ -1,8 +1,8 @@
 /**
  * memory/segment-sync.js — disk → SQLite reconciliation.
  *
- * Source of truth is on-disk memory.md per scope. SQLite is a derived
- * index. This module reads disk, diffs against SQLite, and emits
+ * Sources of truth are on-disk memory.md evidence and canonical content.md.
+ * SQLite is a derived index. This module reads disk, diffs against SQLite, and emits
  * upsert / delete operations.
  *
  * Strategy:
@@ -16,7 +16,7 @@
  * scope to limit work (`syncScope`).
  */
 
-import { listScopes, readScope } from './segment-store.js';
+import { listScopes, readCanonicalContentRecord, readScope } from './segment-store.js';
 
 /**
  * Full sync: walk disk, reconcile every scope into the index. Returns
@@ -61,7 +61,11 @@ export function syncAll(memoryRoot, index) {
  * @returns {{ upserted: number, deleted: number }}
  */
 export function syncScope(memoryRoot, index, scope) {
-  const onDisk = readScope(memoryRoot, scope);
+  const contentRecord = readCanonicalContentRecord(memoryRoot, scope);
+  const onDisk = [
+    ...readScope(memoryRoot, scope),
+    ...(contentRecord ? [contentRecord] : []),
+  ];
   const onDiskIds = new Set(onDisk.map(s => s.id));
   const inIndex = index.listByScope(scope);
   const inIndexIds = new Set(inIndex.map(s => s.id));

package/yeaft/memory/segment.js

@@ -5,8 +5,10 @@
  * a self-contained semantic chunk (one segment per topic). NOT a copy
  * of messages — messages already live in conversation/messages/.
  *
- * Physical layout: each scope's `memory.md` is multiple segments
- * concatenated, each with a YAML frontmatter block and a body.
+ * Physical layout: each scope's `memory.md` is the evidence store containing
+ * multiple segments concatenated with YAML frontmatter. Prompt-facing canonical
+ * prose lives separately in `content.md`; segment bodies are never injected
+ * directly into the normal system prompt.
  *
  *   ---
  *   id: seg_<8hex>
@@ -52,7 +54,12 @@ export const KIND_VALUES = new Set([
   'workflow', 'pitfall', 'correction', 'project-convention',
 ]);
 
-const SCOPE_RE = /^(user|group\/[\w-]+(?:\/(?:user|vp\/[\w-]+|feature\/[\w-]+|topic\/[\w-]+(?:\/[\w-]+)?))?|sessions\/[\w-]+(?:\/(?:user|vp\/[\w-]+|feature\/[\w-]+|topic\/[\w-]+(?:\/[\w-]+)?))?|chat\/[\w-]+(?:\/vp\/[\w-]+)?|session\/[\w-]+(?:\/vp\/[\w-]+)?)$/;
+const TOPIC_PART = '[\\w.\\-\\u4e00-\\u9fff]+';
+const SCOPE_RE = new RegExp(`^(user|global|group\\/[\\w-]+(?:\\/(?:user|vp\\/[\\w-]+|feature\\/[\\w-]+|topic\\/${TOPIC_PART}(?:\\/${TOPIC_PART})?))?|sessions\\/[\\w-]+(?:\\/(?:user|vp\\/[\\w-]+|feature\\/[\\w-]+|topic\\/${TOPIC_PART}(?:\\/${TOPIC_PART})?))?|chat\\/[\\w-]+(?:\\/vp\\/[\\w-]+)?|session\\/[\\w-]+(?:\\/vp\\/[\\w-]+)?)$`);
+
+export function isValidSegmentScope(value) {
+  return typeof value === 'string' && SCOPE_RE.test(value);
+}
 
 /**
  * Compute a stable id from segment content. Same body + scope + kind →

package/yeaft/memory/store.js

@@ -1,16 +1,18 @@
 /**
- * memory/store.js — per-scope memory.md + summary.md (Layer-A storage).
+ * memory/store.js — per-scope canonical content + summary 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
- * a single shape:
+ * Every scope can carry three distinct representations:
+ *
+ *   - content.md: Dream-maintained canonical prose. This is the prompt-facing
+ *     source and preserves all currently valid durable information.
+ *   - summary.md: a short catalog / triage index. It is not authoritative.
+ *   - memory.md: atomic evidence segments with source message ids. Segment I/O
+ *     lives in segment-store.js; this module retains the legacy raw accessors.
  *
  *   ~/.yeaft/memory/
- *     user/                    memory.md  summary.md
- *     vp/<vpId>/               memory.md  summary.md
- *     group/<sessionId>/         memory.md  summary.md
- *     feature/<featureId>/     memory.md  summary.md
- *     topic/<l1>[/<l2>]/       memory.md  summary.md     (≤ 2 levels)
+ *     user/                    content.md  memory.md  summary.md
+ *     sessions/<sessionId>/    content.md  memory.md  summary.md
+ *     .../topic/<l1>[/<l2>]/   content.md  memory.md  summary.md  (≤ 2 levels)
  *
  * Atomicity contract:
  *   - Every write goes via `.tmp.<rand>` + rename. Renames are atomic on a
@@ -21,7 +23,7 @@
  *
  * Concurrency rules:
  *   - Two writers to the same memory.md: last-rename wins. Dream is the only
- *     code path that overwrites memory.md in v2; daily writes append. Append
+ *     code path that overwrites memory.md; daily writes append. Append
  *     is a single fs.appendFile call that POSIX guarantees is atomic for
  *     buffers ≤ PIPE_BUF (≥ 4KB on every supported platform), which fits a
  *     single fragment.
@@ -50,11 +52,12 @@ import {
 } from 'fs';
 import { join, dirname } from 'path';
 import { homedir } from 'os';
+import { resolveTopicRedirect } from './topic-redirect.js';
 
 /** Default memory root. Tests override via `opts.root`. */
 export const DEFAULT_MEMORY_ROOT = join(homedir(), '.yeaft', 'memory');
 
-/** Scope kinds recognised by v2 (group-isolated layout). */
+/** Scope kinds recognised by the current store, including legacy aliases. */
 export const SCOPE_KINDS = Object.freeze([
   'user',
   'group',
@@ -89,10 +92,14 @@ export const SCOPE_KINDS = Object.freeze([
  * @param {Scope} scope
  * @returns {string}
  */
-export function scopeDir(scope) {
+export function scopeDir(scope, opts = {}) {
   if (!scope || typeof scope !== 'object') {
     throw new Error('scopeDir: scope is required');
   }
+  if (scope.kind === 'session-topic' && opts.root) {
+    const redirected = resolveTopicRedirect(opts.root, scope.sessionId, (scope.path || []).join('/'));
+    if (redirected) scope = { ...scope, path: redirected.split('/') };
+  }
   switch (scope.kind) {
     case 'user':
       return 'user';
@@ -230,9 +237,8 @@ export function isValidTopic(scope) {
 // ─── ACL ───────────────────────────────────────────────────────
 
 /**
- * The single ACL: `group/<g>/vp/<other>` is foreign when `currentVpId` is given.
- * Across groups, every `group/<g>/vp/...` path is foreign by construction
- * (the calling VP only runs inside its own group dir).
+ * The single ACL: a Session VP path owned by another VP is foreign when
+ * `currentVpId` is given. The `group/` spelling remains a legacy storage alias.
  *
  * @param {string} relPath
  * @param {string} currentVpId
@@ -268,7 +274,46 @@ async function atomicWrite(absPath, content) {
   await fsp.rename(tmp, absPath);
 }
 
-// ─── memory.md ─────────────────────────────────────────────────
+// ─── content.md ────────────────────────────────────────────────
+
+/**
+ * Read a scope's canonical Dream content. Missing → empty string.
+ *
+ * Deliberately does not fall back to memory.md: modern memory.md is the
+ * segment evidence store. Migration callers must make an explicit,
+ * format-aware fallback decision instead of injecting evidence blocks as prose.
+ *
+ * @param {Scope} scope
+ * @param {{ root?: string, currentVpId?: string }} [opts]
+ * @returns {Promise<string>}
+ */
+export async function readContent(scope, opts = {}) {
+  const { root = DEFAULT_MEMORY_ROOT, currentVpId } = opts;
+  const rel = `${scopeDir(scope, { root })}/content.md`;
+  enforceVpAcl(rel, currentVpId);
+  const abs = join(root, rel);
+  try { return await fsp.readFile(abs, 'utf8'); }
+  catch (err) {
+    if (err && err.code === 'ENOENT') return '';
+    throw err;
+  }
+}
+
+/**
+ * Atomically rewrite a scope's canonical Dream content.
+ *
+ * @param {Scope} scope
+ * @param {string} content
+ * @param {{ root?: string, currentVpId?: string }} [opts]
+ */
+export async function writeContent(scope, content, opts = {}) {
+  const { root = DEFAULT_MEMORY_ROOT, currentVpId } = opts;
+  const rel = `${scopeDir(scope, { root })}/content.md`;
+  enforceVpAcl(rel, currentVpId);
+  await atomicWrite(join(root, rel), typeof content === 'string' ? content : '');
+}
+
+// ─── memory.md (segment evidence / legacy raw access) ──────────
 
 /**
  * Read a scope's memory.md. Missing → empty string.
@@ -279,7 +324,7 @@ async function atomicWrite(absPath, content) {
  */
 export async function readMemory(scope, opts = {}) {
   const { root = DEFAULT_MEMORY_ROOT, currentVpId } = opts;
-  const rel = `${scopeDir(scope)}/memory.md`;
+  const rel = `${scopeDir(scope, { root })}/memory.md`;
   enforceVpAcl(rel, currentVpId);
   const abs = join(root, rel);
   try { return await fsp.readFile(abs, 'utf8'); }
@@ -298,7 +343,7 @@ export async function readMemory(scope, opts = {}) {
  */
 export async function writeMemory(scope, content, opts = {}) {
   const { root = DEFAULT_MEMORY_ROOT, currentVpId } = opts;
-  const rel = `${scopeDir(scope)}/memory.md`;
+  const rel = `${scopeDir(scope, { root })}/memory.md`;
   enforceVpAcl(rel, currentVpId);
   const abs = join(root, rel);
   await atomicWrite(abs, typeof content === 'string' ? content : '');
@@ -320,7 +365,7 @@ export async function writeMemory(scope, content, opts = {}) {
  */
 export async function appendMemory(scope, chunk, opts = {}) {
   const { root = DEFAULT_MEMORY_ROOT, currentVpId } = opts;
-  const rel = `${scopeDir(scope)}/memory.md`;
+  const rel = `${scopeDir(scope, { root })}/memory.md`;
   enforceVpAcl(rel, currentVpId);
   const abs = join(root, rel);
   await fsp.mkdir(dirname(abs), { recursive: true });
@@ -337,8 +382,8 @@ function summaryFileName(language) {
   return normalized === 'zh' ? 'summary.zh.md' : 'summary.md';
 }
 
-function summaryCandidateRels(scope, language) {
-  const dir = scopeDir(scope);
+function summaryCandidateRels(scope, language, root) {
+  const dir = scopeDir(scope, { root });
   const primary = `${dir}/${summaryFileName(language)}`;
   const fallback = `${dir}/summary.md`;
   return primary === fallback ? [fallback] : [primary, fallback];
@@ -353,7 +398,7 @@ function summaryCandidateRels(scope, language) {
  */
 export async function readSummary(scope, opts = {}) {
   const { root = DEFAULT_MEMORY_ROOT, currentVpId, language } = opts;
-  for (const rel of summaryCandidateRels(scope, language)) {
+  for (const rel of summaryCandidateRels(scope, language, root)) {
     enforceVpAcl(rel, currentVpId);
     const abs = join(root, rel);
     try { return (await fsp.readFile(abs, 'utf8')).trim(); }
@@ -374,7 +419,7 @@ export async function readSummary(scope, opts = {}) {
  */
 export async function writeSummary(scope, body, opts = {}) {
   const { root = DEFAULT_MEMORY_ROOT, currentVpId, language } = opts;
-  const rel = `${scopeDir(scope)}/${summaryFileName(language)}`;
+  const rel = `${scopeDir(scope, { root })}/${summaryFileName(language)}`;
   enforceVpAcl(rel, currentVpId);
   const abs = join(root, rel);
   await atomicWrite(abs, `${(body || '').trim()}\n`);
@@ -382,14 +427,12 @@ export async function writeSummary(scope, body, opts = {}) {
 
 /**
  * Seed a scope's summary.md if (and only if) it is missing or empty. Used
- * at create-time for VPs and groups so a fresh session has SOMETHING for
- * `engine.#prepareAms` to pull into the Layer-A resident summary — the
- * earlier behavior of "no summary.md until Dream-v2 runs" left the memory
- * section empty for the entire first session.
+ * at create-time for legacy bootstrap and catalog readers. The prompt path no
+ * longer consumes these seeds; it selects canonical content.md instead.
  *
  * Intentionally a no-op if a non-empty summary.md already exists, so this
- * is safe to call from any place that creates the scope (VP create, group
- * create, first-session bootstrap) without clobbering Dream-v2's writes.
+ * is safe to call from any existing scope-creation path without clobbering
+ * Dream's catalog writes.
  *
  * @param {Scope} scope
  * @param {string} body
@@ -422,7 +465,7 @@ export async function seedSummaryIfMissing(scope, body, opts = {}) {
  */
 export function seedSummaryIfMissingSync(scope, body, opts = {}) {
   const { root = DEFAULT_MEMORY_ROOT } = opts;
-  const rel = `${scopeDir(scope)}/summary.md`;
+  const rel = `${scopeDir(scope, { root })}/summary.md`;
   const abs = join(root, rel);
   let existing = '';
   if (existsSync(abs)) {
@@ -438,7 +481,7 @@ export function seedSummaryIfMissingSync(scope, body, opts = {}) {
 /**
  * Synchronously remove a scope's directory under the memory root. Used by
  * `deleteVp` / `deleteSession` to cascade memory cleanup so a recreate of the
- * same id doesn't see stale `summary.md` / `memory.md` / `segments/` files.
+ * same id doesn't see stale `content.md` / `summary.md` / `memory.md` files.
  *
  * Idempotent — missing directory is a no-op.
  *
@@ -447,7 +490,7 @@ export function seedSummaryIfMissingSync(scope, body, opts = {}) {
  */
 export function removeScopeDirSync(scope, opts = {}) {
   const { root = DEFAULT_MEMORY_ROOT } = opts;
-  const abs = join(root, scopeDir(scope));
+  const abs = join(root, scopeDir(scope, { root }));
   if (!existsSync(abs)) return;
   rmSync(abs, { recursive: true, force: true });
 }
@@ -462,7 +505,7 @@ export function removeScopeDirSync(scope, opts = {}) {
  */
 export function ensureScopeSync(scope, opts = {}) {
   const { root = DEFAULT_MEMORY_ROOT } = opts;
-  const dir = join(root, scopeDir(scope));
+  const dir = join(root, scopeDir(scope, { root }));
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
 }
 
@@ -474,7 +517,7 @@ export function ensureScopeSync(scope, opts = {}) {
  */
 export async function ensureScope(scope, opts = {}) {
   const { root = DEFAULT_MEMORY_ROOT } = opts;
-  const dir = join(root, scopeDir(scope));
+  const dir = join(root, scopeDir(scope, { root }));
   await fsp.mkdir(dir, { recursive: true });
 }
 
@@ -488,7 +531,8 @@ export async function ensureScope(scope, opts = {}) {
  *   group/<g>/user/                        → { kind: 'group-user', sessionId: g }
  *   group/<g>/vp/<v>/                      → { kind: 'group-vp', sessionId: g, id: v }
  *   group/<g>/feature/<f>/                 → { kind: 'group-feature', sessionId: g, id: f }
- *   group/<g>/topic/<l1>[/<l2>]/           → { kind: 'group-topic', sessionId: g, path: [...] }
+ *   group/<g>/topic/<l1>[/<l2>]/           → legacy group-topic
+ *   sessions/<s>/topic/<l1>[/<l2>]/        → { kind: 'session-topic', sessionId: s, path: [...] }
  *
  * Skips `.legacy/` and any dotfile / unsafe segment.
  *
@@ -646,14 +690,20 @@ export async function listScopes(opts = {}) {
     for (const tent of topics) {
       if (!tent.isDirectory()) continue;
       if (!isSafeId(tent.name)) continue;
-      out.push({ kind: 'session-topic', sessionId: s, path: [tent.name] });
+      const topicAbs = join(topicDir, tent.name);
       let subTopics;
-      try { subTopics = await fsp.readdir(join(topicDir, tent.name), { withFileTypes: true }); }
+      try { subTopics = await fsp.readdir(topicAbs, { withFileTypes: true }); }
       catch { subTopics = []; }
+      const hasOwnMemory = ['content.md', 'memory.md', 'summary.md', 'summary.zh.md']
+        .some(name => existsSync(join(topicAbs, name)));
+      if (hasOwnMemory) out.push({ kind: 'session-topic', sessionId: s, path: [tent.name] });
       for (const sub of subTopics) {
         if (!sub.isDirectory()) continue;
         if (!isSafeId(sub.name)) continue;
-        out.push({ kind: 'session-topic', sessionId: s, path: [tent.name, sub.name] });
+        const subAbs = join(topicAbs, sub.name);
+        const hasSubMemory = ['content.md', 'memory.md', 'summary.md', 'summary.zh.md']
+          .some(name => existsSync(join(subAbs, name)));
+        if (hasSubMemory) out.push({ kind: 'session-topic', sessionId: s, path: [tent.name, sub.name] });
       }
     }
   }

package/yeaft/memory/summary-store.js

@@ -1,9 +1,9 @@
 /**
  * memory/summary-store.js — DESIGN-H2-AMS §3.
  *
- * `summary.md` is a bounded, per-scope prose digest derived from all
- * segments in that scope. Resident AMS layer = concatenation of all
- * relevant scope summaries. Regenerated by Dream after segments change.
+ * `summary.md` is a bounded catalog description used by Dream triage and
+ * topic consolidation. It is not authoritative and is not prompt content;
+ * canonical prose lives in content.md, while evidence lives in memory.md.
  *
  * Layout:
  *   ~/.yeaft/memory/<scope>/summary.md

package/yeaft/memory/topic-redirect.js

@@ -0,0 +1,28 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export const TOPIC_REDIRECT_FILE = 'redirect.json';
+
+export function normalizeTopicPath(value) {
+  const parts = String(value || '').split('/').map(part => part.trim()).filter(Boolean);
+  if (parts.length === 0 || parts.length > 2) return '';
+  if (parts.some(part => part === '.' || part === '..' || /[\\\0]/.test(part))) return '';
+  return parts.join('/');
+}
+
+export function resolveTopicRedirect(root, sessionId, path) {
+  let current = normalizeTopicPath(path);
+  const visited = new Set();
+  while (current && !visited.has(current)) {
+    visited.add(current);
+    const redirectPath = join(root, 'sessions', sessionId, 'topic', current, TOPIC_REDIRECT_FILE);
+    if (!existsSync(redirectPath)) break;
+    let payload;
+    try { payload = JSON.parse(readFileSync(redirectPath, 'utf8') || '{}'); }
+    catch { break; }
+    const next = normalizeTopicPath(payload?.canonical);
+    if (!next || next === current) break;
+    current = next;
+  }
+  return current;
+}

package/yeaft/router/continuity.js

@@ -86,7 +86,8 @@ export function extractPriorPlan(messages, vpId) {
 
 /**
  * Return a copy of the messages array with engine-private metadata stripped
- * from every message. The serialisers (anthropic/openai-responses) read this;
+ * from every message. This includes durable UI-only execution provenance.
+ * The serialisers (anthropic/openai-responses) read this;
  * these fields are NEVER part of the wire payload. Cheap because we only
  * shallow-clone the messages that actually have private fields.
  *
@@ -99,9 +100,17 @@ export function stripMetaForWire(messages) {
   const out = messages.map(m => {
     if (m && typeof m === 'object'
         && ('_meta' in m || '_runtimeTurnId' in m || '_partialTurn' in m
-          || '_persistedMessageId' in m || 'userAuthored' in m)) {
+          || '_persistedMessageId' in m || 'userAuthored' in m || 'executionOrigin' in m)) {
       mutated = true;
-      const { _meta, _runtimeTurnId, _partialTurn, _persistedMessageId, userAuthored, ...rest } = m;
+      const {
+        _meta,
+        _runtimeTurnId,
+        _partialTurn,
+        _persistedMessageId,
+        userAuthored,
+        executionOrigin,
+        ...rest
+      } = m;
       return rest;
     }
     return m;

package/yeaft/session.js

@@ -35,18 +35,16 @@ import { TaskManager } from './tasks/manager.js';
 //
 // GC.1 (final): the session opens a SegmentIndex (SQLite FTS5 over
 // memory.md) and passes it to the Engine. Engine.#recallMemory routes
-// pre-turn recall through groups/pre-flow.js → memory/preflow.js (the
+// pre-turn recall through sessions/pre-flow.js → memory/preflow.js (the
 // previous per-scope file reader recall-v2.js has been deleted).
 // The `config.memoryV2` opt-out flag was retired in task-710; wiring is
 // unconditional.
 //
-// GC.1 follow-up: when memoryIndex is wired we also open an
-// AmsRegistry. The registry caches per-group ActiveMemorySet
-// instances and persists their identity-only state under
-// `~/.yeaft/memory/groups/<gid>/ams.json` so a deactivated group
-// resumes with the same onDemand/recent membership it had on
-// disconnect. Engine.#runQuery uses the registry to populate the
-// AMS each turn and to run `memory/adjust.js` post-turn.
+// When memoryIndex is wired we also open an AmsRegistry. It caches the
+// per-Session ActiveMemorySet object and keeps the version-1 ams.json shape for
+// disk compatibility. Engine rebuilds prompt-facing Resident entries from
+// query-selected canonical content on every turn; persisted segment ids are
+// never rehydrated into the prompt.
 import { ensureDefaultSessionIfEmpty, migrateRegisteredWorkDirSessions } from './sessions/session-crud.js';
 import { seedDefaultVps } from './vp/seed-defaults.js';
 import { topUpDefaultVps } from './vp/seed-topup.js';
@@ -54,6 +52,7 @@ import { archiveLegacyScopes } from './memory/seed-backfill.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 { backfillCanonicalContent } from './memory/content-backfill.js';
 import { openAmsRegistry } from './memory/ams-registry.js';
 import { join } from 'path';
 import { existsSync as existsSyncSafe, readFileSync as readFileSyncSafe, mkdirSync as mkdirSyncSafe } from 'fs';
@@ -267,9 +266,10 @@ export async function loadSession(options = {}) {
   const conversationStore = new ConversationStore(yeaftDir);
 
   // ─── 5-fts. (GC.1) Open SegmentIndex for FTS pre-flow ────
-  //     Build a SQLite FTS5 index over ~/.yeaft/memory/<scope>/memory.md
-  //     and pass it to the Engine. Engine.#recallMemory uses it via
-  //     groups/pre-flow.js → memory/preflow.js. Disk is the source of
+  //     Build a SQLite FTS5 index over per-scope evidence memory.md and
+  //     canonical content.md, then pass it to Engine for scope selection.
+  //     Engine.#recallMemory uses it via sessions/pre-flow.js →
+  //     memory/preflow.js. Disk is the source of
   //     truth; on boot we reconcile disk → index via syncAll. Failure
   //     to open the index is non-fatal: #recallMemory returns an empty
   //     result and the turn proceeds without pre-injected memory.
@@ -290,6 +290,7 @@ export async function loadSession(options = {}) {
         }
       }
       try {
+        backfillCanonicalContent(memoryRoot);
         syncSegmentIndex(memoryRoot, memoryIndex);
       } catch (syncErr) {
         // Sync is best-effort; an empty / partial index just produces
@@ -304,12 +305,11 @@ export async function loadSession(options = {}) {
     }
   }
 
-  // ─── 5-ams. (GC.1 follow-up) Group-keyed AMS registry ────
+  // ─── 5-ams. Session-keyed AMS registry ─────────────────
   //     The registry caches one ActiveMemorySet per sessionId and
-  //     persists their state to disk so a deactivated group can be
-  //     reactivated with the same onDemand/recent membership it had
-  //     on disconnect. Without memoryIndex we have nothing to
-  //     re-hydrate against, so the registry is left null in that case.
+  //     retains version-1 metadata for disk compatibility. Prompt state is
+  //     rebuilt from selected canonical content each turn; old segment ids are
+  //     not rehydrated. Without memoryIndex the registry remains disabled.
   let amsRegistry = null;
   if (memoryIndex && !config._readOnly) {
     try {
@@ -559,9 +559,8 @@ export async function loadSession(options = {}) {
 
   // H2.f.5 retired the old session-level thread engine registry, input queue,
   // and dispatcher. The session exposes a default `engine`; PR #797 keeps
-  // group VP thread engines in web-bridge runtime state and calls engine.query()
-  // directly. Memory recall happens via memory/preflow.js (pre-turn) and
-  // memory/adjust.js (post-turn).
+  // Session VP thread engines in web-bridge runtime state and calls engine.query()
+  // directly. Query-time recall happens via memory/preflow.js.
 
   // ─── 10. Build session ─────────────────────────────────
   const status = {

package/yeaft/sessions/pre-flow.js

@@ -1,5 +1,5 @@
 /**
- * groups/pre-flow.js — explicit pre-flow stage for Yeaft.
+ * sessions/pre-flow.js — explicit pre-flow stage for Yeaft.
  *
  * Pre-flow is the "before any VP runs" stage. It owns:
  *
@@ -252,14 +252,16 @@ export function formatPickedForInjection(picked) {
 /**
  * @typedef {object} MemoryPreflowOptions
  * @property {string}         userMsg              The user's message
- * @property {string}         [sessionId]            Active group, if any
+ * @property {string}         [sessionId]            Active Session, if any
  * @property {string}         [vpId]               Responding VP id, if any
  * @property {string}         [featureId]          Active feature, if any
  * @property {string[]}       [extraScopes]        Additional scopes to include
  * @property {string[]}       [currentTags]        Contextual tags for rerank
- * @property {number}         [topK]               Max FTS rows fetched (default 50)
+ * @property {number}         [topK]               Max FTS rows fetched (default 200)
  * @property {number}         [budgetTokens]       Token budget for picked segments
  * @property {number}         [pickLimit]          Max picked segments (default 8)
+ * @property {boolean}        [uniqueScopes]       Pick only the best hit per scope
+ * @property {boolean}        [canonicalOnly]      Search canonical content records only
  * @property {boolean}        [fallbackOnEmpty]    Include bounded recent scoped segments when FTS has no hits
  * @property {number}         [fallbackPerScope]   Max fallback segments per scope
  */
@@ -355,6 +357,8 @@ export function runMemoryPreflow(index, opts) {
     topK: opts.topK,
     budgetTokens: opts.budgetTokens,
     pickLimit: opts.pickLimit,
+    uniqueScopes: opts.uniqueScopes === true,
+    canonicalOnly: opts.canonicalOnly === true,
   });
 
   let fallbackUsed = false;

package/yeaft/sub-agent/runner.js

@@ -353,7 +353,16 @@ async function driveSubAgent(agent, subEngine, vpPersona, deps) {
     // Seed: mission becomes the first user prompt.
     if (!agent.pendingPrompts) agent.pendingPrompts = [];
     if (agent.mission && !agent.__missionSeeded) {
-      agent.pendingPrompts.push(agent.mission);
+      agent.pendingPrompts.push({
+        prompt: agent.mission,
+        projectSessionIds: Array.isArray(deps.projectSessionIds)
+          ? deps.projectSessionIds.slice()
+          : [],
+        projectLabel: typeof deps.projectLabel === 'string' ? deps.projectLabel : '',
+        projectInstruction: typeof deps.projectInstruction === 'string'
+          ? deps.projectInstruction
+          : '',
+      });
       agent.__missionSeeded = true;
     }
 

package/yeaft/work-center/bridge.js

@@ -115,6 +115,7 @@ async function createDefaultService() {
       }
       return {
         ...runtime,
+        yeaftDir: requireYeaftDir(),
         defaultWorkDir: ctx.CONFIG?.workDir || process.cwd(),
       };
     },