@cortexkit/opencode-magic-context 0.30.6 → 0.31.0

package/dist/index.js

@@ -15372,7 +15372,6 @@ var init_magic_context = __esm(() => {
     enabled: exports_external.boolean().default(true).describe("Enable magic context (default: true)"),
     auto_update: exports_external.boolean().optional().describe("Enable automatic npm self-update checks for the OpenCode plugin. Security: USER-only in config loader, so hostile project configs cannot suppress updates."),
     language: exports_external.string().trim().toLowerCase().refine((s) => isValidLanguageCode(s), 'language must be a 2-letter ISO 639-1 code (e.g. "tr", "es", "de")').optional().describe("Output language for Magic Context's generated content and guidance, as a " + '2-letter ISO 639-1 code (e.g. "tr", "es", "de", "ja", "pt"). When set, the ' + "historian, dreamer, sidekick, and the agent-guidance block instruct the model to " + "write its PROSE in this language while keeping all structural tokens (XML tags, " + "the five memory category names, code identifiers, file paths) in English. " + "USER-LEVEL ONLY (ignored in project config for security). Unset = today's " + "behavior (model mirrors the conversation; English scaffolding). Changing it " + "triggers one cache re-materialization; existing compartments/memories keep their " + "original language until naturally rewritten."),
-    ctx_reduce_enabled: exports_external.boolean().default(true).describe("When false, ctx_reduce tool is hidden, all nudges disabled, and prompt guidance about ctx_reduce stripped. Heuristic cleanup, compartments, memory, and other features still work. (default: true)"),
     historian: HistorianConfigSchema.describe("Historian agent configuration (model, fallback_models, variant, temperature, maxTokens, permission, two_pass, etc.)"),
     dreamer: DreamerConfigSchema.optional().describe("Dreamer agent + scheduling configuration (model, fallback_models, disable, schedule, tasks, etc.)"),
     cache_ttl: exports_external.union([exports_external.string(), exports_external.object({ default: exports_external.string() }).catchall(exports_external.string())]).default("5m").describe('Cache TTL: string (e.g. "5m") or per-model object ({ default: "5m", "model-id": "10m" })'),
@@ -15411,9 +15410,9 @@ var init_magic_context = __esm(() => {
     keep_subagents: exports_external.boolean().default(false).describe("Debug: keep the child sessions Magic Context spawns for its own subagents (historian, dreamer, sidekick, memory-migration) instead of deleting them on success. Useful for short-term inspection/data collection — their full transcript (prompt, tool calls, token usage, output) stays in the host session store. Kept sessions accumulate until manually cleared; leave false for normal use. Requires a restart to take effect."),
     smart_drops: exports_external.boolean().default(false).describe("Content-aware reclaim of provably-superseded tool output, layered on the existing execute-pass auto-drop. When on: superseded todowrite (keep newest 1), spent ctx_reduce (keep newest 5), and zero-value meta (bash_status, bash_kill, ctx_note read/dismiss) outputs are dropped; older edits to a file are compressed to a filePath-preserving marker while the newest edit per file stays full. Only acts on passes already busting the cache, so it never originates a cache bust. Honors the protected-tag reserve. Experimental: opt-in, default off until cache stability is proven; when off the wire is byte-identical to the positional-only reclaim. Requires a restart."),
     caveman_text_compression: exports_external.object({
-      enabled: exports_external.boolean().default(false).describe("Apply deterministic caveman-style text compression to old conversation text. Only active when ctx_reduce_enabled=false. Compresses user/assistant text in oldest-first tiers: ultra (oldest 20%), full, lite, untouched (newest 40%)."),
+      enabled: exports_external.boolean().default(false).describe("Apply deterministic caveman-style text compression to old conversation text. Active for primary sessions when enabled; never for subagents. Compresses user/assistant text in oldest-first tiers: ultra (oldest 20%), full, lite, untouched (newest 40%)."),
       min_chars: exports_external.number().min(100).max(1e4).default(500).describe("Text parts shorter than this (characters) stay untouched. Min 100, max 10000. Default: 500.")
-    }).default({ enabled: false, min_chars: 500 }).describe("Age-tier caveman compression for long user/assistant text parts. Only active when ctx_reduce_enabled is false. Oldest 20% of eligible tags (outside protected tail) go to ultra, next 20% to full, next 20% to lite, newest 40% untouched. Graduated from experimental.caveman_text_compression; opt-in, default off (lossy)."),
+    }).default({ enabled: false, min_chars: 500 }).describe("Age-tier caveman compression for long user/assistant text parts. Active for primary sessions when enabled; never for subagents. Oldest 20% of eligible tags (outside protected tail) go to ultra, next 20% to full, next 20% to lite, newest 40% untouched. Graduated from experimental.caveman_text_compression; opt-in, default off (lossy)."),
     memory: exports_external.object({
       enabled: exports_external.boolean().default(true).describe("Enable cross-session memory (default: true)"),
       injection_budget_tokens: exports_external.number().min(500).max(20000).default(4000).describe("Token budget for memory injection on session start (min: 500, max: 20000, default: 4000)"),
@@ -15446,10 +15445,344 @@ var init_magic_context = __esm(() => {
   });
 });
 
+// src/shared/error-message.ts
+function getErrorMessage(error51) {
+  return error51 instanceof Error ? error51.message : String(error51);
+}
+function readString(value) {
+  if (typeof value === "string" && value.length > 0)
+    return value;
+  if (typeof value === "number")
+    return String(value);
+  return;
+}
+function clip(value, max) {
+  if (value.length <= max)
+    return value;
+  return `${value.slice(0, max)}…`;
+}
+function describeError(error51) {
+  const stringForm = clip(safeString(error51), 400);
+  if (!(error51 instanceof Error) && !(error51 && typeof error51 === "object")) {
+    return {
+      name: typeof error51,
+      message: "",
+      stringForm,
+      brief: stringForm || "<empty>"
+    };
+  }
+  const obj = error51;
+  const nameFromField = readString(obj.name);
+  const nameFromCtor = error51?.constructor?.name;
+  const name = nameFromField ?? nameFromCtor ?? "Error";
+  const message = readString(obj.message) ?? "";
+  const status = readString(obj.status) ?? readString(obj.statusCode);
+  const code = readString(obj.code);
+  let causeName;
+  const cause = obj.cause;
+  if (cause && typeof cause === "object") {
+    const causeRecord = cause;
+    causeName = readString(causeRecord.name) ?? cause.constructor?.name;
+  }
+  const stack = readString(obj.stack);
+  const stackHead = stack ? stack.split(`
+`).slice(0, 4).map((l) => l.trim()).filter((l) => l.length > 0).join(" | ") : undefined;
+  const briefParts = [];
+  if (name)
+    briefParts.push(name);
+  if (message)
+    briefParts.push(`message="${clip(message, 200)}"`);
+  if (status)
+    briefParts.push(`status=${status}`);
+  if (code)
+    briefParts.push(`code=${code}`);
+  if (causeName)
+    briefParts.push(`cause=${causeName}`);
+  if (!message && stringForm && stringForm !== name) {
+    briefParts.push(`str="${clip(stringForm, 200)}"`);
+  }
+  const brief = briefParts.join(" ") || stringForm || name;
+  return {
+    name,
+    message,
+    ...status ? { status } : {},
+    ...code ? { code } : {},
+    ...causeName ? { causeName } : {},
+    ...stackHead ? { stackHead } : {},
+    stringForm,
+    brief
+  };
+}
+function safeString(value) {
+  try {
+    return String(value);
+  } catch {
+    return "<unstringifiable>";
+  }
+}
+
+// src/shared/sqlite.ts
+function buildNodeSqliteDatabaseClass(DatabaseSync) {
+  const SAVEPOINT = "mc_tx_sp";
+
+  class NodeSqliteDatabase extends DatabaseSync {
+    constructor(filename, options) {
+      const translated = { ...options };
+      if (options && "readonly" in options) {
+        translated.readOnly = options.readonly;
+        delete translated.readonly;
+      }
+      super(typeof filename === "string" ? filename : ":memory:", translated);
+    }
+    prepare(sql) {
+      const stmt = super.prepare(sql);
+      for (const method of ["run", "get", "all"]) {
+        const original = stmt[method].bind(stmt);
+        stmt[method] = (...args) => args.length === 1 && Array.isArray(args[0]) ? original(...args[0]) : original(...args);
+      }
+      return stmt;
+    }
+    transaction(fn) {
+      const self2 = this;
+      const wrapped = function(...args) {
+        const nested = self2.isTransaction === true;
+        self2.exec(nested ? `SAVEPOINT ${SAVEPOINT}` : "BEGIN");
+        try {
+          const result = fn.apply(this, args);
+          self2.exec(nested ? `RELEASE ${SAVEPOINT}` : "COMMIT");
+          return result;
+        } catch (error51) {
+          if (nested) {
+            self2.exec(`ROLLBACK TO ${SAVEPOINT}`);
+            self2.exec(`RELEASE ${SAVEPOINT}`);
+          } else {
+            self2.exec("ROLLBACK");
+          }
+          throw error51;
+        }
+      };
+      return wrapped;
+    }
+  }
+  return NodeSqliteDatabase;
+}
+var isBun, bunSpec, nodeSpec, sqliteModule, DatabaseImpl, Database;
+var init_sqlite = __esm(async () => {
+  isBun = typeof process !== "undefined" && typeof process.versions?.bun === "string";
+  bunSpec = "bun:" + "sqlite";
+  nodeSpec = "node:" + "sqlite";
+  sqliteModule = isBun ? await import(bunSpec) : await import(nodeSpec);
+  DatabaseImpl = isBun ? sqliteModule.Database : buildNodeSqliteDatabaseClass(sqliteModule.DatabaseSync);
+  Database = DatabaseImpl;
+});
+
+// src/shared/sqlite-helpers.ts
+function closeQuietly(db) {
+  if (!db)
+    return;
+  try {
+    db.close();
+  } catch {}
+}
+
+// src/features/magic-context/compaction-marker.ts
+import { existsSync as existsSync6 } from "node:fs";
+import { join as join3 } from "node:path";
+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 getOpenCodeDbPath() {
+  return join3(getDataDir(), "opencode", "opencode.db");
+}
+function isOpenCodeSchemaCompatible(db, dbPath) {
+  if (cachedSchemaCompatible?.path === dbPath) {
+    return cachedSchemaCompatible.compatible;
+  }
+  try {
+    const messageCols = new Set(db.prepare("PRAGMA table_info(message)").all().map((r) => r.name ?? "").filter((n) => n.length > 0));
+    const partCols = new Set(db.prepare("PRAGMA table_info(part)").all().map((r) => r.name ?? "").filter((n) => n.length > 0));
+    const missingMessage = REQUIRED_MESSAGE_COLUMNS.filter((c) => !messageCols.has(c));
+    const missingPart = REQUIRED_PART_COLUMNS.filter((c) => !partCols.has(c));
+    if (missingMessage.length > 0 || missingPart.length > 0) {
+      log(`[magic-context] compaction-marker: OpenCode DB schema missing required columns ` + `(message: [${missingMessage.join(", ")}], part: [${missingPart.join(", ")}]). ` + `Marker injection disabled for this process. ` + `This usually means OpenCode was updated and magic-context is out of date.`);
+      cachedSchemaCompatible = { path: dbPath, compatible: false };
+      return false;
+    }
+    cachedSchemaCompatible = { path: dbPath, compatible: true };
+    return true;
+  } catch (error51) {
+    log(`[magic-context] compaction-marker: schema probe failed: ${error51 instanceof Error ? error51.message : String(error51)}. ` + `Marker injection disabled until next process restart.`);
+    cachedSchemaCompatible = { path: dbPath, compatible: false };
+    return false;
+  }
+}
+function getWritableOpenCodeDb() {
+  const dbPath = getOpenCodeDbPath();
+  if (cachedWriteDb?.path === dbPath) {
+    return cachedWriteDb.db;
+  }
+  if (cachedWriteDb) {
+    try {
+      closeQuietly(cachedWriteDb.db);
+    } catch {}
+  }
+  if (!existsSync6(dbPath)) {
+    throw new Error(`OpenCode database not found at ${dbPath} (is OpenCode installed?)`);
+  }
+  const db = new Database(dbPath);
+  db.exec("PRAGMA busy_timeout=5000");
+  db.exec("PRAGMA journal_mode=WAL");
+  cachedWriteDb = { path: dbPath, db };
+  return db;
+}
+function getNonSummaryMessageSortKey(sessionId, messageId) {
+  const db = getWritableOpenCodeDb();
+  const row = db.prepare(`SELECT time_created, id
+             FROM message
+             WHERE session_id = ?
+               AND id = ?
+               AND NOT (COALESCE(json_extract(data, '$.summary'), 0) = 1
+                        AND COALESCE(json_extract(data, '$.finish'), '') = 'stop')
+             LIMIT 1`).get(sessionId, messageId);
+  if (typeof row?.time_created !== "number" || typeof row.id !== "string") {
+    return null;
+  }
+  return { id: row.id, timeCreated: row.time_created };
+}
+function findBoundaryUserMessage(sessionId, endMessageId) {
+  const db = getWritableOpenCodeDb();
+  const target = getNonSummaryMessageSortKey(sessionId, endMessageId);
+  if (!target)
+    return null;
+  const boundary = db.prepare(`SELECT id, time_created, data
+             FROM message
+             WHERE session_id = ?
+               AND NOT (COALESCE(json_extract(data, '$.summary'), 0) = 1
+                        AND COALESCE(json_extract(data, '$.finish'), '') = 'stop')
+               AND COALESCE(json_extract(data, '$.role'), '') = 'user'
+               AND (time_created < ? OR (time_created = ? AND id <= ?))
+             ORDER BY time_created DESC, id DESC
+             LIMIT 1`).get(sessionId, target.timeCreated, target.timeCreated, target.id);
+  if (typeof boundary?.id !== "string" || typeof boundary.time_created !== "number") {
+    return null;
+  }
+  return { id: boundary.id, timeCreated: boundary.time_created };
+}
+function compareOpenCodeMessagesByCanonicalOrder(sessionId, leftMessageId, rightMessageId) {
+  const left = getNonSummaryMessageSortKey(sessionId, leftMessageId);
+  const right = getNonSummaryMessageSortKey(sessionId, rightMessageId);
+  if (!left || !right)
+    return null;
+  if (left.timeCreated < right.timeCreated)
+    return -1;
+  if (left.timeCreated > right.timeCreated)
+    return 1;
+  if (left.id < right.id)
+    return -1;
+  if (left.id > right.id)
+    return 1;
+  return 0;
+}
+function getOpenCodeMessageById(sessionId, messageId) {
+  const db = getWritableOpenCodeDb();
+  const row = db.prepare(`SELECT id FROM message WHERE session_id = ? AND id = ? LIMIT 1`).get(sessionId, messageId);
+  return row ?? null;
+}
+function injectCompactionMarker(args) {
+  const db = getWritableOpenCodeDb();
+  if (!isOpenCodeSchemaCompatible(db, getOpenCodeDbPath())) {
+    return null;
+  }
+  const boundary = args.resolvedBoundary ?? findBoundaryUserMessage(args.sessionId, args.endMessageId);
+  if (!boundary) {
+    log(`[magic-context] compaction-marker: no user message found at or before endMessageId ${args.endMessageId} (ordinal ${args.endOrdinal})`);
+    return null;
+  }
+  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 (error51) {
+    log(`[magic-context] compaction-marker: injection failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
+    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 (error51) {
+    log(`[magic-context] compaction-marker: removal failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
+    return false;
+  }
+}
+var BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", cachedWriteDb = null, REQUIRED_MESSAGE_COLUMNS, REQUIRED_PART_COLUMNS, cachedSchemaCompatible = null;
+var init_compaction_marker = __esm(async () => {
+  init_data_path();
+  init_logger();
+  await init_sqlite();
+  REQUIRED_MESSAGE_COLUMNS = ["id", "session_id", "time_created", "time_updated", "data"];
+  REQUIRED_PART_COLUMNS = [
+    "id",
+    "message_id",
+    "session_id",
+    "time_created",
+    "time_updated",
+    "data"
+  ];
+});
+
 // src/features/magic-context/memory/project-identity.ts
 import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync8, realpathSync, statSync as statSync2 } from "node:fs";
 import path3 from "node:path";
 function asError(error51) {
   return error51 instanceof Error ? error51 : undefined;
@@ -15526,6 +15859,9 @@ function classifyGitError(error51, rawDirectory) {
     return new ProjectIdentityError("permission_denied", rawDirectory, "Permission denied while spawning git", asError(error51));
   }
   const stderr = getErrorStderr(error51).toLowerCase();
+  if (stderr.includes("detected dubious ownership")) {
+    return new ProjectIdentityError("dubious_ownership", rawDirectory, "git refused to read the repository because it detected dubious ownership", asError(error51));
+  }
   if (stderr.includes("not a git repository") || stderr.includes("does not have any commits yet") || stderr.includes("ambiguous argument 'head'") || stderr.includes("unknown revision or path")) {
     return new ProjectIdentityError("not_git_repo", rawDirectory, "Directory has no git root commit; caller may use directory fallback", asError(error51));
   }
@@ -15538,9 +15874,12 @@ function resolveProjectIdentityStrict(directory) {
     return cached2;
   }
   assertDirectoryUsable(canonical, directory);
+  if (!hasGitDir(canonical)) {
+    throw new ProjectIdentityError("not_git_repo", directory, "Directory has no git metadata; caller may use directory fallback");
+  }
   let output;
   try {
-    output = execFileSync("git", ["rev-list", "--max-parents=0", "HEAD"], {
+    output = execFileSyncForIdentity("git", ["rev-list", "--max-parents=0", "HEAD"], {
       cwd: canonical,
       encoding: "utf8",
       env: { ...process.env, LC_ALL: "C", LANG: "C" },
@@ -15558,10 +15897,82 @@ function resolveProjectIdentityStrict(directory) {
   }
   const identity = `git:${rootCommit}`;
   identityCache.set(canonical, identity);
+  lastKnownGitIdentityCache.set(canonical, identity);
+  transientFailureCooldown.delete(canonical);
+  dubiousOwnershipFallbackDirectories.delete(canonical);
+  transientGitIdentityReuseLoggedDirectories.delete(canonical);
   return identity;
 }
 function shouldUseDirectoryFallback(error51) {
-  return error51.errorClass === "not_git_repo" || error51.errorClass === "unknown" && error51.message.startsWith("Unable to access project directory:");
+  return error51.errorClass !== "permission_denied";
+}
+function getActiveCooldown(canonical) {
+  const until = transientFailureCooldown.get(canonical);
+  if (until === undefined)
+    return;
+  if (nowMs() < until)
+    return until;
+  transientFailureCooldown.delete(canonical);
+  return;
+}
+function lastKnownGitIdentity(canonical) {
+  return lastKnownGitIdentityCache.get(canonical) ?? identityCache.get(canonical);
+}
+function nearestLastKnownGitIdentity(canonical) {
+  const visited = new Set;
+  const walk = (start) => {
+    let current = start;
+    while (!visited.has(current)) {
+      visited.add(current);
+      const cached2 = lastKnownGitIdentity(current);
+      if (cached2 !== undefined)
+        return { identity: cached2, source: current };
+      const parent = path3.dirname(current);
+      if (parent === current)
+        break;
+      current = parent;
+    }
+    return;
+  };
+  const exactOrAncestor = walk(canonical);
+  if (exactOrAncestor)
+    return exactOrAncestor;
+  try {
+    const realCanonical = realpathSync.native(canonical);
+    if (realCanonical !== canonical)
+      return walk(realCanonical);
+  } catch {}
+  return;
+}
+function reuseLastKnownGitIdentity(canonical) {
+  const cached2 = nearestLastKnownGitIdentity(canonical);
+  if (cached2 === undefined)
+    return;
+  if (!transientGitIdentityReuseLoggedDirectories.has(canonical)) {
+    transientGitIdentityReuseLoggedDirectories.add(canonical);
+    const sourceNote = cached2.source === canonical ? "" : ` from ancestor ${cached2.source}`;
+    log(`[magic-context] git identity resolution is temporarily unavailable for ${canonical}; reusing the last successful project identity${sourceNote} to avoid splitting project-scoped memory`);
+  }
+  return cached2.identity;
+}
+function formatDubiousOwnershipWarning(canonical) {
+  return `Magic Context: git refused to read ${canonical} (dubious ownership — the repo is owned by a different user). Using a directory-based project identity for now, which keeps memory separate from this repo's normal identity. Fix: git config --global --add safe.directory ${canonical}`;
+}
+function recordDubiousOwnershipFallback(canonical) {
+  dubiousOwnershipFallbackDirectories.add(canonical);
+  if (dubiousOwnershipLoggedDirectories.has(canonical))
+    return;
+  dubiousOwnershipLoggedDirectories.add(canonical);
+  log(`[magic-context] ${formatDubiousOwnershipWarning(canonical)}`);
+}
+function takeDubiousOwnershipProjectIdentityWarning(directory) {
+  const canonical = path3.resolve(directory);
+  if (!dubiousOwnershipFallbackDirectories.has(canonical))
+    return null;
+  if (dubiousOwnershipWarnedDirectories.has(canonical))
+    return null;
+  dubiousOwnershipWarnedDirectories.add(canonical);
+  return formatDubiousOwnershipWarning(canonical);
 }
 function resolveProjectIdentity(directory) {
   const canonical = path3.resolve(directory);
@@ -15572,27 +15983,74 @@ function resolveProjectIdentity(directory) {
     }
     directoryFallbackCache.delete(canonical);
   }
+  if (getActiveCooldown(canonical) !== undefined) {
+    if (hasGitDir(canonical)) {
+      const cachedGitIdentity = reuseLastKnownGitIdentity(canonical);
+      if (cachedGitIdentity !== undefined) {
+        return cachedGitIdentity;
+      }
+    }
+    return directoryFallback(canonical);
+  }
   try {
     return resolveProjectIdentityStrict(directory);
   } catch (error51) {
     if (error51 instanceof ProjectIdentityError && shouldUseDirectoryFallback(error51)) {
       const fallback = directoryFallback(canonical);
-      if (!hasGitDir(canonical)) {
+      const hasGitMetadata = hasGitDir(canonical);
+      if (!hasGitMetadata) {
         directoryFallbackCache.set(canonical, fallback);
+        transientFailureCooldown.delete(canonical);
+      } else {
+        transientFailureCooldown.set(canonical, nowMs() + TRANSIENT_FAILURE_COOLDOWN_MS);
+        const cachedGitIdentity = reuseLastKnownGitIdentity(canonical);
+        if (cachedGitIdentity !== undefined) {
+          return cachedGitIdentity;
+        }
+      }
+      if (error51.errorClass === "dubious_ownership") {
+        recordDubiousOwnershipFallback(canonical);
       }
       return fallback;
     }
     throw error51;
   }
 }
-function hasGitDir(canonical) {
+function resolveProjectIdentityOrFallback(directory) {
   try {
-    statSync2(path3.join(canonical, ".git"));
+    return resolveProjectIdentity(directory);
+  } catch (error51) {
+    const canonical = path3.resolve(directory);
+    const fallback = directoryFallback(canonical);
+    const message = error51 instanceof Error ? error51.message : String(error51);
+    log(`[magic-context] project identity resolution failed for ${canonical}; using directory fallback ${fallback}: ${message}`);
+    return fallback;
+  }
+}
+function hasGitDir(canonical) {
+  if (hasGitDirInAncestorChain(canonical)) {
     return true;
+  }
+  try {
+    const realCanonical = realpathSync.native(canonical);
+    return realCanonical !== canonical && hasGitDirInAncestorChain(realCanonical);
   } catch {
     return false;
   }
 }
+function hasGitDirInAncestorChain(startDirectory) {
+  let current = startDirectory;
+  while (true) {
+    if (existsSync8(path3.join(current, ".git"))) {
+      return true;
+    }
+    const parent = path3.dirname(current);
+    if (parent === current) {
+      return false;
+    }
+    current = parent;
+  }
+}
 function normalizeStoredProjectPath(rawOrStored) {
   if (rawOrStored.startsWith("git:") || rawOrStored.startsWith("dir:")) {
     return rawOrStored;
@@ -15606,10 +16064,19 @@ function normalizeStoredProjectPath(rawOrStored) {
 function storedPathBelongsToIdentity(storedProjectPath, projectIdentity) {
   return storedProjectPath === projectIdentity || normalizeStoredProjectPath(storedProjectPath) === projectIdentity;
 }
-var GIT_TIMEOUT_MS = 5000, identityCache, directoryFallbackCache, ProjectIdentityError;
+var GIT_TIMEOUT_MS = 5000, TRANSIENT_FAILURE_COOLDOWN_MS, identityCache, lastKnownGitIdentityCache, directoryFallbackCache, transientFailureCooldown, dubiousOwnershipFallbackDirectories, dubiousOwnershipLoggedDirectories, dubiousOwnershipWarnedDirectories, transientGitIdentityReuseLoggedDirectories, execFileSyncForIdentity, nowMs = () => Date.now(), ProjectIdentityError;
 var init_project_identity = __esm(() => {
+  init_logger();
+  TRANSIENT_FAILURE_COOLDOWN_MS = 5 * 60 * 1000;
   identityCache = new Map;
+  lastKnownGitIdentityCache = new Map;
   directoryFallbackCache = new Map;
+  transientFailureCooldown = new Map;
+  dubiousOwnershipFallbackDirectories = new Set;
+  dubiousOwnershipLoggedDirectories = new Set;
+  dubiousOwnershipWarnedDirectories = new Set;
+  transientGitIdentityReuseLoggedDirectories = new Set;
+  execFileSyncForIdentity = execFileSync;
   ProjectIdentityError = class ProjectIdentityError extends Error {
     errorClass;
     rawDirectory;
@@ -15625,6 +16092,80 @@ var init_project_identity = __esm(() => {
   };
 });
 
+// src/features/magic-context/session-project-storage.ts
+function getUpsertSessionProjectStatement(db) {
+  let stmt = upsertSessionProjectStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`INSERT INTO session_projects (session_id, harness, project_path, updated_at)
+             VALUES (?, ?, ?, ?)
+             ON CONFLICT(session_id, harness) DO UPDATE SET
+                 project_path = excluded.project_path,
+                 updated_at = excluded.updated_at
+             WHERE session_projects.project_path <> excluded.project_path`);
+    upsertSessionProjectStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getRepairSessionChunkProjectStatement(db) {
+  let stmt = repairSessionChunkProjectStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`UPDATE compartment_chunk_embeddings
+             SET project_path = ?
+             WHERE session_id = ?
+               AND harness = ?
+               AND project_path <> ?`);
+    repairSessionChunkProjectStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getRepairProjectChunkProjectStatement(db) {
+  let stmt = repairProjectChunkProjectStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare(`UPDATE compartment_chunk_embeddings
+             SET project_path = (
+                 SELECT sp.project_path
+                 FROM session_projects sp
+                 WHERE sp.session_id = compartment_chunk_embeddings.session_id
+                   AND sp.harness = compartment_chunk_embeddings.harness
+                 LIMIT 1
+             )
+             WHERE EXISTS (
+                 SELECT 1
+                 FROM session_projects sp
+                 WHERE sp.session_id = compartment_chunk_embeddings.session_id
+                   AND sp.harness = compartment_chunk_embeddings.harness
+                   AND sp.project_path <> compartment_chunk_embeddings.project_path
+                   AND (
+                       sp.project_path = ?
+                       OR compartment_chunk_embeddings.project_path = ?
+                   )
+             )`);
+    repairProjectChunkProjectStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function recordSessionProjectIdentity(db, sessionId, projectPath) {
+  if (!sessionId || !projectPath)
+    return;
+  const harness = getHarness();
+  const now = Date.now();
+  db.transaction(() => {
+    getUpsertSessionProjectStatement(db).run(sessionId, harness, projectPath, now);
+    getRepairSessionChunkProjectStatement(db).run(projectPath, sessionId, harness, projectPath);
+  })();
+}
+function repairMisScopedCompartmentChunkEmbeddingsForProject(db, projectPath) {
+  if (!projectPath)
+    return 0;
+  return getRepairProjectChunkProjectStatement(db).run(projectPath, projectPath).changes;
+}
+var upsertSessionProjectStatements, repairSessionChunkProjectStatements, repairProjectChunkProjectStatements;
+var init_session_project_storage = __esm(() => {
+  upsertSessionProjectStatements = new WeakMap;
+  repairSessionChunkProjectStatements = new WeakMap;
+  repairProjectChunkProjectStatements = new WeakMap;
+});
+
 // src/features/magic-context/overflow-detection.ts
 function extractErrorMessage(error51) {
   if (!error51)
@@ -16735,78 +17276,14 @@ function removeSystemReminders(text) {
 }
 var SYSTEM_DIRECTIVE_PREFIX = "[SYSTEM DIRECTIVE: MAGIC-CONTEXT";
 
-// src/shared/sqlite.ts
-function buildNodeSqliteDatabaseClass(DatabaseSync) {
-  const SAVEPOINT = "mc_tx_sp";
-
-  class NodeSqliteDatabase extends DatabaseSync {
-    constructor(filename, options) {
-      const translated = { ...options };
-      if (options && "readonly" in options) {
-        translated.readOnly = options.readonly;
-        delete translated.readonly;
-      }
-      super(typeof filename === "string" ? filename : ":memory:", translated);
-    }
-    prepare(sql) {
-      const stmt = super.prepare(sql);
-      for (const method of ["run", "get", "all"]) {
-        const original = stmt[method].bind(stmt);
-        stmt[method] = (...args) => args.length === 1 && Array.isArray(args[0]) ? original(...args[0]) : original(...args);
-      }
-      return stmt;
-    }
-    transaction(fn) {
-      const self2 = this;
-      const wrapped = function(...args) {
-        const nested = self2.isTransaction === true;
-        self2.exec(nested ? `SAVEPOINT ${SAVEPOINT}` : "BEGIN");
-        try {
-          const result = fn.apply(this, args);
-          self2.exec(nested ? `RELEASE ${SAVEPOINT}` : "COMMIT");
-          return result;
-        } catch (error51) {
-          if (nested) {
-            self2.exec(`ROLLBACK TO ${SAVEPOINT}`);
-            self2.exec(`RELEASE ${SAVEPOINT}`);
-          } else {
-            self2.exec("ROLLBACK");
-          }
-          throw error51;
-        }
-      };
-      return wrapped;
-    }
-  }
-  return NodeSqliteDatabase;
-}
-var isBun, bunSpec, nodeSpec, sqliteModule, DatabaseImpl, Database;
-var init_sqlite = __esm(async () => {
-  isBun = typeof process !== "undefined" && typeof process.versions?.bun === "string";
-  bunSpec = "bun:" + "sqlite";
-  nodeSpec = "node:" + "sqlite";
-  sqliteModule = isBun ? await import(bunSpec) : await import(nodeSpec);
-  DatabaseImpl = isBun ? sqliteModule.Database : buildNodeSqliteDatabaseClass(sqliteModule.DatabaseSync);
-  Database = DatabaseImpl;
-});
-
-// src/shared/sqlite-helpers.ts
-function closeQuietly(db) {
-  if (!db)
-    return;
-  try {
-    db.close();
-  } catch {}
-}
-
 // src/hooks/magic-context/read-session-db.ts
-import { existsSync as existsSync6 } from "node:fs";
-import { join as join3 } from "node:path";
-function getOpenCodeDbPath() {
-  return join3(getDataDir(), "opencode", "opencode.db");
+import { existsSync as existsSync10 } from "node:fs";
+import { join as join4 } from "node:path";
+function getOpenCodeDbPath2() {
+  return join4(getDataDir(), "opencode", "opencode.db");
 }
 function openCodeDbExists() {
-  return existsSync6(getOpenCodeDbPath());
+  return existsSync10(getOpenCodeDbPath2());
 }
 function closeCachedReadOnlyDb() {
   if (!cachedReadOnlyDb) {
@@ -16821,7 +17298,7 @@ function closeCachedReadOnlyDb() {
   }
 }
 function getReadOnlySessionDb() {
-  const dbPath = getOpenCodeDbPath();
+  const dbPath = getOpenCodeDbPath2();
   if (cachedReadOnlyDb?.path === dbPath) {
     return cachedReadOnlyDb.db;
   }
@@ -152420,6 +152897,15 @@ var init_migrations = __esm(() => {
                 );
             `);
       }
+    },
+    {
+      version: 50,
+      description: "add durable ctx-wrapup session marker",
+      up(db) {
+        if (tableExists2(db, "session_meta")) {
+          ensureColumn(db, "session_meta", "wrapup_in_progress_state", "TEXT");
+        }
+      }
     }
   ];
   LATEST_MIGRATION_VERSION = MIGRATIONS.reduce((max, m) => Math.max(max, m.version), 0);
@@ -152555,82 +153041,6 @@ var init_project_docs_hash = __esm(() => {
   docsCache = new Map;
 });
 
-// src/shared/error-message.ts
-function getErrorMessage(error51) {
-  return error51 instanceof Error ? error51.message : String(error51);
-}
-function readString(value) {
-  if (typeof value === "string" && value.length > 0)
-    return value;
-  if (typeof value === "number")
-    return String(value);
-  return;
-}
-function clip(value, max) {
-  if (value.length <= max)
-    return value;
-  return `${value.slice(0, max)}…`;
-}
-function describeError(error51) {
-  const stringForm = clip(safeString(error51), 400);
-  if (!(error51 instanceof Error) && !(error51 && typeof error51 === "object")) {
-    return {
-      name: typeof error51,
-      message: "",
-      stringForm,
-      brief: stringForm || "<empty>"
-    };
-  }
-  const obj = error51;
-  const nameFromField = readString(obj.name);
-  const nameFromCtor = error51?.constructor?.name;
-  const name2 = nameFromField ?? nameFromCtor ?? "Error";
-  const message = readString(obj.message) ?? "";
-  const status = readString(obj.status) ?? readString(obj.statusCode);
-  const code = readString(obj.code);
-  let causeName;
-  const cause = obj.cause;
-  if (cause && typeof cause === "object") {
-    const causeRecord = cause;
-    causeName = readString(causeRecord.name) ?? cause.constructor?.name;
-  }
-  const stack = readString(obj.stack);
-  const stackHead = stack ? stack.split(`
-`).slice(0, 4).map((l) => l.trim()).filter((l) => l.length > 0).join(" | ") : undefined;
-  const briefParts = [];
-  if (name2)
-    briefParts.push(name2);
-  if (message)
-    briefParts.push(`message="${clip(message, 200)}"`);
-  if (status)
-    briefParts.push(`status=${status}`);
-  if (code)
-    briefParts.push(`code=${code}`);
-  if (causeName)
-    briefParts.push(`cause=${causeName}`);
-  if (!message && stringForm && stringForm !== name2) {
-    briefParts.push(`str="${clip(stringForm, 200)}"`);
-  }
-  const brief = briefParts.join(" ") || stringForm || name2;
-  return {
-    name: name2,
-    message,
-    ...status ? { status } : {},
-    ...code ? { code } : {},
-    ...causeName ? { causeName } : {},
-    ...stackHead ? { stackHead } : {},
-    stringForm,
-    brief
-  };
-}
-function safeString(value) {
-  try {
-    return String(value);
-  } catch {
-    return "<unstringifiable>";
-  }
-}
-
 // src/shared/stable-json.ts
 function stableStringify(value, seen = new WeakSet) {
   if (value === undefined)
@@ -152742,12 +153152,12 @@ var init_tool_definition_tokens = __esm(() => {
 });
 
 // src/features/magic-context/tool-owner-backfill.ts
-import { existsSync as existsSync7 } from "node:fs";
-import { join as join4 } from "node:path";
+import { existsSync as existsSync11 } from "node:fs";
+import { join as join5 } from "node:path";
 function resolveOpencodeDbPath() {
-  return join4(getDataDir(), "opencode", "opencode.db");
+  return join5(getDataDir(), "opencode", "opencode.db");
 }
-function ensureBackfillStateTable(db) {
+function ensureBackfillStateTable2(db) {
   db.exec(`
         CREATE TABLE IF NOT EXISTS tool_owner_backfill_state (
             session_id TEXT PRIMARY KEY,
@@ -152763,7 +153173,7 @@ function ensureBackfillStateTable(db) {
 }
 function runToolOwnerBackfill(db) {
   const startedAt = performance.now();
-  ensureBackfillStateTable(db);
+  ensureBackfillStateTable2(db);
   const result = {
     sessionsProcessed: 0,
     sessionsSkippedNoOcDb: 0,
@@ -152780,7 +153190,7 @@ function runToolOwnerBackfill(db) {
     return result;
   }
   const opencodeDbPath = resolveOpencodeDbPath();
-  if (!existsSync7(opencodeDbPath)) {
+  if (!existsSync11(opencodeDbPath)) {
     log(`[backfill] OpenCode DB not found at ${opencodeDbPath} — marking all unbackfilled sessions as skipped. Lazy adoption (defense-in-depth) handles legacy rows at runtime.`);
     markAllUnbackfilledSessionsSkipped(db);
     result.sessionsSkippedNoOcDb = countSessionsByStatus(db, "skipped");
@@ -152803,7 +153213,7 @@ function runToolOwnerBackfill(db) {
   return result;
 }
 function isToolOwnerBackfillNeeded(db) {
-  ensureBackfillStateTable(db);
+  ensureBackfillStateTable2(db);
   const row = db.prepare(`SELECT 1 AS hit
              FROM tags
              WHERE type = 'tool' AND tool_owner_message_id IS NULL
@@ -153004,8 +153414,8 @@ var init_tool_owner_backfill = __esm(() => {
 });
 
 // src/features/magic-context/storage-db.ts
-import { chmodSync, copyFileSync, cpSync, existsSync as existsSync8, mkdirSync as mkdirSync4, mkdtempSync } from "node:fs";
-import { dirname as dirname4, join as join5 } from "node:path";
+import { chmodSync, copyFileSync, cpSync, existsSync as existsSync12, mkdirSync as mkdirSync4, mkdtempSync } from "node:fs";
+import { dirname as dirname4, join as join6 } from "node:path";
 function getSchemaFenceRejection() {
   return lastSchemaFenceRejection;
 }
@@ -153024,7 +153434,7 @@ function restrictDatabaseFilePermissions(dbPath) {
     return;
   for (const suffix of ["", "-wal", "-shm"]) {
     const file2 = `${dbPath}${suffix}`;
-    if (!existsSync8(file2))
+    if (!existsSync12(file2))
       continue;
     try {
       chmodSync(file2, 384);
@@ -153039,22 +153449,22 @@ function resolveDatabasePath(dbPathOverride) {
   }
   const testDataDir = process.env.MAGIC_CONTEXT_TEST_DATA_DIR;
   if (testDataDir && !process.env.XDG_DATA_HOME) {
-    const dbDir2 = join5(testDataDir, "cortexkit", "magic-context");
-    return { dbDir: dbDir2, dbPath: join5(dbDir2, "context.db") };
+    const dbDir2 = join6(testDataDir, "cortexkit", "magic-context");
+    return { dbDir: dbDir2, dbPath: join6(dbDir2, "context.db") };
   }
   if (false) {}
   const dbDir = getMagicContextStorageDir();
-  return { dbDir, dbPath: join5(dbDir, "context.db") };
+  return { dbDir, dbPath: join6(dbDir, "context.db") };
 }
 function getDatabasePath(db) {
   return pathByDatabase.get(db) ?? null;
 }
 function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
-  if (existsSync8(targetDbPath))
+  if (existsSync12(targetDbPath))
     return;
   const legacyDir = getLegacyOpenCodeMagicContextStorageDir();
-  const legacyDbPath = join5(legacyDir, "context.db");
-  if (!existsSync8(legacyDbPath))
+  const legacyDbPath = join6(legacyDir, "context.db");
+  if (!existsSync12(legacyDbPath))
     return;
   log(`[magic-context] migrating legacy plugin storage: ${legacyDir} -> ${targetDbDir} (legacy left in place as backup)`);
   ensureSecureStorageDir(targetDbDir);
@@ -153070,8 +153480,8 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
   }
   for (const suffix of ["", "-wal", "-shm"]) {
     const src = `${legacyDbPath}${suffix}`;
-    const dst = join5(targetDbDir, `context.db${suffix}`);
-    if (existsSync8(src)) {
+    const dst = join6(targetDbDir, `context.db${suffix}`);
+    if (existsSync12(src)) {
       try {
         copyFileSync(src, dst);
       } catch (error51) {
@@ -153079,9 +153489,9 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
       }
     }
   }
-  const legacyModelsDir = join5(legacyDir, "models");
-  const targetModelsDir = join5(targetDbDir, "models");
-  if (existsSync8(legacyModelsDir) && !existsSync8(targetModelsDir)) {
+  const legacyModelsDir = join6(legacyDir, "models");
+  const targetModelsDir = join6(targetDbDir, "models");
+  if (existsSync12(legacyModelsDir) && !existsSync12(targetModelsDir)) {
     try {
       cpSync(legacyModelsDir, targetModelsDir, { recursive: true });
     } catch (error51) {
@@ -153681,6 +154091,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       force_emergency_bypass_used INTEGER NOT NULL DEFAULT 0,
       emergency_drain_active INTEGER NOT NULL DEFAULT 0,
       historian_drain_failure_at INTEGER NOT NULL DEFAULT 0,
+      wrapup_in_progress_state TEXT,
       cached_m0_materialized_at INTEGER,
       cached_m0_session_facts_version INTEGER,
       cached_m0_upgrade_state TEXT,
@@ -153969,6 +154380,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "session_meta", "force_emergency_bypass_used", "INTEGER NOT NULL DEFAULT 0");
   ensureColumn(db, "session_meta", "emergency_drain_active", "INTEGER NOT NULL DEFAULT 0");
   ensureColumn(db, "session_meta", "historian_drain_failure_at", "INTEGER NOT NULL DEFAULT 0");
+  ensureColumn(db, "session_meta", "wrapup_in_progress_state", "TEXT");
   ensureColumn(db, "session_meta", "cached_m0_materialized_at", "INTEGER");
   ensureColumn(db, "session_meta", "cached_m0_session_facts_version", "INTEGER");
   ensureColumn(db, "session_meta", "cached_m0_upgrade_state", "TEXT");
@@ -154147,7 +154559,7 @@ function getDatabasePersistenceError(db) {
     return null;
   return persistenceErrorByDatabase.get(db) ?? null;
 }
-var databases, persistenceByDatabase, persistenceErrorByDatabase, pathByDatabase, lastSchemaFenceRejection = null, LATEST_SUPPORTED_VERSION = 49, PERMISSIONS_ENFORCEABLE, sqlitePragmaConfig, CHANNEL2_CLAIM_TTL_MS = 120000;
+var databases, persistenceByDatabase, persistenceErrorByDatabase, pathByDatabase, lastSchemaFenceRejection = null, LATEST_SUPPORTED_VERSION = 50, PERMISSIONS_ENFORCEABLE, sqlitePragmaConfig, CHANNEL2_CLAIM_TTL_MS = 120000;
 var init_storage_db = __esm(async () => {
   init_data_path();
   init_logger();
@@ -154487,6 +154899,147 @@ function resetProtectedTailNoEligibleHead(db, sessionId) {
     db.prepare("UPDATE session_meta SET recovery_no_eligible_head_count = 0 WHERE session_id = ?").run(sessionId);
   })();
 }
+function parseWrapupState(value) {
+  if (typeof value !== "string" || value.trim().length === 0)
+    return null;
+  try {
+    const parsed = JSON.parse(value);
+    if (!parsed || typeof parsed !== "object")
+      return null;
+    if (typeof parsed.holderId !== "string" || parsed.holderId.length === 0)
+      return null;
+    const numberFields = [
+      "acquiredAt",
+      "expiresAt",
+      "messagesToKeep",
+      "anchorRawMessageCount",
+      "targetEligibleEndOrdinal",
+      "lastCompartmentEnd",
+      "chunkIndex",
+      "expectedChunks",
+      "updatedAt"
+    ];
+    for (const field of numberFields) {
+      if (typeof parsed[field] !== "number" || !Number.isFinite(parsed[field]))
+        return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function readRawWrapupState(db, sessionId) {
+  const row = db.prepare("SELECT wrapup_in_progress_state FROM session_meta WHERE session_id = ?").get(sessionId);
+  return parseWrapupState(row?.wrapup_in_progress_state);
+}
+function getWrapupInProgressState(db, sessionId, now = Date.now()) {
+  const state = readRawWrapupState(db, sessionId);
+  if (!state)
+    return null;
+  if (state.expiresAt > now)
+    return state;
+  try {
+    db.exec("BEGIN IMMEDIATE");
+  } catch {
+    return null;
+  }
+  let finished = false;
+  try {
+    const current = readRawWrapupState(db, sessionId);
+    if (current && current.expiresAt <= now) {
+      db.prepare("UPDATE session_meta SET wrapup_in_progress_state = NULL WHERE session_id = ?").run(sessionId);
+    }
+    db.exec("COMMIT");
+    finished = true;
+  } finally {
+    if (!finished) {
+      try {
+        db.exec("ROLLBACK");
+      } catch {}
+    }
+  }
+  return null;
+}
+function isWrapupInProgress(db, sessionId, now = Date.now()) {
+  return getWrapupInProgressState(db, sessionId, now) !== null;
+}
+function acquireWrapupInProgress(db, sessionId, state, now = Date.now()) {
+  const acquiredAt = now;
+  const next = {
+    ...state,
+    acquiredAt,
+    expiresAt: acquiredAt + WRAPUP_IN_PROGRESS_TTL_MS,
+    updatedAt: acquiredAt
+  };
+  db.exec("BEGIN IMMEDIATE");
+  let finished = false;
+  try {
+    ensureSessionMetaRow(db, sessionId);
+    const current = readRawWrapupState(db, sessionId);
+    if (current && current.expiresAt > now && current.holderId !== state.holderId) {
+      db.exec("COMMIT");
+      finished = true;
+      return { ok: false, state: current };
+    }
+    db.prepare("UPDATE session_meta SET wrapup_in_progress_state = ? WHERE session_id = ?").run(stableStringify(next), sessionId);
+    db.exec("COMMIT");
+    finished = true;
+    return { ok: true, state: next };
+  } finally {
+    if (!finished) {
+      try {
+        db.exec("ROLLBACK");
+      } catch {}
+    }
+  }
+}
+function updateWrapupInProgress(db, sessionId, holderId, updates, now = Date.now()) {
+  db.exec("BEGIN IMMEDIATE");
+  let finished = false;
+  try {
+    const current = readRawWrapupState(db, sessionId);
+    if (!current || current.holderId !== holderId || current.expiresAt <= now) {
+      db.exec("ROLLBACK");
+      finished = true;
+      return null;
+    }
+    const next = {
+      ...current,
+      ...updates,
+      holderId,
+      expiresAt: now + WRAPUP_IN_PROGRESS_TTL_MS,
+      updatedAt: now
+    };
+    db.prepare("UPDATE session_meta SET wrapup_in_progress_state = ? WHERE session_id = ?").run(stableStringify(next), sessionId);
+    db.exec("COMMIT");
+    finished = true;
+    return next;
+  } finally {
+    if (!finished) {
+      try {
+        db.exec("ROLLBACK");
+      } catch {}
+    }
+  }
+}
+function releaseWrapupInProgress(db, sessionId, holderId) {
+  db.exec("BEGIN IMMEDIATE");
+  let finished = false;
+  try {
+    const current = readRawWrapupState(db, sessionId);
+    if (current?.holderId === holderId) {
+      db.prepare("UPDATE session_meta SET wrapup_in_progress_state = NULL WHERE session_id = ?").run(sessionId);
+    }
+    db.exec("COMMIT");
+    finished = true;
+  } finally {
+    if (!finished) {
+      try {
+        db.exec("ROLLBACK");
+      } catch {}
+    }
+  }
+}
 function protectedTailWindowBudget(usagePercentage, usable, perRunCap) {
   if (usagePercentage >= 95)
     return Math.min(1e6, Math.max(4 * perRunCap, Math.round(0.5 * usable)));
@@ -155164,7 +155717,7 @@ function setSessionWorkMetrics(db, sessionId, newWorkTokens, totalInputTokens) {
          SET new_work_tokens = ?, total_input_tokens = ?
          WHERE session_id = ?`).run(Math.max(0, Math.floor(newWorkTokens)), Math.max(0, Math.floor(totalInputTokens)), sessionId);
 }
-var CAS_RETRY_LIMIT = 5, AUTO_SEARCH_NO_HINT_REASONS, DEFAULT_PROTECTED_TAIL_META, DRAIN_WINDOW_MS, EMERGENCY_DRAIN_ENTER_PERCENTAGE = 95, EMERGENCY_DRAIN_EXIT_MARGIN = 10, EMERGENCY_DRAIN_FALLBACK_EXIT_PERCENTAGE = 55, EMERGENCY_DRAIN_FAILURE_BACKOFF_MS = 60000, EMERGENCY_DRAIN_MAX_LATCH_MS;
+var CAS_RETRY_LIMIT = 5, AUTO_SEARCH_NO_HINT_REASONS, DEFAULT_PROTECTED_TAIL_META, DRAIN_WINDOW_MS, WRAPUP_IN_PROGRESS_TTL_MS, EMERGENCY_DRAIN_ENTER_PERCENTAGE = 95, EMERGENCY_DRAIN_EXIT_MARGIN = 10, EMERGENCY_DRAIN_FALLBACK_EXIT_PERCENTAGE = 55, EMERGENCY_DRAIN_FAILURE_BACKOFF_MS = 60000, EMERGENCY_DRAIN_MAX_LATCH_MS;
 var init_storage_meta_persisted = __esm(() => {
   init_logger();
   init_storage_meta_shared();
@@ -155188,6 +155741,7 @@ var init_storage_meta_persisted = __esm(() => {
     historianDrainFailureAt: 0
   };
   DRAIN_WINDOW_MS = 10 * 60 * 1000;
+  WRAPUP_IN_PROGRESS_TTL_MS = 5 * 60 * 1000;
   EMERGENCY_DRAIN_MAX_LATCH_MS = 30 * 60 * 1000;
 });
 
@@ -164181,10 +164735,10 @@ var require_stringify = __commonJS((exports, module) => {
     replacer = null;
     indent = EMPTY;
   };
-  var join6 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two)), gap) : EMPTY;
+  var join7 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two)), gap) : EMPTY;
   var join_content = (inside, value, gap) => {
     const comment = process_comments(value, PREFIX_BEFORE, gap + indent, true);
-    return join6(comment, inside, gap);
+    return join7(comment, inside, gap);
   };
   var stringify_string = (holder, key, value) => {
     const raw = get_raw_string_literal(holder, key);
@@ -164206,13 +164760,13 @@ var require_stringify = __commonJS((exports, module) => {
       if (i !== 0) {
         inside += COMMA;
       }
-      const before = join6(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
+      const before = join7(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 += join6(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join7(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) => {
@@ -164233,13 +164787,13 @@ var require_stringify = __commonJS((exports, module) => {
         inside += COMMA;
       }
       first = false;
-      const before = join6(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
+      const before = join7(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 += join6(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join7(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) {
@@ -165239,16 +165793,16 @@ var init_compartment_prompt = () => {};
 
 // src/shared/opencode-config-dir.ts
 import { homedir as homedir6 } from "node:os";
-import { join as join10, resolve as resolve3 } from "node:path";
+import { join as join11, resolve as resolve3 } from "node:path";
 function getCliConfigDir() {
   const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
   if (envConfigDir) {
     return resolve3(envConfigDir);
   }
   if (process.platform === "win32") {
-    return join10(homedir6(), ".config", "opencode");
+    return join11(homedir6(), ".config", "opencode");
   }
-  return join10(process.env.XDG_CONFIG_HOME || join10(homedir6(), ".config"), "opencode");
+  return join11(process.env.XDG_CONFIG_HOME || join11(homedir6(), ".config"), "opencode");
 }
 function getOpenCodeConfigDir(_options) {
   return getCliConfigDir();
@@ -165257,16 +165811,16 @@ function getOpenCodeConfigPaths(options) {
   const configDir = getOpenCodeConfigDir(options);
   return {
     configDir,
-    configJson: join10(configDir, "opencode.json"),
-    configJsonc: join10(configDir, "opencode.jsonc"),
-    packageJson: join10(configDir, "package.json"),
-    omoConfig: join10(configDir, "magic-context.jsonc")
+    configJson: join11(configDir, "opencode.json"),
+    configJsonc: join11(configDir, "opencode.jsonc"),
+    packageJson: join11(configDir, "package.json"),
+    omoConfig: join11(configDir, "magic-context.jsonc")
   };
 }
 var init_opencode_config_dir = () => {};
 
 // src/shared/conflict-detector.ts
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 function detectConflicts(directory) {
   const conflicts = {
     compactionAuto: false,
@@ -165323,8 +165877,8 @@ function checkCompaction(directory) {
   return { auto: true, prune: false };
 }
 function readProjectCompaction(directory) {
-  const dotOcJsonc = join11(directory, ".opencode", "opencode.jsonc");
-  const dotOcJson = join11(directory, ".opencode", "opencode.json");
+  const dotOcJsonc = join12(directory, ".opencode", "opencode.jsonc");
+  const dotOcJson = join12(directory, ".opencode", "opencode.json");
   const dotOcConfig = readJsoncFile(dotOcJsonc) ?? readJsoncFile(dotOcJson);
   if (dotOcConfig?.compaction) {
     const c = dotOcConfig.compaction;
@@ -165332,8 +165886,8 @@ function readProjectCompaction(directory) {
       return { auto: c.auto === true, prune: c.prune === true, resolved: true };
     }
   }
-  const rootJsonc = join11(directory, "opencode.jsonc");
-  const rootJson = join11(directory, "opencode.json");
+  const rootJsonc = join12(directory, "opencode.jsonc");
+  const rootJson = join12(directory, "opencode.json");
   const rootConfig = readJsoncFile(rootJsonc) ?? readJsoncFile(rootJson);
   if (rootConfig?.compaction) {
     const c = rootConfig.compaction;
@@ -165387,10 +165941,10 @@ function collectPluginEntries(directory) {
     }
   };
   for (const configPath of [
-    join11(directory, ".opencode", "opencode.jsonc"),
-    join11(directory, ".opencode", "opencode.json"),
-    join11(directory, "opencode.jsonc"),
-    join11(directory, "opencode.json")
+    join12(directory, ".opencode", "opencode.jsonc"),
+    join12(directory, ".opencode", "opencode.json"),
+    join12(directory, "opencode.jsonc"),
+    join12(directory, "opencode.json")
   ]) {
     const config2 = readJsoncFile(configPath);
     pushFrom(config2?.plugin);
@@ -165431,7 +165985,7 @@ function readOmoDisabledHooks(directory) {
   try {
     const paths = getOpenCodeConfigPaths({ binary: "opencode" });
     for (const name2 of configNames) {
-      const configPath = join11(paths.configDir, name2);
+      const configPath = join12(paths.configDir, name2);
       const config2 = readJsoncFile(configPath);
       if (config2?.disabled_hooks) {
         for (const hook of config2.disabled_hooks) {
@@ -165441,7 +165995,7 @@ function readOmoDisabledHooks(directory) {
     }
   } catch {}
   for (const name2 of configNames) {
-    const config2 = readJsoncFile(join11(directory, name2));
+    const config2 = readJsoncFile(join12(directory, name2));
     if (config2?.disabled_hooks) {
       for (const hook of config2.disabled_hooks) {
         disabled.add(hook);
@@ -165592,28 +166146,28 @@ __export(exports_conflict_warning_hook, {
   sendConflictWarning: () => sendConflictWarning,
   cleanupConflictWarnings: () => cleanupConflictWarnings
 });
-import { existsSync as existsSync12, readFileSync as readFileSync10 } from "node:fs";
+import { existsSync as existsSync16, readFileSync as readFileSync10 } from "node:fs";
 import { homedir as homedir7, platform as platform2 } from "node:os";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 function getDesktopStatePath() {
   const os2 = platform2();
   const home = homedir7();
   if (os2 === "darwin") {
-    return join12(home, "Library", "Application Support", "ai.opencode.desktop", "opencode.global.dat");
+    return join13(home, "Library", "Application Support", "ai.opencode.desktop", "opencode.global.dat");
   }
   if (os2 === "linux") {
-    const xdgConfig = process.env.XDG_CONFIG_HOME || join12(home, ".config");
-    return join12(xdgConfig, "ai.opencode.desktop", "opencode.global.dat");
+    const xdgConfig = process.env.XDG_CONFIG_HOME || join13(home, ".config");
+    return join13(xdgConfig, "ai.opencode.desktop", "opencode.global.dat");
   }
   if (os2 === "win32") {
-    const appData = process.env.APPDATA || join12(home, "AppData", "Roaming");
-    return join12(appData, "ai.opencode.desktop", "opencode.global.dat");
+    const appData = process.env.APPDATA || join13(home, "AppData", "Roaming");
+    return join13(appData, "ai.opencode.desktop", "opencode.global.dat");
   }
   return null;
 }
 function readDesktopState(directory) {
   const statePath = getDesktopStatePath();
-  if (!statePath || !existsSync12(statePath)) {
+  if (!statePath || !existsSync16(statePath)) {
     log(`[magic-context] conflict-warning: Desktop state file not found at ${statePath}`);
     return { sessionId: null, sidecarUrl: null };
   }
@@ -165915,196 +166469,6 @@ var init_conflict_warning_hook = __esm(() => {
   cachedDesktopStateByDir = new Map;
 });
 
-// src/features/magic-context/compaction-marker.ts
-import { join as join13 } from "node:path";
-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 join13(getDataDir(), "opencode", "opencode.db");
-}
-function isOpenCodeSchemaCompatible(db, dbPath) {
-  if (cachedSchemaCompatible?.path === dbPath) {
-    return cachedSchemaCompatible.compatible;
-  }
-  try {
-    const messageCols = new Set(db.prepare("PRAGMA table_info(message)").all().map((r) => r.name ?? "").filter((n) => n.length > 0));
-    const partCols = new Set(db.prepare("PRAGMA table_info(part)").all().map((r) => r.name ?? "").filter((n) => n.length > 0));
-    const missingMessage = REQUIRED_MESSAGE_COLUMNS.filter((c) => !messageCols.has(c));
-    const missingPart = REQUIRED_PART_COLUMNS.filter((c) => !partCols.has(c));
-    if (missingMessage.length > 0 || missingPart.length > 0) {
-      log(`[magic-context] compaction-marker: OpenCode DB schema missing required columns ` + `(message: [${missingMessage.join(", ")}], part: [${missingPart.join(", ")}]). ` + `Marker injection disabled for this process. ` + `This usually means OpenCode was updated and magic-context is out of date.`);
-      cachedSchemaCompatible = { path: dbPath, compatible: false };
-      return false;
-    }
-    cachedSchemaCompatible = { path: dbPath, compatible: true };
-    return true;
-  } catch (error51) {
-    log(`[magic-context] compaction-marker: schema probe failed: ${error51 instanceof Error ? error51.message : String(error51)}. ` + `Marker injection disabled until next process restart.`);
-    cachedSchemaCompatible = { path: dbPath, compatible: false };
-    return false;
-  }
-}
-function getWritableOpenCodeDb() {
-  const dbPath = getOpenCodeDbPath2();
-  if (cachedWriteDb?.path === dbPath) {
-    return cachedWriteDb.db;
-  }
-  if (cachedWriteDb) {
-    try {
-      closeQuietly(cachedWriteDb.db);
-    } catch {}
-  }
-  const db = new Database(dbPath);
-  db.exec("PRAGMA busy_timeout=5000");
-  db.exec("PRAGMA journal_mode=WAL");
-  cachedWriteDb = { path: dbPath, db };
-  return db;
-}
-function getNonSummaryMessageSortKey(sessionId, messageId) {
-  const db = getWritableOpenCodeDb();
-  const row = db.prepare(`SELECT time_created, id
-             FROM message
-             WHERE session_id = ?
-               AND id = ?
-               AND NOT (COALESCE(json_extract(data, '$.summary'), 0) = 1
-                        AND COALESCE(json_extract(data, '$.finish'), '') = 'stop')
-             LIMIT 1`).get(sessionId, messageId);
-  if (typeof row?.time_created !== "number" || typeof row.id !== "string") {
-    return null;
-  }
-  return { id: row.id, timeCreated: row.time_created };
-}
-function findBoundaryUserMessage(sessionId, endMessageId) {
-  const db = getWritableOpenCodeDb();
-  const target = getNonSummaryMessageSortKey(sessionId, endMessageId);
-  if (!target)
-    return null;
-  const boundary = db.prepare(`SELECT id, time_created, data
-             FROM message
-             WHERE session_id = ?
-               AND NOT (COALESCE(json_extract(data, '$.summary'), 0) = 1
-                        AND COALESCE(json_extract(data, '$.finish'), '') = 'stop')
-               AND COALESCE(json_extract(data, '$.role'), '') = 'user'
-               AND (time_created < ? OR (time_created = ? AND id <= ?))
-             ORDER BY time_created DESC, id DESC
-             LIMIT 1`).get(sessionId, target.timeCreated, target.timeCreated, target.id);
-  if (typeof boundary?.id !== "string" || typeof boundary.time_created !== "number") {
-    return null;
-  }
-  return { id: boundary.id, timeCreated: boundary.time_created };
-}
-function compareOpenCodeMessagesByCanonicalOrder(sessionId, leftMessageId, rightMessageId) {
-  const left = getNonSummaryMessageSortKey(sessionId, leftMessageId);
-  const right = getNonSummaryMessageSortKey(sessionId, rightMessageId);
-  if (!left || !right)
-    return null;
-  if (left.timeCreated < right.timeCreated)
-    return -1;
-  if (left.timeCreated > right.timeCreated)
-    return 1;
-  if (left.id < right.id)
-    return -1;
-  if (left.id > right.id)
-    return 1;
-  return 0;
-}
-function getOpenCodeMessageById(sessionId, messageId) {
-  const db = getWritableOpenCodeDb();
-  const row = db.prepare(`SELECT id FROM message WHERE session_id = ? AND id = ? LIMIT 1`).get(sessionId, messageId);
-  return row ?? null;
-}
-function injectCompactionMarker(args) {
-  const db = getWritableOpenCodeDb();
-  if (!isOpenCodeSchemaCompatible(db, getOpenCodeDbPath2())) {
-    return null;
-  }
-  const boundary = args.resolvedBoundary ?? findBoundaryUserMessage(args.sessionId, args.endMessageId);
-  if (!boundary) {
-    log(`[magic-context] compaction-marker: no user message found at or before endMessageId ${args.endMessageId} (ordinal ${args.endOrdinal})`);
-    return null;
-  }
-  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 (error51) {
-    log(`[magic-context] compaction-marker: injection failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
-    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 (error51) {
-    log(`[magic-context] compaction-marker: removal failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
-    return false;
-  }
-}
-var BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", cachedWriteDb = null, REQUIRED_MESSAGE_COLUMNS, REQUIRED_PART_COLUMNS, cachedSchemaCompatible = null;
-var init_compaction_marker = __esm(async () => {
-  init_data_path();
-  init_logger();
-  await init_sqlite();
-  REQUIRED_MESSAGE_COLUMNS = ["id", "session_id", "time_created", "time_updated", "data"];
-  REQUIRED_PART_COLUMNS = [
-    "id",
-    "message_id",
-    "session_id",
-    "time_created",
-    "time_updated",
-    "data"
-  ];
-});
-
 // src/features/magic-context/dreamer/task-config.ts
 var exports_task_config = {};
 __export(exports_task_config, {
@@ -166979,7 +167343,8 @@ function isNativeRuntimeMissingError(error51) {
   if (code === "ERR_DLOPEN_FAILED" && lower.includes("onnxruntime")) {
     return true;
   }
-  if (!lower.includes("onnxruntime-node"))
+  const mentionsNativeRuntime = lower.includes("onnxruntime-node") || lower.includes("onnxruntime_binding");
+  if (!mentionsNativeRuntime)
     return false;
   return code === "ERR_MODULE_NOT_FOUND" || name2 === "ResolveMessage" || lower.includes("cannot find package") || lower.includes("cannot find module") || lower.includes("err_module_not_found");
 }
@@ -167124,7 +167489,7 @@ class LocalEmbeddingProvider {
       } catch (error51) {
         if (isNativeRuntimeMissingError(error51)) {
           nativeRuntimeMissing = true;
-          log("[magic-context] local embedding runtime is not installed (onnxruntime-node missing from this install). Local embeddings are disabled. Fix: reinstall the plugin (run `npx @cortexkit/magic-context@latest doctor --force`), or configure an `openai-compatible`/`ollama` embedding endpoint instead. Existing memories are unaffected.");
+          log("[magic-context] local embeddings are disabled because the onnxruntime-node native binding is missing or failed to load. Run `npx @cortexkit/magic-context@latest doctor` for repair guidance (use `doctor --force` to reinstall cached plugin packages), or configure an `openai-compatible` embedding HTTP endpoint. Existing memories are unaffected.");
         } else {
           log("[magic-context] embedding model failed to load:", error51);
         }
@@ -168072,80 +168437,6 @@ var init_embedding_cache = __esm(() => {
   embeddingCacheTtlMs = DEFAULT_EMBEDDING_CACHE_TTL_MS;
 });
 
-// src/features/magic-context/session-project-storage.ts
-function getUpsertSessionProjectStatement(db) {
-  let stmt = upsertSessionProjectStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare(`INSERT INTO session_projects (session_id, harness, project_path, updated_at)
-             VALUES (?, ?, ?, ?)
-             ON CONFLICT(session_id, harness) DO UPDATE SET
-                 project_path = excluded.project_path,
-                 updated_at = excluded.updated_at
-             WHERE session_projects.project_path <> excluded.project_path`);
-    upsertSessionProjectStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getRepairSessionChunkProjectStatement(db) {
-  let stmt = repairSessionChunkProjectStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare(`UPDATE compartment_chunk_embeddings
-             SET project_path = ?
-             WHERE session_id = ?
-               AND harness = ?
-               AND project_path <> ?`);
-    repairSessionChunkProjectStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getRepairProjectChunkProjectStatement(db) {
-  let stmt = repairProjectChunkProjectStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare(`UPDATE compartment_chunk_embeddings
-             SET project_path = (
-                 SELECT sp.project_path
-                 FROM session_projects sp
-                 WHERE sp.session_id = compartment_chunk_embeddings.session_id
-                   AND sp.harness = compartment_chunk_embeddings.harness
-                 LIMIT 1
-             )
-             WHERE EXISTS (
-                 SELECT 1
-                 FROM session_projects sp
-                 WHERE sp.session_id = compartment_chunk_embeddings.session_id
-                   AND sp.harness = compartment_chunk_embeddings.harness
-                   AND sp.project_path <> compartment_chunk_embeddings.project_path
-                   AND (
-                       sp.project_path = ?
-                       OR compartment_chunk_embeddings.project_path = ?
-                   )
-             )`);
-    repairProjectChunkProjectStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function recordSessionProjectIdentity(db, sessionId, projectPath) {
-  if (!sessionId || !projectPath)
-    return;
-  const harness = getHarness();
-  const now = Date.now();
-  db.transaction(() => {
-    getUpsertSessionProjectStatement(db).run(sessionId, harness, projectPath, now);
-    getRepairSessionChunkProjectStatement(db).run(projectPath, sessionId, harness, projectPath);
-  })();
-}
-function repairMisScopedCompartmentChunkEmbeddingsForProject(db, projectPath) {
-  if (!projectPath)
-    return 0;
-  return getRepairProjectChunkProjectStatement(db).run(projectPath, projectPath).changes;
-}
-var upsertSessionProjectStatements, repairSessionChunkProjectStatements, repairProjectChunkProjectStatements;
-var init_session_project_storage = __esm(() => {
-  upsertSessionProjectStatements = new WeakMap;
-  repairSessionChunkProjectStatements = new WeakMap;
-  repairProjectChunkProjectStatements = new WeakMap;
-});
-
 // src/features/magic-context/project-embedding-registry.ts
 import { createHash as createHash8, randomUUID } from "node:crypto";
 function markProjectLoadUntrusted(projectIdentity) {
@@ -169782,7 +170073,7 @@ function getMemoryVerifications(db, memoryIds) {
 var MEMORY_VERIFICATION_SENTINEL = "";
 // src/features/magic-context/memory/verification-paths.ts
 import { execFile } from "node:child_process";
-import { existsSync as existsSync14, realpathSync as realpathSync2, statSync as statSync5 } from "node:fs";
+import { existsSync as existsSync17, realpathSync as realpathSync3, statSync as statSync5 } from "node:fs";
 import path6 from "node:path";
 import { promisify } from "node:util";
 async function runGit(cwd, args) {
@@ -169807,7 +170098,7 @@ function isWithin(root, candidate) {
 }
 function safeRealpath(value) {
   try {
-    return realpathSync2.native(value);
+    return realpathSync3.native(value);
   } catch {
     return null;
   }
@@ -169885,7 +170176,7 @@ function verificationFileExists(baseRoot, filePath) {
     return false;
   const root = path6.resolve(baseRoot);
   const candidate = path6.resolve(root, filePath);
-  return isWithin(root, candidate) && existsSync14(candidate);
+  return isWithin(root, candidate) && existsSync17(candidate);
 }
 async function normalizeVerificationFiles(args) {
   const cwd = path6.resolve(args.cwd);
@@ -169918,7 +170209,7 @@ async function normalizeVerificationFiles(args) {
       warnings.push(`Skipped verification path "${value}" because it is the repo/project root.`);
       continue;
     }
-    if (existsSync14(candidate)) {
+    if (existsSync17(candidate)) {
       try {
         if (statSync5(candidate).isDirectory()) {
           warnings.push(`Skipped verification path "${value}" because it is a directory.`);
@@ -169949,7 +170240,7 @@ async function normalizeVerificationFiles(args) {
       }
       normalized.push(tracked);
     } else {
-      if (!existsSync14(candidate)) {
+      if (!existsSync17(candidate)) {
         warnings.push(`Skipped verification path "${value}" because it does not exist.`);
         continue;
       }
@@ -177293,6 +177584,9 @@ function applyDeferredCompactionMarker(db, sessionId, pending, directory) {
   }
 }
 function updateCompactionMarkerAfterPublication(db, sessionId, lastCompartmentEnd, directory) {
+  if (getHarness() !== "opencode") {
+    return true;
+  }
   const targetEndMessageId = getCompartmentEndMessageIdForOrdinal(db, sessionId, lastCompartmentEnd);
   if (!targetEndMessageId) {
     sessionLog(sessionId, `compaction-marker: no compartment endMessageId for ordinal ${lastCompartmentEnd}; preserving existing marker`);
@@ -178934,7 +179228,8 @@ function readCurrentM0SnapshotMarkers(args) {
     sessionFactsVersion: getSessionFactsVersion(args.db, args.sessionId),
     upgradeState: getUpgradeState(args.db, args.sessionId),
     systemHash: hard.systemHash,
-    modelKey: hard.modelKey
+    modelKey: hard.modelKey,
+    projectIdentity: args.projectPath ?? null
   };
 }
 function snapshotMarkersFromCachedM0(state) {
@@ -178967,7 +179262,8 @@ function snapshotMarkersFromCachedM0(state) {
     sessionFactsVersion: state.cachedM0SessionFactsVersion,
     upgradeState: state.cachedM0UpgradeState,
     systemHash: state.cachedM0SystemHash ?? "",
-    modelKey: state.cachedM0ModelKey ?? ""
+    modelKey: state.cachedM0ModelKey ?? "",
+    projectIdentity: state.cachedM0ProjectIdentity ?? null
   };
 }
 function mustMaterialize(args) {
@@ -178986,6 +179282,15 @@ function mustMaterialize(args) {
   if (hard.cacheExpired && hard.lastResponseTime > 0 && hard.lastResponseTime > (args.state.cachedM0MaterializedAt ?? 0)) {
     return { value: true, reason: "ttl_idle" };
   }
+  if (current.projectIdentity !== null) {
+    const cachedProjectIdentity = args.state.cachedM0ProjectIdentity ?? null;
+    if (cachedProjectIdentity === null) {
+      args.state.cachedM0ProjectIdentity = current.projectIdentity;
+      args.db.prepare("UPDATE session_meta SET cached_m0_project_identity = ? WHERE session_id = ?").run(current.projectIdentity, args.sessionId);
+    } else if (cachedProjectIdentity !== current.projectIdentity) {
+      return { value: true, reason: "project_change" };
+    }
+  }
   if (current.workspaceFingerprint !== null || (args.state.cachedM0WorkspaceFingerprint ?? null) !== null) {
     if ((args.state.cachedM0WorkspaceFingerprint ?? null) !== current.workspaceFingerprint) {
       return { value: true, reason: "project_memory_epoch" };
@@ -179226,6 +179531,7 @@ function applyMarkersToState(state, m0Bytes, markers, m1Bytes) {
   state.cachedM0UpgradeState = markers.upgradeState;
   state.cachedM0SystemHash = markers.systemHash;
   state.cachedM0ModelKey = markers.modelKey;
+  state.cachedM0ProjectIdentity = markers.projectIdentity;
   state.snapshotMarkers = markers;
 }
 function historySliceTokens(m0Text) {
@@ -179349,10 +179655,11 @@ function materializeM0(options) {
       sessionFactsVersion: getSessionFactsVersion(options.db, options.sessionId),
       upgradeState: getUpgradeState(options.db, options.sessionId),
       systemHash: snapshotMarkers.systemHash,
-      modelKey: snapshotMarkers.modelKey
+      modelKey: snapshotMarkers.modelKey,
+      projectIdentity: projectPath ?? null
     };
     const memoryEpochStale = current.workspaceFingerprint !== null || snapshotMarkers.workspaceFingerprint !== null ? current.workspaceFingerprint !== snapshotMarkers.workspaceFingerprint : current.projectMemoryEpoch !== snapshotMarkers.projectMemoryEpoch;
-    const stale = memoryEpochStale || current.projectUserProfileVersion !== snapshotMarkers.projectUserProfileVersion || current.maxCompartmentSeq !== snapshotMarkers.maxCompartmentSeq || current.maxMutationId !== snapshotMarkers.maxMutationId || current.maxMemoryMutationId !== snapshotMarkers.maxMemoryMutationId || current.sessionFactsVersion !== snapshotMarkers.sessionFactsVersion || current.upgradeState !== snapshotMarkers.upgradeState;
+    const stale = memoryEpochStale || current.projectUserProfileVersion !== snapshotMarkers.projectUserProfileVersion || current.maxCompartmentSeq !== snapshotMarkers.maxCompartmentSeq || current.maxMutationId !== snapshotMarkers.maxMutationId || current.maxMemoryMutationId !== snapshotMarkers.maxMemoryMutationId || current.sessionFactsVersion !== snapshotMarkers.sessionFactsVersion || current.upgradeState !== snapshotMarkers.upgradeState || (current.projectIdentity ?? null) !== (snapshotMarkers.projectIdentity ?? null);
     if (stale) {
       options.db.exec("ROLLBACK");
       throw new MaterializeContentionError({ reason: "snapshot changed before Phase 3" });
@@ -179381,7 +179688,8 @@ function materializeM0(options) {
       sessionFactsVersion: snapshotMarkers.sessionFactsVersion,
       upgradeState: snapshotMarkers.upgradeState,
       systemHash: snapshotMarkers.systemHash,
-      modelKey: snapshotMarkers.modelKey
+      modelKey: snapshotMarkers.modelKey,
+      projectIdentity: snapshotMarkers.projectIdentity
     });
     options.db.prepare("UPDATE session_meta SET memory_block_count = ?, memory_block_ids = ? WHERE session_id = ?").run(renderedMemoryIds.length, JSON.stringify(renderedMemoryIds), options.sessionId);
     const baselineEndMessageId = lastCompartmentBoundaryId(compartments);
@@ -179539,6 +179847,7 @@ function readCachedM0M1Row(db, sessionId) {
                     cached_m0_upgrade_state,
                     cached_m0_system_hash,
                     cached_m0_model_key,
+                    cached_m0_project_identity,
                     memory_block_ids
                FROM session_meta
               WHERE session_id = ?`).get(sessionId);
@@ -179573,11 +179882,12 @@ function markersFromCachedRow(row) {
     sessionFactsVersion: row.cached_m0_session_facts_version,
     upgradeState: row.cached_m0_upgrade_state,
     systemHash: row.cached_m0_system_hash ?? "",
-    modelKey: row.cached_m0_model_key ?? ""
+    modelKey: row.cached_m0_model_key ?? "",
+    projectIdentity: row.cached_m0_project_identity ?? null
   };
 }
 function cachedRowMatchesState(row, state) {
-  return bufferEqualsNullable(row.cached_m0_bytes, state.cachedM0Bytes) && row.cached_m0_project_memory_epoch === state.cachedM0ProjectMemoryEpoch && (row.cached_m0_workspace_fingerprint ?? null) === (state.cachedM0WorkspaceFingerprint ?? null) && row.cached_m0_project_user_profile_version === state.cachedM0ProjectUserProfileVersion && row.cached_m0_max_compartment_seq === state.cachedM0MaxCompartmentSeq && row.cached_m0_max_memory_id === state.cachedM0MaxMemoryId && row.cached_m0_max_mutation_id === state.cachedM0MaxMutationId && row.cached_m0_max_memory_mutation_id === state.cachedM0MaxMemoryMutationId && row.cached_m0_materialized_at === state.cachedM0MaterializedAt && row.cached_m0_session_facts_version === state.cachedM0SessionFactsVersion && (row.cached_m0_upgrade_state ?? null) === (state.cachedM0UpgradeState ?? null) && (row.cached_m0_system_hash ?? "") === (state.cachedM0SystemHash ?? "") && (row.cached_m0_model_key ?? "") === (state.cachedM0ModelKey ?? "");
+  return bufferEqualsNullable(row.cached_m0_bytes, state.cachedM0Bytes) && row.cached_m0_project_memory_epoch === state.cachedM0ProjectMemoryEpoch && (row.cached_m0_workspace_fingerprint ?? null) === (state.cachedM0WorkspaceFingerprint ?? null) && row.cached_m0_project_user_profile_version === state.cachedM0ProjectUserProfileVersion && row.cached_m0_max_compartment_seq === state.cachedM0MaxCompartmentSeq && row.cached_m0_max_memory_id === state.cachedM0MaxMemoryId && row.cached_m0_max_mutation_id === state.cachedM0MaxMutationId && row.cached_m0_max_memory_mutation_id === state.cachedM0MaxMemoryMutationId && row.cached_m0_materialized_at === state.cachedM0MaterializedAt && row.cached_m0_session_facts_version === state.cachedM0SessionFactsVersion && (row.cached_m0_upgrade_state ?? null) === (state.cachedM0UpgradeState ?? null) && (row.cached_m0_system_hash ?? "") === (state.cachedM0SystemHash ?? "") && (row.cached_m0_model_key ?? "") === (state.cachedM0ModelKey ?? "") && (row.cached_m0_project_identity ?? null) === (state.cachedM0ProjectIdentity ?? null);
 }
 function applyCachedRowToState(state, row) {
   const markers = markersFromCachedRow(row);
@@ -179599,6 +179909,7 @@ function applyCachedRowToState(state, row) {
   state.cachedM0UpgradeState = markers.upgradeState;
   state.cachedM0SystemHash = markers.systemHash;
   state.cachedM0ModelKey = markers.modelKey;
+  state.cachedM0ProjectIdentity = markers.projectIdentity;
   state.snapshotMarkers = markers;
 }
 function replayCachedM1(state) {
@@ -180593,6 +180904,43 @@ function semanticSnapBoundary(args) {
   }
   return snapped;
 }
+function snapWrapupBoundaryToUser(args) {
+  const { messages, index, candidate, offset, triggerBudget } = args;
+  if (candidate <= offset)
+    return candidate;
+  const snapTokenLimit = Math.min(Math.max(triggerBudget, 2000), 48000);
+  for (let ordinal = candidate;ordinal >= offset; ordinal -= 1) {
+    const message = messages.find((m) => m.ordinal === ordinal);
+    if (!message)
+      continue;
+    if (message.role !== "user" || !hasMeaningfulUserText(message.parts))
+      continue;
+    const extraTokens = index.rangeTokens(ordinal, candidate);
+    if (extraTokens <= snapTokenLimit)
+      return ordinal;
+    return candidate;
+  }
+  return candidate;
+}
+function fenceWrapupBoundaryForToolArcs(args) {
+  let boundary = args.candidate;
+  const maxPasses = args.arcs.length + 1;
+  for (let pass = 0;pass < maxPasses; pass += 1) {
+    let next = boundary;
+    for (const arc of args.arcs) {
+      if (arc.resOrdinal === null) {
+        continue;
+      }
+      if (arc.invOrdinal >= args.lastCompartmentEndOrdinal + 1 && arc.invOrdinal < next && next <= arc.resOrdinal) {
+        next = arc.invOrdinal;
+      }
+    }
+    if (next === boundary)
+      return boundary;
+    boundary = next;
+  }
+  return boundary;
+}
 function applyHeadCap(args) {
   const { index, protectedTailStart, offset, arcs, capTokens, recentOpenArcCutoff } = args;
   if (offset >= protectedTailStart)
@@ -180848,6 +181196,124 @@ function resolveBoundaryContext(args) {
 function resolveOpenCodeProtectedTailBoundary(args) {
   return resolveProtectedTailBoundary(resolveBoundaryContext(args));
 }
+function resolveWrapupProtectedTailBoundary(args) {
+  const ctx = resolveBoundaryContext({ ...args, mode: "manual-wrapup" });
+  const createdAt = ctx.createdAt ?? Date.now();
+  const messages = readRawSessionMessages(ctx.sessionId);
+  const absoluteMessageCount = getCachedAbsoluteMessageCount(ctx.sessionId) ?? undefined;
+  const index = buildTrueRawTokenIndex(ctx.sessionId, messages, {
+    providerShapeVersion: ctx.providerShapeVersion,
+    cacheNamespace: ctx.cacheNamespace,
+    absoluteMessageCount,
+    storedTotalForMessage: ctx.storedTokenTotals ? (m) => {
+      const value = ctx.storedTokenTotals?.get(m.id);
+      return value === undefined ? null : value;
+    } : undefined
+  });
+  const rawMessageCount = index.rawMessageCount;
+  const offset = Math.max(1, ctx.lastCompartmentEndOrdinal + 1);
+  const anchorRawMessageCount = Math.max(0, Math.min(rawMessageCount, Math.floor(args.anchorRawMessageCount ?? rawMessageCount)));
+  const usagePercentage = clampPercentage(ctx.usage?.percentage ?? 0);
+  const usageInputTokens = Math.max(0, Math.round(ctx.usage?.inputTokens ?? 0));
+  const rawMessagesAboveLastCompartment = Math.max(0, anchorRawMessageCount - offset + 1);
+  const keep = Math.max(1, Math.floor(args.messagesToKeep));
+  let targetProtectedTailStart = offset;
+  let boundaryReason = "manual-wrapup-empty";
+  if (rawMessageCount === 0 || rawMessagesAboveLastCompartment <= keep) {
+    targetProtectedTailStart = offset;
+    boundaryReason = rawMessageCount === 0 ? "manual-wrapup-empty" : "manual-wrapup-within-keep";
+  } else {
+    targetProtectedTailStart = anchorRawMessageCount - keep + 1;
+    boundaryReason = "manual-wrapup-keep-watermark";
+    const arcs = buildToolArcs(messages);
+    const fenced = fenceWrapupBoundaryForToolArcs({
+      candidate: targetProtectedTailStart,
+      arcs,
+      lastCompartmentEndOrdinal: ctx.lastCompartmentEndOrdinal
+    });
+    if (fenced !== targetProtectedTailStart)
+      boundaryReason = "manual-wrapup-tool-arc";
+    targetProtectedTailStart = fenced;
+    const snapped = snapWrapupBoundaryToUser({
+      messages,
+      index,
+      candidate: targetProtectedTailStart,
+      offset,
+      triggerBudget: ctx.triggerBudget
+    });
+    if (snapped !== targetProtectedTailStart)
+      boundaryReason = "manual-wrapup-user-snap";
+    targetProtectedTailStart = snapped;
+    const refenced = fenceWrapupBoundaryForToolArcs({
+      candidate: targetProtectedTailStart,
+      arcs,
+      lastCompartmentEndOrdinal: ctx.lastCompartmentEndOrdinal
+    });
+    if (refenced !== targetProtectedTailStart)
+      boundaryReason = "manual-wrapup-tool-arc";
+    targetProtectedTailStart = refenced;
+  }
+  targetProtectedTailStart = clampOrdinal(targetProtectedTailStart, rawMessageCount);
+  const target = deriveProtectedTailTokenTarget({
+    contextLimit: ctx.contextLimit,
+    executeThresholdPercentage: ctx.executeThresholdPercentage,
+    usagePercentage,
+    triggerBudget: ctx.triggerBudget
+  });
+  const perRunCap = selectPerRunCap({
+    usagePercentage,
+    N: target.N,
+    contextLimit: ctx.contextLimit,
+    executeThresholdPercentage: ctx.executeThresholdPercentage
+  });
+  const head = applyHeadCap({
+    index,
+    protectedTailStart: targetProtectedTailStart,
+    offset,
+    arcs: buildToolArcs(messages),
+    lastCompartmentEndOrdinal: ctx.lastCompartmentEndOrdinal,
+    capTokens: perRunCap,
+    recentOpenArcCutoff: targetProtectedTailStart
+  });
+  const eligibleEndOrdinal = Math.min(head.eligibleEndOrdinal, targetProtectedTailStart);
+  const rawRangeFingerprint = computeRawRangeFingerprint(messages, offset, eligibleEndOrdinal);
+  const snapshot = {
+    sessionId: ctx.sessionId,
+    mode: "manual-wrapup",
+    offset,
+    offsetMessageId: boundaryMessageId(index, offset),
+    protectedTailStart: targetProtectedTailStart,
+    protectedTailStartMessageId: boundaryMessageId(index, targetProtectedTailStart),
+    eligibleEndOrdinal,
+    eligibleEndMessageId: boundaryMessageId(index, eligibleEndOrdinal - 1),
+    rawMessageCountAtTrigger: rawMessageCount,
+    rawLastMessageIdAtTrigger: boundaryMessageId(index, rawMessageCount),
+    N: keep,
+    usagePercentage,
+    usageInputTokens,
+    usageSource: ctx.usageSource,
+    contextLimit: ctx.contextLimit,
+    executeThresholdPercentage: ctx.executeThresholdPercentage,
+    triggerBudget: ctx.triggerBudget,
+    priorBoundaryOrdinal: ctx.priorBoundaryOrdinal,
+    migrationFloorActive: ctx.migrationFloorActive,
+    emergencyTailScale: ctx.emergencyTailScale,
+    providerShapeVersion: ctx.providerShapeVersion,
+    cacheNamespace: ctx.cacheNamespace,
+    createdAt,
+    rawRangeFingerprint,
+    trueRawEligibleTokens: index.rangeTokens(offset, targetProtectedTailStart),
+    oversizeAtomicUnit: head.oversizeAtomicUnit,
+    boundaryReason
+  };
+  return {
+    snapshot,
+    rawMessagesAboveLastCompartment,
+    anchorRawMessageCount,
+    targetProtectedTailStart,
+    targetEligibleEndOrdinal: targetProtectedTailStart
+  };
+}
 function getRawHistoryEligibility(db, sessionId) {
   const lastCompartmentEnd = getLastCompartmentEndMessage(db, sessionId);
   const offset = Math.max(1, lastCompartmentEnd + 1);
@@ -183075,7 +183541,7 @@ async function runCompartmentAgent(deps) {
       currentContextLimit: deps.currentContextLimit ?? boundarySnapshot.contextLimit
     }) : { ok: true };
     if (!validation.ok && validation.reason === "stale_snapshot") {
-      const refreshed = resolveOpenCodeProtectedTailBoundary({
+      const refreshed = deps.refreshBoundarySnapshot ? deps.refreshBoundarySnapshot(boundarySnapshot, validation) : resolveOpenCodeProtectedTailBoundary({
         db,
         sessionId,
         mode: "incremental-runner",
@@ -183088,7 +183554,7 @@ async function runCompartmentAgent(deps) {
         usageSource: boundarySnapshot.usageSource,
         emergencyTailScale: boundarySnapshot.emergencyTailScale
       });
-      if (hasRunnableCompartmentWindow(refreshed)) {
+      if (refreshed && hasRunnableCompartmentWindow(refreshed)) {
         sessionLog(sessionId, `historian: refreshed stale protected-tail snapshot at run time (was: ${validation.detail ?? "stale"}) — eligible head ${refreshed.offset}-${refreshed.eligibleEndOrdinal - 1}`);
         boundarySnapshot = refreshed;
         validation = { ok: true };
@@ -183106,7 +183572,8 @@ async function runCompartmentAgent(deps) {
     if (protectedTailStart <= offset || eligibleEndOrdinal <= offset) {
       sessionLog(sessionId, `historian no-op: protectedTailStart=${protectedTailStart} eligibleEnd=${eligibleEndOrdinal} <= offset=${offset} — nothing to compact`);
       if (boundarySnapshot.usagePercentage < 80 && !boundarySnapshot.emergencyTailScale) {
-        clearEmergencyRecovery(db, sessionId);
+        if (!isWrapupInProgress(db, sessionId))
+          clearEmergencyRecovery(db, sessionId);
       } else {
         const count = recordHighPressureNoEligibleHead(db, boundarySnapshot);
         sessionLog(sessionId, `historian high-pressure no-op: recovery remains armed (noEligibleHeadCount=${count})`);
@@ -183119,7 +183586,7 @@ async function runCompartmentAgent(deps) {
     }
     const perRunCap = selectPerRunCap(boundarySnapshot);
     const usable = Math.max(1, Math.round(boundarySnapshot.contextLimit * boundarySnapshot.executeThresholdPercentage / 100));
-    const reserve = reserveProtectedTailDrainTokens({
+    const reserve = deps.forceDrainQuota ? { ok: true, reservation: null } : reserveProtectedTailDrainTokens({
       db,
       sessionId,
       runId: crypto.randomUUID(),
@@ -183137,12 +183604,14 @@ async function runCompartmentAgent(deps) {
     }
     drainReservation = reserve.reservation;
     const chunk = readSessionChunk(sessionId, historianChunkTokens, offset, eligibleEndOrdinal);
+    const forceKeepLastCompartmentForChunk = deps.forceKeepLastCompartment === true && !chunk.hasMore;
     telemetry.chunkStartOrdinal = chunk.startIndex;
     telemetry.chunkEndOrdinal = chunk.endIndex;
     if (!chunk.text || chunk.messageCount === 0) {
       sessionLog(sessionId, `historian no-op: chunk empty after filtering (messageCount=${chunk.messageCount}, textLen=${chunk.text?.length ?? 0}) range=${offset}-${eligibleEndOrdinal - 1}`);
       if (boundarySnapshot.usagePercentage < 80 && !boundarySnapshot.emergencyTailScale) {
-        clearEmergencyRecovery(db, sessionId);
+        if (!isWrapupInProgress(db, sessionId))
+          clearEmergencyRecovery(db, sessionId);
       } else {
         recordHighPressureNoEligibleHead(db, boundarySnapshot);
       }
@@ -183216,7 +183685,7 @@ ${chunkText}`,
     const BOUNDARY_HEALING_SLACK = 2;
     const inEmergency = getOverflowState(db, sessionId).needsEmergencyRecovery;
     let persistedCompartments = emittedCompartments;
-    if (!inEmergency && emittedCompartments.length >= 2) {
+    if (!inEmergency && !forceKeepLastCompartmentForChunk && emittedCompartments.length >= 2) {
       const lastEmitted = emittedCompartments[emittedCompartments.length - 1];
       const lookaheadMargin = chunk.endIndex - lastEmitted.endMessage;
       if (lookaheadMargin <= BOUNDARY_HEALING_SLACK) {
@@ -183240,10 +183709,21 @@ ${chunkText}`,
     const lastNewEndMessageId = newCompartments[newCompartments.length - 1]?.endMessageId;
     const promotionDirectory = sessionDirectory || deps.directory;
     const discardedLast = persistedCompartments.length < emittedCompartments.length;
+    const weakLookaheadFinalCompartment = forceKeepLastCompartmentForChunk;
+    const skipUnanchoredPromotion = discardedLast || weakLookaheadFinalCompartment;
     const embeddingActive = !!promotionDirectory && deps.memoryEnabled !== false;
     const promotionActive = embeddingActive && deps.autoPromote !== false;
     const promotionProjectIdentity = promotionDirectory ? resolveProjectIdentity(promotionDirectory) : "";
-    const publishableEvents = (validatedPass.events ?? []).filter((e) => e.atCompartment == null || e.atCompartment <= persistedCompartments.length);
+    const publishableEvents = (validatedPass.events ?? []).filter((e) => {
+      if (typeof e.atCompartment !== "number")
+        return !weakLookaheadFinalCompartment;
+      if (e.atCompartment > persistedCompartments.length)
+        return false;
+      if (weakLookaheadFinalCompartment && e.atCompartment >= emittedCompartments.length) {
+        return false;
+      }
+      return true;
+    });
     let promotedFactRefs = [];
     let persistedIds = [];
     const holderId = deps.compartmentLeaseHolderId;
@@ -183263,7 +183743,7 @@ ${chunkText}`,
       }
       appendCompartments(db, sessionId, persistedCompartments);
       persistedIds = getCompartments(db, sessionId).slice(-persistedCompartments.length).map((c) => c.id);
-      if (promotionActive && !discardedLast) {
+      if (promotionActive && !skipUnanchoredPromotion) {
         promotedFactRefs = promoteSessionFactsDurable(db, sessionId, promotionProjectIdentity, validatedPass.facts ?? []);
       }
       if (publishableEvents.length > 0) {
@@ -183278,7 +183758,8 @@ ${chunkText}`,
       clearHistorianFailureState(db, sessionId);
       clearHistorianDrainFailure(db, sessionId);
       recordProtectedTailPublicationFloor(db, sessionId, lastCompartmentEnd + 1);
-      clearEmergencyRecovery(db, sessionId);
+      if (!isWrapupInProgress(db, sessionId))
+        clearEmergencyRecovery(db, sessionId);
       drainReservation = null;
       if (deferMarkerApplication && lastNewEndMessageId) {
         setPendingCompactionMarkerState(db, sessionId, {
@@ -183350,7 +183831,7 @@ ${chunkText}`,
         }
       })();
     }
-    if (deps.experimentalUserMemories === true && !discardedLast && validatedPass.userObservations && validatedPass.userObservations.length > 0) {
+    if (deps.experimentalUserMemories === true && !skipUnanchoredPromotion && validatedPass.userObservations && validatedPass.userObservations.length > 0) {
       try {
         const lastNew = newCompartments[newCompartments.length - 1];
         insertUserMemoryCandidates(db, validatedPass.userObservations.map((obs) => ({
@@ -183364,7 +183845,7 @@ ${chunkText}`,
         sessionLog(sessionId, "failed to store user memory candidates:", error51);
       }
     }
-    if (!discardedLast && promotionProjectIdentity && validatedPass.primerCandidates && validatedPass.primerCandidates.length > 0) {
+    if (!skipUnanchoredPromotion && promotionProjectIdentity && validatedPass.primerCandidates && validatedPass.primerCandidates.length > 0) {
       try {
         const firstNew = newCompartments[0];
         const lastNew = newCompartments[newCompartments.length - 1];
@@ -184231,6 +184712,21 @@ function markActiveCompartmentRunPublished(sessionId) {
   if (activeRun)
     activeRun.published = true;
 }
+function registerActiveCompartmentRun(sessionId, promise2, kind = "other") {
+  const activeRun = {
+    promise: Promise.resolve(),
+    published: false,
+    kind
+  };
+  const wrapped = promise2.finally(() => {
+    if (activeRuns.get(sessionId)?.promise === wrapped) {
+      activeRuns.delete(sessionId);
+    }
+  });
+  activeRun.promise = wrapped;
+  activeRuns.set(sessionId, activeRun);
+  return activeRun;
+}
 function withPublishedCallback(deps) {
   return {
     ...deps,
@@ -184242,8 +184738,12 @@ function withPublishedCallback(deps) {
 }
 function startLeaseRenewal(deps, holderId) {
   return setInterval(() => {
-    if (!renewCompartmentLease(deps.db, deps.sessionId, holderId)) {
-      sessionLog(deps.sessionId, "compartment lease renewal failed; publish will be skipped if holder is stale");
+    try {
+      if (!renewCompartmentLease(deps.db, deps.sessionId, holderId)) {
+        sessionLog(deps.sessionId, "compartment lease renewal failed; publish will be skipped if holder is stale");
+      }
+    } catch (err) {
+      sessionLog(deps.sessionId, `compartment lease renewal threw; publish will be skipped if holder is stale (${err instanceof Error ? err.message : String(err)})`);
     }
   }, COMPARTMENT_LEASE_RENEWAL_MS);
 }
@@ -184252,6 +184752,11 @@ function startCompartmentAgent(deps) {
   if (existing) {
     return;
   }
+  if (isWrapupInProgress(deps.db, deps.sessionId)) {
+    sessionLog(deps.sessionId, "compartment agent skipped: /ctx-wrapup is active");
+    updateSessionMeta(deps.db, deps.sessionId, { compartmentInProgress: false });
+    return;
+  }
   const holderId = crypto.randomUUID();
   const lease = acquireCompartmentLease(deps.db, deps.sessionId, holderId);
   if (!lease) {
@@ -184259,6 +184764,12 @@ function startCompartmentAgent(deps) {
     updateSessionMeta(deps.db, deps.sessionId, { compartmentInProgress: false });
     return;
   }
+  if (isWrapupInProgress(deps.db, deps.sessionId)) {
+    sessionLog(deps.sessionId, "compartment agent skipped: /ctx-wrapup became active");
+    releaseCompartmentLease(deps.db, deps.sessionId, holderId);
+    updateSessionMeta(deps.db, deps.sessionId, { compartmentInProgress: false });
+    return;
+  }
   const renewal = startLeaseRenewal(deps, holderId);
   let realRunStarted = false;
   const runnerDeps = withPublishedCallback({
@@ -184280,13 +184791,19 @@ function startCompartmentAgent(deps) {
       activeRuns.delete(deps.sessionId);
     }
   });
-  activeRuns.set(deps.sessionId, { promise: promise2, published: false });
+  activeRuns.set(deps.sessionId, { promise: promise2, published: false, kind: "incremental" });
   if (!realRunStarted && activeRuns.get(deps.sessionId)?.promise === promise2) {
     activeRuns.delete(deps.sessionId);
   }
 }
 async function executeContextRecompWithResult(deps, options = {}) {
   const { sessionId } = deps;
+  if (isWrapupInProgress(deps.db, sessionId)) {
+    return {
+      message: "## Magic Recomp — Skipped\n\n/ctx-wrapup is already compacting this session. Wait for it to finish, then try `/ctx-recomp` again.",
+      published: false
+    };
+  }
   if (activeRuns.has(sessionId)) {
     return {
       message: "## Magic Recomp — Skipped\n\nHistorian is already running for this session. Wait for it to finish, then try `/ctx-recomp` again.",
@@ -184310,7 +184827,7 @@ async function executeContextRecompWithResult(deps, options = {}) {
   }).catch((err) => {
     sessionLog(sessionId, "compartment agent: recomp unhandled rejection:", err);
   });
-  activeRuns.set(sessionId, { promise: wrappedPromise, published: false });
+  activeRuns.set(sessionId, { promise: wrappedPromise, published: false, kind: "recomp" });
   try {
     const message = await promise2;
     const published = activeRuns.get(sessionId)?.published === true;
@@ -184738,6 +185255,13 @@ Recomp crashed: ${String(error51)}`;
   }
 }
 async function runManagedUpgrade(ctx, sessionId) {
+  if (isWrapupInProgress(ctx.db, sessionId)) {
+    const message = "/ctx-wrapup is already compacting this session. Wait for it to finish, then try `/ctx-session-upgrade` again.";
+    setRecompTerminal(ctx.liveSessionState, sessionId, "skipped", message);
+    return `## Session Upgrade — Skipped
+
+${message}`;
+  }
   setRecompStarting(ctx.liveSessionState, sessionId, "Starting upgrade…", "upgrade");
   try {
     const compartments = getCompartments(ctx.db, sessionId);
@@ -184892,13 +185416,14 @@ function shouldShowAnnouncement() {
   }
   return ordering > 0;
 }
-var ANNOUNCEMENT_VERSION = "0.30.4", ANNOUNCEMENT_FEATURES, ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/F2uWxjGnU", STATE_FILENAME = "last_announced_version";
+var ANNOUNCEMENT_VERSION = "0.31.0", ANNOUNCEMENT_FEATURES, ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/F2uWxjGnU", STATE_FILENAME = "last_announced_version";
 var init_announcement = __esm(() => {
   init_data_path();
   ANNOUNCEMENT_FEATURES = [
-    "Pi: fixed historian and dreamer failing when your model comes from a provider extension (Antigravity, Anthropic OAuth, etc.). Subagents now load your extensions.",
-    "Pi: fixed the retrospective and refresh-primers dreamer tasks reading sessions through the wrong API.",
-    "OpenCode: the plugin no longer re-adds its TUI sidebar entry on startup, so removing it from tui.jsonc now sticks."
+    "New /ctx-wrapup command: compact older history on demand, keeping the newest N messages raw. Run it before switching to a smaller-context model.",
+    "ctx_search now also searches your session notes and smart notes.",
+    "Project identity now survives transient git failures (slow disks, dubious ownership) without splitting your project memory.",
+    "Removed the ctx_reduce_enabled setting; agent-controlled reduction is always on. Caveman text compression is now independent (caveman_text_compression.enabled)."
   ];
 });
 
@@ -186326,6 +186851,10 @@ function getMagicContextBuiltinCommands() {
       template: "ctx-recomp",
       description: "Rebuild compartments and facts from raw history (full or <start>-<end> range)"
     },
+    "ctx-wrapup": {
+      template: "ctx-wrapup",
+      description: "Compact older live history while keeping the newest messages raw"
+    },
     "ctx-session-upgrade": {
       template: "ctx-session-upgrade",
       description: "Upgrade this session to the latest history format: rebuild compartments and migrate project memories"
@@ -186349,6 +186878,29 @@ function getMagicContextBuiltinCommands() {
   };
 }
 
+// src/features/magic-context/dreamer/open-opencode-db.ts
+init_logger();
+await __promiseAll([
+  init_sqlite(),
+  init_compaction_marker()
+]);
+import { existsSync as existsSync7 } from "node:fs";
+function openOpenCodeDb() {
+  const dbPath = getOpenCodeDbPath();
+  if (!existsSync7(dbPath)) {
+    log(`[dreamer] OpenCode DB not found at ${dbPath} — skipping OpenCode history scan`);
+    return null;
+  }
+  try {
+    const db = new Database(dbPath, { readonly: true });
+    db.exec("PRAGMA busy_timeout = 5000");
+    return db;
+  } catch (error51) {
+    log(`[dreamer] failed to open OpenCode DB at ${dbPath}: ${getErrorMessage(error51)}`);
+    return null;
+  }
+}
+
 // src/features/magic-context/dreamer/task-prompts.ts
 var DREAMER_SYSTEM_PROMPT = `You are a background maintenance agent for the magic-context system, running during a scheduled dream window. Your task and its full instructions arrive in the message below. Never read or quote secrets from .env, credentials, or key files, and never commit — the user handles git.`;
 var PROJECT_MEMORY_TAXONOMY = `## Memory taxonomy (5 categories)
@@ -186658,6 +187210,192 @@ function buildDreamTaskPrompt(task, args) {
 // src/index.ts
 init_project_identity();
 
+// src/features/magic-context/session-project-backfill.ts
+init_logger();
+init_project_identity();
+init_session_project_storage();
+import { existsSync as existsSync9 } from "node:fs";
+var LEASE_TTL_MS = 10 * 60 * 1000;
+var SESSION_QUERY_CHUNK_SIZE = 250;
+var YIELD_EVERY_NEW_DIRECTORIES = 10;
+function ensureBackfillStateTable(db) {
+  db.exec(`
+        CREATE TABLE IF NOT EXISTS session_project_backfill_state (
+            harness TEXT PRIMARY KEY,
+            status TEXT NOT NULL CHECK (status IN ('running', 'completed')),
+            started_at INTEGER,
+            lease_expires_at INTEGER,
+            completed_at INTEGER
+        );
+    `);
+}
+function withImmediateTransaction(db, fn) {
+  db.exec("BEGIN IMMEDIATE");
+  try {
+    const result = fn();
+    db.exec("COMMIT");
+    return result;
+  } catch (error51) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {}
+    throw error51;
+  }
+}
+function defaultYieldFn() {
+  return new Promise((resolve2) => setTimeout(resolve2, 0));
+}
+function acquireBackfillLease(db, harness, now) {
+  ensureBackfillStateTable(db);
+  return withImmediateTransaction(db, () => {
+    const current = db.prepare(`SELECT harness, status, started_at, lease_expires_at, completed_at
+                 FROM session_project_backfill_state
+                 WHERE harness = ?`).get(harness);
+    if (current?.status === "completed") {
+      return "already_completed";
+    }
+    if (current?.status === "running" && current.lease_expires_at !== null && current.lease_expires_at > now) {
+      return "blocked_by_lease";
+    }
+    db.prepare(`INSERT INTO session_project_backfill_state(
+                harness,
+                status,
+                started_at,
+                lease_expires_at,
+                completed_at
+            )
+             VALUES (?, 'running', ?, ?, NULL)
+             ON CONFLICT(harness) DO UPDATE SET
+                status = 'running',
+                started_at = excluded.started_at,
+                lease_expires_at = excluded.lease_expires_at,
+                completed_at = NULL`).run(harness, now, now + LEASE_TTL_MS);
+    return "completed";
+  });
+}
+function renewBackfillLease(db, harness, now) {
+  ensureBackfillStateTable(db);
+  db.prepare(`UPDATE session_project_backfill_state
+         SET lease_expires_at = ?
+         WHERE harness = ? AND status = 'running'`).run(now + LEASE_TTL_MS, harness);
+}
+function markBackfillCompleted(db, harness, now) {
+  ensureBackfillStateTable(db);
+  db.prepare(`INSERT INTO session_project_backfill_state(
+            harness,
+            status,
+            started_at,
+            lease_expires_at,
+            completed_at
+        )
+         VALUES (?, 'completed', ?, NULL, ?)
+         ON CONFLICT(harness) DO UPDATE SET
+            status = 'completed',
+            lease_expires_at = NULL,
+            completed_at = excluded.completed_at`).run(harness, now, now);
+}
+function dedupeSessions(sessions) {
+  const sessionsById = new Map;
+  for (const session of sessions) {
+    if (!session.sessionId)
+      continue;
+    const existing = sessionsById.get(session.sessionId);
+    if (!existing) {
+      sessionsById.set(session.sessionId, {
+        sessionId: session.sessionId,
+        directory: session.directory
+      });
+      continue;
+    }
+    if (!existing.directory && session.directory) {
+      sessionsById.set(session.sessionId, {
+        sessionId: session.sessionId,
+        directory: session.directory
+      });
+    }
+  }
+  return [...sessionsById.values()];
+}
+function getMappedSessionIds(db, harness, sessions) {
+  const mapped = new Set;
+  for (let index = 0;index < sessions.length; index += SESSION_QUERY_CHUNK_SIZE) {
+    const chunk = sessions.slice(index, index + SESSION_QUERY_CHUNK_SIZE);
+    if (chunk.length === 0)
+      continue;
+    const placeholders = chunk.map(() => "?").join(", ");
+    const rows = db.prepare(`SELECT session_id
+                 FROM session_projects
+                 WHERE harness = ?
+                   AND session_id IN (${placeholders})`).all(harness, ...chunk.map((session) => session.sessionId));
+    for (const row of rows) {
+      mapped.add(row.session_id);
+    }
+  }
+  return mapped;
+}
+async function runSessionProjectBackfill(db, sessions, options = {}) {
+  const startedAt = performance.now();
+  const harness = getHarness();
+  const now = options.now ?? Date.now;
+  const resolveIdentity = options.resolveIdentity ?? resolveProjectIdentity;
+  const yieldFn = options.yieldFn ?? defaultYieldFn;
+  const dedupedSessions = dedupeSessions(sessions);
+  const result = {
+    status: "completed",
+    totalSessions: dedupedSessions.length,
+    alreadyMappedSessions: 0,
+    unmappedSessions: 0,
+    backfilledSessions: 0,
+    skippedDeadDirectories: 0,
+    skippedEmptyDirectories: 0,
+    durationMs: 0
+  };
+  const leaseStatus = acquireBackfillLease(db, harness, now());
+  if (leaseStatus !== "completed") {
+    result.status = leaseStatus;
+    result.durationMs = performance.now() - startedAt;
+    return result;
+  }
+  const mappedSessionIds = getMappedSessionIds(db, harness, dedupedSessions);
+  result.alreadyMappedSessions = mappedSessionIds.size;
+  const existenceCache = new Map;
+  const identityCache2 = new Map;
+  let newDirectoryResolutions = 0;
+  for (const session of dedupedSessions) {
+    if (mappedSessionIds.has(session.sessionId)) {
+      continue;
+    }
+    result.unmappedSessions += 1;
+    if (!session.directory) {
+      result.skippedEmptyDirectories += 1;
+      continue;
+    }
+    const stillExists = existenceCache.get(session.directory) ?? existsSync9(session.directory);
+    existenceCache.set(session.directory, stillExists);
+    if (!stillExists) {
+      result.skippedDeadDirectories += 1;
+      continue;
+    }
+    let identity = identityCache2.get(session.directory);
+    if (!identity) {
+      identity = resolveIdentity(session.directory);
+      identityCache2.set(session.directory, identity);
+      newDirectoryResolutions += 1;
+      if (newDirectoryResolutions % YIELD_EVERY_NEW_DIRECTORIES === 0) {
+        renewBackfillLease(db, harness, now());
+        await yieldFn();
+        renewBackfillLease(db, harness, now());
+      }
+    }
+    recordSessionProjectIdentity(db, session.sessionId, identity);
+    result.backfilledSessions += 1;
+  }
+  markBackfillCompleted(db, harness, now());
+  result.durationMs = performance.now() - startedAt;
+  log(`[session-projects] backfilled ${result.backfilledSessions} of ${result.unmappedSessions} unmapped sessions (skipped ${result.skippedDeadDirectories} dead dirs) in ${Math.round(result.durationMs)}ms`);
+  return result;
+}
+
 // src/features/magic-context/sidekick/agent.ts
 init_language_directive();
 
@@ -186821,7 +187559,7 @@ await init_storage_db();
 init_logger();
 init_project_identity();
 import { createHash as createHash5 } from "node:crypto";
-import { realpathSync } from "node:fs";
+import { realpathSync as realpathSync2 } from "node:fs";
 import path5 from "node:path";
 
 // src/features/magic-context/memory/relocate-memory.ts
@@ -186855,7 +187593,10 @@ function countFailures(db) {
 }
 function classifyBackfillError(error51) {
   if (error51 instanceof ProjectIdentityError) {
-    return { errorClass: error51.errorClass, errorMessage: error51.message };
+    return {
+      errorClass: error51.errorClass === "dubious_ownership" ? "unknown" : error51.errorClass,
+      errorMessage: error51.message
+    };
   }
   if (error51 instanceof Error) {
     return { errorClass: "unknown", errorMessage: error51.message };
@@ -186875,7 +187616,7 @@ function resolveBackfillIdentity(rawProjectPath) {
 function computeLegacyRustDirIdentity(rawProjectPath) {
   let canonical;
   try {
-    canonical = realpathSync(rawProjectPath);
+    canonical = realpathSync2(rawProjectPath);
   } catch {
     canonical = path5.isAbsolute(rawProjectPath) ? rawProjectPath : path5.join(process.cwd(), rawProjectPath);
   }
@@ -187048,45 +187789,45 @@ async function runDeferredV22Backfill(db, options = {}) {
 
 // src/hooks/auto-update-checker/index.ts
 init_logger();
-import { existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync9, renameSync as renameSync3, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname7, join as join9 } from "node:path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync5, readFileSync as readFileSync9, renameSync as renameSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname7, join as join10 } from "node:path";
 
 // src/hooks/auto-update-checker/cache.ts
 init_logger();
 var import_comment_json2 = __toESM(require_src2(), 1);
 import { spawn } from "node:child_process";
-import { existsSync as existsSync10, readFileSync as readFileSync8, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "node:fs";
-import { basename as basename2, dirname as dirname6, join as join8 } from "node:path";
+import { existsSync as existsSync14, readFileSync as readFileSync8, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { basename as basename2, dirname as dirname6, join as join9 } from "node:path";
 
 // src/hooks/auto-update-checker/checker.ts
 init_logger();
 var import_comment_json = __toESM(require_src2(), 1);
-import { existsSync as existsSync9, readFileSync as readFileSync7, renameSync as renameSync2, statSync as statSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync13, readFileSync as readFileSync7, renameSync as renameSync2, statSync as statSync4, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { dirname as dirname5, isAbsolute as isAbsolute3, join as join7, resolve as resolve2 } from "node:path";
+import { dirname as dirname5, isAbsolute as isAbsolute3, join as join8, resolve as resolve2 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/hooks/auto-update-checker/constants.ts
 import { homedir as homedir4, platform } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 var PACKAGE_NAME = "@cortexkit/opencode-magic-context";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org";
 var NPM_FETCH_TIMEOUT = 1e4;
 function getOpenCodeCacheRoot() {
   if (platform() === "win32") {
-    return join6(process.env.LOCALAPPDATA ?? homedir4(), "opencode");
+    return join7(process.env.LOCALAPPDATA ?? homedir4(), "opencode");
   }
-  return join6(homedir4(), ".cache", "opencode");
+  return join7(homedir4(), ".cache", "opencode");
 }
 function getOpenCodeConfigRoot() {
   if (platform() === "win32") {
-    return join6(process.env.APPDATA ?? join6(homedir4(), "AppData", "Roaming"), "opencode");
+    return join7(process.env.APPDATA ?? join7(homedir4(), "AppData", "Roaming"), "opencode");
   }
-  return join6(process.env.XDG_CONFIG_HOME ?? join6(homedir4(), ".config"), "opencode");
+  return join7(process.env.XDG_CONFIG_HOME ?? join7(homedir4(), ".config"), "opencode");
 }
-var CACHE_DIR = join6(getOpenCodeCacheRoot(), "packages");
-var USER_OPENCODE_CONFIG = join6(getOpenCodeConfigRoot(), "opencode.json");
-var USER_OPENCODE_CONFIG_JSONC = join6(getOpenCodeConfigRoot(), "opencode.jsonc");
+var CACHE_DIR = join7(getOpenCodeCacheRoot(), "packages");
+var USER_OPENCODE_CONFIG = join7(getOpenCodeConfigRoot(), "opencode.json");
+var USER_OPENCODE_CONFIG_JSONC = join7(getOpenCodeConfigRoot(), "opencode.jsonc");
 // src/hooks/auto-update-checker/types.ts
 init_zod();
 var NpmPackageEnvelopeSchema = exports_external.object({
@@ -187147,8 +187888,8 @@ function extractChannel(version2) {
 }
 function getConfigPaths(directory) {
   return [
-    join7(directory, ".opencode", "opencode.json"),
-    join7(directory, ".opencode", "opencode.jsonc"),
+    join8(directory, ".opencode", "opencode.json"),
+    join8(directory, ".opencode", "opencode.jsonc"),
     USER_OPENCODE_CONFIG,
     USER_OPENCODE_CONFIG_JSONC
   ];
@@ -187170,8 +187911,8 @@ function findPackageJsonUp(startPath) {
     const stat = statSync4(startPath);
     let dir = stat.isDirectory() ? startPath : dirname5(startPath);
     for (let i = 0;i < 10; i++) {
-      const pkgPath = join7(dir, "package.json");
-      if (existsSync9(pkgPath)) {
+      const pkgPath = join8(dir, "package.json");
+      if (existsSync13(pkgPath)) {
         try {
           const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync7(pkgPath, "utf-8")));
           if (pkg.success && pkg.data.name === PACKAGE_NAME)
@@ -187189,7 +187930,7 @@ function findPackageJsonUp(startPath) {
 function getLocalDevPath(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!existsSync9(configPath))
+      if (!existsSync13(configPath))
         continue;
       const rawConfig = parseJsonConfig(readFileSync7(configPath, "utf-8"));
       const plugins = getPluginEntries(rawConfig);
@@ -187235,7 +187976,7 @@ function getCurrentRuntimePackageJsonPath(currentModuleUrl = import.meta.url) {
 function findPluginEntry(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!existsSync9(configPath))
+      if (!existsSync13(configPath))
         continue;
       const rawConfig = parseJsonConfig(readFileSync7(configPath, "utf-8"));
       const plugins = getPluginEntries(rawConfig);
@@ -187260,7 +188001,7 @@ function findPluginEntry(directory) {
 }
 var cachedPackageVersion = null;
 function getSpecCachePackageJsonPath(spec) {
-  return join7(CACHE_DIR, spec, "node_modules", PACKAGE_NAME, "package.json");
+  return join8(CACHE_DIR, spec, "node_modules", PACKAGE_NAME, "package.json");
 }
 function getCachedVersion(spec) {
   if (!spec && cachedPackageVersion)
@@ -187269,11 +188010,11 @@ function getCachedVersion(spec) {
     getCurrentRuntimePackageJsonPath(),
     spec ? getSpecCachePackageJsonPath(spec) : null,
     getSpecCachePackageJsonPath(`${PACKAGE_NAME}@latest`),
-    join7(homedir5(), ".cache", "opencode", "node_modules", PACKAGE_NAME, "package.json")
+    join8(homedir5(), ".cache", "opencode", "node_modules", PACKAGE_NAME, "package.json")
   ].filter(isString);
   for (const packageJsonPath of candidates) {
     try {
-      if (!existsSync9(packageJsonPath))
+      if (!existsSync13(packageJsonPath))
         continue;
       const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync7(packageJsonPath, "utf-8")));
       if (pkg.success && pkg.data.version) {
@@ -187327,8 +188068,8 @@ function stripPackageNameFromPath(pathValue, packageName) {
   return current;
 }
 function removeFromPackageLock(installDir, packageName) {
-  const lockPath = join8(installDir, "package-lock.json");
-  if (!existsSync10(lockPath))
+  const lockPath = join9(installDir, "package-lock.json");
+  if (!existsSync14(lockPath))
     return false;
   try {
     const lock = import_comment_json2.parse(readFileSync8(lockPath, "utf-8"));
@@ -187354,7 +188095,7 @@ function removeFromPackageLock(installDir, packageName) {
   }
 }
 function ensureDependencyVersion(packageJsonPath, packageName, version2) {
-  if (!existsSync10(packageJsonPath))
+  if (!existsSync14(packageJsonPath))
     return false;
   try {
     const raw = import_comment_json2.parse(readFileSync8(packageJsonPath, "utf-8"));
@@ -187376,8 +188117,8 @@ function ensureDependencyVersion(packageJsonPath, packageName, version2) {
   }
 }
 function removeInstalledPackage(installDir, packageName) {
-  const packageDir = join8(installDir, "node_modules", packageName);
-  if (!existsSync10(packageDir))
+  const packageDir = join9(installDir, "node_modules", packageName);
+  if (!existsSync14(packageDir))
     return false;
   try {
     rmSync2(packageDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
@@ -187398,8 +188139,8 @@ function resolveInstallContext(runtimePackageJsonPath = getCurrentRuntimePackage
     const nodeModulesDir = stripPackageNameFromPath(packageDir, PACKAGE_NAME);
     if (nodeModulesDir && basename2(nodeModulesDir) === "node_modules") {
       const installDir = dirname6(nodeModulesDir);
-      const packageJsonPath = join8(installDir, "package.json");
-      if (!existsSync10(packageJsonPath)) {
+      const packageJsonPath = join9(installDir, "package.json");
+      if (!existsSync14(packageJsonPath)) {
         try {
           writeFileSync4(packageJsonPath, `${JSON.stringify({ private: true, dependencies: {} }, null, 2)}
 `);
@@ -187413,8 +188154,8 @@ function resolveInstallContext(runtimePackageJsonPath = getCurrentRuntimePackage
     }
     return null;
   }
-  const legacyPackageJsonPath = join8(dirname6(CACHE_DIR), "package.json");
-  if (existsSync10(legacyPackageJsonPath)) {
+  const legacyPackageJsonPath = join9(dirname6(CACHE_DIR), "package.json");
+  if (existsSync14(legacyPackageJsonPath)) {
     return { installDir: dirname6(CACHE_DIR), packageJsonPath: legacyPackageJsonPath };
   }
   return null;
@@ -187538,8 +188279,8 @@ function claimCheckSlot(storageDir, intervalMs) {
   if (!storageDir)
     return true;
   try {
-    const file2 = join9(storageDir, TIMESTAMP_FILENAME);
-    if (existsSync11(file2)) {
+    const file2 = join10(storageDir, TIMESTAMP_FILENAME);
+    if (existsSync15(file2)) {
       try {
         const raw = JSON.parse(readFileSync9(file2, "utf-8"));
         const last = typeof raw.lastCheckedMs === "number" ? raw.lastCheckedMs : 0;
@@ -187845,29 +188586,6 @@ function releaseLease(db, holderId, leaseKey = DREAMING_LEASE_KEY) {
   });
 }
 
-// src/features/magic-context/dreamer/open-opencode-db.ts
-init_logger();
-await __promiseAll([
-  init_sqlite(),
-  init_compaction_marker()
-]);
-import { existsSync as existsSync13 } from "node:fs";
-function openOpenCodeDb() {
-  const dbPath = getOpenCodeDbPath2();
-  if (!existsSync13(dbPath)) {
-    log(`[key-files] OpenCode DB not found at ${dbPath} — skipping`);
-    return null;
-  }
-  try {
-    const db = new Database(dbPath, { readonly: true });
-    db.exec("PRAGMA busy_timeout = 5000");
-    return db;
-  } catch (error51) {
-    log(`[key-files] failed to open OpenCode DB at ${dbPath}: ${getErrorMessage(error51)}`);
-    return null;
-  }
-}
-
 // src/features/magic-context/dreamer/retrospective-orphan-sweep.ts
 init_logger();
 var RETROSPECTIVE_CHILD_TITLE = "magic-context-dream-retrospective";
@@ -188290,7 +189008,7 @@ init_task_config();
 
 // src/features/magic-context/dreamer/task-executor.ts
 import { createHash as createHash10 } from "node:crypto";
-import { existsSync as existsSync17 } from "node:fs";
+import { existsSync as existsSync20 } from "node:fs";
 
 // src/agents/dreamer.ts
 var DREAMER_AGENT = "dreamer";
@@ -190377,7 +191095,7 @@ Output exactly JSON: {"met": false}`;
 
 // src/features/magic-context/dreamer/maintain-docs-protected-enforcement.ts
 init_logger();
-import { existsSync as existsSync15, readFileSync as readFileSync11, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync18, readFileSync as readFileSync11, writeFileSync as writeFileSync6 } from "node:fs";
 import { join as join15 } from "node:path";
 
 // src/features/magic-context/dreamer/protected-regions.ts
@@ -190481,7 +191199,7 @@ function snapshotMaintainDocsFiles(docsDir) {
   for (const name2 of MAINTAIN_DOCS_SNAPSHOT_FILES) {
     const path8 = join15(docsDir, name2);
     try {
-      if (existsSync15(path8)) {
+      if (existsSync18(path8)) {
         snapshot.set(name2, readFileSync11(path8, "utf8"));
       }
     } catch {}
@@ -190513,7 +191231,7 @@ init_memory();
 init_subagent_token_capture();
 
 // src/features/magic-context/dreamer/map-memories-prompt.ts
-import { existsSync as existsSync16, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync19, statSync as statSync6 } from "node:fs";
 import path8 from "node:path";
 var MAP_MEMORIES_SYSTEM_PROMPT = `You are a memory mapper for the magic-context system. You map project memories to the repository files that back them.
 
@@ -190551,7 +191269,7 @@ function extractMemoryCandidatePaths(content, repoDir) {
     if (!abs.startsWith(`${root}/`))
       continue;
     try {
-      if (existsSync16(abs) && statSync6(abs).isFile())
+      if (existsSync19(abs) && statSync6(abs).isFile())
         found.add(rel);
     } catch {}
     if (found.size >= MAX_SEED_PATHS_PER_MEMORY)
@@ -192380,8 +193098,8 @@ async function runAgenticTask(config2, ctx, helpers) {
   const lastRunAt = getTaskScheduleState(db, projectIdentity, config2.task)?.lastRunAt ?? null;
   const maintainDocsSnapshot = task === "maintain-docs" ? snapshotMaintainDocsFiles(docsDir) : undefined;
   const existingDocs = task === "maintain-docs" ? {
-    architecture: existsSync17(`${docsDir}/ARCHITECTURE.md`),
-    structure: existsSync17(`${docsDir}/STRUCTURE.md`)
+    architecture: existsSync20(`${docsDir}/ARCHITECTURE.md`),
+    structure: existsSync20(`${docsDir}/STRUCTURE.md`)
   } : undefined;
   const userMemories = task === "curate" ? getActiveUserMemories(db).map((um) => ({ id: um.id, content: um.content })) : undefined;
   let curateMemories;
@@ -194548,6 +195266,17 @@ ${c.content}
 init_send_session_notification();
 var recompConfirmationBySession = new Map;
 var RECOMP_CONFIRMATION_WINDOW_MS = 60000;
+function isSubagentSession(db, sessionId) {
+  const meta3 = getOrCreateSessionMeta(db, sessionId);
+  if (meta3.isSubagent)
+    return true;
+  try {
+    const row = db.prepare("SELECT is_subagent FROM session_meta WHERE session_id = ?").get(sessionId);
+    return row?.is_subagent === 1 || row?.is_subagent === true;
+  } catch {
+    return false;
+  }
+}
 var RECOMP_USAGE = [
   "Usage:",
   "- `/ctx-recomp` — full rebuild from message 1 to the protected tail",
@@ -194586,6 +195315,22 @@ ${RECOMP_USAGE}`
   }
   return { kind: "partial", range: { start, end } };
 }
+function parseWrapupArgs(raw) {
+  const trimmed = raw.trim();
+  if (trimmed === "")
+    return { ok: true, messagesToKeep: 20 };
+  if (!/^\d+$/.test(trimmed)) {
+    return {
+      ok: false,
+      message: "Usage: `/ctx-wrapup [messages_to_keep]` where messages_to_keep is a positive integer."
+    };
+  }
+  const messagesToKeep = Number.parseInt(trimmed, 10);
+  if (!Number.isSafeInteger(messagesToKeep) || messagesToKeep <= 0) {
+    return { ok: false, message: "messages_to_keep must be a positive integer." };
+  }
+  return { ok: true, messagesToKeep };
+}
 var SENTINEL_PREFIX = "__CONTEXT_MANAGEMENT_";
 var HTTP_SERVER_RESPONSE_TYPE_ID = "~effect/http/HttpServerResponse";
 var HTTP_COOKIES_TYPE_ID = "~effect/http/Cookies";
@@ -194727,6 +195472,7 @@ function createMagicContextCommandHandler(deps) {
   const isStatusCommand = (command) => command === "ctx-status";
   const isFlushCommand = (command) => command === "ctx-flush";
   const isRecompCommand = (command) => command === "ctx-recomp";
+  const isWrapupCommand = (command) => command === "ctx-wrapup";
   const isAugCommand = (command) => command === "ctx-aug";
   const isDreamCommand = (command) => command === "ctx-dream";
   const isSessionUpgradeCommand = (command) => command === "ctx-session-upgrade";
@@ -194736,11 +195482,12 @@ function createMagicContextCommandHandler(deps) {
       const isStatus = isStatusCommand(input.command);
       const isFlush = isFlushCommand(input.command);
       const isRecomp = isRecompCommand(input.command);
+      const isWrapup = isWrapupCommand(input.command);
       const isAug = isAugCommand(input.command);
       const isDream = isDreamCommand(input.command);
       const isSessionUpgrade = isSessionUpgradeCommand(input.command);
       const isEmbed = isEmbedCommand(input.command);
-      if (!isStatus && !isFlush && !isRecomp && !isAug && !isDream && !isSessionUpgrade && !isEmbed) {
+      if (!isStatus && !isFlush && !isRecomp && !isWrapup && !isAug && !isDream && !isSessionUpgrade && !isEmbed) {
         return;
       }
       const sessionId = input.sessionID;
@@ -194810,6 +195557,26 @@ Embedding status is unavailable.`;
 
 ${statusOutput}` : statusOutput;
       }
+      if (isWrapup) {
+        const parsed = parseWrapupArgs(input.arguments);
+        if (isSubagentSession(deps.db, sessionId)) {
+          result = `## Magic Wrapup — Skipped
+
+/ctx-wrapup is only available in primary sessions.`;
+        } else if (!parsed.ok) {
+          result = `## Magic Wrapup — Invalid Arguments
+
+${parsed.message}`;
+        } else if (!deps.executeWrapup) {
+          result = `## Magic Wrapup
+
+/ctx-wrapup is unavailable because the historian handler is not configured.`;
+        } else {
+          result = await deps.executeWrapup(sessionId, {
+            messagesToKeep: parsed.messagesToKeep
+          });
+        }
+      }
       if (isRecomp) {
         const parsedArgs = parseRecompArgs(input.arguments);
         if (parsedArgs.kind === "error") {
@@ -195116,7 +195883,8 @@ var canonicalReasons = new Set([
   "first_render",
   "pressure_refold",
   "upgrade_state",
-  "cached_m1_missing"
+  "cached_m1_missing",
+  "project_change"
 ]);
 var piReasonAliases = {
   project_memory_change: "project_memory_epoch",
@@ -196047,35 +196815,31 @@ function resolveCtxReduceAvailabilityFromMessages(sessionId, messages) {
   for (const message of messages) {
     if (message.info?.role !== "user")
       continue;
-    const verdict = verdictFromToolsMap(message.info.tools);
-    if (verdict !== null) {
-      availabilityBySession.set(sessionId, verdict);
-      return verdict;
-    }
-    break;
+    const verdict = verdictFromToolsMap(message.info.tools) ?? true;
+    availabilityBySession.set(sessionId, verdict);
+    return verdict;
   }
-  availabilityBySession.set(sessionId, true);
   return true;
 }
 function resolveCtxReduceAvailability(sessionId) {
   const cached2 = availabilityBySession.get(sessionId);
   if (cached2 !== undefined)
-    return cached2;
+    return { callable: cached2, frozen: true };
   if (!openCodeDbExists())
-    return true;
+    return { callable: true, frozen: true };
   try {
     const row = withReadOnlySessionDb((db) => db.prepare(`SELECT json_extract(data, '$.tools') AS tools FROM message
                           WHERE session_id = ? AND json_extract(data, '$.role') = 'user'
                           ORDER BY time_created ASC LIMIT 1`).get(sessionId));
     if (!row)
-      return true;
+      return { callable: true, frozen: false };
     const verdict = row.tools === null ? null : verdictFromToolsMap(JSON.parse(row.tools));
     const resolved = verdict ?? true;
     availabilityBySession.set(sessionId, resolved);
-    return resolved;
+    return { callable: resolved, frozen: true };
   } catch (error51) {
     sessionLog(sessionId, "ctx_reduce availability read failed (fail-open):", error51);
-    return true;
+    return { callable: true, frozen: false };
   }
 }
 
@@ -197764,6 +198528,7 @@ function containsProbeVerbatim(text, probes) {
 init_memory();
 init_embedding();
 init_storage_memory_fts();
+init_storage_notes();
 init_storage_primers();
 init_workspaces();
 var DEFAULT_UNIFIED_SEARCH_LIMIT = 10;
@@ -198167,6 +198932,147 @@ function searchMessages(args) {
     role: entry.row.role
   }));
 }
+var NOTE_SEARCHABLE_STATUSES = ["active", "pending", "ready", "dismissed"];
+function noteSearchText(note) {
+  const reason = note.readyReason?.trim();
+  return reason ? `${note.content}
+Reason: ${reason}` : note.content;
+}
+function tokenizeKeywordNeedle(text) {
+  const matches = text.toLowerCase().match(/[a-z0-9/._:-]+/g) ?? [];
+  const seen = new Set;
+  const tokens = [];
+  for (const match of matches) {
+    if (match.length <= 1 || !/[a-z0-9]/.test(match) || seen.has(match)) {
+      continue;
+    }
+    seen.add(match);
+    tokens.push(match);
+  }
+  return tokens;
+}
+function rankNotesForNeedle(notes, needle) {
+  const normalizedNeedle = needle.trim().toLowerCase();
+  if (normalizedNeedle.length === 0) {
+    return [];
+  }
+  const needleTokens = tokenizeKeywordNeedle(normalizedNeedle);
+  const ranked = [];
+  for (const note of notes) {
+    const text = noteSearchText(note);
+    const normalizedText = text.toLowerCase();
+    const noteTokens = new Set(tokenizeKeywordNeedle(normalizedText));
+    const exact = normalizedText.includes(normalizedNeedle);
+    const matchedTokens = needleTokens.filter((token) => noteTokens.has(token)).length;
+    if (!exact && matchedTokens === 0) {
+      continue;
+    }
+    const coverage = needleTokens.length > 0 ? matchedTokens / needleTokens.length : 0;
+    const score = (exact ? 2 : 0) + coverage + (needleTokens.length > 1 && matchedTokens === needleTokens.length ? 0.5 : 0);
+    ranked.push({ note, score, text });
+  }
+  return ranked.sort((left, right) => {
+    if (right.score !== left.score) {
+      return right.score - left.score;
+    }
+    if (right.note.createdAt !== left.note.createdAt) {
+      return right.note.createdAt - left.note.createdAt;
+    }
+    return left.note.id - right.note.id;
+  });
+}
+function searchNotes(args) {
+  if (args.limit <= 0) {
+    return [];
+  }
+  const notes = [
+    ...getNotes(args.db, {
+      sessionId: args.sessionId,
+      type: "session",
+      status: NOTE_SEARCHABLE_STATUSES
+    }),
+    ...getNotes(args.db, {
+      projectPath: args.projectPath,
+      type: "smart",
+      status: NOTE_SEARCHABLE_STATUSES
+    })
+  ];
+  if (notes.length === 0) {
+    return [];
+  }
+  const baseList = rankNotesForNeedle(notes, args.query);
+  const probes = args.probes ?? [];
+  if (probes.length === 0) {
+    const ranked2 = baseList.slice(0, args.limit);
+    return ranked2.map((entry, rank) => ({
+      source: "note",
+      content: previewText(entry.text),
+      score: linearDecayScore(rank, ranked2.length),
+      noteId: entry.note.id,
+      status: entry.note.status,
+      createdAt: entry.note.createdAt,
+      anchorOrdinal: entry.note.anchorOrdinal,
+      sourceSessionId: entry.note.sessionId
+    }));
+  }
+  const queryLists = [];
+  if (baseList.length > 0) {
+    queryLists.push({ rows: baseList, weight: 1 });
+  }
+  const probeWeights = new Map;
+  for (const probe of probes) {
+    const rows = rankNotesForNeedle(notes, probe);
+    if (rows.length === 0) {
+      continue;
+    }
+    const weight = probeDiscriminationWeight(rows.length, notes.length);
+    probeWeights.set(probe, weight);
+    queryLists.push({ rows, weight });
+  }
+  const fused = new Map;
+  for (const list of queryLists) {
+    list.rows.forEach((row, rank) => {
+      const rrf = list.weight / (RRF_K + rank);
+      const existing = fused.get(row.note.id);
+      if (existing) {
+        existing.score += rrf;
+      } else {
+        fused.set(row.note.id, { entry: row, score: rrf });
+      }
+    });
+  }
+  for (const match of fused.values()) {
+    let best = 0;
+    for (const probe of probes) {
+      const weight = probeWeights.get(probe) ?? 0;
+      if (weight > best && containsProbeVerbatim(match.entry.text, [probe])) {
+        best = weight;
+      }
+    }
+    if (best > 0) {
+      match.score += best * VERBATIM_RANK_BONUS;
+    }
+  }
+  const ranked = [...fused.values()].sort((left, right) => {
+    if (right.score !== left.score) {
+      return right.score - left.score;
+    }
+    if (right.entry.note.createdAt !== left.entry.note.createdAt) {
+      return right.entry.note.createdAt - left.entry.note.createdAt;
+    }
+    return left.entry.note.id - right.entry.note.id;
+  }).slice(0, args.limit);
+  return ranked.map((entry, rank) => ({
+    source: "note",
+    content: previewText(entry.entry.text),
+    score: linearDecayScore(rank, ranked.length),
+    noteId: entry.entry.note.id,
+    status: entry.entry.note.status,
+    createdAt: entry.entry.note.createdAt,
+    anchorOrdinal: entry.entry.note.anchorOrdinal,
+    sourceSessionId: entry.entry.note.sessionId
+  }));
+}
 function searchCompartmentChunks(args) {
   if (!args.queryEmbedding || args.limit <= 0 || !args.modelId || args.modelId === "off")
     return [];
@@ -198252,6 +199158,8 @@ function getSourceBoost(result) {
       return GIT_COMMIT_SOURCE_BOOST;
     case "primer":
       return PRIMER_SOURCE_BOOST;
+    case "note":
+      return 1;
   }
 }
 function compareUnifiedResults(left, right) {
@@ -198275,6 +199183,9 @@ function compareUnifiedResults(left, right) {
   if (left.source === "primer" && right.source === "primer") {
     return right.support - left.support || left.primerId - right.primerId;
   }
+  if (left.source === "note" && right.source === "note") {
+    return right.createdAt - left.createdAt || left.noteId - right.noteId;
+  }
   return 0;
 }
 function toGitCommitResult(hit) {
@@ -198342,11 +199253,11 @@ function searchPrimers(args) {
 }
 function resolveSources(sources) {
   if (sources === undefined) {
-    return new Set(["memory", "message", "git_commit", "primer"]);
+    return new Set(["memory", "message", "git_commit", "primer", "note"]);
   }
   const set2 = new Set;
   for (const source of sources) {
-    if (source === "memory" || source === "message" || source === "git_commit" || source === "primer") {
+    if (source === "memory" || source === "message" || source === "git_commit" || source === "primer" || source === "note") {
       set2.add(source);
     }
   }
@@ -198369,6 +199280,7 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
   const runMessages = activeSources.has("message");
   const runGitCommits = activeSources.has("git_commit") && gitCommitsEnabled;
   const runPrimers = activeSources.has("primer") && memoryFeatureEnabled;
+  const runNotes = activeSources.has("note");
   const runCompartmentChunks = runMessages && memoryFeatureEnabled && embeddingEnabled;
   const needsEmbedding = (runMemory || runGitCommits || runCompartmentChunks || runPrimers) && embeddingEnabled && isEmbeddingRuntimeEnabled();
   const queryEmbeddingPromise = needsEmbedding ? embedQuery(trimmedQuery, options.signal).catch((error51) => {
@@ -198404,7 +199316,7 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
     compartments: compartmentResults,
     limit: tierLimit
   });
-  const [memoryResults, gitCommitResults, primerResults] = await Promise.all([
+  const [memoryResults, gitCommitResults, primerResults, noteResults] = await Promise.all([
     runMemory ? searchMemories({
       db,
       projectPath,
@@ -198431,9 +199343,23 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
       limit: tierLimit,
       queryEmbedding,
       queryModelId: embeddingModelId && embeddingModelId !== "off" ? embeddingModelId : null
+    })) : Promise.resolve([]),
+    runNotes ? Promise.resolve(searchNotes({
+      db,
+      sessionId,
+      projectPath,
+      query: trimmedQuery,
+      limit: tierLimit,
+      probes: messageProbes
     })) : Promise.resolve([])
   ]);
-  const results = [...memoryResults, ...primerResults, ...messageLikeResults, ...gitCommitResults].sort(compareUnifiedResults).slice(0, limit);
+  const results = [
+    ...memoryResults,
+    ...primerResults,
+    ...messageLikeResults,
+    ...gitCommitResults,
+    ...noteResults
+  ].sort(compareUnifiedResults).slice(0, limit);
   const countRetrievals = options.countRetrievals ?? true;
   if (countRetrievals) {
     const memoryIds = results.filter((result) => result.source === "memory").map((result) => result.memoryId);
@@ -198506,6 +199432,10 @@ function renderFragment(result, charCap) {
       const compressed = cavemanCompress(result.content, "ultra");
       return truncate(compressed, charCap);
     }
+    case "note": {
+      const compressed = cavemanCompress(result.content, "ultra");
+      return truncate(compressed, charCap);
+    }
   }
 }
 function buildAutoSearchHint(results, options = {}) {
@@ -199372,6 +200302,13 @@ var degradedCacheCountBySession = new BoundedSessionMap(100);
 function resetDegradedCacheCount(sessionId) {
   degradedCacheCountBySession.delete(sessionId);
 }
+function pendingMarkerCoveredByConsumedBoundary(pending, injection) {
+  if (!injection)
+    return false;
+  if (pending.endMessageId === injection.compartmentEndMessageId)
+    return true;
+  return pending.ordinal <= injection.compartmentEndMessage;
+}
 function clearPendingCompactionMarkerAfterSuccessfulDrain(args) {
   if (clearPendingCompactionMarkerStateIf(args.db, args.sessionId, args.pending)) {
     return "cleared";
@@ -199770,24 +200707,29 @@ async function runPostTransformPhase(args) {
   if (historyWasConsumedThisPass && args.deferredHistoryWasPendingAtPassStart) {
     const pending = getPendingCompactionMarkerState(args.db, args.sessionId);
     if (pending) {
-      const outcome = applyDeferredCompactionMarker(args.db, args.sessionId, pending, args.sessionDirectory);
-      switch (outcome.kind) {
-        case "applied":
-        case "already-current":
-        case "stale-skip":
-          if (clearPendingCompactionMarkerAfterSuccessfulDrain({
-            db: args.db,
-            sessionId: args.sessionId,
-            pending,
-            deferredHistoryRefreshSessions: args.deferredHistoryRefreshSessions
-          }) === "cas-lost-newer-pending") {
+      if (!pendingMarkerCoveredByConsumedBoundary(pending, args.pendingCompartmentInjection)) {
+        suppressV12HistoryDrain = true;
+        sessionLog(args.sessionId, `compaction-marker drain: pending ordinal ${pending.ordinal} is newer than consumed boundary ${args.pendingCompartmentInjection?.compartmentEndMessage ?? "<none>"}; preserving deferred history refresh signal`);
+      } else {
+        const outcome = applyDeferredCompactionMarker(args.db, args.sessionId, pending, args.sessionDirectory);
+        switch (outcome.kind) {
+          case "applied":
+          case "already-current":
+          case "stale-skip":
+            if (clearPendingCompactionMarkerAfterSuccessfulDrain({
+              db: args.db,
+              sessionId: args.sessionId,
+              pending,
+              deferredHistoryRefreshSessions: args.deferredHistoryRefreshSessions
+            }) === "cas-lost-newer-pending") {
+              suppressV12HistoryDrain = true;
+            }
+            break;
+          case "retryable-failure":
+            sessionLog(args.sessionId, "compaction-marker drain: retryable failure; preserving deferred history refresh signal", outcome.error);
             suppressV12HistoryDrain = true;
-          }
-          break;
-        case "retryable-failure":
-          sessionLog(args.sessionId, "compaction-marker drain: retryable failure; preserving deferred history refresh signal", outcome.error);
-          suppressV12HistoryDrain = true;
-          break;
+            break;
+        }
       }
     }
   }
@@ -199892,6 +200834,16 @@ function getMessageTokensCache(sessionId) {
   }
   return cache;
 }
+function maybeSendProjectIdentityWarning(deps, sessionId, directory, notificationParams) {
+  if (!deps.client)
+    return;
+  const warning = takeDubiousOwnershipProjectIdentityWarning(directory);
+  if (!warning)
+    return;
+  sendIgnoredMessage(deps.client, sessionId, warning, notificationParams).catch((error51) => {
+    sessionLog(sessionId, `project identity warning delivery failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
+  });
+}
 function clearMessageTokensCache(sessionId, messageId) {
   if (messageId === undefined) {
     messageTokensBySession.delete(sessionId);
@@ -199966,7 +200918,7 @@ function createTransform(deps) {
     }
     const reducedMode = sessionMeta.isSubagent;
     const fullFeatureMode = !reducedMode;
-    const ctxReduceEnabledEffective = deps.ctxReduceEnabled !== false && resolveCtxReduceAvailabilityFromMessages(sessionId, messages);
+    const ctxReduceCallable = resolveCtxReduceAvailabilityFromMessages(sessionId, messages);
     let sessionDirectory = deps.directory ?? "";
     let sessionDirectoryResolvedFromHost = false;
     const cachedDirectory = deps.sessionDirectoryBySession?.get(sessionId);
@@ -200249,8 +201201,15 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       }
     }
     logTransformTiming(sessionId, "emergencyRecoveryBlock", tFirstPass);
-    const projectIdentity = deps.memoryConfig?.enabled ? resolveProjectIdentity(compartmentDirectory || process.cwd()) : undefined;
+    const memoryProjectDirectory = compartmentDirectory || process.cwd();
+    const projectIdentity = deps.memoryConfig?.enabled ? resolveProjectIdentity(memoryProjectDirectory) : undefined;
+    if (deps.memoryConfig?.enabled) {
+      maybeSendProjectIdentityWarning(deps, sessionId, memoryProjectDirectory, notificationParams);
+    }
     const sessionProjectIdentity = projectIdentity ?? (sessionDirectory ? resolveProjectIdentity(sessionDirectory) : deps.projectPath);
+    if (sessionDirectory) {
+      maybeSendProjectIdentityWarning(deps, sessionId, sessionDirectory, notificationParams);
+    }
     if (sessionProjectIdentity && sessionDirectoryResolvedFromHost && recordedSessionProjectIdentity.get(sessionId) !== sessionProjectIdentity) {
       recordSessionProjectIdentity(db, sessionId, sessionProjectIdentity);
       recordedSessionProjectIdentity.set(sessionId, sessionProjectIdentity);
@@ -200308,7 +201267,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       const tInitFromDb = performance.now();
       deps.tagger.initFromDb(sessionId, db, taggerFloor);
       logTransformTiming(sessionId, "tag.initFromDb", tInitFromDb);
-      const skipPrefixInjection = !ctxReduceEnabledEffective;
+      const skipPrefixInjection = !ctxReduceCallable;
       const result = tagMessages(sessionId, messages, deps.tagger, db, {
         skipPrefixInjection
       });
@@ -200365,7 +201324,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       }
       logTransformTiming(sessionId, "replayReasoningClearing", tReplay);
     }
-    if (!deps.ctxReduceEnabled && !reducedMode && deps.cavemanTextCompression?.enabled) {
+    if (!reducedMode && deps.cavemanTextCompression?.enabled) {
       const tCavemanReplay = performance.now();
       const replayedCaveman = replayCavemanCompression(sessionId, db, targets, targetsSliceTags);
       if (replayedCaveman > 0) {
@@ -200495,7 +201454,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       projectPath: sessionProjectIdentity,
       sessionDirectory,
       autoSearch: deps.autoSearch,
-      cavemanTextCompression: deps.ctxReduceEnabled === false && !reducedMode ? deps.cavemanTextCompression : undefined,
+      cavemanTextCompression: !reducedMode ? deps.cavemanTextCompression : undefined,
       smartDrops: deps.smartDrops === true,
       resolvedProviderID,
       historyRefreshSessions: deps.historyRefreshSessions,
@@ -200651,7 +201610,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         sessionLog(sessionId, "conversation_tokens UPDATE failed:", error51);
       }
     }
-    if (ctxReduceEnabledEffective && deps.channel1StateBySession) {
+    if (ctxReduceCallable && deps.channel1StateBySession) {
       try {
         const resolvedExecuteThresholdPct = resolveExecuteThreshold(deps.executeThresholdPercentage ?? 65, deps.getModelKey?.(sessionId), 65, {
           tokensConfig: deps.executeThresholdTokens,
@@ -201136,6 +202095,343 @@ function createTextCompleteHandler() {
   };
 }
 
+// src/hooks/magic-context/wrapup-orchestrator.ts
+init_compartment_lease();
+init_compartment_storage();
+init_logger();
+init_rpc_notifications();
+init_send_session_notification();
+await __promiseAll([
+  init_storage(),
+  init_compartment_runner(),
+  init_compartment_runner_incremental(),
+  init_protected_tail_boundary(),
+  init_recomp_orchestrator()
+]);
+import * as crypto3 from "node:crypto";
+var WAIT_FOR_LEASE_MS = 1000;
+function sleep2(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+function plural(value, word) {
+  return `${value} ${word}${value === 1 ? "" : "s"}`;
+}
+function formatAlreadyRunningMessage(state) {
+  if (!state)
+    return "/ctx-wrapup is already running for this session.";
+  const chunk = state.expectedChunks > 0 ? ` chunk ${state.chunkIndex}/${state.expectedChunks}` : "";
+  const through = state.lastCompartmentEnd > 0 ? ` through message ${state.lastCompartmentEnd}` : "";
+  return `/ctx-wrapup is already running for this session${chunk}${through}. Wait for it to finish, then run /ctx-wrapup again if more history remains.`;
+}
+function appendFlushHint(ctx, sessionId, message) {
+  if (ctx.hasPendingNaturalBust?.(sessionId))
+    return message;
+  return `${message} If you want it applied on the very next message, run /ctx-flush first.`;
+}
+function buildPlan(ctx, sessionId, messagesToKeep, anchorRawMessageCount) {
+  return resolveWrapupProtectedTailBoundary({
+    db: ctx.db,
+    sessionId,
+    mode: "manual-wrapup",
+    contextLimit: ctx.contextLimit,
+    executeThresholdPercentage: ctx.executeThresholdPercentage,
+    usage: null,
+    usageSource: "manual-none",
+    providerShapeVersion: "opencode-v1",
+    cacheNamespace: `opencode:${sessionId}`,
+    messagesToKeep,
+    anchorRawMessageCount
+  });
+}
+function emitWrapupProgress(ctx, sessionId, progress) {
+  const current = ctx.liveSessionState.recompProgressBySession.get(sessionId);
+  ctx.liveSessionState.recompProgressBySession.set(sessionId, {
+    sessionId,
+    kind: "wrapup",
+    phase: "recomp",
+    processedMessages: progress.processedMessages ?? current?.processedMessages ?? 0,
+    totalMessages: progress.totalMessages ?? current?.totalMessages ?? 0,
+    passCount: progress.passCount ?? current?.passCount ?? 0,
+    compartmentsCreated: progress.compartmentsCreated ?? current?.compartmentsCreated ?? 0,
+    startedAt: current?.startedAt ?? Date.now(),
+    updatedAt: Date.now(),
+    note: progress.note
+  });
+}
+async function waitForExistingIncrementalRun(sessionId) {
+  const active = getActiveCompartmentRun(sessionId);
+  if (!active)
+    return "ok";
+  if (active.kind === "recomp" || active.kind === "wrapup")
+    return "busy";
+  try {
+    await active.promise;
+  } catch {}
+  return "ok";
+}
+async function acquireCompartmentLeaseForWrapup(ctx, sessionId, renewWrapupMarker) {
+  const holderId = crypto3.randomUUID();
+  for (;; ) {
+    const active = getActiveCompartmentRun(sessionId);
+    if (active?.kind === "recomp" || active?.kind === "wrapup")
+      return null;
+    if (active) {
+      emitWrapupProgress(ctx, sessionId, { note: "Waiting for the active historian run…" });
+      try {
+        await active.promise;
+      } catch {}
+      continue;
+    }
+    const lease = acquireCompartmentLease(ctx.db, sessionId, holderId);
+    if (lease)
+      return holderId;
+    emitWrapupProgress(ctx, sessionId, { note: "Waiting for the compartment-state lease…" });
+    if (!renewWrapupMarker({}))
+      return null;
+    await sleep2(WAIT_FOR_LEASE_MS);
+  }
+}
+async function runOneWrapupIteration(args) {
+  const { ctx, sessionId, plan, messagesToKeep, anchorRawMessageCount } = args;
+  const leaseHolderId = await acquireCompartmentLeaseForWrapup(ctx, sessionId, args.renewWrapupMarker);
+  if (!leaseHolderId)
+    return false;
+  const renewal = setInterval(() => {
+    try {
+      if (!renewCompartmentLease(ctx.db, sessionId, leaseHolderId)) {
+        sessionLog(sessionId, "wrapup: compartment lease renewal failed");
+      }
+    } catch (err) {
+      sessionLog(sessionId, `wrapup: compartment lease renewal threw; continuing (${err instanceof Error ? err.message : String(err)})`);
+    }
+  }, COMPARTMENT_LEASE_RENEWAL_MS);
+  const runCompartmentAgentForWrapup = ctx.runCompartmentAgentForWrapup ?? runCompartmentAgent;
+  const runnerPromise = runCompartmentAgentForWrapup({
+    client: ctx.client,
+    db: ctx.db,
+    sessionId,
+    historianChunkTokens: ctx.historianChunkTokens,
+    historianTimeoutMs: ctx.historianTimeoutMs,
+    boundarySnapshot: plan.snapshot,
+    currentContextLimit: ctx.contextLimit,
+    directory: ctx.directory,
+    fallbackModels: ctx.fallbackModels,
+    fallbackModelId: ctx.fallbackModelId,
+    language: ctx.language,
+    historianTwoPass: ctx.historianTwoPass,
+    memoryEnabled: ctx.memoryEnabled,
+    autoPromote: ctx.autoPromote,
+    ensureProjectRegistered: ctx.ensureProjectRegistered,
+    getNotificationParams: () => ctx.getNotificationParams(sessionId),
+    preserveInjectionCacheUntilConsumed: true,
+    compartmentLeaseHolderId: leaseHolderId,
+    forceDrainQuota: true,
+    forceKeepLastCompartment: true,
+    refreshBoundarySnapshot: () => buildPlan(ctx, sessionId, messagesToKeep, anchorRawMessageCount).snapshot,
+    onCompartmentStatePublished: (sid) => {
+      markActiveCompartmentRunPublished(sid);
+      ctx.liveSessionState.deferredHistoryRefreshSessions.add(sid);
+      ctx.liveSessionState.deferredMaterializationSessions.add(sid);
+    },
+    onDeferredMarkerPending: (sid) => {
+      ctx.liveSessionState.deferredHistoryRefreshSessions.add(sid);
+    }
+  });
+  registerActiveCompartmentRun(sessionId, runnerPromise, "wrapup");
+  try {
+    await runnerPromise;
+    return true;
+  } finally {
+    clearInterval(renewal);
+    releaseCompartmentLease(ctx.db, sessionId, leaseHolderId);
+  }
+}
+async function runManagedWrapup(ctx, sessionId, options) {
+  const messagesToKeep = Math.max(1, Math.floor(options.messagesToKeep));
+  setRecompStarting(ctx.liveSessionState, sessionId, "Estimating wrapup…", "wrapup");
+  const existingWrapup = getWrapupInProgressState(ctx.db, sessionId);
+  if (existingWrapup) {
+    const message2 = formatAlreadyRunningMessage(existingWrapup);
+    setRecompTerminal(ctx.liveSessionState, sessionId, "skipped", message2);
+    return `## Magic Wrapup — Skipped
+
+${message2}`;
+  }
+  const initialPlan = buildPlan(ctx, sessionId, messagesToKeep);
+  if (initialPlan.rawMessagesAboveLastCompartment <= messagesToKeep || !hasRunnableCompartmentWindow(initialPlan.snapshot)) {
+    const message2 = `Nothing to wrap up — only ${initialPlan.rawMessagesAboveLastCompartment} messages above the last compartment.`;
+    setRecompTerminal(ctx.liveSessionState, sessionId, "done", message2);
+    return message2;
+  }
+  const expectedChunks = Math.max(1, Math.ceil(initialPlan.snapshot.trueRawEligibleTokens / Math.max(1, ctx.historianChunkTokens)));
+  const wrapupHolderId = crypto3.randomUUID();
+  const acquired = acquireWrapupInProgress(ctx.db, sessionId, {
+    holderId: wrapupHolderId,
+    messagesToKeep,
+    anchorRawMessageCount: initialPlan.anchorRawMessageCount,
+    targetEligibleEndOrdinal: initialPlan.targetEligibleEndOrdinal,
+    lastCompartmentEnd: getLastCompartmentEndMessage(ctx.db, sessionId),
+    chunkIndex: 0,
+    expectedChunks
+  });
+  if (!acquired.ok) {
+    const message2 = formatAlreadyRunningMessage(acquired.state);
+    setRecompTerminal(ctx.liveSessionState, sessionId, "skipped", message2);
+    return `## Magic Wrapup — Skipped
+
+${message2}`;
+  }
+  const startLastEnd = getLastCompartmentEndMessage(ctx.db, sessionId);
+  const startCompartmentCount = getCompartments(ctx.db, sessionId).length;
+  let chunkIndex = 0;
+  let lastEnd = startLastEnd;
+  let stoppedForFailure = false;
+  let stoppedReason = "";
+  let ownershipLost = false;
+  const ownershipLostReason = "another process took over this session's wrapup.";
+  const markOwnershipLost = () => {
+    if (ownershipLost)
+      return;
+    ownershipLost = true;
+    sessionLog(sessionId, "wrapup: durable marker ownership lost; aborting loop");
+  };
+  const renewWrapupMarker = (updates) => {
+    const updated = updateWrapupInProgress(ctx.db, sessionId, wrapupHolderId, updates);
+    if (!updated) {
+      markOwnershipLost();
+      return false;
+    }
+    return true;
+  };
+  const markerRenewal = setInterval(() => {
+    try {
+      renewWrapupMarker({
+        lastCompartmentEnd: getLastCompartmentEndMessage(ctx.db, sessionId),
+        chunkIndex
+      });
+    } catch (err) {
+      sessionLog(sessionId, `wrapup: marker renewal threw; continuing (${err instanceof Error ? err.message : String(err)})`);
+    }
+  }, 60000);
+  markerRenewal.unref?.();
+  try {
+    const activeAtStart = await waitForExistingIncrementalRun(sessionId);
+    if (activeAtStart === "busy") {
+      const message2 = "Another Magic Context rebuild is already running for this session.";
+      setRecompTerminal(ctx.liveSessionState, sessionId, "skipped", message2);
+      return `## Magic Wrapup — Skipped
+
+${message2}`;
+    }
+    try {
+      sendIgnoredMessage(ctx.client, sessionId, `Magic Wrapup started — compacting about ${plural(expectedChunks, "chunk")} of history. This can take a few minutes; the result posts here when done.`, ctx.getNotificationParams(sessionId));
+    } catch {}
+    try {
+      pushNotification("action", { action: "wrapup-progress-kick" }, sessionId);
+    } catch {}
+    if (ownershipLost) {
+      stoppedForFailure = true;
+      stoppedReason = ownershipLostReason;
+    } else {
+      emitWrapupProgress(ctx, sessionId, {
+        processedMessages: Math.max(0, lastEnd),
+        totalMessages: Math.max(0, initialPlan.targetEligibleEndOrdinal - 1),
+        passCount: 0,
+        compartmentsCreated: 0,
+        note: `Eligible ${plural(initialPlan.snapshot.trueRawEligibleTokens, "token")} across about ${plural(expectedChunks, "chunk")}.`
+      });
+      for (;; ) {
+        if (ownershipLost) {
+          stoppedForFailure = true;
+          stoppedReason = ownershipLostReason;
+          break;
+        }
+        if (!renewWrapupMarker({
+          lastCompartmentEnd: getLastCompartmentEndMessage(ctx.db, sessionId),
+          chunkIndex,
+          expectedChunks
+        })) {
+          stoppedForFailure = true;
+          stoppedReason = ownershipLostReason;
+          break;
+        }
+        const plan = buildPlan(ctx, sessionId, messagesToKeep, initialPlan.anchorRawMessageCount);
+        lastEnd = getLastCompartmentEndMessage(ctx.db, sessionId);
+        if (lastEnd + 1 >= plan.targetEligibleEndOrdinal)
+          break;
+        chunkIndex += 1;
+        emitWrapupProgress(ctx, sessionId, {
+          processedMessages: Math.max(0, lastEnd),
+          totalMessages: Math.max(0, plan.targetEligibleEndOrdinal - 1),
+          passCount: chunkIndex - 1,
+          compartmentsCreated: Math.max(0, getCompartments(ctx.db, sessionId).length - startCompartmentCount),
+          note: `Chunk ${chunkIndex}/${expectedChunks}: messages ${plan.snapshot.offset}-${plan.snapshot.eligibleEndOrdinal - 1}…`
+        });
+        if (!renewWrapupMarker({
+          lastCompartmentEnd: lastEnd,
+          chunkIndex,
+          expectedChunks,
+          targetEligibleEndOrdinal: plan.targetEligibleEndOrdinal
+        })) {
+          stoppedForFailure = true;
+          stoppedReason = ownershipLostReason;
+          break;
+        }
+        const beforeEnd = lastEnd;
+        const beforeFailures = getHistorianFailureState(ctx.db, sessionId).failureCount;
+        const ran = await runOneWrapupIteration({
+          ctx,
+          sessionId,
+          plan,
+          messagesToKeep,
+          anchorRawMessageCount: initialPlan.anchorRawMessageCount,
+          renewWrapupMarker
+        });
+        if (!ran) {
+          stoppedForFailure = true;
+          stoppedReason = ownershipLost ? ownershipLostReason : "Another Magic Context rebuild started while wrapup was waiting.";
+          break;
+        }
+        const afterEnd = getLastCompartmentEndMessage(ctx.db, sessionId);
+        const afterFailures = getHistorianFailureState(ctx.db, sessionId).failureCount;
+        if (afterEnd <= beforeEnd) {
+          stoppedForFailure = true;
+          stoppedReason = afterFailures > beforeFailures ? "The historian failed on the current chunk." : "The historian made no forward progress on the current chunk.";
+          break;
+        }
+        lastEnd = afterEnd;
+        emitWrapupProgress(ctx, sessionId, {
+          processedMessages: Math.max(0, lastEnd),
+          totalMessages: Math.max(0, plan.targetEligibleEndOrdinal - 1),
+          passCount: chunkIndex,
+          compartmentsCreated: Math.max(0, getCompartments(ctx.db, sessionId).length - startCompartmentCount),
+          note: `Wrapped through message ${lastEnd}.`
+        });
+      }
+    }
+  } finally {
+    clearInterval(markerRenewal);
+    releaseWrapupInProgress(ctx.db, sessionId, wrapupHolderId);
+  }
+  const finalEnd = getLastCompartmentEndMessage(ctx.db, sessionId);
+  const compartmentsCreated = Math.max(0, getCompartments(ctx.db, sessionId).length - startCompartmentCount);
+  const messagesWrapped = Math.max(0, finalEnd - Math.max(0, startLastEnd));
+  if (stoppedForFailure) {
+    const message2 = `Wrapped up through message ${Math.max(0, finalEnd)} (${plural(messagesWrapped, "message")} into ${plural(compartmentsCreated, "compartment")}). ${stoppedReason} Run /ctx-wrapup again to continue.`;
+    setRecompTerminal(ctx.liveSessionState, sessionId, "failed", message2);
+    return `## Magic Wrapup — Partial
+
+${message2}`;
+  }
+  try {
+    clearEmergencyRecovery(ctx.db, sessionId);
+  } catch {}
+  const base = `Wrapped up ${messagesWrapped} messages into ${compartmentsCreated} compartments. The compacted history is queued and materializes on your next message.`;
+  const message = appendFlushHint(ctx, sessionId, base);
+  setRecompTerminal(ctx.liveSessionState, sessionId, "done", message);
+  return message;
+}
+
 // src/hooks/magic-context/hook.ts
 await init_compaction_marker_manager();
 
@@ -201474,7 +202770,7 @@ Drop silently — do not narrate it. NEVER drop large ranges blindly (e.g., "1-5
 Older tool calls may show \`[dropped §N§]\` sentinels; that is normal context management, not a pattern to copy. ALWAYS make fresh real tool calls when you need data again; never fabricate or inline tool output.`;
 var CAVEMAN_COMPRESSION_WARNING = `
 **BEWARE**: History compression is on; older user AND assistant text — including your own earlier responses — has been deterministically rewritten in a terse caveman style (dropped articles, missing auxiliaries, \`//\` instead of connectives like \`because\`). This is automatic context compression that runs after the fact, not your actual prior wording or the user's. **DO NOT mimic this style in new turns.** Write fresh responses in normal prose. If you notice your output drifting into caveman cadence, that drift is in-context-learning bleeding from the compressed history — consciously revert to full sentences.`;
-function buildMagicContextSection(_agent, protectedTags, ctxReduceEnabled = true, dreamerEnabled = false, temporalAwarenessEnabled = false, cavemanTextCompressionEnabled = false, subagentMode = false, language, memoryEnabled = true) {
+function buildMagicContextSection(_agent, protectedTags, ctxReduceCallable = true, dreamerEnabled = false, temporalAwarenessEnabled = false, cavemanTextCompressionEnabled = false, subagentMode = false, language, memoryEnabled = true) {
   if (subagentMode) {
     return `## Magic Context
 
@@ -201485,12 +202781,12 @@ When \`surface_condition\` is provided with \`write\`, the note becomes a projec
 The dreamer evaluates smart note conditions during nightly runs and surfaces them when conditions are met.
 Example: \`ctx_note(action="write", content="Implement X because Y", surface_condition="When PR #42 is merged in this repo")\`` : "";
   const temporalGuidance = temporalAwarenessEnabled ? TEMPORAL_AWARENESS_GUIDANCE : "";
-  const cavemanWarning = cavemanTextCompressionEnabled && !ctxReduceEnabled ? CAVEMAN_COMPRESSION_WARNING : "";
+  const cavemanWarning = cavemanTextCompressionEnabled ? CAVEMAN_COMPRESSION_WARNING : "";
   const languageDirective = buildPrimaryLanguageDirective(language);
   const languageGuidance = languageDirective ? `
 
 ${languageDirective}` : "";
-  if (!ctxReduceEnabled) {
+  if (!ctxReduceCallable) {
     return `## Magic Context
 
 ${LONG_TERM_PARTNER_FRAME}
@@ -201503,7 +202799,7 @@ ${BASE_INTRO_NO_REDUCE(memoryEnabled)}${smartNoteGuidance}${temporalGuidance}${c
 ${LONG_TERM_PARTNER_FRAME}
 ${PARTNER_FRAME_CLOSER_REDUCE}
 
-${BASE_INTRO(protectedTags, memoryEnabled)}${smartNoteGuidance}${temporalGuidance}
+${BASE_INTRO(protectedTags, memoryEnabled)}${smartNoteGuidance}${temporalGuidance}${cavemanWarning}
 ${GENERIC_SECTION}
 
 Prefer many small targeted operations over one large blanket operation, and keep the working set tidy as routine maintenance.${languageGuidance}`;
@@ -201556,17 +202852,18 @@ function createSystemPromptHashHandler(deps) {
     } catch (error51) {
       sessionLog(sessionId, "system-prompt-hash session meta load failed:", error51);
     }
-    const isSubagentSession = sessionMetaEarly?.isSubagent === true;
-    const ctxReduceCallable = resolveCtxReduceAvailability(sessionId);
-    const subagentReduceMode = isSubagentSession && deps.ctxReduceEnabled !== false && ctxReduceCallable;
-    const effectiveCtxReduceEnabled = isSubagentSession ? false : deps.ctxReduceEnabled !== false && ctxReduceCallable;
-    const skipGuidanceForDisabledSubagent = isSubagentSession && (deps.ctxReduceEnabled === false || !ctxReduceCallable);
+    const isSubagentSession2 = sessionMetaEarly?.isSubagent === true;
+    const availability = resolveCtxReduceAvailability(sessionId);
+    const ctxReduceCallable = availability.callable;
+    const subagentReduceMode = isSubagentSession2 && ctxReduceCallable;
+    const effectiveCtxReduceEnabled = isSubagentSession2 ? false : ctxReduceCallable;
+    const skipGuidanceForDisabledSubagent = isSubagentSession2 && !ctxReduceCallable;
     const fullPrompt = output.system.join(`
 `);
     if (fullPrompt.length > 0 && !fullPrompt.includes(MAGIC_CONTEXT_MARKER) && !skipGuidanceForDisabledSubagent) {
       const guidance = buildMagicContextSection(null, deps.protectedTags, effectiveCtxReduceEnabled, deps.dreamerEnabled, deps.experimentalTemporalAwareness, deps.experimentalCavemanTextCompression, subagentReduceMode, deps.language, deps.memoryEnabled !== false);
       output.system.push(guidance);
-      sessionLog(sessionId, `injected generic guidance into system prompt (ctxReduce=${effectiveCtxReduceEnabled}, subagent=${isSubagentSession}, subagentReduceMode=${subagentReduceMode})`);
+      sessionLog(sessionId, `injected generic guidance into system prompt (ctxReduce=${effectiveCtxReduceEnabled}, subagent=${isSubagentSession2}, subagentReduceMode=${subagentReduceMode})`);
     }
     const isCacheBusting = deps.systemPromptRefreshSessions.has(sessionId);
     const DATE_PATTERN = /Today's date: .+/;
@@ -201593,6 +202890,8 @@ function createSystemPromptHashHandler(deps) {
 `);
     if (systemContent.length === 0)
       return;
+    if (!availability.frozen)
+      return;
     const currentHash = createHash13("md5").update(systemContent).digest("hex");
     if (!sessionMetaEarly) {
       return;
@@ -201781,7 +203080,7 @@ function createMagicContextHook(deps) {
     notifyMagicContextDisabled(deps.client, reason);
     return null;
   }
-  const projectPath = resolveProjectIdentity(deps.directory);
+  const projectPath = resolveProjectIdentityOrFallback(deps.directory);
   try {
     checkCompactionMarkerConsistency(db);
   } catch (error51) {
@@ -201792,20 +203091,21 @@ function createMagicContextHook(deps) {
   const historianFallbackModels = resolveFallbackChain(deps.config.historian?.fallback_models);
   const historyRefreshSessions = deps.liveSessionState?.historyRefreshSessions ?? new Set;
   const deferredHistoryRefreshSessions = deps.liveSessionState?.deferredHistoryRefreshSessions ?? new Set;
+  const systemPromptRefreshSessions = deps.liveSessionState?.systemPromptRefreshSessions ?? new Set;
+  const pendingMaterializationSessions = deps.liveSessionState?.pendingMaterializationSessions ?? new Set;
+  const deferredMaterializationSessions = deps.liveSessionState?.deferredMaterializationSessions ?? new Set;
   try {
     const sessionsWithPending = getSessionsWithPendingMarker(db);
     if (sessionsWithPending.length > 0) {
       for (const sid of sessionsWithPending) {
         deferredHistoryRefreshSessions.add(sid);
+        deferredMaterializationSessions.add(sid);
       }
       log(`[magic-context] rehydrated ${sessionsWithPending.length} session(s) with pending compaction-marker drain at hook init`);
     }
   } catch (error51) {
     log("[magic-context] hook init: pending-marker rehydration failed:", error51);
   }
-  const systemPromptRefreshSessions = deps.liveSessionState?.systemPromptRefreshSessions ?? new Set;
-  const pendingMaterializationSessions = deps.liveSessionState?.pendingMaterializationSessions ?? new Set;
-  const deferredMaterializationSessions = deps.liveSessionState?.deferredMaterializationSessions ?? new Set;
   const lastHeuristicsTurnId = new Map;
   const commitSeenLastPass = new Map;
   const variantBySession = deps.liveSessionState?.variantBySession ?? new Map;
@@ -201826,7 +203126,15 @@ function createMagicContextHook(deps) {
     }
     return;
   };
-  const ctxReduceEnabled = deps.config.ctx_reduce_enabled !== false;
+  const maybeSendProjectIdentitySessionWarning = (sessionId, directory) => {
+    const warning = takeDubiousOwnershipProjectIdentityWarning(directory);
+    if (!warning)
+      return;
+    const notificationParams = getLiveNotificationParams(sessionId, liveModelBySession, variantBySession, agentBySession, deps.config.toast_duration_ms);
+    sendIgnoredMessage(deps.client, sessionId, warning, notificationParams).catch((error51) => {
+      log(`[magic-context] failed to send project identity warning for ${directory}: ${getErrorMessage(error51)}`);
+    });
+  };
   const dreamerRunnable = isDreamerRunnable(deps.config);
   const dreamerConfig = dreamerRunnable ? deps.config.dreamer : undefined;
   const historianRunnable = isHistorianRunnable(deps.config);
@@ -201863,6 +203171,23 @@ function createMagicContextHook(deps) {
     ensureProjectRegistered: ensureProjectRegisteredFromOpenCodeDirectory,
     getNotificationParams: (sid) => getLiveNotificationParams(sid, liveModelBySession, variantBySession, agentBySession, deps.config.toast_duration_ms)
   });
+  const buildManagedWrapupCtx = (sessionId) => ({
+    ...buildManagedRecompCtx(sessionId),
+    contextLimit: (() => {
+      const model = resolveLiveModel(sessionId);
+      return model ? resolveContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : 128000;
+    })(),
+    executeThresholdPercentage: (() => {
+      const model = resolveLiveModel(sessionId);
+      const contextLimit = model ? resolveContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : 128000;
+      return resolveExecuteThresholdDetail(deps.config.execute_threshold_percentage ?? 65, model ? `${model.providerID}/${model.modelID}` : undefined, 65, {
+        tokensConfig: deps.config.execute_threshold_tokens,
+        contextLimit,
+        sessionId
+      }).percentage;
+    })(),
+    hasPendingNaturalBust: (sid) => historyRefreshSessions.has(sid) || systemPromptRefreshSessions.has(sid) || pendingMaterializationSessions.has(sid)
+  });
   const executeEmbedHistory = async (sessionId, options) => {
     if (deps.config.memory?.enabled === false) {
       return "Memory is disabled for this project, so there is no semantic embedding to backfill.";
@@ -201873,7 +203198,8 @@ function createMagicContextHook(deps) {
       return "Embedding is already running for this session.";
     }
     await ensureProjectRegisteredFromOpenCodeDirectory(directory, db);
-    const sessionProjectIdentity = resolveProjectIdentity(directory);
+    const sessionProjectIdentity = resolveProjectIdentityOrFallback(directory);
+    maybeSendProjectIdentitySessionWarning(sessionId, directory);
     embedPauseBySession.delete(sessionId);
     const prior = embedRunStateBySession.get(sessionId);
     if (prior)
@@ -201938,13 +203264,15 @@ function createMagicContextHook(deps) {
     if (ctrl)
       ctrl.abort();
     const directory = sessionDirectoryBySession.get(sessionId) ?? deps.directory;
-    const sessionProjectIdentity = resolveProjectIdentity(directory);
+    const sessionProjectIdentity = resolveProjectIdentityOrFallback(directory);
+    maybeSendProjectIdentitySessionWarning(sessionId, directory);
     const cov = getEmbeddingCoverageStatus(db, sessionProjectIdentity, sessionId);
     return `Paused at ${cov.session.embedded}/${cov.session.total} compartments embedded.`;
   };
   const getEmbedStatusText = (sessionId) => {
     const directory = sessionDirectoryBySession.get(sessionId) ?? deps.directory;
-    const sessionProjectIdentity = resolveProjectIdentity(directory);
+    const sessionProjectIdentity = resolveProjectIdentityOrFallback(directory);
+    maybeSendProjectIdentitySessionWarning(sessionId, directory);
     const coverage = getEmbeddingCoverageStatus(db, sessionProjectIdentity, sessionId);
     const progress = recompProgressBySession.get(sessionId);
     const drainUi = getEmbedDrainUiStatus(sessionId, progress);
@@ -201967,7 +203295,8 @@ function createMagicContextHook(deps) {
       try {
         await new Promise((resolve4) => setTimeout(resolve4, 0));
         await ensureProjectRegisteredFromOpenCodeDirectory(directory, db);
-        const sessionProjectIdentity = resolveProjectIdentity(directory);
+        const sessionProjectIdentity = resolveProjectIdentityOrFallback(directory);
+        maybeSendProjectIdentitySessionWarning(sessionId, directory);
         const coverage = getEmbeddingCoverageStatus(db, sessionProjectIdentity, sessionId);
         if (!coverage.enabled)
           return;
@@ -202001,7 +203330,6 @@ function createMagicContextHook(deps) {
     db,
     channel1StateBySession,
     protectedTags: deps.config.protected_tags,
-    ctxReduceEnabled,
     smartDrops: deps.config.smart_drops === true,
     clearReasoningAge: deps.config.clear_reasoning_age ?? 50,
     commitClusterTrigger: deps.config.commit_cluster_trigger,
@@ -202050,7 +203378,7 @@ function createMagicContextHook(deps) {
       directory: deps.directory,
       ensureProjectRegistered: ensureProjectRegisteredFromOpenCodeDirectory
     } : undefined,
-    cavemanTextCompression: ctxReduceEnabled === false && deps.config.caveman_text_compression?.enabled === true ? {
+    cavemanTextCompression: deps.config.caveman_text_compression?.enabled === true ? {
       enabled: true,
       minChars: deps.config.caveman_text_compression.min_chars ?? 500
     } : undefined,
@@ -202138,6 +203466,7 @@ function createMagicContextHook(deps) {
       systemPromptRefreshSessions.add(sessionId);
       pendingMaterializationSessions.add(sessionId);
     },
+    executeWrapup: historianRunnable ? async (sessionId, options) => runManagedWrapup(buildManagedWrapupCtx(sessionId), sessionId, options) : undefined,
     executeRecomp: historianRunnable ? async (sessionId, options) => runManagedRecomp(buildManagedRecompCtx(sessionId), sessionId, options) : undefined,
     runUpgrade: historianRunnable ? async (sessionId) => runManagedUpgrade(buildManagedRecompCtx(sessionId), sessionId) : undefined,
     executeEmbedHistory,
@@ -202181,7 +203510,6 @@ function createMagicContextHook(deps) {
   const systemPromptHash = createSystemPromptHashHandler({
     db,
     protectedTags: deps.config.protected_tags,
-    ctxReduceEnabled,
     dreamerEnabled: dreamerRunnable,
     memoryEnabled: deps.config.memory?.enabled !== false,
     language: deps.config.language,
@@ -202196,7 +203524,7 @@ function createMagicContextHook(deps) {
     internalChildSessions,
     experimentalUserMemories: userMemoryCollectionEnabled(deps.config.dreamer),
     experimentalTemporalAwareness: deps.config.temporal_awareness === true,
-    experimentalCavemanTextCompression: ctxReduceEnabled === false && deps.config.caveman_text_compression?.enabled === true
+    experimentalCavemanTextCompression: deps.config.caveman_text_compression?.enabled === true
   });
   const systemPromptHashHandler = systemPromptHash.handler;
   const eventHook = createEventHook({
@@ -202215,8 +203543,7 @@ function createMagicContextHook(deps) {
     lastHeuristicsTurnId,
     commitSeenLastPass,
     client: deps.client,
-    protectedTags: deps.config.protected_tags,
-    ctxReduceEnabled
+    protectedTags: deps.config.protected_tags
   });
   return {
     "experimental.chat.messages.transform": transform2,
@@ -202231,7 +203558,6 @@ function createMagicContextHook(deps) {
       systemPromptRefreshSessions,
       pendingMaterializationSessions,
       lastHeuristicsTurnId,
-      ctxReduceEnabled,
       upgradeReminder: historianRunnable ? (sessionId) => maybeSendUpgradeReminder({
         client: deps.client,
         db,
@@ -202263,7 +203589,6 @@ function createMagicContextHook(deps) {
 function buildMagicContextHookConfig(pluginConfig) {
   return {
     protected_tags: pluginConfig.protected_tags ?? DEFAULT_PROTECTED_TAGS,
-    ctx_reduce_enabled: pluginConfig.ctx_reduce_enabled,
     cache_ttl: pluginConfig.cache_ttl,
     clear_reasoning_age: pluginConfig.clear_reasoning_age,
     toast_duration_ms: pluginConfig.toast_duration_ms,
@@ -202784,7 +204109,6 @@ function buildSidebarSnapshot(db, sessionId, directory, liveSessionState, inject
     contextLimit: 0,
     systemPromptTokens: 0,
     compartmentCount: 0,
-    factCount: 0,
     memoryCount: 0,
     memoryBlockCount: 0,
     pendingOpsCount: 0,
@@ -202823,7 +204147,6 @@ function buildSidebarSnapshot(db, sessionId, directory, liveSessionState, inject
     const memoryBlockCount = meta3 ? Number(meta3.memory_block_count ?? 0) : 0;
     const compartmentRow = db.prepare("SELECT COUNT(*) as count FROM compartments WHERE session_id = ?").get(sessionId);
     const compartmentCount = compartmentRow?.count ?? 0;
-    const factCount = 0;
     let memoryCount = 0;
     if (projectIdentity) {
       const memRow = db.prepare("SELECT COUNT(*) as count FROM memories WHERE project_path = ? AND status = 'active'").get(projectIdentity);
@@ -202930,7 +204253,6 @@ function buildSidebarSnapshot(db, sessionId, directory, liveSessionState, inject
       contextLimit,
       systemPromptTokens: calibrated.systemTokens,
       compartmentCount,
-      factCount,
       memoryCount,
       memoryBlockCount,
       pendingOpsCount,
@@ -203943,8 +205265,8 @@ function createCtxMemoryTool(deps) {
           }
         });
         const idList = targets.map((t) => t.memoryId).join(", ");
-        const plural = targets.length > 1 ? "memories" : "memory";
-        return args.reason?.trim() ? `Archived ${plural} [ID: ${idList}] (${args.reason.trim()}).` : `Archived ${plural} [ID: ${idList}].`;
+        const plural2 = targets.length > 1 ? "memories" : "memory";
+        return args.reason?.trim() ? `Archived ${plural2} [ID: ${idList}] (${args.reason.trim()}).` : `Archived ${plural2} [ID: ${idList}].`;
       }
       return "Error: Unknown action.";
     }
@@ -204349,10 +205671,12 @@ Sources (omit for a broad search across all):
 - memory: curated cross-session project knowledge — rules, constraints, conventions.
 - message: the raw conversation behind your compacted history. Hits include message ordinals — expand the surrounding exchange with ctx_expand(start=N-10, end=N+5).
 - git_commit: this repository's commit history.
+- note: parked decisions, follow-ups, and dismissed notes with their recorded text.
 
 Picking sources:
 - "when did this change / was this working before" → ["git_commit", "message"]
 - "did we discuss this earlier" → ["message"]
+- "did we decide something about this / leave a follow-up" → ["note"]
 - "what's our convention / rule for X" → ["memory"]`;
 var DEFAULT_CTX_SEARCH_LIMIT = 10;
 // src/tools/ctx-search/tools.ts
@@ -204364,7 +205688,8 @@ var VALID_SOURCES = new Set([
   "memory",
   "message",
   "git_commit",
-  "primer"
+  "primer",
+  "note"
 ]);
 function normalizeLimit3(limit) {
   if (typeof limit !== "number" || !Number.isFinite(limit)) {
@@ -204407,7 +205732,8 @@ function formatAge2(committedAtMs) {
   const years = Math.floor(days / 365);
   return years === 1 ? "1y ago" : `${years}y ago`;
 }
-function formatResult(result, index) {
+var NOTE_EXPAND_HINT = "Use ctx_expand(start=N-10, end=N) around any note @msg anchor above to read the surrounding conversation context.";
+function formatResult(result, index, currentSessionId) {
   if (result.source === "memory") {
     const source = result.sourceName ? ` source=${result.sourceName}` : "";
     return [
@@ -204428,6 +205754,14 @@ function formatResult(result, index) {
       `[${index}] [primer] score=${result.score.toFixed(2)} id=${result.primerId} support=${result.support} match=${result.matchType}`,
       result.content
     ].join(`
+`);
+  }
+  if (result.source === "note") {
+    const anchor = result.anchorOrdinal !== null && result.sourceSessionId === currentSessionId ? ` @msg ${result.anchorOrdinal}` : "";
+    return [
+      `[${index}] [note] score=${result.score.toFixed(2)} id=#${result.noteId} status=${result.status} ${formatAge2(result.createdAt)}${anchor}`,
+      result.content
+    ].join(`
 `);
   }
   if (result.source === "compartment") {
@@ -204445,14 +205779,17 @@ function formatResult(result, index) {
   ].join(`
 `);
 }
-function formatSearchResults(query, results) {
+function formatSearchResults(query, results, currentSessionId) {
   if (results.length === 0) {
-    return `No results found for "${query}" across memories, primers, git commits, or message history.`;
+    return `No results found for "${query}" across notes, memories, primers, git commits, or message history.`;
   }
-  const bodyParts = results.map((result, index) => formatResult(result, index + 1));
+  const bodyParts = results.map((result, index) => formatResult(result, index + 1, currentSessionId));
   if (results.some((result) => result.source === "message" || result.source === "compartment")) {
     bodyParts.push("Use ctx_expand(start, end) with the range from any message result above to read the full conversation context.");
   }
+  if (results.some((result) => result.source === "note" && result.anchorOrdinal !== null && result.sourceSessionId === currentSessionId)) {
+    bodyParts.push(NOTE_EXPAND_HINT);
+  }
   const body = bodyParts.join(`
 
 `);
@@ -204466,7 +205803,7 @@ function createCtxSearchTool(deps) {
     args: {
       query: tool5.schema.string().describe("Search query. Matches against memory content, Primers, git commit messages, and raw user/assistant message text."),
       limit: tool5.schema.number().optional().describe("Maximum results to return (default: 10)"),
-      sources: tool5.schema.array(tool5.schema.enum(["memory", "message", "git_commit", "primer"])).optional().describe('Optional. Restrict to specific sources. Examples: ["primer"] for standing project explanations, ["git_commit"] for "when did we change X", ["memory"] for naming conventions, ["message"] for "did we discuss this earlier", ["git_commit","message"] for regression hunts. Omit for a broad search across all enabled sources.')
+      sources: tool5.schema.array(tool5.schema.enum(["memory", "message", "git_commit", "primer", "note"])).optional().describe('Optional. Restrict to specific sources. Examples: ["primer"] for standing project explanations, ["git_commit"] for "when did we change X", ["memory"] for naming conventions, ["message"] for "did we discuss this earlier", ["note"] for parked decisions or follow-ups, ["git_commit","message"] for regression hunts. Omit for a broad search across all enabled sources.')
     },
     async execute(args, toolContext) {
       const query = args.query?.trim();
@@ -204498,7 +205835,7 @@ function createCtxSearchTool(deps) {
         visibleMemoryIds,
         explicitSearch: true
       });
-      return formatSearchResults(query, results);
+      return formatSearchResults(query, results, toolContext.sessionID);
     }
   });
 }
@@ -204555,14 +205892,13 @@ function createToolRegistry(args) {
     return {};
   }
   ensureProjectRegisteredFromOpenCodeDirectory(ctx.directory, db);
-  const resolveProjectPath = (directory) => resolveProjectIdentity(directory);
-  const ctxReduceEnabled = pluginConfig.ctx_reduce_enabled !== false;
+  const resolveProjectPath = (directory) => resolveProjectIdentityOrFallback(directory);
   const memoryEnabled = pluginConfig.memory?.enabled !== false;
   const allTools = {
-    ...ctxReduceEnabled ? createCtxReduceTools({
+    ...createCtxReduceTools({
       db,
       protectedTags: pluginConfig.protected_tags ?? DEFAULT_PROTECTED_TAGS
-    }) : {},
+    }),
     ...createCtxExpandTools({ db }),
     ...createCtxNoteTools({
       db,
@@ -204973,6 +206309,31 @@ var server = async (ctx) => {
       log(`[v22-backfill] failed to start background runner: ${err}`);
     }
   }
+  if (pluginConfig.enabled && hooks.magicContext) {
+    setTimeout(() => {
+      try {
+        const db = openDatabase();
+        if (!db || !isDatabasePersisted(db))
+          return;
+        const ocDb = openOpenCodeDb();
+        if (!ocDb)
+          return;
+        try {
+          const sessions = ocDb.prepare("SELECT id, COALESCE(directory, '') AS directory FROM session ORDER BY id ASC").all();
+          runSessionProjectBackfill(db, sessions.map((session) => ({
+            sessionId: session.id,
+            directory: session.directory
+          }))).catch((err) => {
+            log(`[session-projects] background runner failed: ${err}`);
+          });
+        } finally {
+          closeQuietly(ocDb);
+        }
+      } catch (err) {
+        log(`[session-projects] failed to start background runner: ${err}`);
+      }
+    }, 0);
+  }
   const storageDir = getMagicContextStorageDir();
   let rpcServer = null;
   let stopDreamTimerRegistration;
@@ -204980,7 +206341,7 @@ var server = async (ctx) => {
     const dreamerRunnable = isDreamerRunnable(pluginConfig);
     const timerRegistration = {
       directory: ctx.directory,
-      projectIdentity: resolveProjectIdentity(ctx.directory),
+      projectIdentity: resolveProjectIdentityOrFallback(ctx.directory),
       client: ctx.client,
       dreamerConfig: dreamerRunnable ? pluginConfig.dreamer : undefined,
       language: pluginConfig.language,