@yeaft/webchat-agent 0.1.661 → 0.1.663

package/unify/session.js

@@ -32,18 +32,23 @@ import { Engine } from './engine.js';
 // 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 previous per-scope
-// file reader recall-v2.js has been deleted). Post-turn AMS
-// correction (memory/adjust.js) is implemented but not yet wired —
-// requires session-level AMS instance + scope resolution. Tracked
-// as a follow-up.
+// file reader recall-v2.js has been deleted).
+//
+// 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.
 import { ensureDefaultGroupIfEmpty } from './groups/group-crud.js';
 import { seedDefaultVps } from './vp/seed-defaults.js';
 import { createV2DreamScheduler } from './dream-v2/session-wiring.js';
 import { openSegmentIndex } from './memory/index-db.js';
 import { syncAll as syncSegmentIndex } from './memory/segment-sync.js';
-import { migrateR6toV2 } from './memory/migrate-r6-to-v2.js';
+import { openAmsRegistry } from './memory/ams-registry.js';
 import { join } from 'path';
-import { existsSync as existsSyncSafe, readFileSync as readFileSyncSafe, writeFileSync as writeFileSyncSafe } from 'fs';
+import { existsSync as existsSyncSafe, readFileSync as readFileSyncSafe } from 'fs';
 
 /**
  * @typedef {Object} SessionOptions
@@ -140,53 +145,10 @@ export async function loadSession(options = {}) {
     }
   } catch { /* never let this warn path block session load */ }
 
-  // ─── 2.2 Auto-migrate R6 → v2 on first boot with memoryV2=on ──
-  //         If `memoryV2` is on AND a R6-shaped tree is on disk AND we
-  //         haven't already migrated, run the one-shot migration. The
-  //         migration is idempotent and concatenate-don't-synthesise, so
-  //         the worst case on re-run is "no R6 dirs found, exit clean".
-  //         Failure here MUST NOT block session boot — we log + continue;
-  //         dream will gradually backfill v2 from group diffs.
-  try {
-    if (config?.memoryV2 === true && !config?._readOnly) {
-      const memoryRoot = join(yeaftDir, 'memory');
-      const stateFile = join(yeaftDir, '.memory-v2-migration.json');
-      let alreadyMigrated = false;
-      if (existsSyncSafe(stateFile)) {
-        try {
-          const state = JSON.parse(readFileSyncSafe(stateFile, 'utf8') || '{}');
-          alreadyMigrated = Boolean(state && state.completedAt);
-        } catch { /* malformed state → re-run; migration is idempotent */ }
-      }
-      const hasR6 = existsSyncSafe(join(memoryRoot, 'groups'))
-                 || existsSyncSafe(join(memoryRoot, 'features'));
-      if (!alreadyMigrated && hasR6) {
-        console.log('[Yeaft] memoryV2 on + R6 layout detected — running one-shot migration…');
-        const result = await migrateR6toV2({ root: memoryRoot, apply: true });
-        try {
-          writeFileSyncSafe(stateFile, JSON.stringify({
-            completedAt: new Date().toISOString(),
-            migratedScopes: result.migratedScopes,
-            skippedScopes: result.skippedScopes,
-            errors: result.errors,
-            backedUpTo: result.backedUpTo,
-          }, null, 2));
-        } catch { /* state file write is best-effort */ }
-        console.log(`[Yeaft] memory v2 migration done — ${result.migratedScopes} scopes migrated, backup at ${result.backedUpTo}`);
-      } else if (!alreadyMigrated && !hasR6) {
-        // Fresh user, no R6 to migrate. Mark as done so we don't keep checking.
-        try {
-          writeFileSyncSafe(stateFile, JSON.stringify({
-            completedAt: new Date().toISOString(),
-            migratedScopes: 0,
-            note: 'no R6 layout present — fresh v2',
-          }, null, 2));
-        } catch { /* best-effort */ }
-      }
-    }
-  } catch (err) {
-    console.warn(`[Yeaft] memory v2 migration skipped due to error: ${err?.message || err}`);
-  }
+  // ─── 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
+  //         (state file in ~/.yeaft/.memory-v2-migration.json).
 
   // ─── 2a. Permission pre-check ─────────────────────────
   //         If the data dir is not writable, mark session as read-only.
@@ -250,6 +212,22 @@ export async function loadSession(options = {}) {
     }
   }
 
