@yeaft/webchat-agent 0.1.665 → 0.1.667

package/unify/eval/cases/memory.js

@@ -1,134 +1,11 @@
 /**
  * eval/cases/memory.js — Memory recall eval cases
  *
- * Tests the memory recall pipeline:
- *   - Keyword extraction accuracy
- *   - Scope + tag filtering
- *   - LLM selection (when >7 candidates)
- *   - Fingerprint caching
- *   - Memory injection into system prompt
+ * Smoke-level evals for the H2-AMS memory pipeline. Detailed mocks live
+ * in unit tests; this file only declares the eval scenarios.
  */
 
-import {
-  noError,
-  containsText,
-  custom,
-} from '../runner.js';
-
-// ─── Memory Recall Test Helpers ──────────────────────────────
-
-/**
- * Create an engine with pre-loaded memory entries for eval.
- * Uses a mock MemoryStore that returns predefined entries.
- */
-function createMockMemoryStore(entries) {
-  return {
-    readProfile: () => 'User is a senior TypeScript developer who prefers functional programming.',
-    readEntry: (name) => entries.find(e => e.name === name) || null,
-    readSection: () => '',
-    listEntries: () => entries,
-    findByFilter: ({ scope, tags, limit = 15 }) => {
-      // Simple scoring: scope match + tag overlap
-      return entries
-        .map(e => {
-          let score = 0;
-          if (scope && e.scope === scope) score += 3;
-          if (scope && e.scope === 'global') score += 1;
-          if (tags) {
-            for (const t of tags) {
-              if (e.tags && e.tags.includes(t)) score += 1;
-            }
-          }
-          return { ...e, _score: score };
-        })
-        .filter(e => e._score > 0)
-        .sort((a, b) => b._score - a._score)
-        .slice(0, limit);
-    },
-    bumpFrequency: () => {},
-    search: (keyword) => entries.filter(e =>
-      e.content.toLowerCase().includes(keyword.toLowerCase()) ||
-      e.name.toLowerCase().includes(keyword.toLowerCase()),
-    ),
-    stats: () => ({ entryCount: entries.length, scopes: [], kinds: {} }),
-    writeEntry: () => 'test-entry',
-    writeEntries: () => [],
-    deleteEntry: () => true,
-    rebuildScopes: () => {},
-    addToSection: () => {},
-    writeProfile: () => {},
-    clear: () => {},
-  };
-}
-
-const sampleMemoryEntries = [
-  {
-    name: 'typescript-strict-mode',
-    kind: 'preference',
-    scope: 'global',
-    tags: ['typescript', 'config', 'strict'],
-    importance: 'high',
-    frequency: 5,
-    content: 'User always uses TypeScript strict mode with noImplicitAny enabled.',
-    created_at: '2026-03-01T00:00:00Z',
-    updated_at: '2026-04-01T00:00:00Z',
-  },
-  {
-    name: 'prefers-vitest',
-    kind: 'preference',
-    scope: 'work/claude-web-chat',
-    tags: ['testing', 'vitest', 'framework'],
-    importance: 'normal',
-    frequency: 3,
-    content: 'User prefers vitest over jest for testing. Uses vitest for all new projects.',
-    created_at: '2026-03-15T00:00:00Z',
-    updated_at: '2026-04-01T00:00:00Z',
-  },
-  {
-    name: 'error-handling-pattern',
-    kind: 'lesson',
-    scope: 'global',
-    tags: ['error-handling', 'typescript', 'patterns'],
-    importance: 'high',
-    frequency: 4,
-    content: 'Always use Result<T, E> pattern instead of throwing exceptions. Wrap external API calls in try-catch and return Result.',
-    created_at: '2026-02-01T00:00:00Z',
-    updated_at: '2026-04-01T00:00:00Z',
-  },
-  {
-    name: 'project-structure',
-    kind: 'context',
-    scope: 'work/claude-web-chat',
-    tags: ['architecture', 'project', 'monorepo'],
-    importance: 'normal',
-    frequency: 2,
-    content: 'Project uses monorepo with agent/, server/, web/ directories. Agent code is in agent/unify/.',
-    created_at: '2026-01-01T00:00:00Z',
-    updated_at: '2026-03-01T00:00:00Z',
-  },
-  {
-    name: 'functional-programming',
-    kind: 'preference',
-    scope: 'global',
-    tags: ['functional', 'programming', 'style'],
-    importance: 'normal',
-    frequency: 6,
-    content: 'User prefers functional programming: pure functions, immutable data, map/filter/reduce over loops.',
-    created_at: '2026-01-15T00:00:00Z',
-    updated_at: '2026-04-05T00:00:00Z',
-  },
-  {
-    name: 'api-design-rest',
-    kind: 'skill',
-    scope: 'global',
-    tags: ['api', 'rest', 'design'],
-    importance: 'normal',
-    frequency: 1,
-    content: 'REST API conventions: use plural nouns, HTTP methods for CRUD, 2xx success, 4xx client error, 5xx server error.',
-    created_at: '2026-02-15T00:00:00Z',
-    updated_at: '2026-02-15T00:00:00Z',
-  },
-];
+import { noError, custom } from '../runner.js';
 
 // ─── Eval Cases ──────────────────────────────────────────────
 
