@cortexkit/pi-magic-context 0.30.6 → 0.31.0

package/dist/index.js

@@ -62,26 +62,26 @@ var currentHarness = "opencode", harnessLocked = false;
 // ../plugin/src/shared/data-path.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import * as os from "node:os";
-import * as path2 from "node:path";
+import * as path from "node:path";
 function getDataDir() {
-  return process.env.XDG_DATA_HOME ?? path2.join(os.homedir(), ".local", "share");
+  return process.env.XDG_DATA_HOME ?? path.join(os.homedir(), ".local", "share");
 }
 function getMagicContextTempDir(harness = getHarness()) {
-  return path2.join(os.tmpdir(), harness, "magic-context");
+  return path.join(os.tmpdir(), harness, "magic-context");
 }
 function getMagicContextLogPath(harness = getHarness()) {
   const envPath = process.env.MAGIC_CONTEXT_LOG_PATH?.trim();
   if (envPath)
     return envPath;
-  return path2.join(getMagicContextTempDir(harness), "magic-context.log");
+  return path.join(getMagicContextTempDir(harness), "magic-context.log");
 }
 function getProjectMagicContextDir(directory) {
-  return path2.join(directory, ".cortexkit", "magic-context");
+  return path.join(directory, ".cortexkit", "magic-context");
 }
 function ensureCortexKitArtifactGitignore(directory) {
   try {
-    const cortexKitDir = path2.join(directory, ".cortexkit");
-    const gitignorePath = path2.join(cortexKitDir, ".gitignore");
+    const cortexKitDir = path.join(directory, ".cortexkit");
+    const gitignorePath = path.join(cortexKitDir, ".gitignore");
     let existing = "";
     if (existsSync2(gitignorePath)) {
       existing = readFileSync2(gitignorePath, "utf8");
@@ -101,25 +101,25 @@ ${GITIGNORE_GUARD_CLOSE}
   } catch {}
 }
 function getProjectMagicContextHistorianDir(directory) {
-  return path2.join(getProjectMagicContextDir(directory), "historian");
+  return path.join(getProjectMagicContextDir(directory), "historian");
 }
 function getOpenCodeStorageDir() {
-  return path2.join(getDataDir(), "opencode", "storage");
+  return path.join(getDataDir(), "opencode", "storage");
 }
 function getMagicContextStorageDir() {
-  return path2.join(getDataDir(), "cortexkit", "magic-context");
+  return path.join(getDataDir(), "cortexkit", "magic-context");
 }
 function getLegacyOpenCodeMagicContextStorageDir() {
-  return path2.join(getOpenCodeStorageDir(), "plugin", "magic-context");
+  return path.join(getOpenCodeStorageDir(), "plugin", "magic-context");
 }
 var GITIGNORE_GUARD_OPEN = "# >>> cortexkit:magic-context", GITIGNORE_GUARD_CLOSE = "# <<< cortexkit:magic-context";
 var init_data_path = () => {};
 
 // ../plugin/src/shared/logger.ts
 import * as fs from "node:fs";
-import * as path3 from "node:path";
+import * as path2 from "node:path";
 function ensureDir(filePath) {
-  const dir = path3.dirname(filePath);
+  const dir = path2.dirname(filePath);
   if (dir === lastEnsuredDir)
     return;
   try {
@@ -15707,13 +15707,23 @@ function summarizeDreamSchedule(dreamer) {
 }
 
 // ../plugin/src/features/magic-context/memory/project-identity.ts
+init_logger();
 import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { statSync as statSync2 } from "node:fs";
-import path from "node:path";
+import { existsSync as existsSync3, realpathSync, statSync as statSync2 } from "node:fs";
+import path3 from "node:path";
 var GIT_TIMEOUT_MS = 5000;
+var TRANSIENT_FAILURE_COOLDOWN_MS = 5 * 60 * 1000;
 var identityCache = new Map;
+var lastKnownGitIdentityCache = new Map;
 var directoryFallbackCache = new Map;
+var transientFailureCooldown = new Map;
+var dubiousOwnershipFallbackDirectories = new Set;
+var dubiousOwnershipLoggedDirectories = new Set;
+var dubiousOwnershipWarnedDirectories = new Set;
+var transientGitIdentityReuseLoggedDirectories = new Set;
+var execFileSyncForIdentity = execFileSync;
+var nowMs = () => Date.now();
 
 class ProjectIdentityError extends Error {
   errorClass;
@@ -15765,7 +15775,7 @@ function getErrorStderr(error) {
   return "";
 }
 function directoryFallback(directory) {
-  const canonical = path.resolve(directory);
+  const canonical = path3.resolve(directory);
   const hash = createHash("md5").update(canonical, "utf8").digest("hex").slice(0, 12);
   return `dir:${hash}`;
 }
@@ -15803,21 +15813,27 @@ function classifyGitError(error, rawDirectory) {
     return new ProjectIdentityError("permission_denied", rawDirectory, "Permission denied while spawning git", asError(error));
   }
   const stderr = getErrorStderr(error).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(error));
+  }
   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(error));
   }
   return new ProjectIdentityError("unknown", rawDirectory, "git rev-list failed while resolving project identity", asError(error));
 }
 function resolveProjectIdentityStrict(directory) {
-  const canonical = path.resolve(directory);
+  const canonical = path3.resolve(directory);
   const cached = identityCache.get(canonical);
   if (cached !== undefined) {
     return cached;
   }
   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" },
@@ -15835,13 +15851,76 @@ 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(error) {
-  return error.errorClass === "not_git_repo" || error.errorClass === "unknown" && error.message.startsWith("Unable to access project directory:");
+  return error.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 cached = lastKnownGitIdentity(current);
+      if (cached !== undefined)
+        return { identity: cached, 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 cached = nearestLastKnownGitIdentity(canonical);
+  if (cached === undefined)
+    return;
+  if (!transientGitIdentityReuseLoggedDirectories.has(canonical)) {
+    transientGitIdentityReuseLoggedDirectories.add(canonical);
+    const sourceNote = cached.source === canonical ? "" : ` from ancestor ${cached.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 cached.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 resolveProjectIdentity(directory) {
-  const canonical = path.resolve(directory);
+  const canonical = path3.resolve(directory);
   const cachedFallback = directoryFallbackCache.get(canonical);
   if (cachedFallback !== undefined) {
     if (!hasGitDir(canonical)) {
@@ -15849,27 +15928,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 (error) {
     if (error instanceof ProjectIdentityError && shouldUseDirectoryFallback(error)) {
       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 (error.errorClass === "dubious_ownership") {
+        recordDubiousOwnershipFallback(canonical);
       }
       return fallback;
     }
     throw error;
   }
 }
-function hasGitDir(canonical) {
+function resolveProjectIdentityOrFallback(directory) {
   try {
-    statSync2(path.join(canonical, ".git"));
+    return resolveProjectIdentity(directory);
+  } catch (error) {
+    const canonical = path3.resolve(directory);
+    const fallback = directoryFallback(canonical);
+    const message = error instanceof Error ? error.message : String(error);
+    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 (existsSync3(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;
@@ -15902,7 +16028,7 @@ function removeSystemReminders(text) {
 // ../plugin/src/hooks/magic-context/read-session-db.ts
 init_data_path();
 init_logger();
-import { existsSync as existsSync3 } from "node:fs";
+import { existsSync as existsSync4 } from "node:fs";
 import { join as join3 } from "node:path";
 
 // ../plugin/src/shared/sqlite.ts
@@ -15971,7 +16097,7 @@ function getOpenCodeDbPath() {
   return join3(getDataDir(), "opencode", "opencode.db");
 }
 function openCodeDbExists() {
-  return existsSync3(getOpenCodeDbPath());
+  return existsSync4(getOpenCodeDbPath());
 }
 var cachedReadOnlyDb = null;
 function closeCachedReadOnlyDb() {
@@ -149634,6 +149760,263 @@ function parseReportedLimit(message) {
   }
   return;
 }
+
+// ../plugin/src/features/magic-context/session-project-backfill.ts
+init_logger();
+import { existsSync as existsSync5 } from "node:fs";
+
+// ../plugin/src/features/magic-context/session-project-storage.ts
+var upsertSessionProjectStatements = new WeakMap;
+var repairSessionChunkProjectStatements = new WeakMap;
+var repairProjectChunkProjectStatements = new WeakMap;
+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;
+}
+
+// ../plugin/src/features/magic-context/session-project-backfill.ts
+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 (error) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {}
+    throw error;
+  }
+}
+function defaultYieldFn() {
+  return new Promise((resolve) => setTimeout(resolve, 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) ?? existsSync5(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;
+}
 // ../plugin/src/features/magic-context/compartment-lease.ts
 var COMPARTMENT_LEASE_TTL_MS = 5 * 60 * 1000;
 var COMPARTMENT_LEASE_RENEWAL_MS = 60 * 1000;
@@ -151859,6 +152242,15 @@ var MIGRATIONS = [
                 );
             `);
     }
+  },
+  {
+    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");
+      }
+    }
   }
 ];
 var LATEST_MIGRATION_VERSION = MIGRATIONS.reduce((max, m) => Math.max(max, m.version), 0);
@@ -152047,7 +152439,7 @@ function readProjectDocsCanonical(projectDirectory) {
   return { renderedBlock, canonicalHash };
 }
 // ../plugin/src/features/magic-context/storage-db.ts
-import { chmodSync, copyFileSync, cpSync, existsSync as existsSync5, mkdirSync as mkdirSync4, mkdtempSync } from "node:fs";
+import { chmodSync, copyFileSync, cpSync, existsSync as existsSync7, mkdirSync as mkdirSync4, mkdtempSync } from "node:fs";
 init_data_path();
 import { dirname as dirname3, join as join5 } from "node:path";
 