+  // ─── 5-ams. (GC.1 follow-up) Group-keyed AMS registry ────
+  //     The registry caches one ActiveMemorySet per groupId 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.
+  let amsRegistry = null;
+  if (memoryIndex && !config._readOnly) {
+    try {
+      amsRegistry = openAmsRegistry({ yeaftDir, memoryIndex, config });
+    } catch (err) {
+      console.warn(`[Yeaft] Failed to open AMS registry (adjust disabled): ${err?.message || err}`);
+      amsRegistry = null;
+    }
+  }
+
   // ─── 5a. Initialize feature store ──────────────────────
   initFeatureStore(yeaftDir, { readOnly: config._readOnly || false });
 
@@ -315,6 +293,7 @@ export async function loadSession(options = {}) {
     memoryStore,
     memoryShardStore,
     memoryIndex,
+    amsRegistry,
     toolRegistry,
     skillManager,
     mcpManager,
@@ -372,6 +351,11 @@ export async function loadSession(options = {}) {
     } catch {
       // Best-effort cleanup
     }
+    try {
+      if (amsRegistry) amsRegistry.persistAll();
+    } catch {
+      // Best-effort cleanup
+    }
   }
 
   return {
@@ -388,6 +372,7 @@ export async function loadSession(options = {}) {
     trace,
     yeaftDir,
     status,
+    amsRegistry,
     shutdown,
     // task-325c: user-initiated abort API. Delegates to web-bridge which
     // owns the single AbortController. Lazy-imported to avoid a hard cycle

package/unify/stop-hooks.js

@@ -4,14 +4,16 @@
  * Runs after each query loop completes:
  *   1. Persist messages to conversation/messages/
  *   2. Consolidate check (compact + extract) — only when budget exceeded
- *   3. Dream gate check (background)
- *   4. Increment dream query counter
+ *
+ * Dream V2 owns all background memory maintenance (scope summaries +
+ * memory writes via dream-v2/session-wiring.js → createV2DreamScheduler);
+ * the legacy `memory/dream.js` gate that used to fire here was retired
+ * alongside recall-r6.
  *
  * Reference: yeaft-unify-core-systems.md §4.4
  */
 
 import { shouldConsolidate, consolidate } from './memory/consolidate.js';
-import { checkDreamGate, incrementQueryCount, dream } from './memory/dream.js';
 import { isPermissionError } from './init.js';
 
 /** Track whether we've already warned about permission issues in stop hooks. */
@@ -59,7 +61,6 @@ export async function runStopHooks(context) {
   const result = {
     messagesPersisted: 0,
     consolidated: false,
-    dreamTriggered: false,
     errors: [],
   };
 
@@ -164,45 +165,9 @@ export async function runStopHooks(context) {
     }
   }
 
-  // 3. Increment dream query counter
-  try {
-    if (yeaftDir) {
-      incrementQueryCount(yeaftDir);
-    }
-  } catch (err) {
-    if (isPermissionError(err)) {
-      // Silent — already warned about permission issues
-    } else {
-      result.errors.push(`Dream counter failed: ${err.message}`);
-    }
-  }
-
-  // 4. Dream gate check (fire-and-forget, background)
-  try {
-    if (yeaftDir && memoryStore && adapter) {
-      const gate = checkDreamGate(yeaftDir);
-      if (gate.shouldDream) {
-        result.dreamTriggered = true;
-        // Fire and forget — dream runs in background
-        dream({
-          yeaftDir,
-          memoryStore,
-          conversationStore,
-          adapter,
-          config,
-        }).catch(err => {
-          trace?.logEvent({
-            eventType: 'dream_error',
-            eventData: { error: err.message },
-          });
-        });
-      }
-    }
-  } catch (err) {
-    if (!isPermissionError(err)) {
-      result.errors.push(`Dream gate check failed: ${err.message}`);
-    }
-  }
+  // 3. Dream V2 owns background scope-memory maintenance via the session
+  //    dream scheduler (createV2DreamScheduler). No legacy dream gate is
+  //    invoked here; the scheduler decides when to run on its own cadence.
 
   return result;
 }
@@ -211,6 +176,5 @@ export async function runStopHooks(context) {
  * @typedef {Object} StopHookResult
  * @property {number} messagesPersisted — how many messages were persisted
  * @property {boolean} consolidated — whether consolidation ran
- * @property {boolean} dreamTriggered — whether dream was triggered
  * @property {string[]} errors — any non-fatal errors
  */

package/unify/memory/dream-prompt.js

@@ -1,272 +0,0 @@
-/**
- * dream-prompt.js — Dream prompt templates for each phase
- *
- * Dream has 5 phases:
- *   Phase 1: Orient  — assess current memory state
- *   Phase 2: Gather  — collect recent context
- *   Phase 3: Merge   — combine duplicates, update outdated
- *   Phase 4: Prune   — remove stale/low-value entries
- *   Phase 5: Promote — extract patterns, update profile
- *
- * Reference: yeaft-unify-core-systems.md §3.3
- */
-
-/**
- * Build the Orient phase prompt (Phase 1).
- * The LLM assesses the current memory state and identifies issues.
- *
- * @param {{ memorySummary: string, profileContent: string, entryCount: number }} context
- * @returns {string}
- */
-export function buildOrientPrompt({ memorySummary, profileContent, entryCount }) {
-  return `You are in Dream Mode — Phase 1: Orient.
-
-Your task is to assess the current state of the memory store and identify what needs attention.
-
-## Current Memory State
-
-${memorySummary}
-
-## MEMORY.md (User Profile)
-
-${profileContent || '(empty)'}
-
-## Assessment Instructions
-
-Review the memory state and provide:
-1. **Redundancies**: Are there entries that overlap or say the same thing?
-2. **Outdated info**: Are there entries that might be stale or no longer relevant?
-3. **Gaps**: Is there important context missing from MEMORY.md?
-4. **Quality**: Are entries well-categorized (kind, scope, tags)?
-
-Return your assessment as JSON:
-{
-  "redundantGroups": [["entry-a", "entry-b"]],
-  "potentiallyStale": ["entry-name-1"],
-  "profileGaps": ["missing X context"],
-  "qualityIssues": ["entry-y has wrong kind"],
-  "overallHealth": "good" | "needs-attention" | "poor",
-  "suggestedActions": ["merge entries about X", "prune stale context entries"]
-}
-
-Return ONLY valid JSON, no other text.`;
-}
-
-/**
- * Build the Gather phase prompt (Phase 2).
- * Collects recent compact summaries and completed task summaries.
- *
- * @param {{ recentCompact: string, completedTasks: object[], orientResult: object }} context
- * @returns {string}
- */
-export function buildGatherPrompt({ recentCompact, completedTasks, orientResult }) {
-  const taskSummaries = completedTasks.length > 0
-    ? completedTasks.map(t => `- [${t.id}] ${t.description}: ${t.summary || '(no summary)'}`).join('\n')
-    : '(no recently completed tasks)';
-
-  return `You are in Dream Mode — Phase 2: Gather.
-
-Your task is to identify what new information should be incorporated into long-term memory.
-
-## Recent Conversation Summary (compact.md)
-
-${recentCompact || '(no recent summaries)'}
-
-## Recently Completed Tasks
-
-${taskSummaries}
-
-## Orient Assessment
-
-${JSON.stringify(orientResult, null, 2)}
-
-## Instructions
-
-From the recent conversations and tasks, identify:
-1. **New facts** worth remembering (project structure, tech decisions)
-2. **New preferences** expressed by the user
-3. **New skills/lessons** learned during tasks
-4. **Context updates** (project progress, status changes)
-
-Return as JSON:
-{
-  "newEntries": [
-    { "name": "slug-name", "kind": "fact|preference|skill|lesson|context|relation", "scope": "path", "tags": ["tag1", "tag2"], "importance": "high|normal|low", "content": "description" }
-  ],
-  "updatesToExisting": [
-    { "entryName": "existing-slug", "updates": { "content": "updated text", "tags": ["new-tag"] } }
-  ]
-}
-
-Return ONLY valid JSON, no other text.`;
-}
-
-/**
- * Build the Merge phase prompt (Phase 3).
- *
- * @param {{ duplicateGroups: object[][], gatherResult: object }} context
- * @returns {string}
- */
-export function buildMergePrompt({ duplicateGroups, gatherResult }) {
-  const groupDescriptions = duplicateGroups.map((group, i) => {
-    const entries = group.map(e =>
-      `  - [${e.name}] kind=${e.kind}, scope=${e.scope}, tags=[${(e.tags || []).join(', ')}]\n    ${(e.content || '').slice(0, 200)}`
-    ).join('\n');
-    return `Group ${i + 1}:\n${entries}`;
-  }).join('\n\n');
-
-  return `You are in Dream Mode — Phase 3: Merge.
-
-Your task is to merge duplicate/overlapping entries into single, richer entries.
-
-## Potentially Duplicate Groups
-
-${groupDescriptions || '(no duplicates detected)'}
-
-## New Entries from Gather Phase
-
-${JSON.stringify(gatherResult?.newEntries || [], null, 2)}
-
-## Instructions
-
-For each duplicate group:
-1. Decide if they should be merged (combine info) or kept separate (different enough)
-2. For merges, create a single entry that preserves all important info from both
-3. List which old entries should be deleted after merge
-
-Also process the new entries from Gather — check if any overlap with existing entries.
-
-Return as JSON:
-{
-  "merges": [
-    {
-      "merged": { "name": "new-slug", "kind": "...", "scope": "...", "tags": [], "importance": "...", "content": "..." },
-      "deleteOriginals": ["old-entry-1", "old-entry-2"]
-    }
-  ],
-  "newEntries": [
-    { "name": "...", "kind": "...", "scope": "...", "tags": [], "importance": "...", "content": "..." }
-  ],
-  "updates": [
-    { "entryName": "existing-slug", "updates": { "content": "updated text" } }
-  ]
-}
-
-Return ONLY valid JSON, no other text.`;
-}
-
-/**
- * Build the Prune phase prompt (Phase 4).
- *
- * @param {{ staleEntries: object[], entryCount: number, maxEntries: number }} context
- * @returns {string}
- */
-export function buildPrunePrompt({ staleEntries, entryCount, maxEntries }) {
-  const staleDescriptions = staleEntries.map(e =>
-    `- [${e.name}] kind=${e.kind}, scope=${e.scope}, freq=${e.frequency || 1}, days_since_update=${e._daysSinceUpdate}\n  ${(e.content || '').slice(0, 150)}`
-  ).join('\n');
-
-  return `You are in Dream Mode — Phase 4: Prune.
-
-Your task is to remove stale, low-value, or redundant entries.
-
-## Potentially Stale Entries (${staleEntries.length} found)
-
-${staleDescriptions || '(none detected)'}
-
-## Capacity
-
-Current entries: ${entryCount}
-Maximum allowed: ${maxEntries}
-${entryCount > maxEntries ? `⚠️ OVER CAPACITY by ${entryCount - maxEntries} entries — must prune aggressively` : 'Within capacity'}
-
-## Prune Guidelines
-
-Delete entries that are:
-- **Outdated context**: Project status from weeks ago
-- **Never recalled**: frequency=1 and old — nobody needs it
-- **Too vague**: "user mentioned something about X" without useful detail
-- **Redundant with profile**: If MEMORY.md already captures it
-- **Re-derivable**: Info that can be obtained by running a command (e.g., "Node version is 20")
-
-KEEP entries that are:
-- High importance or high frequency
-- Recent preferences or lessons
-- Facts about project structure (hard to re-discover)
-
-Return as JSON:
-{
-  "toDelete": ["entry-name-1", "entry-name-2"],
-  "reasoning": {
-    "entry-name-1": "outdated context from 45 days ago",
-    "entry-name-2": "never recalled, too vague"
-  }
-}
-
-Return ONLY valid JSON, no other text.`;
-}
-
-/**
- * Build the Promote phase prompt (Phase 5).
- *
- * @param {{ entries: object[], profileContent: string, scopesSummary: string }} context
- * @returns {string}
- */
-export function buildPromotePrompt({ entries, profileContent, scopesSummary }) {
-  // Find entries that might form patterns
-  const highFreq = entries
-    .filter(e => (e.frequency || 1) >= 3)
-    .map(e => `- [${e.name}] kind=${e.kind}, freq=${e.frequency}, scope=${e.scope}: ${(e.content || '').slice(0, 150)}`)
-    .join('\n');
-
-  const lessons = entries
-    .filter(e => e.kind === 'lesson')
-    .map(e => `- [${e.name}] scope=${e.scope}: ${(e.content || '').slice(0, 150)}`)
-    .join('\n');
-
-  return `You are in Dream Mode — Phase 5: Promote.
-
-Your task is to identify patterns and update the user profile.
-
-## High-Frequency Entries (recalled ≥3 times)
-
-${highFreq || '(none)'}
-
-## All Lessons
-
-${lessons || '(none)'}
-
-## Current MEMORY.md Profile
-
-${profileContent || '(empty)'}
-
-## Scopes
-
-${scopesSummary}
-
-## Instructions
-
-1. **Pattern promotion**: If multiple entries share a pattern, create a higher-level insight
-   - Example: 3 entries about "user corrects indentation" → 1 preference: "default to 2-space indent"
-2. **Profile update**: Update MEMORY.md sections based on accumulated knowledge
-   - Keep MEMORY.md under 200 lines
-   - Sections: Facts, Preferences, Project Context, Skills, Lessons
-3. **Scope promotion**: If a lesson applies across projects, promote scope to parent or global
-
-Return as JSON:
-{
-  "profileUpdates": {
-    "Facts": ["- New fact line 1"],
-    "Preferences": ["- New preference line"],
-    "Project Context": [],
-    "Skills": [],
-    "Lessons": []
-  },
-  "promotedEntries": [
-    { "name": "...", "kind": "...", "scope": "global", "tags": [], "importance": "high", "content": "..." }
-  ],
-  "entriesToDelete": ["entry-that-was-promoted-to-profile"]
-}
-
-Return ONLY valid JSON, no other text.`;
-}