@@ -139,12 +16,8 @@ export const memoryCases = [
   {
     id: 'memory-profile-injection',
     suite: 'memory',
-    description: 'System prompt should include user profile from memory',
+    description: 'System prompt should include memory section after preflow',
     prompt: 'Help me with a coding task',
-    setupEngine: (engine) => {
-      // We can't directly inject memoryStore here since Engine uses private fields
-      // Instead, this eval verifies via the adapter call log that system prompt contains memory
-    },
     criteria: [
       noError,
       custom('has-response', 'Model produces a response', 5, (result) => ({
@@ -154,29 +27,23 @@ export const memoryCases = [
     ],
   },
 
-  // ─── Keyword Extraction (unit-level eval) ─────────────
+  // ─── Recall Event ──────────────────────────────────────
 
   {
     id: 'memory-keyword-extraction',
     suite: 'memory',
-    description: 'Keyword extraction produces relevant keywords',
+    description: 'Recall event emitted when preflow has hits',
     prompt: 'How should I handle TypeScript errors in my Express API?',
     criteria: [
       noError,
-      // This is tested at unit level but verifiable here via recall event
-      custom('recall-event', 'Recall event emitted (if memory store provided)', 3, (result) => {
-        // Without a real memory store this won't emit recall, so we check gracefully
+      custom('recall-event', 'Recall event emitted (if FTS index seeded)', 3, (result) => {
         const recallEvent = result.events.find(e => e.type === 'recall');
         return {
-          pass: true, // Always passes — it's informational
+          pass: true,
           score: recallEvent ? 1 : 0.5,
-          reason: recallEvent ? `Recalled ${recallEvent.entryCount} entries` : 'No memory store configured',
+          reason: recallEvent ? `Recalled ${recallEvent.entryCount} segments` : 'No FTS hits',
         };
       }),
     ],
   },
 ];
-
-// ─── Exported for direct import in unit tests ────────────────
-
-export { createMockMemoryStore, sampleMemoryEntries };

package/unify/features/summary.js

@@ -1,30 +1,18 @@
 /**
- * summary.js — task-334n: Feature multi-VP collaboration summary protocol.
+ * summary.js — Feature multi-VP collaboration summary protocol.
  *
  * Owns:
  *   - postSummary()          — write a `type=summary` message to the group jsonl
- *                              and run the extractor (B + C)
- *   - extractFeatureMemory() — turn a summary body into 2-5 feature-memory entries
- *                              via 334f feature-memory shard lib (C)
  *   - buildSummaryReminder() — compute the §Δ31.4 3-AND soft reminder shape
- *                              consumed by 334e's `featureCtx.summaryReminder` (D)
- *   - buildFeatureCtxMemories() — assemble feature-memory top-5 (pinned + recent +
- *                                 tag relevance) for feature_ctx (E)
+ *   - buildFeatureCtxMemories() — feature-memory top-5 (post-rip stub: returns [])
  *
  * Hard boundaries:
- *   - does NOT touch 334o jsonl rotation internals (calls group.appendMessage)
- *   - does NOT touch 334f shard-store impl (calls openMemoryShardStore API)
- *   - does NOT touch 334e prompts main frame (returns plain shapes that feed
- *     the existing renderFeatureCtx contract)
- *   - does NOT self-loop-write VP-memory (extractor writes feature-memory only;
- *     VP-level synthesis is deferred to 334g dream)
- *   - softCap overflow does NOT create new shards (334f already routes into
- *     dream queue via projectDeriveHint; we just surface `needsRecompression`)
+ *   - does NOT touch jsonl rotation internals (calls group.appendMessage)
+ *   - does NOT write feature-memory shards — the H2-AMS rip retired the shard
+ *     store; feature memory now flows through Dream V2's scope merge instead.
  */
 
 import { join } from 'path';
-import { openMemoryShardStore } from '../memory/shard-store.js';
-import { AUTHORED_BY } from '../memory/schema.js';
 
 // ─── §Δ31.4 soft-reminder thresholds ─────────────────────────────
 /** Must be initiator AND members>1 AND (age≥20min OR turns≥10). */
@@ -119,36 +107,11 @@ export function postSummary(opts) {
     },
   });
 
-  // 2) Run the extractor → write feature-memory entries (C).
+  // 2) Feature-memory extraction is now owned by Dream V2 (per-group diff →
+  //    triage → merge by target scope → atomic segments). The legacy in-line
+  //    shard-store extractor was retired in the H2-AMS rip; we leave
+  //    `memoryIds` empty so callers don't depend on inline-extracted IDs.
   const memoryIds = [];
-  try {
-    const store = openMemoryShardStore(memoryDir, 'feature');
-    const raw = extractor(body) || [];
-    const bounded = clampExtracted(raw);
-    for (const [i, item] of bounded.entries()) {
-      const kind = EXTRACT_KINDS.includes(item.kind) ? item.kind : 'progress';
-      const shard = KIND_TO_SHARD[kind] || 'progress';
-      const id = `mem-${stored.id}-${i + 1}`;
-      store.put({
-        id,
-        shard,
-        kind,
-        featureId,
-        body: typeof item.body === 'string' ? item.body.trim() : '',
-        tags: Array.isArray(item.tags) ? item.tags.slice(0, 5) : [],
-        authoredBy: AUTHORED_BY.SUMMARY,
-        sourceRef: { featureId, msgIds: [stored.id] },
-        createdAt: new Date(now()).toISOString(),
-      });
-      memoryIds.push(id);
-    }
-  } catch (err) {
-    // Extractor failures must not fail the summary post; the message is
-    // already persisted (audit property). We return the empty memoryIds so
-    // callers can surface a warning if they want.
-    // eslint-disable-next-line no-console
-    console.warn('[task-334n] summary-extractor failed:', err?.message || err);
-  }
 
   return {
     message: stored,
@@ -241,62 +204,16 @@ export function buildSummaryReminder(input) {
 
 /**
  * Assemble feature-memory top-5 for 334e's `featureCtx.memories` field.
- * Ordering (§Δ16.5): pinned first → recent → tag-relevant. Supersedes are
- * hidden (entries with supersededBy != null are filtered out).
+ * Post-rip stub: the underlying shard store was retired in the H2-AMS rip;
+ * Dream V2 owns feature-scope memory now. Returning `[]` keeps the prompt
+ * shape valid until a follow-up wires the new scope-summary read path.
  *
- * @param {string} memoryDir  groups/<g>/features/<f>/memory/
+ * @param {string} memoryDir  unused (kept for callsite compatibility)
  * @param {{ tags?: string[], top?: number }} [opts]
  * @returns {Array<{body:string, shard:string, authoredBy?:string}>}
  */
-export function buildFeatureCtxMemories(memoryDir, opts = {}) {
-  const top = Number.isFinite(opts.top) ? Number(opts.top) : 5;
-  const tagHints = Array.isArray(opts.tags) ? opts.tags : [];
-  const nowMs = typeof opts.now === 'number' ? opts.now : Date.now();
-  let results = [];
-  try {
-    const store = openMemoryShardStore(memoryDir, 'feature');
-    const q = store.query({});
-    const hits = (q.results || [])
-      .filter((r) => !r.supersededBy)
-      .map((r) => {
-        const full = store.get(r.id);
-        return {
-          id: r.id,
-          shard: r.shard || 'general',
-          body: full?.body || '',
-          tags: Array.isArray(r.tags) ? r.tags : [],
-          pinned: !!r.pinned,
-          createdAt: full?.createdAt || null,
-          authoredBy: full?.authoredBy || null,
-        };
-      })
-      .filter((r) => r.body && r.body.trim());
-
-    const score = (r) => {
-      let s = 0;
-      if (r.pinned) s += 1000;
-      if (r.createdAt) {
-        const ageMs = nowMs - new Date(r.createdAt).getTime();
-        const halfLifeMs = 24 * 60 * 60 * 1000;
-        s += Math.max(0, 100 * Math.pow(0.5, Math.max(0, ageMs) / halfLifeMs));
-      }
-      for (const t of tagHints) if (r.tags.includes(t)) s += 5;
-      return s;
-    };
-    hits.sort((a, b) => {
-      const ds = score(b) - score(a);
-      if (ds !== 0) return ds;
-      return String(b.createdAt || '').localeCompare(String(a.createdAt || ''));
-    });
-    results = hits.slice(0, top).map((r) => ({
-      body: r.body,
-      shard: r.shard,
-      ...(r.authoredBy ? { authoredBy: r.authoredBy } : {}),
-    }));
-  } catch {
-    results = [];
-  }
-  return results;
+export function buildFeatureCtxMemories(_memoryDir, _opts = {}) {
+  return [];
 }
 
 // ─── (F) related-feature ACL fail-closed gate ─────────────────────

package/unify/index.js

@@ -22,10 +22,8 @@ export { buildSystemPrompt, SUPPORTED_LANGUAGES } from './prompts.js';
 export { Engine } from './engine.js';
 export { ConversationStore, parseMessage, estimateTokens } from './conversation/persist.js';
 export { searchMessages } from './conversation/search.js';
-export { MemoryStore, parseEntry, serializeEntry, MEMORY_KINDS } from './memory/store.js';
 
 // Phase 5: Advanced features
-export { KINDS, KIND_PRIORITY, KIND_DESCRIPTIONS, IMPORTANCE_LEVELS, validateEntry, parseScopePath, getAncestorScopes, areScopesRelated } from './memory/types.js';
 export { runStopHooks } from './stop-hooks.js';
 export { MCPManager, createMCPManager } from './mcp.js';
 export { SkillManager, createSkillManager, parseSkill, serializeSkill } from './skills.js';

package/unify/memory/ams.js

@@ -11,7 +11,7 @@
  * truth is `<scope>/memory.md` + `<scope>/summary.md`. AMS itself
  * doesn't write to disk — that's Dream's job.
  *
- * Privacy (DESIGN-v2 §2.2): `vp/<other>` scopes are ALWAYS filtered out
+ * Privacy: `vp/<other>` scopes are ALWAYS filtered out
  * for any worker that isn't `<other>`. The owning code passes its own
  * vpId at construction.
  */

package/unify/memory/consolidate.js

@@ -1,22 +1,19 @@
 /**
- * consolidate.js — Consolidate = compact + extract (one LLM call)
+ * consolidate.js — Hot-window budget partitioning utilities.
  *
- * Triggered when hot_tokens > MESSAGE_TOKEN_BUDGET.
- * One LLM call does two things simultaneously:
- *   1. Generate compact summary → append to compact.md ("short-term memory")
- *   2. Extract memory entries → write to entries/ ("long-term memory")
+ * Reduced surface (PR-B rip): the legacy LLM-driven consolidate() pipeline
+ * (compact summary + entries-store extraction) has been retired. The only
+ * survivors are the pure functions used by the compact orchestrator:
  *
- * After consolidation:
- *   - Processed messages moved from messages/ to cold/
- *   - index.md + scopes.md updated
+ *   - shouldConsolidate(store, budget) — decide when to compact
+ *   - partitionMessages(messages, budget) — split hot messages into
+ *     toArchive / toKeep based on token budget
  *
- * Reference: yeaft-unify-core-systems.md §3.1, §4.2
- *            yeaft-unify-design.md §6.1
+ * Memory extraction is now owned by Dream V2 (per-group diff -> triage ->
+ * merge by target scope -> apply via segment-store + summary-store).
+ * Conversation summarisation lives in compact/orchestrator.js's hooks.
  */
 
-import { extractMemories } from './extract.js';
-import { pickEffort } from '../effort.js';
-
 // ─── Constants ──────────────────────────────────────────────────
 
 /** Default MESSAGE_TOKEN_BUDGET (context * 4%, default ~8192). */
@@ -28,8 +25,6 @@ export const COMPACT_KEEP_RATIO = 0.4;
 /** Minimum messages to keep hot (newest). */
 const MIN_KEEP_MESSAGES = 3;
 
-// ─── Consolidate ────────────────────────────────────────────────
-
 /**
  * Check if consolidation should be triggered.
  *
@@ -81,113 +76,3 @@ export function partitionMessages(messages, budget = DEFAULT_MESSAGE_TOKEN_BUDGE
     toKeep: messages.slice(keepStart),
   };
 }
-
-/**
- * Generate a compact summary of messages.
- *
- * @param {object[]} messages — messages to summarize
- * @param {object} adapter — LLM adapter with .call()
- * @param {object} config — { model }
- * @returns {Promise<string>} — compact summary text
- */
-async function generateSummary(messages, adapter, config) {
-  const conversation = messages.map(m => {
-    const prefix = m.role === 'user' ? 'User' : m.role === 'assistant' ? 'Assistant' : m.role;
-    return `[${prefix}]: ${(m.content || '').slice(0, 500)}`;
-  }).join('\n\n');
-
-  const system = 'You are a conversation summarizer. Summarize the conversation concisely in 2-3 paragraphs, preserving key decisions, facts, and context. Write in the same language as the conversation.';
-
-  try {
-    const result = await adapter.call({
-      model: config.model,
-      system,
-      messages: [{ role: 'user', content: `Summarize this conversation:\n\n${conversation}` }],
-      maxTokens: 1024,
-      // task-327c: consolidate is a high-complexity side-query; flag as
-      // 'max' effort so supported models use extended thinking / reasoning.
-      // Router/adapter silently drops the param for models that don't
-      // support thinking, or when UNIFY_THINKING_V1 is off.
-      effort: pickEffort({ scenario: 'consolidate' }),
-    });
-    return result.text.trim();
-  } catch {
-    // Fallback: simple concatenation of first/last messages
-    const first = messages[0]?.content?.slice(0, 200) || '';
-    const last = messages[messages.length - 1]?.content?.slice(0, 200) || '';
-    return `[Auto-summary failed] Started with: ${first}... Ended with: ${last}`;
-  }
-}
-
-/**
- * Run the full Consolidate pipeline.
- *
- * 1. Partition messages (what to archive vs keep)
- * 2. Generate compact summary (LLM call)
- * 3. Extract memory entries (LLM call)
- * 4. Move archived messages to cold/
- * 5. Update compact.md, index.md, scopes.md
- *
- * @param {{
- *   conversationStore: import('../conversation/persist.js').ConversationStore,
- *   memoryStore: import('./store.js').MemoryStore,
- *   adapter: object,
- *   config: object,
- *   budget?: number
- * }} params
- * @returns {Promise<{ compactSummary: string, extractedEntries: string[], archivedCount: number }>}
- */
-export async function consolidate({ conversationStore, memoryStore, adapter, config, budget = DEFAULT_MESSAGE_TOKEN_BUDGET }) {
-  // Load all hot messages
-  const messages = conversationStore.loadAll();
-
-  if (messages.length <= MIN_KEEP_MESSAGES) {
-    return { compactSummary: '', extractedEntries: [], archivedCount: 0 };
-  }
-
-  // Step 1: Partition
-  const { toArchive, toKeep } = partitionMessages(messages, budget);
-
-  if (toArchive.length === 0) {
-    return { compactSummary: '', extractedEntries: [], archivedCount: 0 };
-  }
-
-  // Step 2: Generate compact summary
-  const compactSummary = await generateSummary(toArchive, adapter, config);
-
-  // Step 3: Extract memory entries
-  const extracted = await extractMemories({ messages: toArchive, adapter, config });
-
-  // Step 4: Move archived messages to cold
-  const archiveIds = toArchive.map(m => m.id).filter(Boolean);
-  conversationStore.moveToColdBatch(archiveIds);
-
-  // Step 5a: Update compact.md
-  if (compactSummary) {
-    conversationStore.updateCompactSummary(compactSummary);
-  }
-
-  // Step 5b: Write extracted memory entries
-  const entryNames = [];
-  for (const entry of extracted) {
-    const slug = memoryStore.writeEntry(entry);
-    entryNames.push(slug);
-  }
-
-  // Step 5c: Update index.md
-  const lastMsg = toKeep[toKeep.length - 1];
-  conversationStore.updateIndex({
-    lastMessageId: lastMsg?.id || null,
-  });
-
-  // Step 5d: Rebuild scopes.md
-  if (entryNames.length > 0) {
-    memoryStore.rebuildScopes();
-  }
-
-  return {
-    compactSummary,
-    extractedEntries: entryNames,
-    archivedCount: archiveIds.length,
-  };
-}

package/unify/memory/segment-store.js

@@ -5,7 +5,7 @@
  * segment blocks) and the SQLite segment index. This layer handles
  * scope <-> file path mapping; the index layer is scope-agnostic.
  *
- * Path conventions (DESIGN-v2 §5):
+ * Path conventions:
  *   ~/.yeaft/memory/user/memory.md
  *   ~/.yeaft/memory/vp/<id>/memory.md
  *   ~/.yeaft/memory/group/<id>/memory.md

package/unify/memory/store-v2.js

@@ -1,5 +1,5 @@
 /**
- * memory/store-v2.js — DESIGN-v2.md Part I: per-scope memory.md + summary.md.
+ * memory/store-v2.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
@@ -29,18 +29,15 @@
  * ACL:
  *   - This module enforces ONE ACL: `vp/<other>` paths are blocked when
  *     `currentVpId` is given and differs from `<other>`. Every other scope
- *     boundary is ACL-free in v2 (DESIGN-v2 §3.2).
+ *     boundary is ACL-free.
  *
  * 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.
  *   - No LLM calls, no extraction, no summarisation. Pure I/O.
- *   - No legacy R6 fallback. The old MemoryStore (memory/store.js) and
- *     ScopeTree (memory/scope-tree.js) remain in service until PR-E swaps
- *     callers; this module is additive.
  *
- * Reference: agent/unify/memory/DESIGN-v2.md §2, §5, §9.
+ * Reference: agent/unify/memory/DESIGN-H2-AMS.md.
  */
 
 import {
@@ -228,8 +225,8 @@ export async function writeMemory(scope, content, opts = {}) {
 }
 
 /**
- * Append to a scope's memory.md. Used by the rare "direct write" path
- * (DESIGN-v2 §7.1); main flow is dream-driven rewrites.
+ * Append to a scope's memory.md. Used by the rare "direct write" path;
+ * main flow is dream-driven rewrites.
  *
  * Append is non-atomic with concurrent readers in the strict sense, but a
  * single appendFile of a small buffer is atomic at the kernel level on POSIX
@@ -316,7 +313,7 @@ export async function ensureScope(scope, opts = {}) {
 
 /**
  * Enumerate all scopes present on disk. Returns Scope shapes that round-trip
- * back through `scopeDir`. Used by Triage (DESIGN-v2 §14) to list candidate
+ * back through `scopeDir`. Used by Triage to list candidate
  * scopes for a group's diff.
  *
  * Walks shallowly:

package/unify/prompts.js

@@ -8,39 +8,13 @@
  * and used to enrich the system prompt beyond the hardcoded fallbacks.
  *
  * Phase 2 additions:
- *   - Memory section (user profile + recalled entries)
+ *   - Memory section (recalled segments via H2-AMS pre-flow)
  *   - Compact summary section (conversation history summary)
  *
- * task-287 refactor (tool-on-demand memory):
- *   - New `memoryInjection` param carries prebuilt "Memory Index + user
- *     preferences + project header" text (~1.5k tokens). Engine builds this
- *     via memory/layout.buildMemoryInjection() and passes it every turn.
- *   - Legacy `memory={profile,entries}` param still supported for callers
- *     (tests, CLI) that have not migrated.
- *
- * task-334e additions (R6 §Δ24.5 / §Δ27.3 / §Δ31.4 / §Δ29.3):
- *   - `taskCtx` param → renders a `## task_ctx` block with:
- *       * task-memory top-5 bodies with semantic shard prefix `[shard]`
- *         (no sourceRef — memory_trace opens the trail on demand)
- *       * `### related tasks` sub-section — `relatedTaskIds` top-3 (sorted
- *         by updatedAt desc) + per-task top-2 memory; ACL-gated by
- *         `target.members` ∋ currentVpId (§Δ31.4)
- *       * `### summary reminder` soft nudge — condition (§Δ27.3):
- *           non-summary msgs ≥ 3 AND since-lastSummary > 15min AND
- *           currentVpId == task.initiatorVpId → emits a DYNAMIC hint
- *   - `userProfile` param → renders a `## user_profile` block. Stub
- *     implementation: when not passed explicitly, we fall back to reading
- *     `~/.yeaft/user/profile.json` ({ "content": "…string…" }) if present
- *     (§Δ29.3 placeholder until 334l wires real user-memory recall).
- *   - `coreMemory` param → renders a `## core_memory` block with recall
- *     top-7 memory bodies (no sourceRef) and a trailing meta line pointing
- *     at `memory_trace` as the way to open the original message.
- *
- * Hard constraints (task-334e contract):
- *   - Does NOT modify engine.js turn loop.
- *   - Does NOT implement memory_trace / open_source_message (task-334f).
- *   - Does NOT implement task_summary_post (task-334n).
- *   - Changes limited to prompts.js + templates/.
+ * Memory injection (H2-AMS):
+ *   - `memoryInjection` carries prebuilt FTS-recall text from
+ *     `memory/preflow.js` over the relevant scopes (user/group/vp/feature/
+ *     global). Engine passes it every turn after preflow runs.
  *
  * Reference: yeaft-unify-system-prompt-budget.md — Static + Dynamic + Context layers
  */
@@ -368,27 +342,11 @@ export function buildSystemPrompt({
   }
 
   // ─── 6. Memory Section ─────────────────────────────────
+  // FTS5 pre-flow recall + AMS snapshot are concatenated upstream by the
+  // engine into a single `memoryInjection` block. The legacy entries-based
+  // memory.profile / memory.entries shape was retired in the H2-AMS rip.
   if (memoryInjection && memoryInjection.trim()) {
-    // New path (task-287): prebuilt injection from memory/layout.buildMemoryInjection()
-    // Contains index.md + user-preferences.md + optional project header excerpt.
     parts.push(memoryInjection.trim());
-  } else if (memory && (memory.profile || (memory.entries && memory.entries.length > 0))) {
-    // Legacy path — kept for callers (tests, CLI) that have not migrated yet.
-    const memoryParts = [lang.memoryHeader];
-
-    if (memory.profile) {
-      memoryParts.push(`${lang.profileHeader}\n${memory.profile}`);
-    }
-
-    if (memory.entries && memory.entries.length > 0) {
-      const entryLines = memory.entries.map(e => {
-        const tags = (e.tags && e.tags.length > 0) ? ` [${e.tags.join(', ')}]` : '';
-        return `- **${e.name}** (${e.kind}): ${e.content}${tags}`;
-      });
-      memoryParts.push(`${lang.recalledHeader}\n${entryLines.join('\n')}`);
-    }
-
-    parts.push(memoryParts.join('\n\n'));
   }
 
   // ─── 7. Compact Summary Section ────────────────────────