@@ -152186,14 +152578,14 @@ function loadToolDefinitionMeasurements(db) {
 // ../plugin/src/features/magic-context/tool-owner-backfill.ts
 init_data_path();
 init_logger();
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync6 } from "node:fs";
 import { join as join4 } from "node:path";
 var LEASE_DURATION_MS = 5 * 60 * 1000;
 var LEASE_RENEWAL_MS = 60 * 1000;
 function resolveOpencodeDbPath() {
   return join4(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,
@@ -152209,7 +152601,7 @@ function ensureBackfillStateTable(db) {
 }
 function runToolOwnerBackfill(db) {
   const startedAt = performance.now();
-  ensureBackfillStateTable(db);
+  ensureBackfillStateTable2(db);
   const result = {
     sessionsProcessed: 0,
     sessionsSkippedNoOcDb: 0,
@@ -152226,7 +152618,7 @@ function runToolOwnerBackfill(db) {
     return result;
   }
   const opencodeDbPath = resolveOpencodeDbPath();
-  if (!existsSync4(opencodeDbPath)) {
+  if (!existsSync6(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");
@@ -152249,7 +152641,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
@@ -152448,7 +152840,7 @@ var persistenceByDatabase = new WeakMap;
 var persistenceErrorByDatabase = new WeakMap;
 var pathByDatabase = new WeakMap;
 var lastSchemaFenceRejection = null;
-var LATEST_SUPPORTED_VERSION = 49;
+var LATEST_SUPPORTED_VERSION = 50;
 var PERMISSIONS_ENFORCEABLE = process.platform !== "win32";
 function ensureSecureStorageDir(dir) {
   mkdirSync4(dir, { recursive: true, mode: 448 });
@@ -152465,7 +152857,7 @@ function restrictDatabaseFilePermissions(dbPath) {
     return;
   for (const suffix of ["", "-wal", "-shm"]) {
     const file = `${dbPath}${suffix}`;
-    if (!existsSync5(file))
+    if (!existsSync7(file))
       continue;
     try {
       chmodSync(file, 384);
@@ -152491,11 +152883,11 @@ function getDatabasePath(db) {
   return pathByDatabase.get(db) ?? null;
 }
 function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
-  if (existsSync5(targetDbPath))
+  if (existsSync7(targetDbPath))
     return;
   const legacyDir = getLegacyOpenCodeMagicContextStorageDir();
   const legacyDbPath = join5(legacyDir, "context.db");
-  if (!existsSync5(legacyDbPath))
+  if (!existsSync7(legacyDbPath))
     return;
   log(`[magic-context] migrating legacy plugin storage: ${legacyDir} -> ${targetDbDir} (legacy left in place as backup)`);
   ensureSecureStorageDir(targetDbDir);
@@ -152512,7 +152904,7 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
   for (const suffix of ["", "-wal", "-shm"]) {
     const src = `${legacyDbPath}${suffix}`;
     const dst = join5(targetDbDir, `context.db${suffix}`);
-    if (existsSync5(src)) {
+    if (existsSync7(src)) {
       try {
         copyFileSync(src, dst);
       } catch (error) {
@@ -152522,7 +152914,7 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
   }
   const legacyModelsDir = join5(legacyDir, "models");
   const targetModelsDir = join5(targetDbDir, "models");
-  if (existsSync5(legacyModelsDir) && !existsSync5(targetModelsDir)) {
+  if (existsSync7(legacyModelsDir) && !existsSync7(targetModelsDir)) {
     try {
       cpSync(legacyModelsDir, targetModelsDir, { recursive: true });
     } catch (error) {
@@ -153126,6 +153518,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,
@@ -153414,6 +153807,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");
@@ -153886,6 +154280,148 @@ function recordProtectedTailNoEligibleHead(db, sessionId) {
   return loadProtectedTailMeta(db, sessionId).recoveryNoEligibleHeadCount;
 }
 var DRAIN_WINDOW_MS = 10 * 60 * 1000;
+var WRAPUP_IN_PROGRESS_TTL_MS = 5 * 60 * 1000;
+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)));
@@ -155742,7 +156278,7 @@ var ERROR_CLASSES = new Set([
 // ../plugin/src/features/magic-context/v22-deferred-backfill.ts
 init_logger();
 import { createHash as createHash4 } from "node:crypto";
-import { realpathSync } from "node:fs";
+import { realpathSync as realpathSync2 } from "node:fs";
 import path5 from "node:path";
 
 // ../plugin/src/features/magic-context/memory/relocate-memory.ts
@@ -155776,7 +156312,10 @@ function countFailures(db) {
 }
 function classifyBackfillError(error) {
   if (error instanceof ProjectIdentityError) {
-    return { errorClass: error.errorClass, errorMessage: error.message };
+    return {
+      errorClass: error.errorClass === "dubious_ownership" ? "unknown" : error.errorClass,
+      errorMessage: error.message
+    };
   }
   if (error instanceof Error) {
     return { errorClass: "unknown", errorMessage: error.message };
@@ -155796,7 +156335,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);
   }
@@ -156487,11 +157026,12 @@ function compareSemverCore(a, b) {
 
 // ../plugin/src/shared/announcement.ts
 init_data_path();
-var ANNOUNCEMENT_VERSION = "0.30.4";
+var ANNOUNCEMENT_VERSION = "0.31.0";
 var 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)."
 ];
 var ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/F2uWxjGnU";
 var STATE_FILENAME = "last_announced_version";
@@ -156667,7 +157207,7 @@ init_logger();
 
 // src/subagent-runner.ts
 import * as childProcess from "node:child_process";
-import { existsSync as existsSync7, mkdtempSync as mkdtempSync2, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync9, mkdtempSync as mkdtempSync2, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import { tmpdir as tmpdir2 } from "node:os";
 import { basename as basename2, dirname as dirname4, join as join8, resolve as resolvePath } from "node:path";
@@ -156798,7 +157338,7 @@ function resolveBundledPiCli() {
     const require_ = createRequire2(import.meta.url);
     const pkgJson = require_.resolve("@earendil-works/pi-coding-agent/package.json");
     const cliPath = join8(dirname4(pkgJson), "dist/cli.js");
-    if (existsSync7(cliPath))
+    if (existsSync9(cliPath))
       return cliPath;
     return null;
   } catch {
@@ -156809,7 +157349,7 @@ function resolvePiInvocation() {
   const execPath = process.execPath;
   const currentScript = process.argv[1];
   const isBunVirtualScript = currentScript?.startsWith("/$bunfs/root/") ?? false;
-  if (currentScript && !isBunVirtualScript && existsSync7(currentScript)) {
+  if (currentScript && !isBunVirtualScript && existsSync9(currentScript)) {
     return { command: execPath, prefixArgs: [currentScript] };
   }
   const execName = basename2(execPath).toLowerCase();
@@ -156827,7 +157367,7 @@ function resolveSubagentEntryPath() {
   try {
     const here = dirname4(fileURLToPath(import.meta.url));
     const candidate = resolvePath(here, "subagent-entry.js");
-    if (existsSync7(candidate))
+    if (existsSync9(candidate))
       return candidate;
     return;
   } catch {
@@ -157496,12 +158036,13 @@ ${sidekickText}
 init_logger();
 
 // ../plugin/src/features/magic-context/dreamer/open-opencode-db.ts
-import { existsSync as existsSync8 } from "node:fs";
+import { existsSync as existsSync11 } from "node:fs";
 init_logger();
 
 // ../plugin/src/features/magic-context/compaction-marker.ts
 init_data_path();
 init_logger();
+import { existsSync as existsSync10 } from "node:fs";
 import { join as join9 } from "node:path";
 var BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 function randomBase62(length) {
@@ -157568,6 +158109,9 @@ function getWritableOpenCodeDb() {
       closeQuietly(cachedWriteDb.db);
     } catch {}
   }
+  if (!existsSync10(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");
@@ -157686,8 +158230,8 @@ function removeCompactionMarker(state) {
 // ../plugin/src/features/magic-context/dreamer/open-opencode-db.ts
 function openOpenCodeDb() {
   const dbPath = getOpenCodeDbPath2();
-  if (!existsSync8(dbPath)) {
-    log(`[key-files] OpenCode DB not found at ${dbPath} — skipping`);
+  if (!existsSync11(dbPath)) {
+    log(`[dreamer] OpenCode DB not found at ${dbPath} — skipping OpenCode history scan`);
     return null;
   }
   try {
@@ -157695,14 +158239,14 @@ function openOpenCodeDb() {
     db.exec("PRAGMA busy_timeout = 5000");
     return db;
   } catch (error) {
-    log(`[key-files] failed to open OpenCode DB at ${dbPath}: ${getErrorMessage(error)}`);
+    log(`[dreamer] failed to open OpenCode DB at ${dbPath}: ${getErrorMessage(error)}`);
     return null;
   }
 }
 
 // ../plugin/src/features/magic-context/dreamer/task-executor.ts
 import { createHash as createHash10 } from "node:crypto";
-import { existsSync as existsSync12 } from "node:fs";
+import { existsSync as existsSync15 } from "node:fs";
 
 // ../plugin/src/agents/dreamer.ts
 var DREAMER_AGENT = "dreamer";
@@ -172654,7 +173198,6 @@ var MagicContextConfigSchema = exports_external.object({
   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" })'),
@@ -172693,9 +173236,9 @@ var MagicContextConfigSchema = exports_external.object({
   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)"),
@@ -173502,7 +174045,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");
 }
@@ -173647,7 +174191,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);
         }
@@ -174572,77 +175116,6 @@ function invalidateMemory(projectPath, memoryId) {
   }
 }
 
-// ../plugin/src/features/magic-context/session-project-storage.ts
-var upsertSessionProjectStatements = new WeakMap;
-var repairSessionChunkProjectStatements = new WeakMap;
-var repairProjectChunkProjectStatements = new WeakMap;
-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;
-}
-
 // ../plugin/src/features/magic-context/project-embedding-registry.ts
 var OFF_PROVIDER_IDENTITY = "embedding-provider:off";
 var SWEEP_MAX_WALL_CLOCK_MS = 10 * 60 * 1000;
@@ -176295,7 +176768,7 @@ function getMemoryVerifications(db, memoryIds) {
 }
 // ../plugin/src/features/magic-context/memory/verification-paths.ts
 import { execFile } from "node:child_process";
-import { existsSync as existsSync9, realpathSync as realpathSync2, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync12, realpathSync as realpathSync3, statSync as statSync4 } from "node:fs";
 import path7 from "node:path";
 import { promisify } from "node:util";
 var execFileAsync = promisify(execFile);
@@ -176322,7 +176795,7 @@ function isWithin(root, candidate) {
 }
 function safeRealpath(value) {
   try {
-    return realpathSync2.native(value);
+    return realpathSync3.native(value);
   } catch {
     return null;
   }
@@ -176400,7 +176873,7 @@ function verificationFileExists(baseRoot, filePath) {
     return false;
   const root = path7.resolve(baseRoot);
   const candidate = path7.resolve(root, filePath);
-  return isWithin(root, candidate) && existsSync9(candidate);
+  return isWithin(root, candidate) && existsSync12(candidate);
 }
 async function normalizeVerificationFiles(args) {
   const cwd = path7.resolve(args.cwd);
@@ -176433,7 +176906,7 @@ async function normalizeVerificationFiles(args) {
       warnings.push(`Skipped verification path "${value}" because it is the repo/project root.`);
       continue;
     }
-    if (existsSync9(candidate)) {
+    if (existsSync12(candidate)) {
       try {
         if (statSync4(candidate).isDirectory()) {
           warnings.push(`Skipped verification path "${value}" because it is a directory.`);
@@ -176464,7 +176937,7 @@ async function normalizeVerificationFiles(args) {
       }
       normalized.push(tracked);
     } else {
-      if (!existsSync9(candidate)) {
+      if (!existsSync12(candidate)) {
         warnings.push(`Skipped verification path "${value}" because it does not exist.`);
         continue;
       }
@@ -179107,7 +179580,7 @@ Output exactly JSON: {"met": false}`;
 
 // ../plugin/src/features/magic-context/dreamer/maintain-docs-protected-enforcement.ts
 init_logger();
-import { existsSync as existsSync10, readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync13, readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "node:fs";
 import { join as join11 } from "node:path";
 
 // ../plugin/src/features/magic-context/dreamer/protected-regions.ts
@@ -179211,7 +179684,7 @@ function snapshotMaintainDocsFiles(docsDir) {
   for (const name2 of MAINTAIN_DOCS_SNAPSHOT_FILES) {
     const path9 = join11(docsDir, name2);
     try {
-      if (existsSync10(path9)) {
+      if (existsSync13(path9)) {
         snapshot.set(name2, readFileSync6(path9, "utf8"));
       }
     } catch {}
@@ -179239,7 +179712,7 @@ function enforceMaintainDocsProtectedRegions(args) {
 init_logger();
 
 // ../plugin/src/features/magic-context/dreamer/map-memories-prompt.ts
-import { existsSync as existsSync11, statSync as statSync5 } from "node:fs";
+import { existsSync as existsSync14, statSync as statSync5 } from "node:fs";
 import path9 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.
 
@@ -179277,7 +179750,7 @@ function extractMemoryCandidatePaths(content, repoDir) {
     if (!abs.startsWith(`${root}/`))
       continue;
     try {
-      if (existsSync11(abs) && statSync5(abs).isFile())
+      if (existsSync14(abs) && statSync5(abs).isFile())
         found.add(rel);
     } catch {}
     if (found.size >= MAX_SEED_PATHS_PER_MEMORY)
@@ -181418,8 +181891,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: existsSync12(`${docsDir}/ARCHITECTURE.md`),
-    structure: existsSync12(`${docsDir}/STRUCTURE.md`)
+    architecture: existsSync15(`${docsDir}/ARCHITECTURE.md`),
+    structure: existsSync15(`${docsDir}/STRUCTURE.md`)
   } : undefined;
   const userMemories = task === "curate" ? getActiveUserMemories(db).map((um) => ({ id: um.id, content: um.content })) : undefined;
   let curateMemories;
@@ -182634,7 +183107,7 @@ function pruneNestedConfigLeaf(block, relativePath) {
 }
 
 // src/config/index.ts
-import { existsSync as existsSync14, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync17, readFileSync as readFileSync8 } from "node:fs";
 
 // ../plugin/src/config/migrate-dreamer-v2.ts
 var OLD_VERIFY_TASK = "verify";
@@ -183016,7 +183489,7 @@ function dropInheritedEmbeddingKeyOnRedirect(projectRaw, mergedRaw, userRaw) {
 }
 
 // ../plugin/src/config/variable.ts
-import { existsSync as existsSync13, readFileSync as readFileSync7 } from "node:fs";
+import { existsSync as existsSync16, readFileSync as readFileSync7 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 import { dirname as dirname6, isAbsolute as isAbsolute2, resolve } from "node:path";
 
@@ -183151,7 +183624,7 @@ function substituteConfigVariables(input) {
     if (sensitiveReason) {
       warnings.push(`${token} resolves to a sensitive path (${sensitiveReason}: ${filePath}); ` + "inlining its contents into config — make sure this is intentional.");
     }
-    if (!existsSync13(filePath)) {
+    if (!existsSync16(filePath)) {
       warnings.push(`File not found for ${token} (resolved to ${filePath}); using empty string`);
       continue;
     }
@@ -183180,10 +183653,10 @@ function getUserConfigPaths() {
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function resolveFirstExisting(paths) {
-  return paths.find((path11) => existsSync14(path11));
+  return paths.find((path11) => existsSync17(path11));
 }
 function resolvePiLegacyFallback(sources) {
-  return sources.find((source) => existsSync14(source.path)) ?? null;
+  return sources.find((source) => existsSync17(source.path)) ?? null;
 }
 function loadConfigFile(path11, scope) {
   try {
@@ -183320,7 +183793,7 @@ function loadPiConfig(opts = {}) {
     if (loaded)
       loadedFiles.push(loaded);
   }
-  const legacyProjectUnmigrated = !projectPath && !projectLegacyFallback && legacySources.project.some((source) => existsSync14(source.path));
+  const legacyProjectUnmigrated = !projectPath && !projectLegacyFallback && legacySources.project.some((source) => existsSync17(source.path));
   const userPath = resolveFirstExisting(getUserConfigPaths());
   const userLegacyFallback = userPath ? null : resolvePiLegacyFallback(harnessLegacy.user);
   const userReadPath = userPath ?? userLegacyFallback?.path;
@@ -183329,7 +183802,7 @@ function loadPiConfig(opts = {}) {
     if (loaded)
       loadedFiles.push(loaded);
   }
-  const legacyUserUnmigrated = !userPath && !userLegacyFallback && legacySources.user.some((source) => existsSync14(source.path));
+  const legacyUserUnmigrated = !userPath && !userLegacyFallback && legacySources.user.some((source) => existsSync17(source.path));
   if (userLegacyFallback) {
     warnings.push(`[user config] reading legacy config from ${userLegacyFallback.path} until migration completes; run \`npx @cortexkit/magic-context doctor\` to consolidate into the shared CortexKit location.`);
   } else if (legacyUserUnmigrated) {
@@ -183430,7 +183903,7 @@ function loadPiConfigDetailed(opts = {}) {
     if (loaded)
       loadedFiles.push(loaded);
   }
-  const legacyProjectUnmigrated = !projectPath && !projectLegacyFallback && legacySources.project.some((source) => existsSync14(source.path));
+  const legacyProjectUnmigrated = !projectPath && !projectLegacyFallback && legacySources.project.some((source) => existsSync17(source.path));
   const userPath = resolveFirstExisting(getUserConfigPaths());
   const userLegacyFallback = userPath ? null : resolvePiLegacyFallback(harnessLegacy.user);
   const userReadPath = userPath ?? userLegacyFallback?.path;
@@ -183439,7 +183912,7 @@ function loadPiConfigDetailed(opts = {}) {
     if (loaded)
       loadedFiles.push(loaded);
   }
-  const legacyUserUnmigrated = !userPath && !userLegacyFallback && legacySources.user.some((source) => existsSync14(source.path));
+  const legacyUserUnmigrated = !userPath && !userLegacyFallback && legacySources.user.some((source) => existsSync17(source.path));
   if (userLegacyFallback) {
     warnings.push(`[user config] reading legacy config from ${userLegacyFallback.path} until migration completes; run \`npx @cortexkit/magic-context doctor\` to consolidate into the shared CortexKit location.`);
   } else if (legacyUserUnmigrated) {
@@ -184910,7 +185383,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",
@@ -186189,6 +186663,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)
@@ -186444,6 +186955,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);
@@ -188489,6 +189118,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 [];
@@ -188574,6 +189344,8 @@ function getSourceBoost(result) {
       return GIT_COMMIT_SOURCE_BOOST;
     case "primer":
       return PRIMER_SOURCE_BOOST;
+    case "note":
+      return 1;
   }
 }
 function compareUnifiedResults(left, right) {
@@ -188597,6 +189369,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) {
@@ -188664,11 +189439,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);
     }
   }
@@ -188691,6 +189466,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) => {
@@ -188726,7 +189502,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,
@@ -188753,9 +189529,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);
@@ -188824,6 +189614,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 = {}) {
@@ -189045,13 +189839,11 @@ async function runAutoSearchHintForPi(args) {
     };
     results = await unifiedSearchWithTimeout(db, sessionId, options.projectPath, rawPrompt, searchOptions, AUTO_SEARCH_TIMEOUT_MS);
   } catch (error51) {
-    log(`[auto-search] unified search failed for session ${sessionId}: ${error51 instanceof Error ? error51.message : String(error51)}`);
-    writeNoHintAndReconcile("error");
+    log(`[auto-search] unified search failed for session ${sessionId} (will retry next pass): ${error51 instanceof Error ? error51.message : String(error51)}`);
     return messages;
   }
   if (results === null) {
-    sessionLog(sessionId, `auto-search: timed out after ${AUTO_SEARCH_TIMEOUT_MS}ms, skipping hint for this turn`);
-    writeNoHintAndReconcile("timeout");
+    sessionLog(sessionId, `auto-search: timed out after ${AUTO_SEARCH_TIMEOUT_MS}ms, skipping hint for this turn (will retry)`);
     return messages;
   }
   if (results.length === 0) {
@@ -190626,6 +191418,15 @@ function findCompartmentBoundaryForSnapshot(markers) {
     return null;
   return markers.lastBaselineEndMessageId;
 }
+function resolveRenderedCompartmentBoundary(compartments, boundaryId) {
+  if (!boundaryId)
+    return { endMessageId: null, ordinal: null };
+  const boundary = compartments.find((compartment) => compartment.endMessageId === boundaryId);
+  return {
+    endMessageId: boundaryId,
+    ordinal: typeof boundary?.endMessage === "number" ? boundary.endMessage : null
+  };
+}
 function prependM0M1Messages(piMessages, m0, m1) {
   const firstTimestamp = piMessages[0]?.timestamp;
   const baseTimestamp = typeof firstTimestamp === "number" ? firstTimestamp : Date.now();
@@ -190755,6 +191556,7 @@ function injectM0M1Pi(state, db, piMessages, entryIds, recomputeM1ThisPass = fal
     }
   }
   const boundaryId = findCompartmentBoundaryForSnapshot(markers);
+  const renderedBoundary = resolveRenderedCompartmentBoundary(currentCompartments, boundaryId);
   const skippedVisibleMessages = boundaryId ? trimPiMessagesToBoundary(piMessages, entryIds, boundaryId) : 0;
   prependM0M1Messages(piMessages, m0, m1);
   sessionLog(state.sessionId, `injected m[0]/m[1] into Pi messages (${m0.length} + ${m1.length} bytes, materialized=${materialized}${decision.reason ? ` reason=${decision.reason}` : ""})`);
@@ -190771,6 +191573,8 @@ function injectM0M1Pi(state, db, piMessages, entryIds, recomputeM1ThisPass = fal
     m0Reason: decision.reason,
     m0Bytes: m0.length,
     m1Bytes: m1.length,
+    contentionExhausted,
+    renderedBoundary,
     syntheticLeadingCount: 2
   };
 }
@@ -194042,7 +194846,9 @@ async function runPiHistorian(deps) {
     compartmentLeaseHolderId,
     readBranchEntries,
     notifyIssue,
-    ensureProjectRegistered = ensureProjectRegisteredFromPiDirectory
+    ensureProjectRegistered = ensureProjectRegisteredFromPiDirectory,
+    forceDrainQuota,
+    forceKeepLastCompartment
   } = deps;
   const notify = async (message) => {
     if (shouldSuppressHistorianAlert(sessionId)) {
@@ -194117,7 +194923,8 @@ async function runPiHistorian(deps) {
       if (protectedTailStart <= offset || eligibleEndOrdinal <= offset) {
         sessionLog(sessionId, `historian no-op: protectedTailStart=${protectedTailStart} eligibleEnd=${eligibleEndOrdinal} <= offset=${offset} — nothing to compact`);
         if (boundarySnapshot.usagePercentage < 80) {
-          clearEmergencyRecovery(db, sessionId);
+          if (!isWrapupInProgress(db, sessionId))
+            clearEmergencyRecovery(db, sessionId);
         } else {
           recordHighPressureNoEligibleHead(db, boundarySnapshot);
         }
@@ -194126,7 +194933,7 @@ async function runPiHistorian(deps) {
       }
       const perRunCap = selectPerRunCap(boundarySnapshot);
       const usable = Math.max(1, Math.round(boundarySnapshot.contextLimit * boundarySnapshot.executeThresholdPercentage / 100));
-      const reserve = reserveProtectedTailDrainTokens({
+      const reserve = forceDrainQuota ? { ok: true, reservation: null } : reserveProtectedTailDrainTokens({
         db,
         sessionId,
         runId: crypto2.randomUUID(),
@@ -194144,10 +194951,12 @@ async function runPiHistorian(deps) {
       }
       drainReservation = reserve.reservation;
       const chunk = readSessionChunk(sessionId, historianChunkTokens, offset, eligibleEndOrdinal);
+      const forceKeepLastCompartmentForChunk = forceKeepLastCompartment === true && !chunk.hasMore;
       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}-${protectedTailStart - 1}`);
         if (boundarySnapshot.usagePercentage < 80) {
-          clearEmergencyRecovery(db, sessionId);
+          if (!isWrapupInProgress(db, sessionId))
+            clearEmergencyRecovery(db, sessionId);
         } else {
           recordHighPressureNoEligibleHead(db, boundarySnapshot);
         }
@@ -194337,7 +195146,7 @@ ${chunkText}`,
       const inEmergency = getOverflowState(db, sessionId).needsEmergencyRecovery;
       const emittedCompartments = validatedPass.compartments;
       let newCompartments = 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) {
@@ -194370,9 +195179,19 @@ ${chunkText}`,
         }
       }
       const discardedLast = newCompartments.length < emittedCompartments.length;
+      const weakLookaheadFinalCompartment = forceKeepLastCompartmentForChunk;
+      const skipUnanchoredPromotion = discardedLast || weakLookaheadFinalCompartment;
       const embeddingActive = memoryEnabled !== false;
       const promotionActive = embeddingActive && autoPromote !== false;
-      const publishableEvents = (validatedPass.events ?? []).filter((e) => e.atCompartment == null || e.atCompartment <= newCompartments.length);
+      const publishableEvents = (validatedPass.events ?? []).filter((e) => {
+        if (typeof e.atCompartment !== "number")
+          return !weakLookaheadFinalCompartment;
+        if (e.atCompartment > newCompartments.length)
+          return false;
+        if (weakLookaheadFinalCompartment && e.atCompartment >= emittedCompartments.length)
+          return false;
+        return true;
+      });
       let promotedFactRefs = [];
       let persistedIds = [];
       if (!compartmentLeaseHolderId) {
@@ -194391,7 +195210,7 @@ ${chunkText}`,
         }
         appendCompartments(db, sessionId, newCompartments);
         persistedIds = getCompartments(db, sessionId).slice(-newCompartments.length).map((c) => c.id);
-        if (promotionActive && !discardedLast) {
+        if (promotionActive && !skipUnanchoredPromotion) {
           promotedFactRefs = promoteSessionFactsDurable(db, sessionId, projectPath, validatedPass.facts ?? []);
         }
         if (publishableEvents.length > 0) {
@@ -194406,7 +195225,8 @@ ${chunkText}`,
         clearHistorianFailureState(db, sessionId);
         clearHistorianDrainFailure(db, sessionId);
         recordProtectedTailPublicationFloor(db, sessionId, lastNewEnd + 1);
-        clearEmergencyRecovery(db, sessionId);
+        if (!isWrapupInProgress(db, sessionId))
+          clearEmergencyRecovery(db, sessionId);
         if (firstKeptEntryId && lastNewEndMessageId) {
           setPendingPiCompactionMarkerState(db, sessionId, {
             firstKeptEntryId,
@@ -194430,7 +195250,7 @@ ${chunkText}`,
       completedSuccessfully = true;
       sessionLog(sessionId, `historian: published ${newCompartments.length} compartment(s), ${validatedPass.facts?.length ?? 0} fact(s) covering messages ${chunk.startIndex}-${lastNewEnd}`);
       onNoteTrigger(db, sessionId, "historian_complete");
-      if (userMemoriesEnabled === true && !discardedLast && validatedPass.userObservations?.length) {
+      if (userMemoriesEnabled === true && !skipUnanchoredPromotion && validatedPass.userObservations?.length) {
         try {
           insertUserMemoryCandidates(db, validatedPass.userObservations.map((obs) => ({
             content: obs,
@@ -194443,7 +195263,7 @@ ${chunkText}`,
           sessionLog(sessionId, "failed to store user memory candidates:", error51);
         }
       }
-      if (!discardedLast && validatedPass.primerCandidates?.length && projectPath) {
+      if (!skipUnanchoredPromotion && validatedPass.primerCandidates?.length && projectPath) {
         try {
           const firstNew = newCompartments[0];
           const lastNew = newCompartments[newCompartments.length - 1];
@@ -195140,7 +195960,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
 
@@ -195151,12 +195971,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}
@@ -195169,7 +195989,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}`;
@@ -195184,7 +196004,7 @@ function buildMagicContextBlock(opts) {
   const includeGuidance = (opts.includeGuidance ?? true) && !existing.includes(MAGIC_CONTEXT_MARKER);
   if (!includeGuidance)
     return null;
-  return buildMagicContextSection(null, opts.protectedTags ?? 20, opts.ctxReduceEnabled ?? true, opts.dreamerEnabled ?? false, opts.temporalAwarenessEnabled ?? false, opts.cavemanTextCompressionEnabled ?? false, false, opts.language, opts.memoryEnabled !== false);
+  return buildMagicContextSection(null, opts.protectedTags ?? 20, opts.ctxReduceCallable ?? true, opts.dreamerEnabled ?? false, opts.temporalAwarenessEnabled ?? false, opts.cavemanTextCompressionEnabled ?? false, false, opts.language, opts.memoryEnabled !== false);
 }
 var DATE_PATTERN = /Today's date: .+/;
 function processSystemPromptForCache(args) {
@@ -195877,6 +196697,7 @@ function applyForwardPressureFloor(trailingPercentage, trailingInputTokens, piUs
     inputTokens: Math.max(trailingInputTokens, forwardTokens)
   } : { percentage: trailingPercentage, inputTokens: trailingInputTokens };
 }
+var injectM0M1PiForRun = injectM0M1Pi;
 var DEFAULT_CLEAR_REASONING_AGE = 50;
 var PI_STABLE_ID_SCHEME = 1;
 var lastEmergencyNotificationAtMs = new Map;
@@ -196576,7 +197397,6 @@ function registerPiContextHandler(pi, baseOptions) {
         projectIdentity,
         projectDirectory,
         messages: event.messages,
-        ctxReduceEnabled: options.ctxReduceEnabled,
         smartDrops: options.smartDrops === true,
         protectedTags: options.protectedTags ?? 20,
         heuristics: options.heuristics,
@@ -196609,7 +197429,8 @@ function registerPiContextHandler(pi, baseOptions) {
         },
         temporalAwareness: options.injection?.temporalAwareness === true,
         appendCompaction: resolvePiAppendCompaction(ctx),
-        readBranchEntries: resolvePiReadBranchEntries(ctx)
+        readBranchEntries: resolvePiReadBranchEntries(ctx),
+        isSubagent: sessionMeta.isSubagent
       });
       const piDecisionSnapshotNewestAssistant = branchEntries === null ? undefined : findNewestPiAssistantEntryId(branchEntries);
       if (result.bustedThisPass && piDecisionSnapshotNewestAssistant !== undefined) {
@@ -196691,7 +197512,7 @@ function registerPiContextHandler(pi, baseOptions) {
       }
       try {
         const sessionMetaForCh1 = getOrCreateSessionMeta(options.db, sessionId);
-        if (options.ctxReduceEnabled && !sessionMetaForCh1.isSubagent) {
+        if (!sessionMetaForCh1.isSubagent) {
           const resolvedExecuteThresholdPct = resolveExecuteThreshold(schedulerConfig.executeThresholdPercentage ?? 65, liveModelBySession.get(sessionId), 65, {
             tokensConfig: schedulerConfig.executeThresholdTokens,
             contextLimit: usageContextLimit ?? 0
@@ -196819,8 +197640,12 @@ function resolveHistoryBudgetTokensForPi(args) {
 }
 function startPiCompartmentLeaseRenewal(db, sessionId, holderId) {
   return setInterval(() => {
-    if (!renewCompartmentLease(db, sessionId, holderId)) {
-      sessionLog(sessionId, "compartment lease renewal failed; publish will be skipped if holder is stale");
+    try {
+      if (!renewCompartmentLease(db, sessionId, holderId)) {
+        sessionLog(sessionId, "compartment lease renewal failed; publish will be skipped if holder is stale");
+      }
+    } catch (err) {
+      sessionLog(sessionId, `compartment lease renewal threw; publish will be skipped if holder is stale (${err instanceof Error ? err.message : String(err)})`);
     }
   }, COMPARTMENT_LEASE_RENEWAL_MS);
 }
@@ -196880,6 +197705,11 @@ function spawnPiHistorianRun(args) {
       sessionLog(sessionId, "historian skipped: compartment lease held by another process");
       return;
     }
+    if (isWrapupInProgress(db, sessionId)) {
+      sessionLog(sessionId, "historian skipped: /ctx-wrapup became active");
+      releaseCompartmentLease(db, sessionId, holderId);
+      return;
+    }
     const renewal = startPiCompartmentLeaseRenewal(db, sessionId, holderId);
     try {
       await runPiHistorian({
@@ -196958,6 +197788,10 @@ function maybeFireHistorian(args) {
     sessionLog(sessionId, "historian trigger eval: in-flight, skipping");
     return;
   }
+  if (isWrapupInProgress(db, sessionId)) {
+    sessionLog(sessionId, "historian trigger eval: /ctx-wrapup active, skipping");
+    return;
+  }
   let usage;
   let usageContextLimit;
   try {
@@ -197100,6 +197934,14 @@ Historian previously failed ${failureState.failureCount} time(s), so Magic Conte
       unregister();
   }
 }
+function pendingPiMarkerCoveredByRenderedBoundary(pending, injection) {
+  if (!injection || injection.contentionExhausted)
+    return false;
+  const boundary = injection.renderedBoundary;
+  if (pending.endMessageId === boundary.endMessageId)
+    return true;
+  return boundary.ordinal !== null && pending.ordinal <= boundary.ordinal;
+}
 async function runPipeline(args) {
   let executedWorkThisPass = false;
   let historyWasConsumedThisPass = false;
@@ -197113,6 +197955,7 @@ async function runPipeline(args) {
   let emergency = false;
   let autoReclaimDidMutateThisPass = false;
   let suppressDeferredHistoryDrain = false;
+  let deferredMaterializationConsumedThisPass = false;
   let casLost = false;
   const deferredHistoryWasPendingAtPassStart = deferredHistoryRefreshSessions.has(args.sessionId);
   if (args.temporalAwareness) {
@@ -197135,6 +197978,8 @@ async function runPipeline(args) {
     return findLatestUserMessageIdPi(args.messages, ids)?.messageId ?? null;
   })();
   const alreadyRanHeuristicsThisTurn = currentTurnId !== null && lastHeuristicsTurnIdBySession.get(args.sessionId) === currentTurnId;
+  const sessionMetaForAvailability = getOrCreateSessionMeta(args.db, args.sessionId);
+  const ctxReduceCallable = !sessionMetaForAvailability.isSubagent;
   const canConsumeDeferredLate = args.schedulerDecision === "execute" || args.forceMaterialization === true || args.contextUsage.percentage >= FORCE_MATERIALIZATION_PERCENTAGE;
   const deferredMaterializeEligible = canConsumeDeferredLate && deferredMaterializationSessions.has(args.sessionId);
   const piHardSignals = args.injection ? (() => {
@@ -197175,7 +198020,7 @@ async function runPipeline(args) {
   }
   const tTag = performance.now();
   const { targets } = tagTranscript(args.sessionId, transcript, args.tagger, args.db, {
-    skipPrefixInjection: !args.ctxReduceEnabled,
+    skipPrefixInjection: !ctxReduceCallable,
     entryFingerprintByMessageId
   });
   logTransformTiming(args.sessionId, "tagMessages", tTag);
@@ -197261,14 +198106,16 @@ async function runPipeline(args) {
       sessionLog(args.sessionId, `reasoning replay failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
     }
   }
-  try {
-    const tags = getTagsByNumbers(args.db, args.sessionId, targetTagNumbers);
-    const replayed = replayCavemanCompression(args.sessionId, args.db, targets, tags);
-    if (replayed > 0) {
-      sessionLog(args.sessionId, `caveman replay: ${replayed} tags re-compressed from source`);
+  if (args.heuristics?.caveman?.enabled && !args.isSubagent) {
+    try {
+      const tags = getTagsByNumbers(args.db, args.sessionId, targetTagNumbers);
+      const replayed = replayCavemanCompression(args.sessionId, args.db, targets, tags);
+      if (replayed > 0) {
+        sessionLog(args.sessionId, `caveman replay: ${replayed} tags re-compressed from source`);
+      }
+    } catch (err) {
+      sessionLog(args.sessionId, `caveman replay failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
     }
-  } catch (err) {
-    sessionLog(args.sessionId, `caveman replay failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
   }
   let heuristicsExecuted = false;
   let heuristicsResult = null;
@@ -197291,7 +198138,7 @@ async function runPipeline(args) {
           currentTotalInputTokens: args.contextUsage.inputTokens,
           ceilingTokens: args.emergencyCeilingTokens
         } : undefined,
-        caveman: args.heuristics.caveman
+        caveman: args.isSubagent ? undefined : args.heuristics.caveman
       }, activeTags, stableIdResolver);
       const heuristicMutationCount = heuristicsResult.droppedTools + heuristicsResult.deduplicatedTools + heuristicsResult.droppedInjections + heuristicsResult.droppedStaleReduceCalls + heuristicsResult.mutatedTextTags;
       droppedCount += heuristicsResult.droppedTools + heuristicsResult.deduplicatedTools + heuristicsResult.droppedInjections + heuristicsResult.droppedStaleReduceCalls + heuristicsResult.mutatedTextTags;
@@ -197314,7 +198161,7 @@ async function runPipeline(args) {
   if (deferredMaterialize && pendingOpsAppliedThisPass) {
     const fullPassSucceeded = shouldRunHeuristics ? heuristicsExecuted : true;
     if (fullPassSucceeded) {
-      consumeDeferredMaterialization(args.sessionId);
+      deferredMaterializationConsumedThisPass = consumeDeferredMaterialization(args.sessionId);
     }
   }
   if (args.reasoningClearing && shouldRunHeuristics) {
@@ -197431,7 +198278,7 @@ async function runPipeline(args) {
   if (args.injection) {
     try {
       const tInjection = performance.now();
-      injectionResult = injectM0M1Pi({
+      injectionResult = injectM0M1PiForRun({
         sessionId: args.sessionId,
         projectIdentity: args.projectIdentity,
         projectDirectory: args.projectDirectory,
@@ -197463,11 +198310,23 @@ async function runPipeline(args) {
     forceDiscovery: args.stableIdSchemeCutover === true
   });
   const deferredHistoryDrainEligible = historyWasConsumedThisPass && materializationSatisfiedThisPass && (deferredHistoryWasPendingAtPassStart || hasPendingMaterializeSignal) && !suppressDeferredHistoryDrain && !casLost;
+  let preserveDeferredMaterializationForMarkerDrain = false;
   if (deferredHistoryDrainEligible) {
     try {
       const pending = getPendingPiCompactionMarkerState(args.db, args.sessionId);
       if (!pending) {
-        consumeDeferredHistoryRefresh(args.sessionId);
+        if (injectionResult?.contentionExhausted === true) {
+          suppressDeferredHistoryDrain = true;
+          preserveDeferredMaterializationForMarkerDrain = true;
+          sessionLog(args.sessionId, "Pi deferred-history drain skipped: m[0]/m[1] used a contention fallback; preserving deferred signals");
+        } else {
+          consumeDeferredHistoryRefresh(args.sessionId);
+        }
+      } else if (!pendingPiMarkerCoveredByRenderedBoundary(pending, injectionResult)) {
+        suppressDeferredHistoryDrain = true;
+        preserveDeferredMaterializationForMarkerDrain = true;
+        const boundary = injectionResult?.renderedBoundary;
+        sessionLog(args.sessionId, `Pi compaction-marker drain skipped: pending ordinal ${pending.ordinal} is newer than rendered boundary ${boundary?.ordinal ?? "<none>"} endMessageId=${boundary?.endMessageId ?? "<none>"}; preserving deferred signals`);
       } else if (!args.appendCompaction || !args.readBranchEntries) {
         suppressDeferredHistoryDrain = true;
         sessionLog(args.sessionId, "Pi compaction-marker drain skipped: sessionManager appendCompaction/getBranch unavailable; preserving deferred-history signal");
@@ -197490,6 +198349,9 @@ async function runPipeline(args) {
       sessionLog(args.sessionId, `Pi compaction-marker drain failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
     }
   }
+  if (preserveDeferredMaterializationForMarkerDrain && deferredMaterializationConsumedThisPass) {
+    signalPiDeferredMaterialization(args.sessionId);
+  }
   if (executedWorkThisPass) {
     try {
       const currentFlag = peekDeferredExecutePending(args.db, args.sessionId);
@@ -197795,6 +198657,9 @@ function existingMarkerAlreadyCoversTarget(sessionId, existing, targetOrdinal, t
   return true;
 }
 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`);
@@ -199042,13 +199907,23 @@ 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);
 }
 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.",
@@ -199072,7 +199947,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;
@@ -199404,6 +200279,14 @@ ${parsed.message}`,
         });
         return;
       }
+      if (isWrapupInProgress(deps.db, sessionId)) {
+        sendCtxStatusMessage(pi, {
+          title: "/ctx-recomp",
+          text: "## Magic Recomp\n\n/ctx-wrapup is already compacting this session. Wait for it to finish, then try `/ctx-recomp` again.",
+          level: "warning"
+        });
+        return;
+      }
       if (isPiRecompInFlight(sessionId)) {
         sendCtxStatusMessage(pi, {
           title: "/ctx-recomp",
@@ -199795,6 +200678,16 @@ No active Pi session is available.`,
         });
         return;
       }
+      if (isWrapupInProgress(deps.db, sessionId)) {
+        sendCtxStatusMessage(pi, {
+          title: "/ctx-session-upgrade",
+          text: `## Session Upgrade
+
+/ctx-wrapup is already compacting this session. Wait for it to finish, then try again.`,
+          level: "warning"
+        });
+        return;
+      }
       if (isPiRecompInFlight(sessionId)) {
         sendCtxStatusMessage(pi, {
           title: "/ctx-session-upgrade",
@@ -200126,7 +201019,7 @@ function formatThresholdPercent(value) {
 // package.json
 var package_default = {
   name: "@cortexkit/pi-magic-context",
-  version: "0.30.6",
+  version: "0.31.0",
   type: "module",
   description: "Pi coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -200392,7 +201285,6 @@ ${safeStringify(tool.parameters)}`);
     inputTokens,
     systemPromptTokens,
     compartmentCount: compartments.length,
-    factCount: 0,
     memoryCount: safeRead(() => getMemoryCount(deps.db, deps.projectIdentity), 0),
     memoryBlockCount,
     sessionNoteCount: safeRead(() => getNotes(deps.db, {
@@ -200668,6 +201560,365 @@ function readHistorianState(db, sessionId, meta3) {
   };
 }
 
+// src/commands/ctx-wrapup.ts
+import * as crypto4 from "node:crypto";
+var DEFAULT_MESSAGES_TO_KEEP = 20;
+var LEASE_WAIT_MS = 1000;
+function parseWrapupArgs(raw) {
+  const trimmed = raw.trim();
+  if (trimmed === "")
+    return { ok: true, messagesToKeep: DEFAULT_MESSAGES_TO_KEEP };
+  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 };
+}
+function registerCtxWrapupCommand(pi, deps) {
+  pi.registerCommand("ctx-wrapup", {
+    description: "Compact older Magic Context history while keeping the newest messages raw",
+    handler: async (args, ctx) => {
+      const sessionId = resolveSessionId(ctx);
+      if (!sessionId) {
+        sendCtxStatusMessage(pi, {
+          title: "/ctx-wrapup",
+          text: `## Magic Wrapup
+
+No active Pi session is available.`,
+          level: "error"
+        });
+        return;
+      }
+      const sessionMeta = getOrCreateSessionMeta(deps.db, sessionId);
+      if (sessionMeta.isSubagent) {
+        sendCtxStatusMessage(pi, {
+          title: "/ctx-wrapup",
+          text: `## Magic Wrapup — Skipped
+
+/ctx-wrapup is only available in primary sessions.`,
+          level: "warning"
+        });
+        return;
+      }
+      if (!deps.historianModel) {
+        sendCtxStatusMessage(pi, {
+          title: "/ctx-wrapup",
+          text: "## Magic Wrapup\n\n/ctx-wrapup is unavailable because `historian.model` is not configured.",
+          level: "error"
+        });
+        return;
+      }
+      const parsed = parseWrapupArgs(args);
+      if (!parsed.ok) {
+        sendCtxStatusMessage(pi, {
+          title: "/ctx-wrapup",
+          text: `## Magic Wrapup — Invalid Arguments
+
+${parsed.message}`,
+          level: "error"
+        });
+        return;
+      }
+      const result = await runPiWrapup(pi, deps, ctx, sessionId, parsed.messagesToKeep);
+      sendCtxStatusMessage(pi, {
+        title: "/ctx-wrapup",
+        text: result,
+        level: result.includes("Failed") || result.includes("Partial") ? "error" : "success"
+      });
+    }
+  });
+}
+async function runPiWrapup(pi, deps, ctx, sessionId, messagesToKeep) {
+  if (getOrCreateSessionMeta(deps.db, sessionId).isSubagent) {
+    return `## Magic Wrapup — Skipped
+
+/ctx-wrapup is only available in primary sessions.`;
+  }
+  if (isPiRecompInFlight(sessionId)) {
+    return "## Magic Wrapup — Skipped\n\nA recomp or upgrade is already running for this session. Wait for it to finish, then try `/ctx-wrapup` again.";
+  }
+  const provider2 = { readMessages: () => readPiSessionMessages(ctx) };
+  const unregister = setRawMessageProvider(sessionId, provider2);
+  let holderId = "";
+  try {
+    const contextLimit = resolvePiContextLimit(ctx);
+    const modelKey = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined;
+    const executeThresholdPercentage = resolveExecuteThreshold(deps.executeThresholdPercentage ?? 65, modelKey, 65, {
+      tokensConfig: deps.executeThresholdTokens,
+      contextLimit,
+      sessionId
+    });
+    const initialPlan = resolveWrapupProtectedTailBoundary({
+      db: deps.db,
+      sessionId,
+      mode: "manual-wrapup",
+      contextLimit,
+      executeThresholdPercentage,
+      usage: { percentage: 0, inputTokens: 0 },
+      usageSource: "manual-none",
+      providerShapeVersion: "pi-folded-v1",
+      cacheNamespace: `pi:${sessionId}`,
+      messagesToKeep
+    });
+    if (initialPlan.rawMessagesAboveLastCompartment <= messagesToKeep) {
+      return `## Magic Wrapup
+
+Nothing to wrap up — only ${initialPlan.rawMessagesAboveLastCompartment} messages above the last compartment.`;
+    }
+    if (!hasRunnableCompartmentWindow(initialPlan.snapshot)) {
+      return `## Magic Wrapup — Partial
+
+No runnable wrapup boundary is available yet; wrapped up 0 messages into 0 compartments. Run /ctx-wrapup again to continue.`;
+    }
+    holderId = crypto4.randomUUID();
+    const acquired = acquireWrapupInProgress(deps.db, sessionId, {
+      holderId,
+      messagesToKeep,
+      anchorRawMessageCount: initialPlan.anchorRawMessageCount,
+      targetEligibleEndOrdinal: initialPlan.targetEligibleEndOrdinal,
+      lastCompartmentEnd: getLastCompartmentEndMessage(deps.db, sessionId),
+      chunkIndex: 0,
+      expectedChunks: estimateChunks(initialPlan.snapshot.trueRawEligibleTokens, deps.historianChunkTokens)
+    });
+    if (!acquired.ok) {
+      return formatExistingWrapup(acquired.state ?? getWrapupInProgressState(deps.db, sessionId));
+    }
+    let ownershipLost = false;
+    const ownershipLostReason = "another process took over this session's wrapup";
+    const markOwnershipLost = () => {
+      if (ownershipLost)
+        return;
+      ownershipLost = true;
+    };
+    const renewWrapupMarker = (updates) => {
+      const updated = updateWrapupInProgress(deps.db, sessionId, holderId, updates);
+      if (!updated) {
+        markOwnershipLost();
+        return false;
+      }
+      return true;
+    };
+    const renewal = setInterval(() => {
+      try {
+        renewWrapupMarker({
+          lastCompartmentEnd: getLastCompartmentEndMessage(deps.db, sessionId)
+        });
+      } catch (err) {
+        console.warn(`[magic-context][pi] /ctx-wrapup marker renewal failed for ${sessionId}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }, 60000);
+    try {
+      sendCtxStatusMessage(pi, {
+        title: "/ctx-wrapup",
+        text: `## Magic Wrapup
+
+Eligible history is about ${initialPlan.snapshot.trueRawEligibleTokens.toLocaleString()} tokens across approximately ${estimateChunks(initialPlan.snapshot.trueRawEligibleTokens, deps.historianChunkTokens)} historian chunk(s).`,
+        level: "info"
+      });
+      const startEnd = getLastCompartmentEndMessage(deps.db, sessionId);
+      const startCompartmentCount = getCompartments(deps.db, sessionId).length;
+      let chunkIndex = 0;
+      let lastEnd = startEnd;
+      let targetEligibleEndOrdinal = initialPlan.targetEligibleEndOrdinal;
+      let failure = null;
+      for (;; ) {
+        if (ownershipLost) {
+          failure = `${ownershipLostReason}; wrapped up through message ${lastEnd}. Run /ctx-wrapup again to continue.`;
+          break;
+        }
+        if (!renewWrapupMarker({
+          chunkIndex,
+          lastCompartmentEnd: getLastCompartmentEndMessage(deps.db, sessionId)
+        })) {
+          failure = `${ownershipLostReason}; wrapped up through message ${lastEnd}. Run /ctx-wrapup again to continue.`;
+          break;
+        }
+        const plan = resolveWrapupProtectedTailBoundary({
+          db: deps.db,
+          sessionId,
+          mode: "manual-wrapup",
+          contextLimit,
+          executeThresholdPercentage,
+          usage: { percentage: 0, inputTokens: 0 },
+          usageSource: "manual-none",
+          providerShapeVersion: "pi-folded-v1",
+          cacheNamespace: `pi:${sessionId}`,
+          messagesToKeep,
+          anchorRawMessageCount: initialPlan.anchorRawMessageCount
+        });
+        targetEligibleEndOrdinal = plan.targetEligibleEndOrdinal;
+        lastEnd = getLastCompartmentEndMessage(deps.db, sessionId);
+        if (lastEnd + 1 >= targetEligibleEndOrdinal)
+          break;
+        if (!hasRunnableCompartmentWindow(plan.snapshot)) {
+          failure = `No runnable wrapup boundary is available yet; wrapped up through message ${lastEnd}. Run /ctx-wrapup again to continue.`;
+          break;
+        }
+        chunkIndex += 1;
+        if (!renewWrapupMarker({
+          chunkIndex,
+          lastCompartmentEnd: getLastCompartmentEndMessage(deps.db, sessionId),
+          targetEligibleEndOrdinal: plan.targetEligibleEndOrdinal,
+          expectedChunks: Math.max(chunkIndex, estimateChunks(plan.snapshot.trueRawEligibleTokens, deps.historianChunkTokens))
+        })) {
+          failure = `${ownershipLostReason}; wrapped up through message ${lastEnd}. Run /ctx-wrapup again to continue.`;
+          break;
+        }
+        sendCtxStatusMessage(pi, {
+          title: "/ctx-wrapup",
+          text: `## Magic Wrapup
+
+Chunk ${chunkIndex}: wrapping messages ${plan.snapshot.offset}-${plan.snapshot.eligibleEndOrdinal - 1} (~${plan.snapshot.trueRawEligibleTokens.toLocaleString()} eligible tokens remain).`,
+          level: "info"
+        });
+        const leaseHolder = await acquireCompartmentLeaseEventually(deps.db, sessionId, renewWrapupMarker);
+        if (!leaseHolder) {
+          failure = ownershipLost ? `${ownershipLostReason}; wrapped up through message ${lastEnd}. Run /ctx-wrapup again to continue.` : "Another Magic Context rebuild started while wrapup was waiting. Run /ctx-wrapup again to continue.";
+          break;
+        }
+        const leaseRenewal = setInterval(() => {
+          try {
+            renewCompartmentLease(deps.db, sessionId, leaseHolder);
+          } catch (err) {
+            console.warn(`[magic-context][pi] /ctx-wrapup compartment lease renewal failed for ${sessionId}: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }, COMPARTMENT_LEASE_RENEWAL_MS);
+        try {
+          const runHistorian = deps.runPiHistorianForWrapup ?? runPiHistorian;
+          await runHistorian({
+            db: deps.db,
+            sessionId,
+            directory: ctx.cwd,
+            provider: provider2,
+            runner: deps.runner,
+            historianModel: deps.historianModel,
+            fallbackModels: deps.historianFallbacks,
+            historianChunkTokens: deps.historianChunkTokens,
+            boundarySnapshot: plan.snapshot,
+            refreshBoundarySnapshot: () => resolveWrapupProtectedTailBoundary({
+              db: deps.db,
+              sessionId,
+              mode: "manual-wrapup",
+              contextLimit,
+              executeThresholdPercentage,
+              usage: { percentage: 0, inputTokens: 0 },
+              usageSource: "manual-none",
+              providerShapeVersion: "pi-folded-v1",
+              cacheNamespace: `pi:${sessionId}`,
+              messagesToKeep,
+              anchorRawMessageCount: initialPlan.anchorRawMessageCount
+            }).snapshot,
+            currentContextLimit: contextLimit,
+            historianTimeoutMs: deps.historianTimeoutMs,
+            thinkingLevel: deps.historianThinkingLevel,
+            memoryEnabled: deps.memoryEnabled,
+            autoPromote: deps.autoPromote,
+            userMemoriesEnabled: deps.userMemoriesEnabled,
+            language: deps.language,
+            compartmentLeaseHolderId: leaseHolder,
+            readBranchEntries: () => readBranchEntries(ctx),
+            notifyIssue: (text) => sendCtxStatusMessage(pi, {
+              title: "/ctx-wrapup",
+              text,
+              level: "warning"
+            }),
+            ensureProjectRegistered: ensureProjectRegisteredFromPiDirectory,
+            forceDrainQuota: true,
+            forceKeepLastCompartment: true,
+            onPublished: () => {
+              updateStatusLine(ctx, { db: deps.db, projectIdentity: ctx.cwd });
+              signalPiDeferredHistoryRefresh(sessionId);
+              signalPiDeferredMaterialization(sessionId);
+            }
+          });
+        } finally {
+          clearInterval(leaseRenewal);
+          releaseCompartmentLease(deps.db, sessionId, leaseHolder);
+        }
+        const afterEnd = getLastCompartmentEndMessage(deps.db, sessionId);
+        if (afterEnd <= lastEnd) {
+          failure = `No forward progress after chunk ${chunkIndex}; wrapped up through message ${lastEnd}. Run /ctx-wrapup again to continue.`;
+          break;
+        }
+        lastEnd = afterEnd;
+      }
+      const finalEnd = getLastCompartmentEndMessage(deps.db, sessionId);
+      if (!failure && finalEnd + 1 < targetEligibleEndOrdinal) {
+        failure = `Wrapped up through message ${finalEnd}, but no runnable wrapup boundary remained before target message ${targetEligibleEndOrdinal}. Run /ctx-wrapup again to continue.`;
+      }
+      const finalCompartmentCount = getCompartments(deps.db, sessionId).length;
+      const messagesWrapped = Math.max(0, finalEnd - startEnd);
+      const compartmentsCreated = Math.max(0, finalCompartmentCount - startCompartmentCount);
+      if (failure) {
+        return `## Magic Wrapup — Partial
+
+Wrapped up ${messagesWrapped} messages into ${compartmentsCreated} compartments; ${failure}`;
+      }
+      try {
+        clearEmergencyRecovery(deps.db, sessionId);
+      } catch {}
+      return `## Magic Wrapup
+
+Wrapped up ${messagesWrapped} messages into ${compartmentsCreated} compartments. The compacted history is queued and materializes on your next message.`;
+    } finally {
+      clearInterval(renewal);
+      releaseWrapupInProgress(deps.db, sessionId, holderId);
+    }
+  } finally {
+    unregister();
+  }
+}
+function resolvePiContextLimit(ctx) {
+  const usage = ctx.getContextUsage?.();
+  if (typeof usage?.contextWindow === "number" && usage.contextWindow > 0) {
+    return usage.contextWindow;
+  }
+  if (typeof ctx.model?.contextWindow === "number" && ctx.model.contextWindow > 0) {
+    return ctx.model.contextWindow;
+  }
+  return 128000;
+}
+async function acquireCompartmentLeaseEventually(db, sessionId, renewWrapupMarker) {
+  for (;; ) {
+    const holderId = crypto4.randomUUID();
+    const lease = acquireCompartmentLease(db, sessionId, holderId);
+    if (lease)
+      return holderId;
+    if (!renewWrapupMarker({}))
+      return null;
+    await new Promise((resolve3) => setTimeout(resolve3, LEASE_WAIT_MS));
+  }
+}
+function estimateChunks(tokens, chunkTokens) {
+  return Math.max(1, Math.ceil(Math.max(0, tokens) / Math.max(1, chunkTokens)));
+}
+function formatExistingWrapup(state) {
+  if (!state) {
+    return `## Magic Wrapup — Skipped
+
+Another /ctx-wrapup is already compacting this session. Wait for it to finish, then try again.`;
+  }
+  return `## Magic Wrapup — Skipped
+
+Another /ctx-wrapup is already compacting this session (chunk ${state.chunkIndex}/${Math.max(state.chunkIndex, state.expectedChunks)}, wrapped through message ${state.lastCompartmentEnd}). Wait for it to finish, then try again.`;
+}
+function readBranchEntries(ctx) {
+  const getBranch = ctx.sessionManager.getBranch;
+  if (typeof getBranch !== "function")
+    return [];
+  const branch = getBranch.call(ctx.sessionManager);
+  return Array.isArray(branch?.entries) ? branch.entries : [];
+}
+
 // src/pi-pressure.ts
 function extractAssistantUsage(message) {
   if (!message || typeof message !== "object")
@@ -206059,14 +207310,17 @@ 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"]`;
 
 // src/tools/ctx-search.ts
 var DEFAULT_LIMIT = 10;
+var NOTE_EXPAND_HINT = "Use ctx_expand(start=N-10, end=N) around any note @msg anchor above to read the surrounding conversation context.";
 var ParamsSchema5 = exports_typebox.Object({
   query: exports_typebox.String({
     description: "Search query. Matches against memory content, Primers, git commit messages, and raw user/assistant message text."
@@ -206078,9 +207332,10 @@ var ParamsSchema5 = exports_typebox.Object({
     exports_typebox.Literal("memory"),
     exports_typebox.Literal("message"),
     exports_typebox.Literal("git_commit"),
-    exports_typebox.Literal("primer")
+    exports_typebox.Literal("primer"),
+    exports_typebox.Literal("note")
   ]), {
-    description: '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.'
+    description: '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.'
   }))
 });
 function normalizeLimit3(limit) {
@@ -206107,7 +207362,7 @@ function formatAge2(committedAtMs) {
   const years = Math.floor(days / 365);
   return years === 1 ? "1y ago" : `${years}y ago`;
 }
-function formatResult(result, index) {
+function formatResult(result, index, currentSessionId) {
   if (result.source === "memory") {
     const source = result.sourceName ? ` source=${result.sourceName}` : "";
     return [
@@ -206128,6 +207383,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") {
@@ -206145,14 +207408,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(`
 
 `);
@@ -206201,7 +207467,12 @@ function createCtxSearchTool(deps) {
         explicitSearch: true
       });
       return {
-        content: [{ type: "text", text: formatSearchResults(query, results) }],
+        content: [
+          {
+            type: "text",
+            text: formatSearchResults(query, results, sessionId)
+          }
+        ],
         details: undefined
       };
     }
@@ -206298,7 +207569,7 @@ function registerMagicContextTools(pi, opts) {
     pi.registerTool(createCtxExpandTool({ db: opts.db }));
   }
   pi.registerTool(createTodowriteTool());
-  if (opts.ctxReduceEnabled === true) {
+  if (!opts.sessionScopedToolsDisabled) {
     pi.registerTool(createCtxReduceTool({
       db: opts.db,
       protectedTags: opts.protectedTags ?? 20
@@ -206310,7 +207581,7 @@ function registerMagicContextTools(pi, opts) {
 var PREFIX = "[magic-context][pi]";
 function resolveCurrentProject(ctx) {
   const projectDir = ctx.cwd;
-  const projectIdentity = resolveProjectIdentity(projectDir);
+  const projectIdentity = resolveProjectIdentityOrFallback(projectDir);
   return { projectDir, projectIdentity };
 }
 function persistPiMessageEndModelMeta(args) {
@@ -206497,14 +207768,28 @@ async function src_default2(pi) {
   runDeferredV22Backfill(db).catch((err5) => {
     warn(`[v22-backfill] background runner failed: ${err5}`);
   });
+  setTimeout(() => {
+    (async () => {
+      try {
+        const api2 = await loadDefaultPiSessionApi();
+        const sessions = await api2.listSessions();
+        await runSessionProjectBackfill(database, sessions.map((session) => ({
+          sessionId: typeof session?.id === "string" ? session.id : "",
+          directory: typeof session?.cwd === "string" ? session.cwd : ""
+        })));
+      } catch (err5) {
+        warn(`[session-projects] background runner failed: ${err5}`);
+      }
+    })();
+  }, 0);
   const projectDir = process.cwd();
-  const projectIdentity = resolveProjectIdentity(projectDir);
+  const projectIdentity = resolveProjectIdentityOrFallback(projectDir);
   const seenDreamerProjectIdentities = new Set([projectIdentity]);
   try {
     const pendingPiMarkerSessions = getSessionsWithPendingPiMarker(db);
     for (const sid of pendingPiMarkerSessions) {
       signalPiDeferredHistoryRefresh(sid);
-      signalPiPendingMaterialization(sid);
+      signalPiDeferredMaterialization(sid);
     }
     if (pendingPiMarkerSessions.length > 0) {
       log(`${PREFIX} rehydrated ${pendingPiMarkerSessions.length} Pi deferred compaction marker session(s)`);
@@ -206542,11 +207827,10 @@ async function src_default2(pi) {
     ensureProjectRegistered: ensureProjectRegisteredFromPiDirectory,
     allowDreamerActions: false,
     memoryToolEnabled: true,
-    ctxReduceEnabled: config2.ctx_reduce_enabled === true,
     protectedTags: config2.protected_tags ?? 20,
     dreamerEnabled: isDreamerRunnable(config2)
   });
-  info(`registered tools: ctx_search, ctx_memory, ctx_note, ctx_expand${config2.ctx_reduce_enabled === true ? ", ctx_reduce" : ""}`);
+  info("registered tools: ctx_search, ctx_memory, ctx_note, ctx_expand, ctx_reduce");
   const historianConfig = resolveHistorianFromConfig(config2);
   if (historianConfig) {
     historianConfig.onStatusChange = (ctx) => {
@@ -206560,11 +207844,10 @@ async function src_default2(pi) {
   const contextOptionsByDir = new Map;
   const buildContextOptions = (cfg, hist, auto) => ({
     db: database,
-    ctxReduceEnabled: cfg.ctx_reduce_enabled,
     smartDrops: cfg.smart_drops === true,
     protectedTags: cfg.protected_tags ?? 20,
     heuristics: {
-      caveman: cfg.ctx_reduce_enabled === false && cfg.caveman_text_compression ? {
+      caveman: cfg.caveman_text_compression ? {
         enabled: cfg.caveman_text_compression.enabled,
         minChars: cfg.caveman_text_compression.min_chars
       } : undefined,
@@ -206621,7 +207904,7 @@ async function src_default2(pi) {
   const bootContextOptions = buildContextOptions(config2, historianConfig, autoSearchConfig);
   contextOptionsByDir.set(projectDir, bootContextOptions);
   registerPiContextHandler(pi, bootContextOptions);
-  info(historianConfig ? `registered historian trigger (model=${historianConfig.model}, executeThreshold=${historianConfig.executeThresholdPercentage ?? 65}%)` : "registered historian trigger: DISABLED (set historian.model in magic-context.jsonc)");
+  info(historianConfig ? `registered historian trigger (model=${historianConfig.model}, executeThreshold=${formatExecuteThresholdForLog(historianConfig.executeThresholdPercentage)})` : "registered historian trigger: DISABLED (set historian.model in magic-context.jsonc)");
   info(autoSearchConfig.enabled ? `registered auto-search hint (threshold=${autoSearchConfig.scoreThreshold}, minChars=${autoSearchConfig.minPromptChars})` : "registered auto-search hint: DISABLED (memory.auto_search.enabled=false)");
   const sidekickConfig = resolveSidekickFromConfig(config2);
   registerCtxAugCommand(pi, sidekickConfig);
@@ -206659,6 +207942,22 @@ async function src_default2(pi) {
     autoPromote: config2.memory.auto_promote
   });
   info("registered /ctx-recomp");
+  registerCtxWrapupCommand(pi, {
+    db,
+    runner: new PiSubagentRunner,
+    historianModel: historianConfig?.model,
+    historianChunkTokens: deriveHistorianChunkTokens(resolveHistorianContextLimit(historianConfig?.model)),
+    historianFallbacks: historianConfig?.fallbackModels,
+    historianTimeoutMs: config2.historian_timeout_ms,
+    historianThinkingLevel: historianConfig?.thinkingLevel,
+    language: config2.language,
+    memoryEnabled: config2.memory.enabled,
+    autoPromote: config2.memory.auto_promote,
+    userMemoriesEnabled: userMemoryCollectionEnabled(config2.dreamer),
+    executeThresholdPercentage: config2.execute_threshold_percentage,
+    executeThresholdTokens: config2.execute_threshold_tokens
+  });
+  info("registered /ctx-wrapup");
   registerCtxSessionUpgradeCommand(pi, {
     db,
     runner: new PiSubagentRunner,
@@ -206808,10 +208107,10 @@ async function src_default2(pi) {
         memoryEnabled: effectiveConfig.memory.enabled,
         includeGuidance: true,
         protectedTags: effectiveConfig.protected_tags,
-        ctxReduceEnabled: effectiveConfig.ctx_reduce_enabled,
+        ctxReduceCallable: true,
         dreamerEnabled: effectiveDreamerRunnable,
         temporalAwarenessEnabled: effectiveConfig.temporal_awareness ?? false,
-        cavemanTextCompressionEnabled: effectiveConfig.ctx_reduce_enabled === false && effectiveConfig.caveman_text_compression?.enabled === true,
+        cavemanTextCompressionEnabled: effectiveConfig.caveman_text_compression?.enabled === true,
         language: effectiveConfig.language,
         userMemoriesEnabled: userMemoryCollectionEnabled(effectiveConfig.dreamer),
         isCacheBusting,
@@ -207078,6 +208377,15 @@ ${block}` : event.systemPrompt;
     } catch {}
   });
 }
+function formatExecuteThresholdForLog(value) {
+  if (value === undefined)
+    return "65%";
+  if (typeof value === "number")
+    return `${value}%`;
+  const overrides = Object.entries(value).filter(([key]) => key !== "default").map(([key, pct]) => `${key}=${pct}%`);
+  const base = `${value.default}%`;
+  return overrides.length > 0 ? `${base} (${overrides.join(", ")})` : base;
+}
 export {
   resolveSidekickFromConfig,
   resolveHistorianFromConfig,