@cortexkit/opencode-magic-context 0.5.2 → 0.6.0

package/dist/index.js

@@ -8323,10 +8323,10 @@ var require_stringify = __commonJS((exports, module) => {
     replacer = null;
     indent = EMPTY;
   };
-  var join12 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one, gap)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
+  var join13 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one, gap)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
   var join_content = (inside, value, gap) => {
     const comment = process_comments(value, PREFIX_BEFORE, gap + indent, true);
-    return join12(comment, inside, gap);
+    return join13(comment, inside, gap);
   };
   var stringify_string = (holder, key, value) => {
     const raw = get_raw_string_literal(holder, key);
@@ -8348,13 +8348,13 @@ var require_stringify = __commonJS((exports, module) => {
       if (i !== 0) {
         inside += COMMA;
       }
-      const before = join12(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
+      const before = join13(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += stringify(i, value, deeper_gap) || STR_NULL;
       inside += process_comments(value, AFTER_VALUE(i), deeper_gap);
       after_comma = process_comments(value, AFTER(i), deeper_gap);
     }
-    inside += join12(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join13(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return BRACKET_OPEN + join_content(inside, value, gap) + BRACKET_CLOSE;
   };
   var object_stringify = (value, gap) => {
@@ -8375,13 +8375,13 @@ var require_stringify = __commonJS((exports, module) => {
         inside += COMMA;
       }
       first = false;
-      const before = join12(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
+      const before = join13(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += quote(key) + process_comments(value, AFTER_PROP(key), deeper_gap) + COLON + process_comments(value, AFTER_COLON(key), deeper_gap) + SPACE + sv + process_comments(value, AFTER_VALUE(key), deeper_gap);
       after_comma = process_comments(value, AFTER(key), deeper_gap);
     };
     keys.forEach(iteratee);
-    inside += join12(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join13(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return CURLY_BRACKET_OPEN + join_content(inside, value, gap) + CURLY_BRACKET_CLOSE;
   };
   function stringify(key, holder, gap) {
@@ -8479,11 +8479,11 @@ __export(exports_tui_config, {
   ensureTuiPluginEntry: () => ensureTuiPluginEntry
 });
 import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
-import { dirname, join as join12 } from "path";
+import { dirname, join as join13 } from "path";
 function resolveTuiConfigPath() {
   const configDir = getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
-  const jsoncPath = join12(configDir, "tui.jsonc");
-  const jsonPath = join12(configDir, "tui.json");
+  const jsoncPath = join13(configDir, "tui.jsonc");
+  const jsonPath = join13(configDir, "tui.json");
   if (existsSync6(jsoncPath))
     return jsoncPath;
   if (existsSync6(jsonPath))
@@ -22197,6 +22197,16 @@ var MagicContextConfigSchema = exports_external.object({
     provider: "local",
     model: DEFAULT_LOCAL_EMBEDDING_MODEL
   }),
+  experimental: exports_external.object({
+    compaction_markers: exports_external.boolean().default(false),
+    user_memories: exports_external.object({
+      enabled: exports_external.boolean().default(false),
+      promotion_threshold: exports_external.number().min(2).max(20).default(3)
+    }).default({ enabled: false, promotion_threshold: 3 })
+  }).default({
+    compaction_markers: false,
+    user_memories: { enabled: false, promotion_threshold: 3 }
+  }),
   memory: exports_external.object({
     enabled: exports_external.boolean().default(true),
     injection_budget_tokens: exports_external.number().min(500).max(20000).default(4000),
@@ -23262,6 +23272,22 @@ More summary text.
 </output>
 
 Omit empty fact categories. Compartments must be ordered, contiguous for the ranges they cover, and non-overlapping.`;
+var USER_OBSERVATIONS_APPENDIX = `
+
+User observation rules (EXPERIMENTAL):
+- After outputting compartments and facts, also output a <user_observations> section.
+- User observations capture UNIVERSAL behavioral patterns about the human user \u2014 not project-specific or technical.
+- Good observations: communication preferences, review focus areas, expertise level, decision-making patterns, frustration triggers, working style.
+- Bad observations (DO NOT emit): project-specific preferences, framework choices, coding language preferences, one-off moods, task-local frustration.
+- Each observation must be a single concise sentence in present tense.
+- Only emit observations you have strong evidence for from the conversation. Do not speculate.
+- Emit 0-5 observations per run. Zero is fine if nothing stands out.
+- The output shape inside <output> gains an additional section:
+<user_observations>
+* User prefers terse communication and dislikes verbose explanations.
+* User is technically deep \u2014 understands cache invalidation, SQLite internals, and prompt engineering.
+</user_observations>
+If no observations, omit the <user_observations> section entirely.`;
 function buildCompressorPrompt(compartments, currentTokens, targetTokens, averageDepth = 0) {
   const lines = [];
   lines.push(`These ${compartments.length} compartments use approximately ${currentTokens} tokens. Compress them to approximately ${targetTokens} tokens.`);
@@ -23290,7 +23316,7 @@ function buildCompressorPrompt(compartments, currentTokens, targetTokens, averag
   return lines.join(`
 `);
 }
-function buildCompartmentAgentPrompt(existingState, inputSource) {
+function buildCompartmentAgentPrompt(existingState, inputSource, options) {
   return [
     "Existing state (read-only context for continuity and fact normalization \u2014 do NOT re-emit these compartments):",
     existingState,
@@ -23305,7 +23331,10 @@ function buildCompartmentAgentPrompt(existingState, inputSource) {
     "- Rewrite every fact into terse, present-tense operational form. Merge semantic duplicates within each category.",
     "- Drop any session fact already covered by a project memory in the existing state.",
     "- Do not preserve prior narrative wording verbatim; if a fact is already canonical and still correct, keep or lightly normalize it.",
-    "- Drop obsolete or task-local facts."
+    "- Drop obsolete or task-local facts.",
+    ...options?.userMemoriesEnabled ? [
+      "- Also emit <user_observations> with universal behavioral observations about the user (see system prompt for rules)."
+    ] : []
   ].join(`
 `);
 }
@@ -23955,40 +23984,96 @@ function getMemoryCountsByStatus(db, projectPath) {
   return counts;
 }
 
-// src/features/magic-context/storage-smart-notes.ts
-function isSmartNoteRow(row) {
+// src/features/magic-context/storage-notes.ts
+var NOTE_TYPES = new Set(["session", "smart"]);
+var NOTE_STATUSES = new Set(["active", "pending", "ready", "dismissed"]);
+var DEFAULT_SMART_STATUSES = ["pending", "ready"];
+function toNullableString(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function toNullableNumber(value) {
+  return typeof value === "number" ? value : null;
+}
+function isNoteRow(row) {
   if (row === null || typeof row !== "object")
     return false;
-  const r = row;
-  return typeof r.id === "number" && typeof r.project_path === "string" && typeof r.content === "string" && typeof r.surface_condition === "string" && typeof r.status === "string" && typeof r.created_at === "number" && typeof r.updated_at === "number";
+  const candidate = row;
+  return typeof candidate.id === "number" && typeof candidate.type === "string" && NOTE_TYPES.has(candidate.type) && typeof candidate.status === "string" && NOTE_STATUSES.has(candidate.status) && typeof candidate.content === "string" && (candidate.session_id === null || typeof candidate.session_id === "string") && (candidate.project_path === null || typeof candidate.project_path === "string") && (candidate.surface_condition === null || typeof candidate.surface_condition === "string") && typeof candidate.created_at === "number" && typeof candidate.updated_at === "number" && (candidate.last_checked_at === null || typeof candidate.last_checked_at === "number") && (candidate.ready_at === null || typeof candidate.ready_at === "number") && (candidate.ready_reason === null || typeof candidate.ready_reason === "string");
 }
-function toSmartNote(row) {
+function toNote(row) {
   return {
     id: row.id,
-    projectPath: row.project_path,
-    content: row.content,
-    surfaceCondition: row.surface_condition,
+    type: row.type,
     status: row.status,
-    createdSessionId: row.created_session_id && row.created_session_id.length > 0 ? row.created_session_id : null,
+    content: row.content,
+    sessionId: toNullableString(row.session_id),
+    projectPath: toNullableString(row.project_path),
+    surfaceCondition: toNullableString(row.surface_condition),
     createdAt: row.created_at,
     updatedAt: row.updated_at,
-    lastCheckedAt: row.last_checked_at,
-    readyAt: row.ready_at,
-    readyReason: row.ready_reason && row.ready_reason.length > 0 ? row.ready_reason : null
+    lastCheckedAt: toNullableNumber(row.last_checked_at),
+    readyAt: toNullableNumber(row.ready_at),
+    readyReason: toNullableString(row.ready_reason)
   };
 }
-function addSmartNote(db, projectPath, content, surfaceCondition, sessionId) {
+function getNoteById(db, noteId) {
+  const row = db.prepare("SELECT * FROM notes WHERE id = ?").get(noteId);
+  return isNoteRow(row) ? toNote(row) : null;
+}
+function buildStatusClause(status) {
+  if (status === undefined) {
+    return null;
+  }
+  const statuses = Array.isArray(status) ? status : [status];
+  if (statuses.length === 0) {
+    return null;
+  }
+  const placeholders = statuses.map(() => "?").join(", ");
+  return {
+    sql: `status IN (${placeholders})`,
+    params: statuses
+  };
+}
+function getNotes(db, options = {}) {
+  const clauses = [];
+  const params = [];
+  if (options.sessionId !== undefined) {
+    clauses.push("session_id = ?");
+    params.push(options.sessionId);
+  }
+  if (options.projectPath !== undefined) {
+    clauses.push("project_path = ?");
+    params.push(options.projectPath);
+  }
+  if (options.type !== undefined) {
+    clauses.push("type = ?");
+    params.push(options.type);
+  }
+  const statusClause = buildStatusClause(options.status);
+  if (statusClause) {
+    clauses.push(statusClause.sql);
+    params.push(...statusClause.params);
+  }
+  const where = clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "";
+  return db.prepare(`SELECT * FROM notes${where} ORDER BY created_at ASC, id ASC`).all(...params).filter(isNoteRow).map(toNote);
+}
+function addNote(db, type, options) {
   const now = Date.now();
-  const result = db.prepare("INSERT INTO smart_notes (project_path, content, surface_condition, status, created_session_id, created_at, updated_at) VALUES (?, ?, ?, 'pending', ?, ?, ?) RETURNING *").get(projectPath, content, surfaceCondition, sessionId ?? null, now, now);
-  if (!isSmartNoteRow(result)) {
-    throw new Error("[smart-notes] failed to insert smart note");
+  const result = type === "session" ? db.prepare("INSERT INTO notes (type, status, content, session_id, created_at, updated_at) VALUES ('session', 'active', ?, ?, ?, ?) RETURNING *").get(options.content, options.sessionId, now, now) : db.prepare("INSERT INTO notes (type, status, content, session_id, project_path, surface_condition, created_at, updated_at) VALUES ('smart', 'pending', ?, ?, ?, ?, ?, ?) RETURNING *").get(options.content, options.sessionId ?? null, options.projectPath, options.surfaceCondition, now, now);
+  if (!isNoteRow(result)) {
+    throw new Error("[notes] failed to insert note");
   }
-  return toSmartNote(result);
+  return toNote(result);
+}
+function getSessionNotes(db, sessionId) {
+  return getNotes(db, { sessionId, type: "session", status: "active" });
 }
 function getSmartNotes(db, projectPath, status) {
-  const query = status ? "SELECT * FROM smart_notes WHERE project_path = ? AND status = ? ORDER BY created_at ASC" : "SELECT * FROM smart_notes WHERE project_path = ? AND status != 'dismissed' ORDER BY created_at ASC";
-  const params = status ? [projectPath, status] : [projectPath];
-  return db.prepare(query).all(...params).filter(isSmartNoteRow).map(toSmartNote);
+  return getNotes(db, {
+    projectPath,
+    type: "smart",
+    status: status ?? DEFAULT_SMART_STATUSES
+  });
 }
 function getPendingSmartNotes(db, projectPath) {
   return getSmartNotes(db, projectPath, "pending");
@@ -23996,17 +24081,294 @@ function getPendingSmartNotes(db, projectPath) {
 function getReadySmartNotes(db, projectPath) {
   return getSmartNotes(db, projectPath, "ready");
 }
-function markSmartNoteReady(db, noteId, readyReason) {
+function updateNote(db, noteId, updates) {
+  const existing = getNoteById(db, noteId);
+  if (!existing) {
+    return null;
+  }
+  const now = Date.now();
+  const sets = ["updated_at = ?"];
+  const params = [now];
+  if (updates.content !== undefined) {
+    sets.push("content = ?");
+    params.push(updates.content);
+  }
+  if (updates.sessionId !== undefined) {
+    sets.push("session_id = ?");
+    params.push(updates.sessionId);
+  }
+  if (updates.status !== undefined) {
+    sets.push("status = ?");
+    params.push(updates.status);
+  }
+  if (existing.type === "smart") {
+    if (updates.projectPath !== undefined) {
+      sets.push("project_path = ?");
+      params.push(updates.projectPath);
+    }
+    if (updates.surfaceCondition !== undefined) {
+      sets.push("surface_condition = ?");
+      params.push(updates.surfaceCondition);
+    }
+    if (updates.lastCheckedAt !== undefined) {
+      sets.push("last_checked_at = ?");
+      params.push(updates.lastCheckedAt);
+    }
+    if (updates.readyAt !== undefined) {
+      sets.push("ready_at = ?");
+      params.push(updates.readyAt);
+    }
+    if (updates.readyReason !== undefined) {
+      sets.push("ready_reason = ?");
+      params.push(updates.readyReason);
+    }
+  }
+  if (sets.length === 1) {
+    return null;
+  }
+  params.push(noteId);
+  const result = db.prepare(`UPDATE notes SET ${sets.join(", ")} WHERE id = ? RETURNING *`).get(...params);
+  return isNoteRow(result) ? toNote(result) : null;
+}
+function dismissNote(db, noteId) {
+  const result = db.prepare("UPDATE notes SET status = 'dismissed', updated_at = ? WHERE id = ? AND status != 'dismissed'").run(Date.now(), noteId);
+  return result.changes > 0;
+}
+function markNoteReady(db, noteId, reason) {
   const now = Date.now();
-  db.prepare("UPDATE smart_notes SET status = 'ready', ready_at = ?, ready_reason = ?, updated_at = ?, last_checked_at = ? WHERE id = ?").run(now, readyReason ?? null, now, now, noteId);
+  db.prepare("UPDATE notes SET status = 'ready', ready_at = ?, ready_reason = ?, updated_at = ?, last_checked_at = ? WHERE id = ? AND type = 'smart'").run(now, reason ?? null, now, now, noteId);
 }
-function markSmartNoteChecked(db, noteId) {
+function markNoteChecked(db, noteId) {
   const now = Date.now();
-  db.prepare("UPDATE smart_notes SET last_checked_at = ?, updated_at = ? WHERE id = ?").run(now, now, noteId);
+  db.prepare("UPDATE notes SET last_checked_at = ?, updated_at = ? WHERE id = ? AND type = 'smart'").run(now, now, noteId);
 }
-function dismissSmartNote(db, noteId) {
-  const result = db.prepare("UPDATE smart_notes SET status = 'dismissed', updated_at = ? WHERE id = ?").run(Date.now(), noteId);
-  return result.changes > 0;
+
+// src/features/magic-context/user-memory/review-user-memories.ts
+init_logger();
+
+// src/features/magic-context/user-memory/storage-user-memory.ts
+function insertUserMemoryCandidates(db, candidates) {
+  if (candidates.length === 0)
+    return;
+  const now = Date.now();
+  const stmt = db.prepare("INSERT INTO user_memory_candidates (content, session_id, source_compartment_start, source_compartment_end, created_at) VALUES (?, ?, ?, ?, ?)");
+  db.transaction(() => {
+    for (const c of candidates) {
+      stmt.run(c.content, c.sessionId, c.sourceCompartmentStart ?? null, c.sourceCompartmentEnd ?? null, now);
+    }
+  })();
+}
+function getUserMemoryCandidates(db) {
+  const rows = db.prepare("SELECT id, content, session_id, source_compartment_start, source_compartment_end, created_at FROM user_memory_candidates ORDER BY created_at ASC").all();
+  return rows.map((r) => ({
+    id: r.id,
+    content: r.content,
+    sessionId: r.session_id,
+    sourceCompartmentStart: r.source_compartment_start,
+    sourceCompartmentEnd: r.source_compartment_end,
+    createdAt: r.created_at
+  }));
+}
+function deleteUserMemoryCandidates(db, ids) {
+  if (ids.length === 0)
+    return;
+  const placeholders = ids.map(() => "?").join(",");
+  db.prepare(`DELETE FROM user_memory_candidates WHERE id IN (${placeholders})`).run(...ids);
+}
+function insertUserMemory(db, content, sourceCandidateIds) {
+  const now = Date.now();
+  const result = db.prepare("INSERT INTO user_memories (content, status, promoted_at, source_candidate_ids, created_at, updated_at) VALUES (?, 'active', ?, ?, ?, ?)").run(content, now, JSON.stringify(sourceCandidateIds), now, now);
+  return Number(result.lastInsertRowid);
+}
+function getActiveUserMemories(db) {
+  const rows = db.prepare("SELECT id, content, status, promoted_at, source_candidate_ids, created_at, updated_at FROM user_memories WHERE status = 'active' ORDER BY promoted_at ASC").all();
+  return rows.map(parseUserMemoryRow);
+}
+function updateUserMemoryContent(db, id, content) {
+  db.prepare("UPDATE user_memories SET content = ?, updated_at = ? WHERE id = ?").run(content, Date.now(), id);
+}
+function dismissUserMemory(db, id) {
+  db.prepare("UPDATE user_memories SET status = 'dismissed', updated_at = ? WHERE id = ?").run(Date.now(), id);
+}
+function parseUserMemoryRow(row) {
+  let candidateIds = [];
+  try {
+    candidateIds = JSON.parse(row.source_candidate_ids);
+  } catch {}
+  return {
+    id: row.id,
+    content: row.content,
+    status: row.status === "dismissed" ? "dismissed" : "active",
+    promotedAt: row.promoted_at,
+    sourceCandidateIds: candidateIds,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+
+// src/features/magic-context/user-memory/review-user-memories.ts
+async function reviewUserMemories(args) {
+  const result = { promoted: 0, merged: 0, dismissed: 0, candidatesConsumed: 0 };
+  const candidates = getUserMemoryCandidates(args.db);
+  if (candidates.length < args.promotionThreshold) {
+    log(`[dreamer] user-memories: ${candidates.length} candidate(s), need ${args.promotionThreshold} \u2014 skipping`);
+    return result;
+  }
+  const stableMemories = getActiveUserMemories(args.db);
+  log(`[dreamer] user-memories: reviewing ${candidates.length} candidate(s) against ${stableMemories.length} stable memorie(s)`);
+  const candidateList = candidates.map((c) => `- Candidate #${c.id} [session ${c.sessionId.slice(0, 12)}]: "${c.content}"`).join(`
+`);
+  const stableList = stableMemories.length > 0 ? stableMemories.map((m) => `- Memory #${m.id}: "${m.content}"`).join(`
+`) : "(none)";
+  const prompt = `## Task: Review User Memory Candidates
+
+You are reviewing behavioral observations about a human user to decide which patterns are real and persistent.
+
+### Current Stable User Memories
+${stableList}
+
+### Candidate Observations (from recent historian runs)
+${candidateList}
+
+### Instructions
+
+1. Look for **recurring patterns** across multiple candidates \u2014 observations that appear independently from different sessions or historian runs indicate a real user trait.
+2. A candidate must appear in at least ${args.promotionThreshold} semantically similar variants before promotion.
+3. Only promote **truly universal** user traits \u2014 communication style, expertise level, review focus, decision-making patterns, working habits.
+4. Do NOT promote: project-specific preferences, framework choices, one-off moods, task-local frustrations.
+5. If a candidate is semantically equivalent to an existing stable memory, mark it as already covered.
+6. If multiple candidates describe the same trait, merge them into one clean statement.
+7. If an existing stable memory should be updated based on new evidence, include the update.
+
+### Output Format
+
+Return valid JSON (no markdown fencing):
+
+{
+  "promote": [
+    { "content": "Clean universal observation text", "candidate_ids": [1, 3, 7] }
+  ],
+  "update_existing": [
+    { "memory_id": 5, "content": "Updated text incorporating new evidence", "candidate_ids": [2] }
+  ],
+  "dismiss_existing": [
+    { "memory_id": 3, "reason": "No longer supported by recent observations" }
+  ],
+  "consume_candidate_ids": [1, 2, 3, 4, 5, 7, 8]
+}
+
+- \`promote\`: new stable memories to create from candidates
+- \`update_existing\`: existing stable memories to rewrite with new evidence
+- \`dismiss_existing\`: existing stable memories that are no longer valid
+- \`consume_candidate_ids\`: ALL candidate IDs that were reviewed (promoted, merged, or rejected) \u2014 they will be deleted from the candidate pool
+
+If no promotions are warranted, return empty arrays. Always consume reviewed candidates so they don't accumulate indefinitely.`;
+  let agentSessionId = null;
+  const abortController = new AbortController;
+  const leaseInterval = setInterval(() => {
+    try {
+      if (!renewLease(args.db, args.holderId)) {
+        log("[dreamer] user-memories: lease renewal failed \u2014 aborting");
+        abortController.abort();
+      }
+    } catch {
+      abortController.abort();
+    }
+  }, 60000);
+  try {
+    const createResponse = await args.client.session.create({
+      body: {
+        ...args.parentSessionId ? { parentID: args.parentSessionId } : {},
+        title: "magic-context-dream-user-memories"
+      },
+      query: { directory: args.sessionDirectory }
+    });
+    const created = normalizeSDKResponse(createResponse, null, { preferResponseOnMissingData: true });
+    agentSessionId = typeof created?.id === "string" ? created.id : null;
+    if (!agentSessionId)
+      throw new Error("Could not create user memory review session.");
+    log(`[dreamer] user-memories: child session created ${agentSessionId}`);
+    const remainingMs = Math.max(0, args.deadline - Date.now());
+    await promptSyncWithModelSuggestionRetry(args.client, {
+      path: { id: agentSessionId },
+      query: { directory: args.sessionDirectory },
+      body: {
+        agent: DREAMER_AGENT,
+        system: DREAMER_SYSTEM_PROMPT,
+        parts: [{ type: "text", text: prompt }]
+      }
+    }, { timeoutMs: Math.min(remainingMs, 5 * 60 * 1000), signal: abortController.signal });
+    const messagesResponse = await args.client.session.messages({
+      path: { id: agentSessionId },
+      query: { directory: args.sessionDirectory }
+    });
+    const messages = normalizeSDKResponse(messagesResponse, [], {
+      preferResponseOnMissingData: true
+    });
+    const responseText = extractLatestAssistantText(messages);
+    if (!responseText) {
+      log("[dreamer] user-memories: no response from review agent");
+      return result;
+    }
+    const jsonMatch = responseText.match(/```(?:json)?\s*([\s\S]*?)```/) ?? responseText.match(/(\{[\s\S]*\})/);
+    if (!jsonMatch) {
+      log("[dreamer] user-memories: could not parse JSON from response");
+      return result;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(jsonMatch[1]);
+    } catch {
+      log("[dreamer] user-memories: JSON parse failed");
+      return result;
+    }
+    if (parsed.promote) {
+      for (const p of parsed.promote) {
+        if (p.content?.trim()) {
+          insertUserMemory(args.db, p.content.trim(), p.candidate_ids ?? []);
+          result.promoted++;
+          log(`[dreamer] user-memories: promoted "${p.content.trim().slice(0, 60)}..."`);
+        }
+      }
+    }
+    if (parsed.update_existing) {
+      for (const u of parsed.update_existing) {
+        if (u.memory_id && u.content?.trim()) {
+          updateUserMemoryContent(args.db, u.memory_id, u.content.trim());
+          result.merged++;
+          log(`[dreamer] user-memories: updated memory #${u.memory_id}`);
+        }
+      }
+    }
+    if (parsed.dismiss_existing) {
+      for (const d of parsed.dismiss_existing) {
+        if (d.memory_id) {
+          dismissUserMemory(args.db, d.memory_id);
+          result.dismissed++;
+          log(`[dreamer] user-memories: dismissed memory #${d.memory_id} \u2014 ${d.reason ?? "no reason"}`);
+        }
+      }
+    }
+    if (parsed.consume_candidate_ids && parsed.consume_candidate_ids.length > 0) {
+      deleteUserMemoryCandidates(args.db, parsed.consume_candidate_ids);
+      result.candidatesConsumed = parsed.consume_candidate_ids.length;
+      log(`[dreamer] user-memories: consumed ${result.candidatesConsumed} candidate(s)`);
+    }
+    return result;
+  } catch (error48) {
+    log(`[dreamer] user-memories: review failed: ${getErrorMessage(error48)}`);
+    return result;
+  } finally {
+    clearInterval(leaseInterval);
+    if (agentSessionId) {
+      await args.client.session.delete({
+        path: { id: agentSessionId },
+        query: { directory: args.sessionDirectory }
+      }).catch((e) => {
+        log(`[dreamer] user-memories: session cleanup failed: ${getErrorMessage(e)}`);
+      });
+    }
+  }
 }
 
 // src/features/magic-context/dreamer/storage-dream-runs.ts
@@ -24186,6 +24548,24 @@ async function runDream(args) {
         }
       }
     }
+    if (args.experimentalUserMemories?.enabled && Date.now() <= deadline) {
+      try {
+        const reviewResult = await reviewUserMemories({
+          db: args.db,
+          client: args.client,
+          parentSessionId,
+          sessionDirectory: args.sessionDirectory,
+          holderId,
+          deadline,
+          promotionThreshold: args.experimentalUserMemories.promotionThreshold
+        });
+        if (reviewResult.promoted > 0 || reviewResult.merged > 0 || reviewResult.dismissed > 0) {
+          log(`[dreamer] user-memories: promoted=${reviewResult.promoted} merged=${reviewResult.merged} dismissed=${reviewResult.dismissed} consumed=${reviewResult.candidatesConsumed}`);
+        }
+      } catch (error48) {
+        log(`[dreamer] user-memory review failed: ${getErrorMessage(error48)}`);
+      }
+    }
     if (Date.now() <= deadline) {
       try {
         await evaluateSmartNotes({
@@ -24326,7 +24706,7 @@ Only include notes whose conditions you could definitively evaluate. Skip notes
     if (!jsonMatch) {
       log("[dreamer] smart notes: no JSON array found in output, skipping");
       for (const note of pendingNotes)
-        markSmartNoteChecked(args.db, note.id);
+        markNoteChecked(args.db, note.id);
       throw new Error("Smart note evaluation returned no JSON array.");
     }
     let evaluations;
@@ -24335,7 +24715,7 @@ Only include notes whose conditions you could definitively evaluate. Skip notes
     } catch {
       log(`[dreamer] smart notes: failed to parse JSON from LLM output, marking all checked`);
       for (const note of pendingNotes)
-        markSmartNoteChecked(args.db, note.id);
+        markNoteChecked(args.db, note.id);
       throw new Error("Smart note evaluation returned invalid JSON.");
     }
     let surfaced = 0;
@@ -24346,16 +24726,16 @@ Only include notes whose conditions you could definitively evaluate. Skip notes
       if (!note)
         continue;
       if (evaluation.met) {
-        markSmartNoteReady(args.db, note.id, evaluation.reason);
+        markNoteReady(args.db, note.id, evaluation.reason);
         surfaced++;
         log(`[dreamer] smart notes: #${note.id} condition MET \u2014 "${evaluation.reason ?? "condition satisfied"}"`);
       } else {
-        markSmartNoteChecked(args.db, note.id);
+        markNoteChecked(args.db, note.id);
       }
     }
     for (const note of pendingNotes) {
       if (!evaluations.some((e) => e.id === note.id)) {
-        markSmartNoteChecked(args.db, note.id);
+        markNoteChecked(args.db, note.id);
       }
     }
     const durationMs = Date.now() - taskStartedAt;
@@ -24409,7 +24789,8 @@ async function processDreamQueue(args) {
       tasks: args.tasks,
       taskTimeoutMinutes: args.taskTimeoutMinutes,
       maxRuntimeMinutes: args.maxRuntimeMinutes,
-      sessionDirectory: projectDirectory
+      sessionDirectory: projectDirectory,
+      experimentalUserMemories: args.experimentalUserMemories
     });
   } catch (error48) {
     log(`[dreamer] runDream threw for ${entry.projectIdentity}: ${getErrorMessage(error48)}`);
@@ -24461,7 +24842,8 @@ function isInScheduleWindow(schedule, now = new Date) {
 function findProjectsNeedingDream(db) {
   const projectRows = db.query(`SELECT DISTINCT project_path FROM memories WHERE status = 'active'
              UNION
-             SELECT DISTINCT project_path FROM smart_notes WHERE status = 'pending'
+             SELECT DISTINCT project_path FROM notes
+             WHERE type = 'smart' AND status = 'pending' AND project_path IS NOT NULL
              ORDER BY project_path`).all();
   const projects = [];
   for (const row of projectRows) {
@@ -24470,8 +24852,8 @@ function findProjectsNeedingDream(db) {
     const lastDreamAt = Number(lastDreamAtStr ?? fallbackStr ?? "0") || 0;
     const updatedMemories = db.query(`SELECT COUNT(*) as cnt FROM memories
                  WHERE project_path = ? AND status = 'active' AND updated_at > ?`).get(row.project_path, lastDreamAt);
-    const pendingSmartNotes = db.query(`SELECT COUNT(*) as cnt FROM smart_notes
-                 WHERE project_path = ? AND status = 'pending'`).get(row.project_path);
+    const pendingSmartNotes = db.query(`SELECT COUNT(*) as cnt FROM notes
+                 WHERE project_path = ? AND type = 'smart' AND status = 'pending'`).get(row.project_path);
     if (updatedMemories && updatedMemories.cnt > 0 || pendingSmartNotes && pendingSmartNotes.cnt > 0) {
       projects.push(row.project_path);
     }
@@ -24518,6 +24900,22 @@ function cosineSimilarity(a, b) {
 
 // src/features/magic-context/memory/embedding-local.ts
 init_logger();
+async function withQuietConsole(fn) {
+  const origWarn = console.warn;
+  const origError = console.error;
+  const redirect = (...args) => {
+    const message = args.map((a) => typeof a === "string" ? a : String(a)).join(" ");
+    log(`[transformers] ${message}`);
+  };
+  console.warn = redirect;
+  console.error = redirect;
+  try {
+    return await fn();
+  } finally {
+    console.warn = origWarn;
+    console.error = origError;
+  }
+}
 function isArrayLikeNumber(value) {
   if (typeof value !== "object" || value === null || !("length" in value)) {
     return false;
@@ -24573,10 +24971,16 @@ class LocalEmbeddingProvider {
     this.initPromise = (async () => {
       try {
         const transformersModule = await import("@huggingface/transformers");
+        const env = transformersModule.env;
+        const LogLevel = transformersModule.LogLevel;
+        if (LogLevel && "ERROR" in LogLevel) {
+          env.logLevel = LogLevel.ERROR;
+        }
         const createPipeline = transformersModule.pipeline;
-        this.pipeline = await createPipeline("feature-extraction", this.model, {
-          quantized: true
-        });
+        this.pipeline = await withQuietConsole(() => createPipeline("feature-extraction", this.model, {
+          quantized: true,
+          dtype: "fp32"
+        }));
         log(`[magic-context] embedding model loaded: ${this.model}`);
       } catch (error48) {
         log("[magic-context] embedding model failed to load:", error48);
@@ -24593,13 +24997,14 @@ class LocalEmbeddingProvider {
       return null;
     }
     try {
-      if (!this.pipeline) {
+      const pipeline = this.pipeline;
+      if (!pipeline) {
         return null;
       }
-      const result = await this.pipeline(text, {
+      const result = await withQuietConsole(() => pipeline(text, {
         pooling: "mean",
         normalize: true
-      });
+      }));
       return extractBatchEmbeddings(result, 1)[0] ?? null;
     } catch (error48) {
       log("[magic-context] embedding failed:", error48);
@@ -24614,13 +25019,14 @@ class LocalEmbeddingProvider {
       return Array.from({ length: texts.length }, () => null);
     }
     try {
-      if (!this.pipeline) {
+      const pipeline = this.pipeline;
+      if (!pipeline) {
         return Array.from({ length: texts.length }, () => null);
       }
-      const result = await this.pipeline(texts, {
+      const result = await withQuietConsole(() => pipeline(texts, {
         pooling: "mean",
         normalize: true
-      });
+      }));
       return extractBatchEmbeddings(result, texts.length);
     } catch (error48) {
       log("[magic-context] embedding batch failed:", error48);
@@ -25220,7 +25626,11 @@ function readRawSessionMessagesFromDb(db, sessionId) {
     list.push(parseJsonUnknown(part.data));
     partsByMessageId.set(part.message_id, list);
   }
-  return messageRows.flatMap((row, index) => {
+  const filtered = messageRows.filter((row) => {
+    const info = parseJsonRecord(row.data);
+    return !(info?.summary === true && info?.finish === "stop");
+  });
+  return filtered.flatMap((row, index) => {
     const info = parseJsonRecord(row.data);
     if (!info)
       return [];
@@ -25594,6 +26004,158 @@ import { Database as Database2 } from "bun:sqlite";
 import { mkdirSync } from "fs";
 import { join as join9 } from "path";
 init_logger();
+
+// src/features/magic-context/migrations.ts
+init_logger();
+var MIGRATIONS = [
+  {
+    version: 1,
+    description: "Merge session_notes + smart_notes into unified notes table",
+    up: (db) => {
+      db.exec(`
+				CREATE TABLE IF NOT EXISTS notes (
+					id INTEGER PRIMARY KEY AUTOINCREMENT,
+					type TEXT NOT NULL DEFAULT 'session',
+					status TEXT NOT NULL DEFAULT 'active',
+					content TEXT NOT NULL,
+					session_id TEXT,
+					project_path TEXT,
+					surface_condition TEXT,
+					created_at INTEGER NOT NULL,
+					updated_at INTEGER NOT NULL,
+					last_checked_at INTEGER,
+					ready_at INTEGER,
+					ready_reason TEXT
+				);
+				CREATE INDEX IF NOT EXISTS idx_notes_session_status ON notes(session_id, status);
+				CREATE INDEX IF NOT EXISTS idx_notes_project_status ON notes(project_path, status);
+				CREATE INDEX IF NOT EXISTS idx_notes_type_status ON notes(type, status);
+			`);
+      const hasSessionNotes = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='session_notes'").get();
+      if (hasSessionNotes) {
+        db.exec(`
+					INSERT INTO notes (type, status, content, session_id, created_at, updated_at)
+					SELECT 'session', 'active', content, session_id, created_at, created_at
+					FROM session_notes
+				`);
+      }
+      const hasSmartNotes = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='smart_notes'").get();
+      if (hasSmartNotes) {
+        db.exec(`
+					INSERT INTO notes (type, status, content, session_id, project_path, surface_condition,
+						created_at, updated_at, last_checked_at, ready_at, ready_reason)
+					SELECT 'smart', status, content, created_session_id, project_path, surface_condition,
+						created_at, updated_at, last_checked_at, ready_at, ready_reason
+					FROM smart_notes
+				`);
+      }
+      if (hasSessionNotes) {
+        const sourceCount = db.prepare("SELECT COUNT(*) as c FROM session_notes").get().c;
+        const migratedCount = db.prepare("SELECT COUNT(*) as c FROM notes WHERE type = 'session'").get().c;
+        if (migratedCount >= sourceCount) {
+          db.exec("DROP TABLE session_notes");
+        } else {
+          throw new Error(`session_notes migration verification failed: expected ${sourceCount} rows, got ${migratedCount}`);
+        }
+      }
+      if (hasSmartNotes) {
+        const sourceCount = db.prepare("SELECT COUNT(*) as c FROM smart_notes").get().c;
+        const migratedCount = db.prepare("SELECT COUNT(*) as c FROM notes WHERE type = 'smart'").get().c;
+        if (migratedCount >= sourceCount) {
+          db.exec("DROP TABLE smart_notes");
+        } else {
+          throw new Error(`smart_notes migration verification failed: expected ${sourceCount} rows, got ${migratedCount}`);
+        }
+      }
+    }
+  },
+  {
+    version: 2,
+    description: "Add plugin_messages table for TUI \u2194 server communication",
+    up: (db) => {
+      db.exec(`
+				CREATE TABLE IF NOT EXISTS plugin_messages (
+					id INTEGER PRIMARY KEY AUTOINCREMENT,
+					direction TEXT NOT NULL,
+					type TEXT NOT NULL,
+					payload TEXT NOT NULL DEFAULT '{}',
+					session_id TEXT,
+					created_at INTEGER NOT NULL,
+					consumed_at INTEGER
+				);
+				CREATE INDEX IF NOT EXISTS idx_plugin_messages_direction_consumed
+					ON plugin_messages(direction, consumed_at);
+				CREATE INDEX IF NOT EXISTS idx_plugin_messages_created
+					ON plugin_messages(created_at);
+			`);
+    }
+  },
+  {
+    version: 3,
+    description: "Add user_memory_candidates and user_memories tables",
+    up: (db) => {
+      db.exec(`
+                CREATE TABLE IF NOT EXISTS user_memory_candidates (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    content TEXT NOT NULL,
+                    session_id TEXT NOT NULL,
+                    source_compartment_start INTEGER,
+                    source_compartment_end INTEGER,
+                    created_at INTEGER NOT NULL
+                );
+                CREATE INDEX IF NOT EXISTS idx_umc_created ON user_memory_candidates(created_at);
+
+                CREATE TABLE IF NOT EXISTS user_memories (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    content TEXT NOT NULL,
+                    status TEXT NOT NULL DEFAULT 'active',
+                    promoted_at INTEGER NOT NULL,
+                    source_candidate_ids TEXT DEFAULT '[]',
+                    created_at INTEGER NOT NULL,
+                    updated_at INTEGER NOT NULL
+                );
+                CREATE INDEX IF NOT EXISTS idx_um_status ON user_memories(status);
+            `);
+    }
+  }
+];
+function ensureMigrationsTable(db) {
+  db.exec(`
+		CREATE TABLE IF NOT EXISTS schema_migrations (
+			version INTEGER PRIMARY KEY,
+			description TEXT NOT NULL,
+			applied_at INTEGER NOT NULL
+		)
+	`);
+}
+function getCurrentVersion(db) {
+  const row = db.prepare("SELECT MAX(version) as version FROM schema_migrations").get();
+  return row?.version ?? 0;
+}
+function runMigrations(db) {
+  ensureMigrationsTable(db);
+  const currentVersion = getCurrentVersion(db);
+  const pendingMigrations = MIGRATIONS.filter((m) => m.version > currentVersion);
+  if (pendingMigrations.length === 0) {
+    return;
+  }
+  log(`[migrations] current schema version: ${currentVersion}, applying ${pendingMigrations.length} migration(s)`);
+  for (const migration of pendingMigrations) {
+    try {
+      db.transaction(() => {
+        migration.up(db);
+        db.prepare("INSERT INTO schema_migrations (version, description, applied_at) VALUES (?, ?, ?)").run(migration.version, migration.description, Date.now());
+      })();
+      log(`[migrations] applied v${migration.version}: ${migration.description}`);
+    } catch (error48) {
+      log(`[migrations] FAILED v${migration.version}: ${migration.description} \u2014 ${error48 instanceof Error ? error48.message : String(error48)}`);
+      throw new Error(`Migration v${migration.version} failed: ${error48 instanceof Error ? error48.message : String(error48)}. Database may need manual repair.`);
+    }
+  }
+  log(`[migrations] schema version now: ${MIGRATIONS[MIGRATIONS.length - 1].version}`);
+}
+
+// src/features/magic-context/storage-db.ts
 var databases = new Map;
 var FALLBACK_DATABASE_KEY = "__fallback__:memory:";
 var persistenceByDatabase = new WeakMap;
@@ -25873,6 +26435,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "dream_queue", "retry_count", "INTEGER DEFAULT 0");
   ensureColumn(db, "tags", "reasoning_byte_size", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "system_prompt_tokens", "INTEGER DEFAULT 0");
+  ensureColumn(db, "session_meta", "compaction_marker_state", "TEXT DEFAULT ''");
 }
 function ensureColumn(db, table, column, definition) {
   if (!/^[a-z_]+$/.test(table) || !/^[a-z_]+$/.test(column) || !/^[A-Z0-9_'(),\s]+$/i.test(definition)) {
@@ -25888,6 +26451,7 @@ function createFallbackDatabase() {
   try {
     const fallback = new Database2(":memory:");
     initializeDatabase(fallback);
+    runMigrations(fallback);
     return fallback;
   } catch (error48) {
     throw new Error(`[magic-context] storage fatal: failed to initialize fallback database: ${getErrorMessage(error48)}`);
@@ -25906,6 +26470,7 @@ function openDatabase() {
     mkdirSync(dbDir, { recursive: true });
     const db = new Database2(dbPath);
     initializeDatabase(db);
+    runMigrations(db);
     databases.set(dbPath, db);
     persistenceByDatabase.set(db, true);
     persistenceErrorByDatabase.delete(db);
@@ -26138,6 +26703,24 @@ function setPersistedDeliveredNoteNudge(db, sessionId, text, messageId = "") {
 function clearPersistedNoteNudge(db, sessionId) {
   db.prepare("UPDATE session_meta SET note_nudge_trigger_pending = 0, note_nudge_trigger_message_id = '', note_nudge_sticky_text = '', note_nudge_sticky_message_id = '' WHERE session_id = ?").run(sessionId);
 }
+function getPersistedCompactionMarkerState(db, sessionId) {
+  const row = db.prepare("SELECT compaction_marker_state FROM session_meta WHERE session_id = ?").get(sessionId);
+  const raw = row?.compaction_marker_state;
+  if (!raw || raw.length === 0)
+    return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && typeof parsed.boundaryMessageId === "string" && typeof parsed.summaryMessageId === "string" && typeof parsed.compactionPartId === "string" && typeof parsed.summaryPartId === "string" && typeof parsed.boundaryOrdinal === "number") {
+      return parsed;
+    }
+  } catch {}
+  return null;
+}
+function setPersistedCompactionMarkerState(db, sessionId, state) {
+  ensureSessionMetaRow(db, sessionId);
+  const json2 = state ? JSON.stringify(state) : "";
+  db.prepare("UPDATE session_meta SET compaction_marker_state = ? WHERE session_id = ?").run(json2, sessionId);
+}
 function getStrippedPlaceholderIds(db, sessionId) {
   const row = db.prepare("SELECT stripped_placeholder_ids FROM session_meta WHERE session_id = ?").get(sessionId);
   const raw = row?.stripped_placeholder_ids;
@@ -26208,37 +26791,12 @@ function clearSession(db, sessionId) {
     db.prepare("DELETE FROM compartments WHERE session_id = ?").run(sessionId);
     clearCompressionDepth(db, sessionId);
     db.prepare("DELETE FROM session_facts WHERE session_id = ?").run(sessionId);
-    db.prepare("DELETE FROM session_notes WHERE session_id = ?").run(sessionId);
+    db.prepare("DELETE FROM notes WHERE session_id = ? AND type = 'session'").run(sessionId);
     db.prepare("DELETE FROM recomp_compartments WHERE session_id = ?").run(sessionId);
     db.prepare("DELETE FROM recomp_facts WHERE session_id = ?").run(sessionId);
     clearIndexedMessages(db, sessionId);
   })();
 }
-// src/features/magic-context/storage-notes.ts
-function isSessionNoteRow(row) {
-  if (row === null || typeof row !== "object")
-    return false;
-  const candidate = row;
-  return typeof candidate.id === "number" && typeof candidate.session_id === "string" && typeof candidate.content === "string" && typeof candidate.created_at === "number";
-}
-function toSessionNote(row) {
-  return {
-    id: row.id,
-    sessionId: row.session_id,
-    content: row.content,
-    createdAt: row.created_at
-  };
-}
-function getSessionNotes(db, sessionId) {
-  const rows = db.prepare("SELECT * FROM session_notes WHERE session_id = ? ORDER BY id ASC").all(sessionId).filter(isSessionNoteRow);
-  return rows.map(toSessionNote);
-}
-function addSessionNote(db, sessionId, content) {
-  db.prepare("INSERT INTO session_notes (session_id, content, created_at) VALUES (?, ?, ?)").run(sessionId, content, Date.now());
-}
-function clearSessionNotes(db, sessionId) {
-  db.prepare("DELETE FROM session_notes WHERE session_id = ?").run(sessionId);
-}
 // src/features/magic-context/storage-ops.ts
 init_logger();
 var queuePendingOpStatements = new WeakMap;
@@ -26455,7 +27013,14 @@ function getTopNBySize(db, sessionId, n) {
 init_logger();
 var DREAM_TIMER_INTERVAL_MS = 15 * 60 * 1000;
 function startDreamScheduleTimer(args) {
-  const { client, directory, dreamerConfig, embeddingConfig: embeddingConfig2, memoryEnabled } = args;
+  const {
+    client,
+    directory,
+    dreamerConfig,
+    embeddingConfig: embeddingConfig2,
+    memoryEnabled,
+    experimentalUserMemories
+  } = args;
   const dreamingEnabled = Boolean(dreamerConfig?.enabled && dreamerConfig.schedule?.trim());
   const embeddingSweepEnabled = memoryEnabled && embeddingConfig2.provider !== "off";
   if (!dreamingEnabled && !embeddingSweepEnabled) {
@@ -26483,7 +27048,8 @@ function startDreamScheduleTimer(args) {
         client,
         tasks: dreamerConfig.tasks,
         taskTimeoutMinutes: dreamerConfig.task_timeout_minutes,
-        maxRuntimeMinutes: dreamerConfig.max_runtime_minutes
+        maxRuntimeMinutes: dreamerConfig.max_runtime_minutes,
+        experimentalUserMemories
       }).catch((error48) => {
         log("[dreamer] timer-triggered queue processing failed:", error48);
       });
@@ -27204,6 +27770,8 @@ async function sendUserPrompt(client, sessionId, text) {
 }
 
 // src/hooks/magic-context/command-handler.ts
+var recompConfirmationBySession = new Map;
+var RECOMP_CONFIRMATION_WINDOW_MS = 60000;
 var SENTINEL_PREFIX = "__CONTEXT_MANAGEMENT_";
 async function executeAugmentation(deps, sessionId, userPrompt) {
   if (!deps.sidekick?.config) {
@@ -27279,7 +27847,8 @@ Dreaming is not configured for this project.`, {});
     client: deps.dreamer.client,
     tasks: deps.dreamer.config.tasks,
     taskTimeoutMinutes: deps.dreamer.config.task_timeout_minutes,
-    maxRuntimeMinutes: deps.dreamer.config.max_runtime_minutes
+    maxRuntimeMinutes: deps.dreamer.config.max_runtime_minutes,
+    experimentalUserMemories: deps.dreamer.experimentalUserMemories
   });
   await deps.sendNotification(sessionId, result ? summarizeDreamResult(result) : "Dream queued, but another worker is already processing the queue.", {});
   throw new Error(`${SENTINEL_PREFIX}CTX-DREAM_HANDLED__`);
@@ -27322,12 +27891,40 @@ function createMagicContextCommandHandler(deps) {
 ${statusOutput}` : statusOutput;
       }
       if (isRecomp) {
-        await deps.sendNotification(sessionId, `## Magic Recomp
-
-Historian recomp started. Rebuilding compartments and facts from raw session history now.`, {});
-        result = deps.executeRecomp ? await deps.executeRecomp(sessionId) : `## Magic Recomp
+        if (!deps.executeRecomp) {
+          result = `## Magic Recomp
 
 /ctx-recomp is unavailable because the recomp handler is not configured.`;
+        } else {
+          const lastConfirmation = recompConfirmationBySession.get(sessionId);
+          const now = Date.now();
+          if (lastConfirmation && now - lastConfirmation < RECOMP_CONFIRMATION_WINDOW_MS) {
+            recompConfirmationBySession.delete(sessionId);
+            await deps.sendNotification(sessionId, `## Magic Recomp
+
+Historian recomp started. Rebuilding compartments and facts from raw session history now.`, {});
+            result = await deps.executeRecomp(sessionId);
+          } else {
+            recompConfirmationBySession.set(sessionId, now);
+            const compartments = getCompartments(deps.db, sessionId);
+            const compartmentCount = compartments.length;
+            const warningLines = [
+              "## \u26A0\uFE0F Recomp Confirmation Required",
+              "",
+              `You currently have **${compartmentCount}** compartments.`,
+              "Running /ctx-recomp will **regenerate all compartments and facts** from raw session history.",
+              "",
+              "This operation:",
+              "- May take a long time (minutes to hours for long sessions)",
+              "- Will consume significant tokens on your historian model",
+              "- Cannot be interrupted cleanly once started",
+              "",
+              "**To confirm, run `/ctx-recomp` again within 60 seconds.**"
+            ];
+            result = warningLines.join(`
+`);
+          }
+        }
       }
       await deps.sendNotification(sessionId, result, {});
       sessionLog(sessionId, `command ${input.command} handled via command.execute.before`);
@@ -27339,6 +27936,175 @@ Historian recomp started. Rebuilding compartments and facts from raw session his
 // src/hooks/magic-context/event-handler.ts
 init_logger();
 
+// src/features/magic-context/compaction-marker.ts
+import { Database as Database3 } from "bun:sqlite";
+import { join as join10 } from "path";
+init_logger();
+var BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+function randomBase62(length) {
+  const chars = [];
+  for (let i = 0;i < length; i++) {
+    chars.push(BASE62_CHARS[Math.floor(Math.random() * BASE62_CHARS.length)]);
+  }
+  return chars.join("");
+}
+function generateId(prefix, timestampMs, counter = 0n) {
+  const encoded = BigInt(timestampMs) * 0x1000n + counter;
+  const hex3 = encoded.toString(16).padStart(14, "0");
+  return `${prefix}_${hex3}${randomBase62(14)}`;
+}
+function generateMessageId(timestampMs, counter = 0n) {
+  return generateId("msg", timestampMs, counter);
+}
+function generatePartId(timestampMs, counter = 0n) {
+  return generateId("prt", timestampMs, counter);
+}
+function getOpenCodeDbPath2() {
+  return join10(getDataDir(), "opencode", "opencode.db");
+}
+var cachedWriteDb = null;
+function getWritableOpenCodeDb() {
+  const dbPath = getOpenCodeDbPath2();
+  if (cachedWriteDb?.path === dbPath) {
+    return cachedWriteDb.db;
+  }
+  if (cachedWriteDb) {
+    try {
+      cachedWriteDb.db.close(false);
+    } catch {}
+  }
+  const db = new Database3(dbPath);
+  db.exec("PRAGMA journal_mode=WAL");
+  db.exec("PRAGMA busy_timeout=5000");
+  cachedWriteDb = { path: dbPath, db };
+  return db;
+}
+function findBoundaryUserMessage(sessionId, endOrdinal) {
+  const db = getWritableOpenCodeDb();
+  const rows = db.prepare("SELECT id, time_created, data FROM message WHERE session_id = ? ORDER BY time_created ASC, id ASC").all(sessionId);
+  const filtered = rows.filter((row) => {
+    try {
+      const info = JSON.parse(row.data);
+      return !(info.summary === true && info.finish === "stop");
+    } catch {
+      return true;
+    }
+  });
+  let bestMatch = null;
+  for (let i = 0;i < filtered.length && i < endOrdinal; i++) {
+    const row = filtered[i];
+    try {
+      const info = JSON.parse(row.data);
+      if (info.role === "user") {
+        bestMatch = { id: row.id, timeCreated: row.time_created };
+      }
+    } catch {}
+  }
+  return bestMatch;
+}
+function injectCompactionMarker(args) {
+  const boundary = findBoundaryUserMessage(args.sessionId, args.endOrdinal);
+  if (!boundary) {
+    log(`[magic-context] compaction-marker: no user message found at or before ordinal ${args.endOrdinal}`);
+    return null;
+  }
+  const db = getWritableOpenCodeDb();
+  const boundaryTime = boundary.timeCreated;
+  const summaryMsgId = generateMessageId(boundaryTime + 1, 1n);
+  const compactionPartId = generatePartId(boundaryTime, 1n);
+  const summaryPartId = generatePartId(boundaryTime + 1, 2n);
+  const summaryMsgData = JSON.stringify({
+    role: "assistant",
+    parentID: boundary.id,
+    summary: true,
+    finish: "stop",
+    mode: "compaction",
+    agent: "compaction",
+    path: { cwd: args.directory, root: args.directory },
+    cost: 0,
+    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+    modelID: "magic-context",
+    providerID: "magic-context",
+    time: { created: boundaryTime + 1 }
+  });
+  try {
+    db.transaction(() => {
+      db.prepare("INSERT INTO part (id, message_id, session_id, time_created, time_updated, data) VALUES (?, ?, ?, ?, ?, ?)").run(compactionPartId, boundary.id, args.sessionId, boundaryTime, boundaryTime, '{"type":"compaction","auto":true}');
+      db.prepare("INSERT INTO message (id, session_id, time_created, time_updated, data) VALUES (?, ?, ?, ?, ?)").run(summaryMsgId, args.sessionId, boundaryTime + 1, boundaryTime + 1, summaryMsgData);
+      db.prepare("INSERT INTO part (id, message_id, session_id, time_created, time_updated, data) VALUES (?, ?, ?, ?, ?, ?)").run(summaryPartId, summaryMsgId, args.sessionId, boundaryTime + 1, boundaryTime + 1, JSON.stringify({ type: "text", text: args.summaryText }));
+    })();
+    log(`[magic-context] compaction-marker: injected boundary at user msg ${boundary.id} (ordinal ~${args.endOrdinal}), summary msg ${summaryMsgId}`);
+    return {
+      boundaryMessageId: boundary.id,
+      summaryMessageId: summaryMsgId,
+      compactionPartId,
+      summaryPartId
+    };
+  } catch (error48) {
+    log(`[magic-context] compaction-marker: injection failed: ${error48 instanceof Error ? error48.message : String(error48)}`);
+    return null;
+  }
+}
+function removeCompactionMarker(state) {
+  try {
+    const db = getWritableOpenCodeDb();
+    db.transaction(() => {
+      db.prepare("DELETE FROM part WHERE id = ?").run(state.summaryPartId);
+      db.prepare("DELETE FROM message WHERE id = ?").run(state.summaryMessageId);
+      db.prepare("DELETE FROM part WHERE id = ?").run(state.compactionPartId);
+    })();
+    return true;
+  } catch (error48) {
+    log(`[magic-context] compaction-marker: removal failed: ${error48 instanceof Error ? error48.message : String(error48)}`);
+    return false;
+  }
+}
+
+// src/hooks/magic-context/compaction-marker-manager.ts
+init_logger();
+var MARKER_SUMMARY_TEXT = "[Compacted by magic-context \u2014 session history is managed by the plugin]";
+function updateCompactionMarkerAfterPublication(db, sessionId, lastCompartmentEnd, directory) {
+  const existing = getPersistedCompactionMarkerState(db, sessionId);
+  if (existing) {
+    if (existing.boundaryOrdinal === lastCompartmentEnd) {
+      return;
+    }
+    try {
+      removeCompactionMarker(existing);
+      setPersistedCompactionMarkerState(db, sessionId, null);
+      sessionLog(sessionId, `compaction-marker: removed old boundary at ordinal ${existing.boundaryOrdinal}, moving to ${lastCompartmentEnd}`);
+    } catch (error48) {
+      sessionLog(sessionId, `compaction-marker: failed to remove old boundary at ordinal ${existing.boundaryOrdinal}, proceeding with new injection:`, error48);
+    }
+  }
+  const result = injectCompactionMarker({
+    sessionId,
+    endOrdinal: lastCompartmentEnd,
+    summaryText: MARKER_SUMMARY_TEXT,
+    directory: directory ?? process.cwd()
+  });
+  if (result) {
+    setPersistedCompactionMarkerState(db, sessionId, {
+      ...result,
+      boundaryOrdinal: lastCompartmentEnd
+    });
+    sessionLog(sessionId, `compaction-marker: injected at ordinal ${lastCompartmentEnd}, boundary user msg ${result.boundaryMessageId}`);
+  }
+}
+function removeCompactionMarkerForSession(db, sessionId) {
+  const existing = getPersistedCompactionMarkerState(db, sessionId);
+  if (existing) {
+    try {
+      removeCompactionMarker(existing);
+      setPersistedCompactionMarkerState(db, sessionId, null);
+      sessionLog(sessionId, "compaction-marker: removed on session cleanup");
+    } catch (error48) {
+      setPersistedCompactionMarkerState(db, sessionId, null);
+      sessionLog(sessionId, "compaction-marker: removal failed during session cleanup, cleared persisted state:", error48);
+    }
+  }
+}
+
 // src/hooks/magic-context/event-payloads.ts
 function getSessionProperties(properties) {
   if (!isRecord(properties)) {
@@ -27635,6 +28401,11 @@ function createEventHandler2(deps) {
           clearNoteNudgeState(deps.db, info.sessionID, { persist: false });
           sessionLog(info.sessionID, "event message.removed: cleared in-memory note nudge state");
         }
+        const markerState = getPersistedCompactionMarkerState(deps.db, info.sessionID);
+        if (markerState && (markerState.boundaryMessageId === info.messageID || markerState.summaryMessageId === info.messageID)) {
+          removeCompactionMarkerForSession(deps.db, info.sessionID);
+          sessionLog(info.sessionID, `event message.removed: cleared compaction marker (boundary or summary message removed)`);
+        }
         deps.onSessionCacheInvalidated?.(info.sessionID);
         sessionLog(info.sessionID, "event message.removed: cleared session injection cache");
       } catch (error48) {
@@ -27652,6 +28423,11 @@ function createEventHandler2(deps) {
       } catch (error48) {
         sessionLog(sessionId, "event session.compacted handling failed:", error48);
       }
+      try {
+        removeCompactionMarkerForSession(deps.db, sessionId);
+      } catch (error48) {
+        sessionLog(sessionId, "event session.compacted marker cleanup failed:", error48);
+      }
       deps.onSessionCacheInvalidated?.(sessionId);
       return;
     }
@@ -27662,6 +28438,7 @@ function createEventHandler2(deps) {
       }
       deps.nudgePlacements.clear(sessionId);
       try {
+        removeCompactionMarkerForSession(deps.db, sessionId);
         clearSession(deps.db, sessionId);
       } catch (error48) {
         sessionLog(sessionId, "event session.deleted persistence failed:", error48);
@@ -27741,7 +28518,10 @@ function trimMemoriesToBudget(sessionId, memories, budgetTokens) {
       return -1;
     if (b.status === "permanent" && a.status !== "permanent")
       return 1;
-    return b.seenCount - a.seenCount;
+    const seenDiff = b.seenCount - a.seenCount;
+    if (seenDiff !== 0)
+      return seenDiff;
+    return a.id - b.id;
   });
   const result = [];
   let usedTokens = 0;
@@ -28479,6 +29259,9 @@ function searchMemoriesFTS(db, projectPath, query, limit = DEFAULT_SEARCH_LIMIT)
   const rows = getSearchStatement(db).all(projectPath, Date.now(), sanitized, limit).filter(isMemoryRow);
   return rows.map(toMemory);
 }
+// src/hooks/magic-context/compartment-runner-incremental.ts
+init_logger();
+
 // src/hooks/magic-context/compartment-runner-compressor.ts
 init_logger();
 
@@ -28487,6 +29270,8 @@ var COMPARTMENT_REGEX = /<compartment\s+(?:id="[^"]*"\s+)?start="(\d+)"\s+end="(
 var CATEGORY_BLOCK_REGEX = /<(WORKFLOW_RULES|ARCHITECTURE_DECISIONS|CONSTRAINTS|CONFIG_DEFAULTS|KNOWN_ISSUES|ENVIRONMENT|NAMING|USER_PREFERENCES|USER_DIRECTIVES)>(.*?)<\/\1>/gs;
 var FACT_ITEM_REGEX = /^\s*\*\s*(.+)$/gm;
 var UNPROCESSED_REGEX = /<unprocessed_from>(\d+)<\/unprocessed_from>/;
+var USER_OBSERVATIONS_REGEX = /<user_observations>(.*?)<\/user_observations>/s;
+var USER_OBS_ITEM_REGEX = /^\s*\*\s*(.+)$/gm;
 function parseCompartmentOutput(text) {
   const compartments = [];
   const facts = [];
@@ -28511,8 +29296,17 @@ function parseCompartmentOutput(text) {
   }
   const unprocessedMatch = text.match(UNPROCESSED_REGEX);
   const unprocessedFrom = unprocessedMatch ? parseInt(unprocessedMatch[1], 10) : null;
+  const userObservations = [];
+  const userObsMatch = text.match(USER_OBSERVATIONS_REGEX);
+  if (userObsMatch) {
+    for (const itemMatch of userObsMatch[1].matchAll(USER_OBS_ITEM_REGEX)) {
+      const obs = unescapeXml(itemMatch[1].trim());
+      if (obs)
+        userObservations.push(obs);
+    }
+  }
   compartments.sort((a, b) => a.startMessage - b.startMessage);
-  return { compartments, facts, unprocessedFrom };
+  return { compartments, facts, unprocessedFrom, userObservations };
 }
 function unescapeXml(s) {
   return s.replace(/&amp;/g, "&").replace(/&apos;/g, "'").replace(/&quot;/g, '"').replace(/&lt;/g, "<").replace(/&gt;/g, ">");
@@ -28671,6 +29465,7 @@ ${compartment.content}
       }
     }
     replaceAllCompartmentState(db, sessionId, allCompartments, facts.map((f) => ({ category: f.category, content: f.content })));
+    clearInjectionCache(sessionId);
     incrementCompressionDepth(db, sessionId, originalStart, originalEnd);
     sessionLog(sessionId, `compressor: replaced ${selectedCompartments.length} compartments with ${compressed.length} compressed compartments`);
     sessionLog(sessionId, `compressor: incremented compression depth for messages ${originalStart}-${originalEnd}`);
@@ -28790,7 +29585,7 @@ function queueDropsForCompartmentalizedMessages(db, sessionId, upToMessageIndex)
 // src/hooks/magic-context/compartment-runner-historian.ts
 import { mkdirSync as mkdirSync2, unlinkSync, writeFileSync } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 
 // src/hooks/magic-context/compartment-runner-mapping.ts
 function mapParsedCompartmentsToChunk(compartments, chunk, sequenceOffset) {
@@ -28857,7 +29652,8 @@ function validateHistorianOutput(text, _sessionId, chunk, _priorCompartments, se
   return {
     ok: true,
     compartments: mapped.compartments,
-    facts: parsed.facts
+    facts: parsed.facts,
+    userObservations: parsed.userObservations.length > 0 ? parsed.userObservations : undefined
   };
 }
 function buildHistorianRepairPrompt(originalPrompt, previousOutput, validationError) {
@@ -28950,7 +29746,7 @@ function getReducedRecompTokenBudget(currentBudget) {
 }
 
 // src/hooks/magic-context/compartment-runner-historian.ts
-var HISTORIAN_RESPONSE_DUMP_DIR = join10(tmpdir2(), "magic-context-historian");
+var HISTORIAN_RESPONSE_DUMP_DIR = join11(tmpdir2(), "magic-context-historian");
 async function runValidatedHistorianPass(args) {
   const firstRun = await runHistorianPrompt({
     ...args,
@@ -29052,7 +29848,7 @@ function dumpHistorianResponse(sessionId, label, text) {
     mkdirSync2(HISTORIAN_RESPONSE_DUMP_DIR, { recursive: true });
     const safeSessionId = sanitizeDumpName(sessionId);
     const safeLabel = sanitizeDumpName(label);
-    const dumpPath = join10(HISTORIAN_RESPONSE_DUMP_DIR, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
+    const dumpPath = join11(HISTORIAN_RESPONSE_DUMP_DIR, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
     writeFileSync(dumpPath, text, "utf8");
     sessionLog(sessionId, "compartment agent: historian response dumped", {
       label,
@@ -29201,11 +29997,15 @@ No new compartments or facts were written. Check the historian model/output and
       appendCompartments(db, sessionId, newCompartments);
       replaceSessionFacts(db, sessionId, validatedPass.facts ?? []);
     })();
+    clearInjectionCache(sessionId);
     if (deps.directory) {
       promoteSessionFactsToMemory(db, sessionId, resolveProjectIdentity(deps.directory), validatedPass.facts ?? []);
     }
     const lastCompartmentEnd = lastNewEnd;
     queueDropsForCompartmentalizedMessages(db, sessionId, lastCompartmentEnd);
+    if (deps.experimentalCompactionMarkers) {
+      updateCompactionMarkerAfterPublication(db, sessionId, lastCompartmentEnd, sessionDirectory);
+    }
     if (deps.historyBudgetTokens && deps.historyBudgetTokens > 0) {
       await runCompressionPassIfNeeded({
         client,
@@ -29219,6 +30019,20 @@ No new compartments or facts were written. Check the historian model/output and
     updateSessionMeta(db, sessionId, { compartmentInProgress: false });
     completedSuccessfully = true;
     onNoteTrigger(db, sessionId, "historian_complete");
+    if (validatedPass.userObservations && validatedPass.userObservations.length > 0) {
+      try {
+        const lastNew = newCompartments[newCompartments.length - 1];
+        insertUserMemoryCandidates(db, validatedPass.userObservations.map((obs) => ({
+          content: obs,
+          sessionId,
+          sourceCompartmentStart: newCompartments[0]?.startMessage,
+          sourceCompartmentEnd: lastNew?.endMessage
+        })));
+        sessionLog(sessionId, `stored ${validatedPass.userObservations.length} user memory candidate(s)`);
+      } catch (error48) {
+        sessionLog(sessionId, "failed to store user memory candidates:", error48);
+      }
+    }
   } catch (error48) {
     const msg = getErrorMessage(error48);
     if (!issueNotified) {
@@ -29259,6 +30073,7 @@ async function executeContextRecompInternal(deps) {
       const promoted2 = promoteRecompStaging(db, sessionId);
       if (!promoted2)
         return null;
+      clearInjectionCache(sessionId);
       if (deps.directory) {
         promoteSessionFactsToMemory(db, sessionId, resolveProjectIdentity(deps.directory), promoted2.facts);
       }
@@ -29266,6 +30081,9 @@ async function executeContextRecompInternal(deps) {
       if (lastCompartmentEnd2 > 0) {
         queueDropsForCompartmentalizedMessages(db, sessionId, lastCompartmentEnd2);
       }
+      if (deps.experimentalCompactionMarkers && lastCompartmentEnd2 > 0) {
+        updateCompactionMarkerAfterPublication(db, sessionId, lastCompartmentEnd2, deps.directory);
+      }
       return [
         `Persisted ${promoted2.compartments.length} compartment${promoted2.compartments.length === 1 ? "" : "s"} from ${passCount} successful pass${passCount === 1 ? "" : "es"}.`,
         `Covered raw history 1-${lastCompartmentEnd2} out of ${rawMessageCount} total messages.`,
@@ -29420,6 +30238,7 @@ Nothing was written.`;
       replaceAllCompartmentState(db, sessionId, candidateCompartments, candidateFacts);
       clearRecompStaging(db, sessionId);
     }
+    clearInjectionCache(sessionId);
     const finalCompartments = promoted?.compartments ?? candidateCompartments;
     const finalFacts = promoted?.facts ?? candidateFacts;
     if (deps.directory) {
@@ -29549,7 +30368,9 @@ async function runCompartmentPhase(args) {
         historyBudgetTokens: args.historyBudgetTokens,
         historianTimeoutMs: args.historianTimeoutMs,
         directory: args.compartmentDirectory,
-        getNotificationParams: args.getNotificationParams
+        getNotificationParams: args.getNotificationParams,
+        experimentalCompactionMarkers: args.experimentalCompactionMarkers,
+        experimentalUserMemories: args.experimentalUserMemories
       });
       compartmentInProgress = true;
     }
@@ -29575,7 +30396,9 @@ async function runCompartmentPhase(args) {
         historyBudgetTokens: args.historyBudgetTokens,
         historianTimeoutMs: args.historianTimeoutMs,
         directory: args.compartmentDirectory,
-        getNotificationParams: args.getNotificationParams
+        getNotificationParams: args.getNotificationParams,
+        experimentalCompactionMarkers: args.experimentalCompactionMarkers,
+        experimentalUserMemories: args.experimentalUserMemories
       });
       activeRun = getActiveCompartmentRun(args.sessionId);
     } else if (!activeRun && hasEligibleHistoryForCompartment()) {
@@ -29589,7 +30412,7 @@ async function runCompartmentPhase(args) {
   }
   if (args.cacheAlreadyBusting && args.historyBudgetTokens && args.historyBudgetTokens > 0 && args.client && !compartmentInProgress && !awaitedCompartmentRun) {
     try {
-      await runCompressionPassIfNeeded({
+      const compressed = await runCompressionPassIfNeeded({
         client: args.client,
         db: args.db,
         sessionId: args.sessionId,
@@ -29597,6 +30420,9 @@ async function runCompartmentPhase(args) {
         historyBudgetTokens: args.historyBudgetTokens,
         historianTimeoutMs: args.historianTimeoutMs
       });
+      if (compressed && args.projectPath !== undefined) {
+        pendingCompartmentInjection = prepareCompartmentInjection(args.db, args.sessionId, args.messages, true, args.projectPath, args.injectionBudgetTokens);
+      }
     } catch (error48) {
       sessionLog(args.sessionId, "transform: independent compressor check failed:", getErrorMessage(error48));
     }
@@ -30744,7 +31570,18 @@ function runPostTransformPhase(args) {
       if (pendingUserTurnReminder.messageId) {
         const reinjected = appendReminderToUserMessageById(args.messages, pendingUserTurnReminder.messageId, pendingUserTurnReminder.text);
         if (!reinjected) {
-          sessionLog(args.sessionId, `preserving sticky turn reminder anchor to avoid cache bust: messageId=${pendingUserTurnReminder.messageId}`);
+          if (isCacheBustingPass) {
+            const newAnchorId = appendReminderToLatestUserMessage(args.messages, pendingUserTurnReminder.text);
+            if (newAnchorId) {
+              setPersistedStickyTurnReminder(args.db, args.sessionId, pendingUserTurnReminder.text, newAnchorId);
+              sessionLog(args.sessionId, `sticky turn reminder re-anchored: ${pendingUserTurnReminder.messageId} \u2192 ${newAnchorId}`);
+            } else {
+              clearPersistedStickyTurnReminder(args.db, args.sessionId);
+              sessionLog(args.sessionId, `sticky turn reminder cleared \u2014 anchor ${pendingUserTurnReminder.messageId} gone and no user message visible`);
+            }
+          } else {
+            sessionLog(args.sessionId, `preserving sticky turn reminder anchor to avoid cache bust: messageId=${pendingUserTurnReminder.messageId}`);
+          }
         }
       } else {
         const anchoredMessageId = appendReminderToLatestUserMessage(args.messages, pendingUserTurnReminder.text);
@@ -30781,7 +31618,17 @@ function runPostTransformPhase(args) {
   if (stickyNoteNudge) {
     const reinjected = appendReminderToUserMessageById(args.messages, stickyNoteNudge.messageId, stickyNoteNudge.text);
     if (!reinjected) {
-      sessionLog(args.sessionId, `preserving sticky note nudge anchor to avoid cache bust: messageId=${stickyNoteNudge.messageId}`);
+      if (isCacheBustingPass) {
+        const newAnchorId = appendReminderToLatestUserMessage(args.messages, stickyNoteNudge.text);
+        if (newAnchorId) {
+          markNoteNudgeDelivered(args.db, args.sessionId, stickyNoteNudge.text, newAnchorId);
+          sessionLog(args.sessionId, `sticky note nudge re-anchored: ${stickyNoteNudge.messageId} \u2192 ${newAnchorId}`);
+        } else {
+          sessionLog(args.sessionId, `sticky note nudge anchor ${stickyNoteNudge.messageId} gone \u2014 no user message visible to re-anchor`);
+        }
+      } else {
+        sessionLog(args.sessionId, `preserving sticky note nudge anchor to avoid cache bust: messageId=${stickyNoteNudge.messageId}`);
+      }
     }
   }
   const deferredNoteText = peekNoteNudgeText(args.db, args.sessionId, args.currentTurnId, args.projectPath);
@@ -30856,7 +31703,7 @@ function createTransform(deps) {
     const canRunCompartments = fullFeatureMode && deps.client !== undefined && compartmentDirectory.length > 0;
     const contextUsageEarly = loadContextUsage(deps.contextUsageMap, db, sessionId);
     const schedulerDecisionEarly = resolveSchedulerDecision(deps.scheduler, sessionMeta, contextUsageEarly, sessionId, deps.getModelKey?.(sessionId));
-    const isCacheBusting = deps.flushedSessions.has(sessionId) || schedulerDecisionEarly === "execute";
+    const isCacheBusting = deps.flushedSessions.has(sessionId);
     let pendingCompartmentInjection = null;
     if (fullFeatureMode) {
       const projectPath = deps.memoryConfig?.enabled ? resolveProjectIdentity(deps.directory ?? process.cwd()) : undefined;
@@ -30947,7 +31794,9 @@ function createTransform(deps) {
       projectPath: deps.memoryConfig?.enabled ? resolveProjectIdentity(deps.directory ?? process.cwd()) : undefined,
       injectionBudgetTokens: deps.memoryConfig?.injectionBudgetTokens,
       getNotificationParams: rawGetNotifParams ? () => rawGetNotifParams(sessionId) : undefined,
-      cacheAlreadyBusting: isCacheBusting
+      cacheAlreadyBusting: isCacheBusting || schedulerDecisionEarly === "execute",
+      experimentalCompactionMarkers: deps.experimentalCompactionMarkers,
+      experimentalUserMemories: deps.experimentalUserMemories
     });
     pendingCompartmentInjection = compartmentPhase.pendingCompartmentInjection;
     const awaitedCompartmentRun = compartmentPhase.awaitedCompartmentRun;
@@ -31137,7 +31986,7 @@ function createToolExecuteAfterHook(args) {
 
 // src/hooks/magic-context/system-prompt-hash.ts
 import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 
 // src/agents/magic-context-prompt.ts
 var BASE_INTRO = (protectedTags) => `Messages and tool outputs are tagged with \xA7N\xA7 identifiers (e.g., \xA71\xA7, \xA742\xA7).
@@ -31338,11 +32187,13 @@ Prefer many small targeted operations over one large blanket operation. Compress
 init_logger();
 var MAGIC_CONTEXT_MARKER = "## Magic Context";
 var PROJECT_DOCS_MARKER = "<project-docs>";
+var USER_PROFILE_MARKER = "<user-profile>";
+var cachedUserProfileBySession = new Map;
 var DOC_FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
 function readProjectDocs(directory) {
   const sections = [];
   for (const filename of DOC_FILES) {
-    const filePath = join11(directory, filename);
+    const filePath = join12(directory, filename);
     try {
       if (existsSync5(filePath)) {
         const content = readFileSync4(filePath, "utf-8").trim();
@@ -31397,6 +32248,28 @@ function createSystemPromptHashHandler(deps) {
         output.system.push(docsBlock);
       }
     }
+    if (deps.experimentalUserMemories) {
+      const hasCachedProfile = cachedUserProfileBySession.has(sessionId);
+      if (!hasCachedProfile || isCacheBusting) {
+        const memories = getActiveUserMemories(deps.db);
+        if (memories.length > 0) {
+          const items = memories.map((m) => `- ${m.content}`).join(`
+`);
+          cachedUserProfileBySession.set(sessionId, `${USER_PROFILE_MARKER}
+${items}
+</user-profile>`);
+          if (!hasCachedProfile) {
+            sessionLog(sessionId, `loaded ${memories.length} user profile memorie(s)`);
+          }
+        } else {
+          cachedUserProfileBySession.set(sessionId, null);
+        }
+      }
+      const profileBlock = cachedUserProfileBySession.get(sessionId);
+      if (profileBlock && !fullPrompt.includes(USER_PROFILE_MARKER)) {
+        output.system.push(profileBlock);
+      }
+    }
     const DATE_PATTERN = /Today's date: .+/;
     for (let i = 0;i < output.system.length; i++) {
       const match = output.system[i].match(DATE_PATTERN);
@@ -31530,7 +32403,9 @@ function createMagicContextHook(deps) {
       const model = liveModelBySession.get(sessionId);
       return resolveModelKey(model?.providerID, model?.modelID);
     },
-    projectPath
+    projectPath,
+    experimentalCompactionMarkers: deps.config.experimental?.compaction_markers,
+    experimentalUserMemories: deps.config.experimental?.user_memories?.enabled
   });
   const eventHandler = createEventHandler2({
     contextUsageMap,
@@ -31565,7 +32440,11 @@ function createMagicContextHook(deps) {
       client: deps.client,
       tasks: dreaming.tasks,
       taskTimeoutMinutes: dreaming.task_timeout_minutes,
-      maxRuntimeMinutes: dreaming.max_runtime_minutes
+      maxRuntimeMinutes: dreaming.max_runtime_minutes,
+      experimentalUserMemories: deps.config.experimental?.user_memories?.enabled ? {
+        enabled: true,
+        promotionThreshold: deps.config.experimental.user_memories?.promotion_threshold
+      } : undefined
     }).catch((error48) => {
       log("[dreamer] scheduled queue processing failed:", error48);
     });
@@ -31607,7 +32486,11 @@ function createMagicContextHook(deps) {
       config: deps.config.dreamer,
       projectPath,
       client: deps.client,
-      directory: deps.directory
+      directory: deps.directory,
+      experimentalUserMemories: deps.config.experimental?.user_memories?.enabled ? {
+        enabled: true,
+        promotionThreshold: deps.config.experimental.user_memories?.promotion_threshold
+      } : undefined
     } : undefined
   });
   const emergencyNudgeFired = new Set;
@@ -31619,7 +32502,8 @@ function createMagicContextHook(deps) {
     injectDocs: deps.config.dreamer?.inject_docs !== false,
     directory: deps.directory,
     flushedSessions,
-    lastHeuristicsTurnId
+    lastHeuristicsTurnId,
+    experimentalUserMemories: deps.config.experimental?.user_memories?.enabled
   });
   const eventHook = createEventHook({
     eventHandler,
@@ -31696,7 +32580,8 @@ function createSessionHooks(args) {
         historian_timeout_ms: pluginConfig.historian_timeout_ms,
         memory: pluginConfig.memory,
         sidekick: pluginConfig.sidekick,
-        dreamer: pluginConfig.dreamer
+        dreamer: pluginConfig.dreamer,
+        experimental: pluginConfig.experimental
       }
     })
   };
@@ -32079,9 +32964,9 @@ Use this for short goals, constraints, decisions, or reminders worth carrying fo
 
 Actions:
 - \`write\`: Append one note. Optionally provide \`surface_condition\` to create a smart note.
-- \`read\`: Show current notes (session notes + ready smart notes).
-- \`clear\`: Remove all session notes.
-- \`dismiss\`: Dismiss a ready smart note by \`note_id\`.
+- \`read\`: Show current notes. Defaults to active session notes + ready smart notes; use \`filter\` to inspect all, pending, ready, active, or dismissed notes.
+- \`dismiss\`: Dismiss a note by \`note_id\`.
+- \`update\`: Update a note by \`note_id\`.
 
 **Smart Notes**: When \`surface_condition\` is provided with \`write\`, the note becomes a project-scoped smart note.
 The dreamer evaluates smart note conditions during nightly runs and surfaces them when conditions are met.
@@ -32090,14 +32975,79 @@ Example: \`ctx_note(action="write", content="Implement X because Y", surface_con
 Historian reads these notes, deduplicates them, and rewrites the remaining useful notes over time.`;
 // src/tools/ctx-note/tools.ts
 import { tool as tool3 } from "@opencode-ai/plugin";
+function formatNoteLine(note) {
+  const statusSuffix = note.status === "active" ? "" : ` (${note.status})`;
+  const dismissHint = note.status === "dismissed" ? "" : ` _(dismiss with \`ctx_note(action="dismiss", note_id=${note.id})\`)_`;
+  if (note.type === "session") {
+    return `- **#${note.id}**${statusSuffix}: ${note.content}${dismissHint}`;
+  }
+  const conditionText = note.status === "ready" ? note.readyReason ?? note.surfaceCondition ?? "Condition satisfied" : note.surfaceCondition ?? "No condition recorded";
+  const conditionLabel = note.status === "ready" ? "Condition met" : "Condition";
+  return `- **#${note.id}**${statusSuffix}: ${note.content}
+  ${conditionLabel}: ${conditionText}${dismissHint}`;
+}
+function buildReadSections(args) {
+  if (args.filter === undefined) {
+    const sessionNotes2 = getSessionNotes(args.db, args.sessionId);
+    const readySmartNotes = args.projectIdentity ? getReadySmartNotes(args.db, args.projectIdentity) : [];
+    const sections2 = [];
+    if (sessionNotes2.length > 0) {
+      sections2.push(`## Session Notes
+
+${sessionNotes2.map((note) => formatNoteLine(note)).join(`
+`)}`);
+    }
+    if (readySmartNotes.length > 0) {
+      sections2.push(`## \uD83D\uDD14 Ready Smart Notes
+
+${readySmartNotes.map((note) => formatNoteLine(note)).join(`
+
+`)}`);
+    }
+    return sections2;
+  }
+  const statusByFilter = {
+    active: "active",
+    all: ["active", "pending", "ready", "dismissed"],
+    dismissed: "dismissed",
+    pending: "pending",
+    ready: "ready"
+  };
+  const sessionNotes = getNotes(args.db, {
+    sessionId: args.sessionId,
+    type: "session",
+    status: statusByFilter[args.filter]
+  });
+  const smartNotes = args.projectIdentity ? getNotes(args.db, {
+    projectPath: args.projectIdentity,
+    type: "smart",
+    status: statusByFilter[args.filter]
+  }) : [];
+  const sections = [];
+  if (sessionNotes.length > 0) {
+    sections.push(`## Session Notes
+
+${sessionNotes.map((note) => formatNoteLine(note)).join(`
+`)}`);
+  }
+  if (smartNotes.length > 0) {
+    sections.push(`## Smart Notes
+
+${smartNotes.map((note) => formatNoteLine(note)).join(`
+
+`)}`);
+  }
+  return sections;
+}
 function createCtxNoteTool(deps) {
   return tool3({
     description: CTX_NOTE_DESCRIPTION,
     args: {
-      action: tool3.schema.enum(["write", "read", "clear", "dismiss"]).optional().describe("Operation to perform. Defaults to 'write' when content is provided, otherwise 'read'."),
+      action: tool3.schema.enum(["write", "read", "dismiss", "update"]).optional().describe("Operation to perform. Defaults to 'write' when content is provided, otherwise 'read'."),
       content: tool3.schema.string().optional().describe("Note text to store when action is 'write'."),
       surface_condition: tool3.schema.string().optional().describe("Open-ended condition for smart notes. When provided, creates a project-scoped smart note that the dreamer evaluates nightly. The note surfaces when the condition is met."),
-      note_id: tool3.schema.number().optional().describe("Smart note ID to dismiss (required for 'dismiss' action).")
+      filter: tool3.schema.enum(["all", "active", "pending", "ready", "dismissed"]).optional().describe("Optional read filter. Defaults to active session notes + ready smart notes. Use 'all' to inspect every status or 'pending' to inspect unsurfaced smart notes."),
+      note_id: tool3.schema.number().optional().describe("Note ID (required for 'dismiss' and 'update' actions).")
     },
     async execute(args, toolContext) {
       const sessionId = toolContext.sessionID;
@@ -32114,48 +33064,59 @@ function createCtxNoteTool(deps) {
           if (!deps.projectIdentity) {
             return "Error: Could not resolve project identity for smart note.";
           }
-          const note = addSmartNote(deps.db, deps.projectIdentity, content, args.surface_condition.trim(), sessionId);
-          return `Created smart note #${note.id}. Dreamer will evaluate the condition during nightly runs:
+          const note2 = addNote(deps.db, "smart", {
+            content,
+            projectPath: deps.projectIdentity,
+            sessionId,
+            surfaceCondition: args.surface_condition.trim()
+          });
+          return `Created smart note #${note2.id}. Dreamer will evaluate the condition during nightly runs:
 - Content: ${content}
 - Condition: ${args.surface_condition.trim()}`;
         }
-        addSessionNote(deps.db, sessionId, content);
-        const total = getSessionNotes(deps.db, sessionId).length;
-        return `Saved session note ${total}. Historian will rewrite or deduplicate notes as needed.`;
+        const note = addNote(deps.db, "session", { sessionId, content });
+        return `Saved session note #${note.id}. Historian will rewrite or deduplicate notes as needed.`;
       }
       if (action === "dismiss") {
         const noteId = args.note_id;
         if (typeof noteId !== "number") {
           return "Error: 'note_id' is required when action is 'dismiss'.";
         }
-        const dismissed = dismissSmartNote(deps.db, noteId);
-        return dismissed ? `Smart note #${noteId} dismissed.` : `Smart note #${noteId} not found or already dismissed.`;
-      }
-      if (action === "clear") {
-        const existing = getSessionNotes(deps.db, sessionId);
-        clearSessionNotes(deps.db, sessionId);
-        return existing.length === 0 ? "Session notes were already empty." : `Cleared ${existing.length} session note${existing.length === 1 ? "" : "s"}.`;
-      }
-      const notes = getSessionNotes(deps.db, sessionId);
-      const readySmartNotes = deps.projectIdentity ? getReadySmartNotes(deps.db, deps.projectIdentity) : [];
-      const sections = [];
-      if (notes.length > 0) {
-        const lines = notes.map((note, index) => `${index + 1}. ${note.content}`);
-        sections.push(`## Session Notes
-
-${lines.join(`
-`)}`);
-      }
-      if (readySmartNotes.length > 0) {
-        const lines = readySmartNotes.map((n) => `- **#${n.id}**: ${n.content}
-  Condition met: ${n.readyReason ?? n.surfaceCondition}
-  _(dismiss with \`ctx_note(action="dismiss", note_id=${n.id})\`)_`);
-        sections.push(`## \uD83D\uDD14 Ready Smart Notes
-
-${lines.join(`
-
-`)}`);
+        const dismissed = dismissNote(deps.db, noteId);
+        return dismissed ? `Note #${noteId} dismissed.` : `Note #${noteId} not found or already dismissed.`;
       }
+      if (action === "update") {
+        const noteId = args.note_id;
+        if (typeof noteId !== "number") {
+          return "Error: 'note_id' is required when action is 'update'.";
+        }
+        const updates = {};
+        if (args.content?.trim())
+          updates.content = args.content.trim();
+        if (args.surface_condition?.trim())
+          updates.surfaceCondition = args.surface_condition.trim();
+        if (!updates.content && !updates.surfaceCondition) {
+          return "Error: Provide 'content' and/or 'surface_condition' to update.";
+        }
+        const updated = updateNote(deps.db, noteId, updates);
+        if (!updated) {
+          return `Note #${noteId} not found or has no compatible fields to update.`;
+        }
+        const parts = [];
+        if (updates.content)
+          parts.push(`Content: ${updates.content}`);
+        if (updates.surfaceCondition)
+          parts.push(`Condition: ${updates.surfaceCondition}`);
+        return `Updated note #${noteId}:
+${parts.join(`
+`)}`;
+      }
+      const sections = buildReadSections({
+        db: deps.db,
+        filter: args.filter,
+        projectIdentity: deps.projectIdentity,
+        sessionId
+      });
       if (sections.length === 0) {
         return `## Notes
 
@@ -32789,6 +33750,115 @@ function createToolRegistry(args) {
   return allTools;
 }
 
+// src/features/magic-context/plugin-messages.ts
+function isPluginMessageRow(row) {
+  if (row === null || typeof row !== "object")
+    return false;
+  const r = row;
+  return typeof r.id === "number" && typeof r.direction === "string" && typeof r.type === "string" && typeof r.payload === "string" && typeof r.created_at === "number";
+}
+function toPluginMessage(row) {
+  let payload = {};
+  try {
+    payload = JSON.parse(row.payload);
+  } catch {}
+  return {
+    id: row.id,
+    direction: row.direction,
+    type: row.type,
+    payload,
+    sessionId: row.session_id,
+    createdAt: row.created_at,
+    consumedAt: row.consumed_at
+  };
+}
+var CLEANUP_THRESHOLD_MS = 5 * 60 * 1000;
+function sendToTui(db, type, payload, sessionId) {
+  const result = db.prepare("INSERT INTO plugin_messages (direction, type, payload, session_id, created_at) VALUES (?, ?, ?, ?, ?)").run("server_to_tui", type, JSON.stringify(payload), sessionId ?? null, Date.now());
+  return Number(result.lastInsertRowid);
+}
+function consumeMessages(db, direction, options) {
+  const now = Date.now();
+  const conditions = ["direction = ?", "consumed_at IS NULL"];
+  const params = [direction];
+  if (options?.type) {
+    conditions.push("type = ?");
+    params.push(options.type);
+  }
+  if (options?.sessionId) {
+    conditions.push("session_id = ?");
+    params.push(options.sessionId);
+  }
+  const query = `SELECT * FROM plugin_messages WHERE ${conditions.join(" AND ")} ORDER BY created_at ASC`;
+  const rows = db.prepare(query).all(...params);
+  const messages = rows.filter(isPluginMessageRow).map(toPluginMessage);
+  if (messages.length > 0) {
+    const ids = messages.map((m) => m.id);
+    db.prepare(`UPDATE plugin_messages SET consumed_at = ? WHERE id IN (${ids.map(() => "?").join(",")})`).run(now, ...ids);
+  }
+  db.prepare("DELETE FROM plugin_messages WHERE created_at < ?").run(now - CLEANUP_THRESHOLD_MS);
+  return messages;
+}
+function sendTuiToast(db, message, options) {
+  return sendToTui(db, "toast", {
+    message,
+    variant: options?.variant ?? "info",
+    duration: options?.duration ?? 5000
+  }, options?.sessionId);
+}
+
+// src/plugin/tui-action-consumer.ts
+init_logger();
+var DEFAULT_COMPARTMENT_TOKEN_BUDGET2 = 20000;
+var DEFAULT_HISTORIAN_TIMEOUT_MS2 = 10 * 60 * 1000;
+var TUI_ACTION_POLL_INTERVAL_MS = 2000;
+function startTuiActionConsumer(args) {
+  const { client, directory, config: config2 } = args;
+  const timer = setInterval(() => {
+    try {
+      const db = openDatabase();
+      const actions = consumeMessages(db, "tui_to_server", { type: "action" });
+      for (const msg of actions) {
+        const command = msg.payload.command;
+        const sessionId = msg.sessionId;
+        if (command === "recomp" && sessionId) {
+          log(`[magic-context] TUI action: recomp requested for session ${sessionId}`);
+          sendTuiToast(db, "Historian recomp started", {
+            variant: "info",
+            sessionId
+          });
+          executeContextRecomp({
+            client,
+            db,
+            sessionId,
+            tokenBudget: config2.compartment_token_budget ?? DEFAULT_COMPARTMENT_TOKEN_BUDGET2,
+            historianTimeoutMs: config2.historian_timeout_ms ?? DEFAULT_HISTORIAN_TIMEOUT_MS2,
+            directory,
+            getNotificationParams: () => ({})
+          }).then((result) => {
+            sendTuiToast(db, "Recomp completed", { variant: "success", sessionId });
+            sendIgnoredMessage(client, sessionId, result, {}).catch(() => {});
+          }).catch((error48) => {
+            log("[magic-context] TUI recomp failed:", error48);
+            sendTuiToast(db, `Recomp failed: ${error48 instanceof Error ? error48.message : "unknown error"}`, { variant: "error", sessionId });
+          });
+        } else {
+          log(`[magic-context] TUI action: unknown command=${String(command)} session=${String(sessionId)}`);
+        }
+      }
+    } catch (error48) {
+      log("[magic-context] TUI action consumer error:", error48);
+    }
+  }, TUI_ACTION_POLL_INTERVAL_MS);
+  if (typeof timer === "object" && "unref" in timer) {
+    timer.unref();
+  }
+  log("[magic-context] started TUI action consumer (2s poll)");
+  return () => {
+    clearInterval(timer);
+  };
+}
+
 // src/index.ts
 init_conflict_detector();
 init_logger();
@@ -32818,7 +33888,16 @@ var plugin = async (ctx) => {
       client: ctx.client,
       dreamerConfig: pluginConfig.dreamer,
       embeddingConfig: pluginConfig.embedding,
-      memoryEnabled: pluginConfig.memory?.enabled === true
+      memoryEnabled: pluginConfig.memory?.enabled === true,
+      experimentalUserMemories: pluginConfig.experimental?.user_memories?.enabled ? {
+        enabled: true,
+        promotionThreshold: pluginConfig.experimental.user_memories?.promotion_threshold
+      } : undefined
+    });
+    startTuiActionConsumer({
+      client: ctx.client,
+      directory: ctx.directory,
+      config: pluginConfig
     });
   }
   if (conflictResult?.hasConflict) {
@@ -32898,7 +33977,7 @@ var plugin = async (ctx) => {
       config2.agent = {
         ...config2.agent ?? {},
         [DREAMER_AGENT]: buildHiddenAgentConfig(DREAMER_AGENT, DREAMER_SYSTEM_PROMPT, dreamerAgentOverrides),
-        [HISTORIAN_AGENT]: buildHiddenAgentConfig(HISTORIAN_AGENT, COMPARTMENT_AGENT_SYSTEM_PROMPT, pluginConfig.historian),
+        [HISTORIAN_AGENT]: buildHiddenAgentConfig(HISTORIAN_AGENT, pluginConfig.experimental?.user_memories?.enabled ? COMPARTMENT_AGENT_SYSTEM_PROMPT + USER_OBSERVATIONS_APPENDIX : COMPARTMENT_AGENT_SYSTEM_PROMPT, pluginConfig.historian),
         [SIDEKICK_AGENT]: buildHiddenAgentConfig(SIDEKICK_AGENT, SIDEKICK_SYSTEM_PROMPT, sidekickAgentOverrides)
       };
     }