@yeaft/webchat-agent 0.1.662 → 0.1.664

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.662",
+  "version": "0.1.664",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/unify/cli.js

@@ -619,11 +619,6 @@ async function runREPL(config, args) {
               process.stderr.write(`[compact] Memory consolidated\n`);
             }
             break;
-          case 'dream_triggered':
-            if (session.config.debug) {
-              process.stderr.write(`[dream] Dream cycle triggered (background)\n`);
-            }
-            break;
           case 'fallback':
             process.stderr.write(`\n[fallback] ${event.from} → ${event.to}: ${event.reason}\n`);
             break;
@@ -717,11 +712,6 @@ async function runOnce(config, args) {
             process.stderr.write(`[consolidate] archived=${event.archivedCount}, extracted=${event.extractedCount}\n`);
           }
           break;
-        case 'dream_triggered':
-          if (args.verbose || args.debug) {
-            process.stderr.write(`[dream] Dream cycle triggered (background)\n`);
-          }
-          break;
         case 'fallback':
           process.stderr.write(`\n[fallback] ${event.from} → ${event.to}: ${event.reason}\n`);
           break;

package/unify/engine.js

@@ -416,6 +416,15 @@ export class Engine {
     const ownVpId = args.ownVpId || null;
     const ams = this.#amsRegistry.getOrCreate(groupKey, { ownVpId });
 
+    // Prime #adjustRanByGroup from disk-hydrated state on first access:
+    // a reactivated group resumes with whatever adjustRanThisSession bit
+    // it had on disconnect, so we don't burn a fresh adjust on every
+    // reload. Once set true in this session we never clear it.
+    if (!this.#adjustRanByGroup.has(groupKey)
+        && this.#amsRegistry.adjustRanThisSession(groupKey)) {
+      this.#adjustRanByGroup.set(groupKey, true);
+    }
+
     // (a) Resident: rebuild from the same scope summaries the worker
     // prompt is already going to see.
     const residentEntries = [];
@@ -1456,9 +1465,6 @@ export class Engine {
           if (hookResult.consolidated) {
             yield { type: 'consolidate', archivedCount: 0, extractedCount: 0 };
           }
-          if (hookResult.dreamTriggered) {
-            yield { type: 'dream_triggered' };
-          }
         } else {
           // Legacy path (no yeaftDir → use old behavior)
           this.#persistMessages(prompt, fullResponseText, assistantMsg.toolCalls, groupId);

package/unify/index.js

@@ -26,7 +26,6 @@ export { MemoryStore, parseEntry, serializeEntry, MEMORY_KINDS } from './memory/
 
 // Phase 5: Advanced features
 export { KINDS, KIND_PRIORITY, KIND_DESCRIPTIONS, IMPORTANCE_LEVELS, validateEntry, parseScopePath, getAncestorScopes, areScopesRelated } from './memory/types.js';
-export { scanEntries, scoreEntry, findStaleEntries, findDuplicateGroups, summarizeScan } from './memory/scan.js';
 export { runStopHooks } from './stop-hooks.js';
 export { MCPManager, createMCPManager } from './mcp.js';
 export { SkillManager, createSkillManager, parseSkill, serializeSkill } from './skills.js';

package/unify/init.js

@@ -79,7 +79,6 @@ const SUBDIRS = [
   'conversation/blobs',
   'memory/entries',
   'tasks',
-  'dream',
   'skills',
 ];
 

package/unify/memory/ams-registry.js

@@ -48,6 +48,7 @@ export const DEFAULT_GROUP_KEY = 'default';
  * @typedef {object} AmsCacheEntry
  * @property {ActiveMemorySet} ams
  * @property {string|null}     ownVpId
+ * @property {boolean}         adjustRanThisSession
  */
 
 /**
@@ -77,12 +78,16 @@ export class AmsRegistry {
   /**
    * Resolve the on-disk path for a group's ams.json.
    *
+   * `groupId` is trusted: `nextGroupId()` (groups/ids.js) emits ids matching
+   * `grp_[a-z0-9_-]+`, and the single-VP path uses the literal
+   * `DEFAULT_GROUP_KEY`. No defensive escaping is needed.
+   *
    * @param {string} groupId
    * @returns {string}
    */
   amsPath(groupId) {
-    const safe = String(groupId || DEFAULT_GROUP_KEY).replace(/[^A-Za-z0-9._-]/g, '_');
-    return join(this.yeaftDir, 'memory', 'groups', safe, 'ams.json');
+    const key = String(groupId || DEFAULT_GROUP_KEY);
+    return join(this.yeaftDir, 'memory', 'groups', key, 'ams.json');
   }
 
   /**
@@ -114,12 +119,40 @@ export class AmsRegistry {
     const ownVpId = opts.ownVpId || null;
     const budget = this._budget();
     const ams = new ActiveMemorySet({ ownVpId, budget });
-    // Best-effort hydrate from disk.
-    this._hydrate(key, ams);
-    this._cache.set(key, { ams, ownVpId });
+    const entry = { ams, ownVpId, adjustRanThisSession: false };
+    // Best-effort hydrate from disk — populates ams + entry flags.
+    this._hydrate(key, entry);
+    this._cache.set(key, entry);
     return ams;
   }
 
+  /**
+   * Read the persisted-and-rehydrated `adjustRanThisSession` flag for a
+   * group. Engine consults this on first AMS access so a reactivated group
+   * doesn't re-run `runAdjust` on its first turn back online.
+   *
+   * @param {string|null|undefined} groupId
+   * @returns {boolean}
+   */
+  adjustRanThisSession(groupId) {
+    const key = groupId || DEFAULT_GROUP_KEY;
+    return this._cache.get(key)?.adjustRanThisSession === true;
+  }
+
+  /**
+   * Update the cached `adjustRanThisSession` flag (does not persist on its
+   * own — call `persist()` to flush). Engine flips this true after
+   * `runAdjust` actually ran.
+   *
+   * @param {string|null|undefined} groupId
+   * @param {boolean} value
+   */
+  setAdjustRanThisSession(groupId, value) {
+    const key = groupId || DEFAULT_GROUP_KEY;
+    const entry = this._cache.get(key);
+    if (entry) entry.adjustRanThisSession = Boolean(value);
+  }
+
   /**
    * Mark a group's AMS as dirty so the next persist() actually writes.
    * The engine calls this after `runAdjust` mutates membership.
@@ -134,6 +167,10 @@ export class AmsRegistry {
    * Persist a single group's AMS to disk. No-op when the cached entry
    * is missing or hasn't been marked dirty.
    *
+   * `opts.adjustRanThisSession`, when supplied, also updates the cached
+   * entry so subsequent `adjustRanThisSession()` reads see the latest flag
+   * without a round-trip through disk.
+   *
    * @param {string|null|undefined} groupId
    * @param {{ force?: boolean, adjustRanThisSession?: boolean }} [opts]
    * @returns {boolean} true if the file was written
@@ -144,13 +181,17 @@ export class AmsRegistry {
     if (!entry) return false;
     if (!opts.force && !this._dirty.has(key)) return false;
 
+    if (typeof opts.adjustRanThisSession === 'boolean') {
+      entry.adjustRanThisSession = opts.adjustRanThisSession;
+    }
+
     const path = this.amsPath(key);
     const payload = {
       version: AMS_FILE_VERSION,
       ownVpId: entry.ownVpId,
       onDemandIds: entry.ams.onDemandIds(),
       recentIds: entry.ams.recentIds(),
-      adjustRanThisSession: Boolean(opts.adjustRanThisSession),
+      adjustRanThisSession: Boolean(entry.adjustRanThisSession),
       savedAt: new Date().toISOString(),
     };
 
@@ -182,15 +223,16 @@ export class AmsRegistry {
 
   /**
    * Best-effort hydrate: read ams.json, re-resolve segment ids via the
-   * SegmentIndex (skipping ids that no longer exist), populate AMS.
+   * SegmentIndex (skipping ids that no longer exist), populate AMS, and
+   * restore the persisted `adjustRanThisSession` flag onto the cache entry.
    * Silent on every error — a corrupt or missing file is the cold-start
    * case, indistinguishable from "first use of this group".
    *
    * @private
    * @param {string} key
-   * @param {ActiveMemorySet} ams
+   * @param {AmsCacheEntry} entry
    */
-  _hydrate(key, ams) {
+  _hydrate(key, entry) {
     const path = this.amsPath(key);
     if (!existsSync(path)) return;
     let payload;
@@ -198,6 +240,10 @@ export class AmsRegistry {
     catch { return; }
     if (!payload || typeof payload !== 'object') return;
 
+    if (payload.adjustRanThisSession === true) {
+      entry.adjustRanThisSession = true;
+    }
+
     if (!this.memoryIndex) return;
 
     const onDemandIds = Array.isArray(payload.onDemandIds) ? payload.onDemandIds : [];
@@ -210,12 +256,12 @@ export class AmsRegistry {
         if (seg) onDemandSegs.push(seg);
       } catch { /* skip unresolvable */ }
     }
-    if (onDemandSegs.length > 0) ams.setOnDemand(onDemandSegs);
+    if (onDemandSegs.length > 0) entry.ams.setOnDemand(onDemandSegs);
 
     for (const id of recentIds) {
       try {
         const seg = this.memoryIndex.get(id);
-        if (seg) ams.touchRecent(seg);
+        if (seg) entry.ams.touchRecent(seg);
       } catch { /* skip */ }
     }
   }

package/unify/session.js

@@ -47,9 +47,8 @@ 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 { openAmsRegistry } from './memory/ams-registry.js';
-import { migrateR6toV2 } from './memory/migrate-r6-to-v2.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
@@ -146,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.

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.`;
-}