@cortexkit/opencode-magic-context 0.30.7 → 0.31.0

package/dist/index.js

@@ -15372,7 +15372,6 @@ var init_magic_context = __esm(() => {
     enabled: exports_external.boolean().default(true).describe("Enable magic context (default: true)"),
     auto_update: exports_external.boolean().optional().describe("Enable automatic npm self-update checks for the OpenCode plugin. Security: USER-only in config loader, so hostile project configs cannot suppress updates."),
     language: exports_external.string().trim().toLowerCase().refine((s) => isValidLanguageCode(s), 'language must be a 2-letter ISO 639-1 code (e.g. "tr", "es", "de")').optional().describe("Output language for Magic Context's generated content and guidance, as a " + '2-letter ISO 639-1 code (e.g. "tr", "es", "de", "ja", "pt"). When set, the ' + "historian, dreamer, sidekick, and the agent-guidance block instruct the model to " + "write its PROSE in this language while keeping all structural tokens (XML tags, " + "the five memory category names, code identifiers, file paths) in English. " + "USER-LEVEL ONLY (ignored in project config for security). Unset = today's " + "behavior (model mirrors the conversation; English scaffolding). Changing it " + "triggers one cache re-materialization; existing compartments/memories keep their " + "original language until naturally rewritten."),
-    ctx_reduce_enabled: exports_external.boolean().default(true).describe("When false, ctx_reduce tool is hidden, all nudges disabled, and prompt guidance about ctx_reduce stripped. Heuristic cleanup, compartments, memory, and other features still work. (default: true)"),
     historian: HistorianConfigSchema.describe("Historian agent configuration (model, fallback_models, variant, temperature, maxTokens, permission, two_pass, etc.)"),
     dreamer: DreamerConfigSchema.optional().describe("Dreamer agent + scheduling configuration (model, fallback_models, disable, schedule, tasks, etc.)"),
     cache_ttl: exports_external.union([exports_external.string(), exports_external.object({ default: exports_external.string() }).catchall(exports_external.string())]).default("5m").describe('Cache TTL: string (e.g. "5m") or per-model object ({ default: "5m", "model-id": "10m" })'),
@@ -15411,9 +15410,9 @@ var init_magic_context = __esm(() => {
     keep_subagents: exports_external.boolean().default(false).describe("Debug: keep the child sessions Magic Context spawns for its own subagents (historian, dreamer, sidekick, memory-migration) instead of deleting them on success. Useful for short-term inspection/data collection — their full transcript (prompt, tool calls, token usage, output) stays in the host session store. Kept sessions accumulate until manually cleared; leave false for normal use. Requires a restart to take effect."),
     smart_drops: exports_external.boolean().default(false).describe("Content-aware reclaim of provably-superseded tool output, layered on the existing execute-pass auto-drop. When on: superseded todowrite (keep newest 1), spent ctx_reduce (keep newest 5), and zero-value meta (bash_status, bash_kill, ctx_note read/dismiss) outputs are dropped; older edits to a file are compressed to a filePath-preserving marker while the newest edit per file stays full. Only acts on passes already busting the cache, so it never originates a cache bust. Honors the protected-tag reserve. Experimental: opt-in, default off until cache stability is proven; when off the wire is byte-identical to the positional-only reclaim. Requires a restart."),
     caveman_text_compression: exports_external.object({
-      enabled: exports_external.boolean().default(false).describe("Apply deterministic caveman-style text compression to old conversation text. Only active when ctx_reduce_enabled=false. Compresses user/assistant text in oldest-first tiers: ultra (oldest 20%), full, lite, untouched (newest 40%)."),
+      enabled: exports_external.boolean().default(false).describe("Apply deterministic caveman-style text compression to old conversation text. Active for primary sessions when enabled; never for subagents. Compresses user/assistant text in oldest-first tiers: ultra (oldest 20%), full, lite, untouched (newest 40%)."),
       min_chars: exports_external.number().min(100).max(1e4).default(500).describe("Text parts shorter than this (characters) stay untouched. Min 100, max 10000. Default: 500.")
-    }).default({ enabled: false, min_chars: 500 }).describe("Age-tier caveman compression for long user/assistant text parts. Only active when ctx_reduce_enabled is false. Oldest 20% of eligible tags (outside protected tail) go to ultra, next 20% to full, next 20% to lite, newest 40% untouched. Graduated from experimental.caveman_text_compression; opt-in, default off (lossy)."),
+    }).default({ enabled: false, min_chars: 500 }).describe("Age-tier caveman compression for long user/assistant text parts. Active for primary sessions when enabled; never for subagents. Oldest 20% of eligible tags (outside protected tail) go to ultra, next 20% to full, next 20% to lite, newest 40% untouched. Graduated from experimental.caveman_text_compression; opt-in, default off (lossy)."),
     memory: exports_external.object({
       enabled: exports_external.boolean().default(true).describe("Enable cross-session memory (default: true)"),
       injection_budget_tokens: exports_external.number().min(500).max(20000).default(4000).describe("Token budget for memory injection on session start (min: 500, max: 20000, default: 4000)"),
@@ -15783,7 +15782,7 @@ var init_compaction_marker = __esm(async () => {
 // src/features/magic-context/memory/project-identity.ts
 import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync8, realpathSync, statSync as statSync2 } from "node:fs";
 import path3 from "node:path";
 function asError(error51) {
   return error51 instanceof Error ? error51 : undefined;
@@ -15860,6 +15859,9 @@ function classifyGitError(error51, rawDirectory) {
     return new ProjectIdentityError("permission_denied", rawDirectory, "Permission denied while spawning git", asError(error51));
   }
   const stderr = getErrorStderr(error51).toLowerCase();
+  if (stderr.includes("detected dubious ownership")) {
+    return new ProjectIdentityError("dubious_ownership", rawDirectory, "git refused to read the repository because it detected dubious ownership", asError(error51));
+  }
   if (stderr.includes("not a git repository") || stderr.includes("does not have any commits yet") || stderr.includes("ambiguous argument 'head'") || stderr.includes("unknown revision or path")) {
     return new ProjectIdentityError("not_git_repo", rawDirectory, "Directory has no git root commit; caller may use directory fallback", asError(error51));
   }
@@ -15872,9 +15874,12 @@ function resolveProjectIdentityStrict(directory) {
     return cached2;
   }
   assertDirectoryUsable(canonical, directory);
+  if (!hasGitDir(canonical)) {
+    throw new ProjectIdentityError("not_git_repo", directory, "Directory has no git metadata; caller may use directory fallback");
+  }
   let output;
   try {
-    output = execFileSync("git", ["rev-list", "--max-parents=0", "HEAD"], {
+    output = execFileSyncForIdentity("git", ["rev-list", "--max-parents=0", "HEAD"], {
       cwd: canonical,
       encoding: "utf8",
       env: { ...process.env, LC_ALL: "C", LANG: "C" },
@@ -15892,10 +15897,82 @@ function resolveProjectIdentityStrict(directory) {
   }
   const identity = `git:${rootCommit}`;
   identityCache.set(canonical, identity);
+  lastKnownGitIdentityCache.set(canonical, identity);
+  transientFailureCooldown.delete(canonical);
+  dubiousOwnershipFallbackDirectories.delete(canonical);
+  transientGitIdentityReuseLoggedDirectories.delete(canonical);
   return identity;
 }
 function shouldUseDirectoryFallback(error51) {
-  return error51.errorClass === "not_git_repo" || error51.errorClass === "unknown" && error51.message.startsWith("Unable to access project directory:");
+  return error51.errorClass !== "permission_denied";
+}
+function getActiveCooldown(canonical) {
+  const until = transientFailureCooldown.get(canonical);
+  if (until === undefined)
+    return;
+  if (nowMs() < until)
+    return until;
+  transientFailureCooldown.delete(canonical);
+  return;
+}
+function lastKnownGitIdentity(canonical) {
+  return lastKnownGitIdentityCache.get(canonical) ?? identityCache.get(canonical);
+}
+function nearestLastKnownGitIdentity(canonical) {
+  const visited = new Set;
+  const walk = (start) => {
+    let current = start;
+    while (!visited.has(current)) {
+      visited.add(current);
+      const cached2 = lastKnownGitIdentity(current);
+      if (cached2 !== undefined)
+        return { identity: cached2, source: current };
+      const parent = path3.dirname(current);
+      if (parent === current)
+        break;
+      current = parent;
+    }
+    return;
+  };
+  const exactOrAncestor = walk(canonical);
+  if (exactOrAncestor)
+    return exactOrAncestor;
+  try {
+    const realCanonical = realpathSync.native(canonical);
+    if (realCanonical !== canonical)
+      return walk(realCanonical);
+  } catch {}
+  return;
+}
+function reuseLastKnownGitIdentity(canonical) {
+  const cached2 = nearestLastKnownGitIdentity(canonical);
+  if (cached2 === undefined)
+    return;
+  if (!transientGitIdentityReuseLoggedDirectories.has(canonical)) {
+    transientGitIdentityReuseLoggedDirectories.add(canonical);
+    const sourceNote = cached2.source === canonical ? "" : ` from ancestor ${cached2.source}`;
+    log(`[magic-context] git identity resolution is temporarily unavailable for ${canonical}; reusing the last successful project identity${sourceNote} to avoid splitting project-scoped memory`);
+  }
+  return cached2.identity;
+}
+function formatDubiousOwnershipWarning(canonical) {
+  return `Magic Context: git refused to read ${canonical} (dubious ownership — the repo is owned by a different user). Using a directory-based project identity for now, which keeps memory separate from this repo's normal identity. Fix: git config --global --add safe.directory ${canonical}`;
+}
+function recordDubiousOwnershipFallback(canonical) {
+  dubiousOwnershipFallbackDirectories.add(canonical);
+  if (dubiousOwnershipLoggedDirectories.has(canonical))
+    return;
+  dubiousOwnershipLoggedDirectories.add(canonical);
+  log(`[magic-context] ${formatDubiousOwnershipWarning(canonical)}`);
+}
+function takeDubiousOwnershipProjectIdentityWarning(directory) {
+  const canonical = path3.resolve(directory);
+  if (!dubiousOwnershipFallbackDirectories.has(canonical))
+    return null;
+  if (dubiousOwnershipWarnedDirectories.has(canonical))
+    return null;
+  dubiousOwnershipWarnedDirectories.add(canonical);
+  return formatDubiousOwnershipWarning(canonical);
 }
 function resolveProjectIdentity(directory) {
   const canonical = path3.resolve(directory);
@@ -15906,27 +15983,74 @@ function resolveProjectIdentity(directory) {
     }
     directoryFallbackCache.delete(canonical);
   }
+  if (getActiveCooldown(canonical) !== undefined) {
+    if (hasGitDir(canonical)) {
+      const cachedGitIdentity = reuseLastKnownGitIdentity(canonical);
+      if (cachedGitIdentity !== undefined) {
+        return cachedGitIdentity;
+      }
+    }
+    return directoryFallback(canonical);
+  }
   try {
     return resolveProjectIdentityStrict(directory);
   } catch (error51) {
     if (error51 instanceof ProjectIdentityError && shouldUseDirectoryFallback(error51)) {
       const fallback = directoryFallback(canonical);
-      if (!hasGitDir(canonical)) {
+      const hasGitMetadata = hasGitDir(canonical);
+      if (!hasGitMetadata) {
         directoryFallbackCache.set(canonical, fallback);
+        transientFailureCooldown.delete(canonical);
+      } else {
+        transientFailureCooldown.set(canonical, nowMs() + TRANSIENT_FAILURE_COOLDOWN_MS);
+        const cachedGitIdentity = reuseLastKnownGitIdentity(canonical);
+        if (cachedGitIdentity !== undefined) {
+          return cachedGitIdentity;
+        }
+      }
+      if (error51.errorClass === "dubious_ownership") {
+        recordDubiousOwnershipFallback(canonical);
       }
       return fallback;
     }
     throw error51;
   }
 }
-function hasGitDir(canonical) {
+function resolveProjectIdentityOrFallback(directory) {
   try {
-    statSync2(path3.join(canonical, ".git"));
+    return resolveProjectIdentity(directory);
+  } catch (error51) {
+    const canonical = path3.resolve(directory);
+    const fallback = directoryFallback(canonical);
+    const message = error51 instanceof Error ? error51.message : String(error51);
+    log(`[magic-context] project identity resolution failed for ${canonical}; using directory fallback ${fallback}: ${message}`);
+    return fallback;
+  }
+}
+function hasGitDir(canonical) {
+  if (hasGitDirInAncestorChain(canonical)) {
     return true;
+  }
+  try {
+    const realCanonical = realpathSync.native(canonical);
+    return realCanonical !== canonical && hasGitDirInAncestorChain(realCanonical);
   } catch {
     return false;
   }
 }
+function hasGitDirInAncestorChain(startDirectory) {
+  let current = startDirectory;
+  while (true) {
+    if (existsSync8(path3.join(current, ".git"))) {
+      return true;
+    }
+    const parent = path3.dirname(current);
+    if (parent === current) {
+      return false;
+    }
+    current = parent;
+  }
+}
 function normalizeStoredProjectPath(rawOrStored) {
   if (rawOrStored.startsWith("git:") || rawOrStored.startsWith("dir:")) {
     return rawOrStored;
@@ -15940,10 +16064,19 @@ function normalizeStoredProjectPath(rawOrStored) {
 function storedPathBelongsToIdentity(storedProjectPath, projectIdentity) {
   return storedProjectPath === projectIdentity || normalizeStoredProjectPath(storedProjectPath) === projectIdentity;
 }
-var GIT_TIMEOUT_MS = 5000, identityCache, directoryFallbackCache, ProjectIdentityError;
+var GIT_TIMEOUT_MS = 5000, TRANSIENT_FAILURE_COOLDOWN_MS, identityCache, lastKnownGitIdentityCache, directoryFallbackCache, transientFailureCooldown, dubiousOwnershipFallbackDirectories, dubiousOwnershipLoggedDirectories, dubiousOwnershipWarnedDirectories, transientGitIdentityReuseLoggedDirectories, execFileSyncForIdentity, nowMs = () => Date.now(), ProjectIdentityError;
 var init_project_identity = __esm(() => {
+  init_logger();
+  TRANSIENT_FAILURE_COOLDOWN_MS = 5 * 60 * 1000;
   identityCache = new Map;
+  lastKnownGitIdentityCache = new Map;
   directoryFallbackCache = new Map;
+  transientFailureCooldown = new Map;
+  dubiousOwnershipFallbackDirectories = new Set;
+  dubiousOwnershipLoggedDirectories = new Set;
+  dubiousOwnershipWarnedDirectories = new Set;
+  transientGitIdentityReuseLoggedDirectories = new Set;
+  execFileSyncForIdentity = execFileSync;
   ProjectIdentityError = class ProjectIdentityError extends Error {
     errorClass;
     rawDirectory;
@@ -17144,13 +17277,13 @@ function removeSystemReminders(text) {
 var SYSTEM_DIRECTIVE_PREFIX = "[SYSTEM DIRECTIVE: MAGIC-CONTEXT";
 
 // src/hooks/magic-context/read-session-db.ts
-import { existsSync as existsSync9 } from "node:fs";
+import { existsSync as existsSync10 } from "node:fs";
 import { join as join4 } from "node:path";
 function getOpenCodeDbPath2() {
   return join4(getDataDir(), "opencode", "opencode.db");
 }
 function openCodeDbExists() {
-  return existsSync9(getOpenCodeDbPath2());
+  return existsSync10(getOpenCodeDbPath2());
 }
 function closeCachedReadOnlyDb() {
   if (!cachedReadOnlyDb) {
@@ -152764,6 +152897,15 @@ var init_migrations = __esm(() => {
                 );
             `);
       }
+    },
+    {
+      version: 50,
+      description: "add durable ctx-wrapup session marker",
+      up(db) {
+        if (tableExists2(db, "session_meta")) {
+          ensureColumn(db, "session_meta", "wrapup_in_progress_state", "TEXT");
+        }
+      }
     }
   ];
   LATEST_MIGRATION_VERSION = MIGRATIONS.reduce((max, m) => Math.max(max, m.version), 0);
@@ -153010,7 +153152,7 @@ var init_tool_definition_tokens = __esm(() => {
 });
 
 // src/features/magic-context/tool-owner-backfill.ts
-import { existsSync as existsSync10 } from "node:fs";
+import { existsSync as existsSync11 } from "node:fs";
 import { join as join5 } from "node:path";
 function resolveOpencodeDbPath() {
   return join5(getDataDir(), "opencode", "opencode.db");
@@ -153048,7 +153190,7 @@ function runToolOwnerBackfill(db) {
     return result;
   }
   const opencodeDbPath = resolveOpencodeDbPath();
-  if (!existsSync10(opencodeDbPath)) {
+  if (!existsSync11(opencodeDbPath)) {
     log(`[backfill] OpenCode DB not found at ${opencodeDbPath} — marking all unbackfilled sessions as skipped. Lazy adoption (defense-in-depth) handles legacy rows at runtime.`);
     markAllUnbackfilledSessionsSkipped(db);
     result.sessionsSkippedNoOcDb = countSessionsByStatus(db, "skipped");
@@ -153272,7 +153414,7 @@ var init_tool_owner_backfill = __esm(() => {
 });
 
 // src/features/magic-context/storage-db.ts
-import { chmodSync, copyFileSync, cpSync, existsSync as existsSync11, mkdirSync as mkdirSync4, mkdtempSync } from "node:fs";
+import { chmodSync, copyFileSync, cpSync, existsSync as existsSync12, mkdirSync as mkdirSync4, mkdtempSync } from "node:fs";
 import { dirname as dirname4, join as join6 } from "node:path";
 function getSchemaFenceRejection() {
   return lastSchemaFenceRejection;
@@ -153292,7 +153434,7 @@ function restrictDatabaseFilePermissions(dbPath) {
     return;
   for (const suffix of ["", "-wal", "-shm"]) {
     const file2 = `${dbPath}${suffix}`;
-    if (!existsSync11(file2))
+    if (!existsSync12(file2))
       continue;
     try {
       chmodSync(file2, 384);
@@ -153318,11 +153460,11 @@ function getDatabasePath(db) {
   return pathByDatabase.get(db) ?? null;
 }
 function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
-  if (existsSync11(targetDbPath))
+  if (existsSync12(targetDbPath))
     return;
   const legacyDir = getLegacyOpenCodeMagicContextStorageDir();
   const legacyDbPath = join6(legacyDir, "context.db");
-  if (!existsSync11(legacyDbPath))
+  if (!existsSync12(legacyDbPath))
     return;
   log(`[magic-context] migrating legacy plugin storage: ${legacyDir} -> ${targetDbDir} (legacy left in place as backup)`);
   ensureSecureStorageDir(targetDbDir);
@@ -153339,7 +153481,7 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
   for (const suffix of ["", "-wal", "-shm"]) {
     const src = `${legacyDbPath}${suffix}`;
     const dst = join6(targetDbDir, `context.db${suffix}`);
-    if (existsSync11(src)) {
+    if (existsSync12(src)) {
       try {
         copyFileSync(src, dst);
       } catch (error51) {
@@ -153349,7 +153491,7 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
   }
   const legacyModelsDir = join6(legacyDir, "models");
   const targetModelsDir = join6(targetDbDir, "models");
-  if (existsSync11(legacyModelsDir) && !existsSync11(targetModelsDir)) {
+  if (existsSync12(legacyModelsDir) && !existsSync12(targetModelsDir)) {
     try {
       cpSync(legacyModelsDir, targetModelsDir, { recursive: true });
     } catch (error51) {
@@ -153949,6 +154091,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       force_emergency_bypass_used INTEGER NOT NULL DEFAULT 0,
       emergency_drain_active INTEGER NOT NULL DEFAULT 0,
       historian_drain_failure_at INTEGER NOT NULL DEFAULT 0,
+      wrapup_in_progress_state TEXT,
       cached_m0_materialized_at INTEGER,
       cached_m0_session_facts_version INTEGER,
       cached_m0_upgrade_state TEXT,
@@ -154237,6 +154380,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "session_meta", "force_emergency_bypass_used", "INTEGER NOT NULL DEFAULT 0");
   ensureColumn(db, "session_meta", "emergency_drain_active", "INTEGER NOT NULL DEFAULT 0");
   ensureColumn(db, "session_meta", "historian_drain_failure_at", "INTEGER NOT NULL DEFAULT 0");
+  ensureColumn(db, "session_meta", "wrapup_in_progress_state", "TEXT");
   ensureColumn(db, "session_meta", "cached_m0_materialized_at", "INTEGER");
   ensureColumn(db, "session_meta", "cached_m0_session_facts_version", "INTEGER");
   ensureColumn(db, "session_meta", "cached_m0_upgrade_state", "TEXT");
@@ -154415,7 +154559,7 @@ function getDatabasePersistenceError(db) {
     return null;
   return persistenceErrorByDatabase.get(db) ?? null;
 }
-var databases, persistenceByDatabase, persistenceErrorByDatabase, pathByDatabase, lastSchemaFenceRejection = null, LATEST_SUPPORTED_VERSION = 49, PERMISSIONS_ENFORCEABLE, sqlitePragmaConfig, CHANNEL2_CLAIM_TTL_MS = 120000;
+var databases, persistenceByDatabase, persistenceErrorByDatabase, pathByDatabase, lastSchemaFenceRejection = null, LATEST_SUPPORTED_VERSION = 50, PERMISSIONS_ENFORCEABLE, sqlitePragmaConfig, CHANNEL2_CLAIM_TTL_MS = 120000;
 var init_storage_db = __esm(async () => {
   init_data_path();
   init_logger();
@@ -154755,6 +154899,147 @@ function resetProtectedTailNoEligibleHead(db, sessionId) {
     db.prepare("UPDATE session_meta SET recovery_no_eligible_head_count = 0 WHERE session_id = ?").run(sessionId);
   })();
 }
+function parseWrapupState(value) {
+  if (typeof value !== "string" || value.trim().length === 0)
+    return null;
+  try {
+    const parsed = JSON.parse(value);
+    if (!parsed || typeof parsed !== "object")
+      return null;
+    if (typeof parsed.holderId !== "string" || parsed.holderId.length === 0)
+      return null;
+    const numberFields = [
+      "acquiredAt",
+      "expiresAt",
+      "messagesToKeep",
+      "anchorRawMessageCount",
+      "targetEligibleEndOrdinal",
+      "lastCompartmentEnd",
+      "chunkIndex",
+      "expectedChunks",
+      "updatedAt"
+    ];
+    for (const field of numberFields) {
+      if (typeof parsed[field] !== "number" || !Number.isFinite(parsed[field]))
+        return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function readRawWrapupState(db, sessionId) {
+  const row = db.prepare("SELECT wrapup_in_progress_state FROM session_meta WHERE session_id = ?").get(sessionId);
+  return parseWrapupState(row?.wrapup_in_progress_state);
+}
+function getWrapupInProgressState(db, sessionId, now = Date.now()) {
+  const state = readRawWrapupState(db, sessionId);
+  if (!state)
+    return null;
+  if (state.expiresAt > now)
+    return state;
+  try {
+    db.exec("BEGIN IMMEDIATE");
+  } catch {
+    return null;
+  }
+  let finished = false;
+  try {
+    const current = readRawWrapupState(db, sessionId);
+    if (current && current.expiresAt <= now) {
+      db.prepare("UPDATE session_meta SET wrapup_in_progress_state = NULL WHERE session_id = ?").run(sessionId);
+    }
+    db.exec("COMMIT");
+    finished = true;
+  } finally {
+    if (!finished) {
+      try {
+        db.exec("ROLLBACK");
+      } catch {}
+    }
+  }
+  return null;
+}
+function isWrapupInProgress(db, sessionId, now = Date.now()) {
+  return getWrapupInProgressState(db, sessionId, now) !== null;
+}
+function acquireWrapupInProgress(db, sessionId, state, now = Date.now()) {
+  const acquiredAt = now;
+  const next = {
+    ...state,
+    acquiredAt,
+    expiresAt: acquiredAt + WRAPUP_IN_PROGRESS_TTL_MS,
+    updatedAt: acquiredAt
+  };
+  db.exec("BEGIN IMMEDIATE");
+  let finished = false;
+  try {
+    ensureSessionMetaRow(db, sessionId);
+    const current = readRawWrapupState(db, sessionId);
+    if (current && current.expiresAt > now && current.holderId !== state.holderId) {
+      db.exec("COMMIT");
+      finished = true;
+      return { ok: false, state: current };
+    }
+    db.prepare("UPDATE session_meta SET wrapup_in_progress_state = ? WHERE session_id = ?").run(stableStringify(next), sessionId);
+    db.exec("COMMIT");
+    finished = true;
+    return { ok: true, state: next };
+  } finally {
+    if (!finished) {
+      try {
+        db.exec("ROLLBACK");
+      } catch {}
+    }
+  }
+}
+function updateWrapupInProgress(db, sessionId, holderId, updates, now = Date.now()) {
+  db.exec("BEGIN IMMEDIATE");
+  let finished = false;
+  try {
+    const current = readRawWrapupState(db, sessionId);
+    if (!current || current.holderId !== holderId || current.expiresAt <= now) {
+      db.exec("ROLLBACK");
+      finished = true;
+      return null;
+    }
+    const next = {
+      ...current,
+      ...updates,
+      holderId,
+      expiresAt: now + WRAPUP_IN_PROGRESS_TTL_MS,
+      updatedAt: now
+    };
+    db.prepare("UPDATE session_meta SET wrapup_in_progress_state = ? WHERE session_id = ?").run(stableStringify(next), sessionId);
+    db.exec("COMMIT");
+    finished = true;
+    return next;
+  } finally {
+    if (!finished) {
+      try {
+        db.exec("ROLLBACK");
+      } catch {}
+    }
+  }
+}
+function releaseWrapupInProgress(db, sessionId, holderId) {
+  db.exec("BEGIN IMMEDIATE");
+  let finished = false;
+  try {
+    const current = readRawWrapupState(db, sessionId);
+    if (current?.holderId === holderId) {
+      db.prepare("UPDATE session_meta SET wrapup_in_progress_state = NULL WHERE session_id = ?").run(sessionId);
+    }
+    db.exec("COMMIT");
+    finished = true;
+  } finally {
+    if (!finished) {
+      try {
+        db.exec("ROLLBACK");
+      } catch {}
+    }
+  }
+}
 function protectedTailWindowBudget(usagePercentage, usable, perRunCap) {
   if (usagePercentage >= 95)
     return Math.min(1e6, Math.max(4 * perRunCap, Math.round(0.5 * usable)));
@@ -155432,7 +155717,7 @@ function setSessionWorkMetrics(db, sessionId, newWorkTokens, totalInputTokens) {
          SET new_work_tokens = ?, total_input_tokens = ?
          WHERE session_id = ?`).run(Math.max(0, Math.floor(newWorkTokens)), Math.max(0, Math.floor(totalInputTokens)), sessionId);
 }
-var CAS_RETRY_LIMIT = 5, AUTO_SEARCH_NO_HINT_REASONS, DEFAULT_PROTECTED_TAIL_META, DRAIN_WINDOW_MS, EMERGENCY_DRAIN_ENTER_PERCENTAGE = 95, EMERGENCY_DRAIN_EXIT_MARGIN = 10, EMERGENCY_DRAIN_FALLBACK_EXIT_PERCENTAGE = 55, EMERGENCY_DRAIN_FAILURE_BACKOFF_MS = 60000, EMERGENCY_DRAIN_MAX_LATCH_MS;
+var CAS_RETRY_LIMIT = 5, AUTO_SEARCH_NO_HINT_REASONS, DEFAULT_PROTECTED_TAIL_META, DRAIN_WINDOW_MS, WRAPUP_IN_PROGRESS_TTL_MS, EMERGENCY_DRAIN_ENTER_PERCENTAGE = 95, EMERGENCY_DRAIN_EXIT_MARGIN = 10, EMERGENCY_DRAIN_FALLBACK_EXIT_PERCENTAGE = 55, EMERGENCY_DRAIN_FAILURE_BACKOFF_MS = 60000, EMERGENCY_DRAIN_MAX_LATCH_MS;
 var init_storage_meta_persisted = __esm(() => {
   init_logger();
   init_storage_meta_shared();
@@ -155456,6 +155741,7 @@ var init_storage_meta_persisted = __esm(() => {
     historianDrainFailureAt: 0
   };
   DRAIN_WINDOW_MS = 10 * 60 * 1000;
+  WRAPUP_IN_PROGRESS_TTL_MS = 5 * 60 * 1000;
   EMERGENCY_DRAIN_MAX_LATCH_MS = 30 * 60 * 1000;
 });
 
@@ -165860,7 +166146,7 @@ __export(exports_conflict_warning_hook, {
   sendConflictWarning: () => sendConflictWarning,
   cleanupConflictWarnings: () => cleanupConflictWarnings
 });
-import { existsSync as existsSync15, readFileSync as readFileSync10 } from "node:fs";
+import { existsSync as existsSync16, readFileSync as readFileSync10 } from "node:fs";
 import { homedir as homedir7, platform as platform2 } from "node:os";
 import { join as join13 } from "node:path";
 function getDesktopStatePath() {
@@ -165881,7 +166167,7 @@ function getDesktopStatePath() {
 }
 function readDesktopState(directory) {
   const statePath = getDesktopStatePath();
-  if (!statePath || !existsSync15(statePath)) {
+  if (!statePath || !existsSync16(statePath)) {
     log(`[magic-context] conflict-warning: Desktop state file not found at ${statePath}`);
     return { sessionId: null, sidecarUrl: null };
   }
@@ -167057,7 +167343,8 @@ function isNativeRuntimeMissingError(error51) {
   if (code === "ERR_DLOPEN_FAILED" && lower.includes("onnxruntime")) {
     return true;
   }
-  if (!lower.includes("onnxruntime-node"))
+  const mentionsNativeRuntime = lower.includes("onnxruntime-node") || lower.includes("onnxruntime_binding");
+  if (!mentionsNativeRuntime)
     return false;
   return code === "ERR_MODULE_NOT_FOUND" || name2 === "ResolveMessage" || lower.includes("cannot find package") || lower.includes("cannot find module") || lower.includes("err_module_not_found");
 }
@@ -167202,7 +167489,7 @@ class LocalEmbeddingProvider {
       } catch (error51) {
         if (isNativeRuntimeMissingError(error51)) {
           nativeRuntimeMissing = true;
-          log("[magic-context] local embedding runtime is not installed (onnxruntime-node missing from this install). Local embeddings are disabled. Fix: reinstall the plugin (run `npx @cortexkit/magic-context@latest doctor --force`), or configure an `openai-compatible`/`ollama` embedding endpoint instead. Existing memories are unaffected.");
+          log("[magic-context] local embeddings are disabled because the onnxruntime-node native binding is missing or failed to load. Run `npx @cortexkit/magic-context@latest doctor` for repair guidance (use `doctor --force` to reinstall cached plugin packages), or configure an `openai-compatible` embedding HTTP endpoint. Existing memories are unaffected.");
         } else {
           log("[magic-context] embedding model failed to load:", error51);
         }
@@ -169786,7 +170073,7 @@ function getMemoryVerifications(db, memoryIds) {
 var MEMORY_VERIFICATION_SENTINEL = "";
 // src/features/magic-context/memory/verification-paths.ts
 import { execFile } from "node:child_process";
-import { existsSync as existsSync16, realpathSync as realpathSync2, statSync as statSync5 } from "node:fs";
+import { existsSync as existsSync17, realpathSync as realpathSync3, statSync as statSync5 } from "node:fs";
 import path6 from "node:path";
 import { promisify } from "node:util";
 async function runGit(cwd, args) {
@@ -169811,7 +170098,7 @@ function isWithin(root, candidate) {
 }
 function safeRealpath(value) {
   try {
-    return realpathSync2.native(value);
+    return realpathSync3.native(value);
   } catch {
     return null;
   }
@@ -169889,7 +170176,7 @@ function verificationFileExists(baseRoot, filePath) {
     return false;
   const root = path6.resolve(baseRoot);
   const candidate = path6.resolve(root, filePath);
-  return isWithin(root, candidate) && existsSync16(candidate);
+  return isWithin(root, candidate) && existsSync17(candidate);
 }
 async function normalizeVerificationFiles(args) {
   const cwd = path6.resolve(args.cwd);
@@ -169922,7 +170209,7 @@ async function normalizeVerificationFiles(args) {
       warnings.push(`Skipped verification path "${value}" because it is the repo/project root.`);
       continue;
     }
-    if (existsSync16(candidate)) {
+    if (existsSync17(candidate)) {
       try {
         if (statSync5(candidate).isDirectory()) {
           warnings.push(`Skipped verification path "${value}" because it is a directory.`);
@@ -169953,7 +170240,7 @@ async function normalizeVerificationFiles(args) {
       }
       normalized.push(tracked);
     } else {
-      if (!existsSync16(candidate)) {
+      if (!existsSync17(candidate)) {
         warnings.push(`Skipped verification path "${value}" because it does not exist.`);
         continue;
       }
@@ -178941,7 +179228,8 @@ function readCurrentM0SnapshotMarkers(args) {
     sessionFactsVersion: getSessionFactsVersion(args.db, args.sessionId),
     upgradeState: getUpgradeState(args.db, args.sessionId),
     systemHash: hard.systemHash,
-    modelKey: hard.modelKey
+    modelKey: hard.modelKey,
+    projectIdentity: args.projectPath ?? null
   };
 }
 function snapshotMarkersFromCachedM0(state) {
@@ -178974,7 +179262,8 @@ function snapshotMarkersFromCachedM0(state) {
     sessionFactsVersion: state.cachedM0SessionFactsVersion,
     upgradeState: state.cachedM0UpgradeState,
     systemHash: state.cachedM0SystemHash ?? "",
-    modelKey: state.cachedM0ModelKey ?? ""
+    modelKey: state.cachedM0ModelKey ?? "",
+    projectIdentity: state.cachedM0ProjectIdentity ?? null
   };
 }
 function mustMaterialize(args) {
@@ -178993,6 +179282,15 @@ function mustMaterialize(args) {
   if (hard.cacheExpired && hard.lastResponseTime > 0 && hard.lastResponseTime > (args.state.cachedM0MaterializedAt ?? 0)) {
     return { value: true, reason: "ttl_idle" };
   }
+  if (current.projectIdentity !== null) {
+    const cachedProjectIdentity = args.state.cachedM0ProjectIdentity ?? null;
+    if (cachedProjectIdentity === null) {
+      args.state.cachedM0ProjectIdentity = current.projectIdentity;
+      args.db.prepare("UPDATE session_meta SET cached_m0_project_identity = ? WHERE session_id = ?").run(current.projectIdentity, args.sessionId);
+    } else if (cachedProjectIdentity !== current.projectIdentity) {
+      return { value: true, reason: "project_change" };
+    }
+  }
   if (current.workspaceFingerprint !== null || (args.state.cachedM0WorkspaceFingerprint ?? null) !== null) {
     if ((args.state.cachedM0WorkspaceFingerprint ?? null) !== current.workspaceFingerprint) {
       return { value: true, reason: "project_memory_epoch" };
@@ -179233,6 +179531,7 @@ function applyMarkersToState(state, m0Bytes, markers, m1Bytes) {
   state.cachedM0UpgradeState = markers.upgradeState;
   state.cachedM0SystemHash = markers.systemHash;
   state.cachedM0ModelKey = markers.modelKey;
+  state.cachedM0ProjectIdentity = markers.projectIdentity;
   state.snapshotMarkers = markers;
 }
 function historySliceTokens(m0Text) {
@@ -179356,10 +179655,11 @@ function materializeM0(options) {
       sessionFactsVersion: getSessionFactsVersion(options.db, options.sessionId),
       upgradeState: getUpgradeState(options.db, options.sessionId),
       systemHash: snapshotMarkers.systemHash,
-      modelKey: snapshotMarkers.modelKey
+      modelKey: snapshotMarkers.modelKey,
+      projectIdentity: projectPath ?? null
     };
     const memoryEpochStale = current.workspaceFingerprint !== null || snapshotMarkers.workspaceFingerprint !== null ? current.workspaceFingerprint !== snapshotMarkers.workspaceFingerprint : current.projectMemoryEpoch !== snapshotMarkers.projectMemoryEpoch;
-    const stale = memoryEpochStale || current.projectUserProfileVersion !== snapshotMarkers.projectUserProfileVersion || current.maxCompartmentSeq !== snapshotMarkers.maxCompartmentSeq || current.maxMutationId !== snapshotMarkers.maxMutationId || current.maxMemoryMutationId !== snapshotMarkers.maxMemoryMutationId || current.sessionFactsVersion !== snapshotMarkers.sessionFactsVersion || current.upgradeState !== snapshotMarkers.upgradeState;
+    const stale = memoryEpochStale || current.projectUserProfileVersion !== snapshotMarkers.projectUserProfileVersion || current.maxCompartmentSeq !== snapshotMarkers.maxCompartmentSeq || current.maxMutationId !== snapshotMarkers.maxMutationId || current.maxMemoryMutationId !== snapshotMarkers.maxMemoryMutationId || current.sessionFactsVersion !== snapshotMarkers.sessionFactsVersion || current.upgradeState !== snapshotMarkers.upgradeState || (current.projectIdentity ?? null) !== (snapshotMarkers.projectIdentity ?? null);
     if (stale) {
       options.db.exec("ROLLBACK");
       throw new MaterializeContentionError({ reason: "snapshot changed before Phase 3" });
@@ -179388,7 +179688,8 @@ function materializeM0(options) {
       sessionFactsVersion: snapshotMarkers.sessionFactsVersion,
       upgradeState: snapshotMarkers.upgradeState,
       systemHash: snapshotMarkers.systemHash,
-      modelKey: snapshotMarkers.modelKey
+      modelKey: snapshotMarkers.modelKey,
+      projectIdentity: snapshotMarkers.projectIdentity
     });
     options.db.prepare("UPDATE session_meta SET memory_block_count = ?, memory_block_ids = ? WHERE session_id = ?").run(renderedMemoryIds.length, JSON.stringify(renderedMemoryIds), options.sessionId);
     const baselineEndMessageId = lastCompartmentBoundaryId(compartments);
@@ -179546,6 +179847,7 @@ function readCachedM0M1Row(db, sessionId) {
                     cached_m0_upgrade_state,
                     cached_m0_system_hash,
                     cached_m0_model_key,
+                    cached_m0_project_identity,
                     memory_block_ids
                FROM session_meta
               WHERE session_id = ?`).get(sessionId);
@@ -179580,11 +179882,12 @@ function markersFromCachedRow(row) {
     sessionFactsVersion: row.cached_m0_session_facts_version,
     upgradeState: row.cached_m0_upgrade_state,
     systemHash: row.cached_m0_system_hash ?? "",
-    modelKey: row.cached_m0_model_key ?? ""
+    modelKey: row.cached_m0_model_key ?? "",
+    projectIdentity: row.cached_m0_project_identity ?? null
   };
 }
 function cachedRowMatchesState(row, state) {
-  return bufferEqualsNullable(row.cached_m0_bytes, state.cachedM0Bytes) && row.cached_m0_project_memory_epoch === state.cachedM0ProjectMemoryEpoch && (row.cached_m0_workspace_fingerprint ?? null) === (state.cachedM0WorkspaceFingerprint ?? null) && row.cached_m0_project_user_profile_version === state.cachedM0ProjectUserProfileVersion && row.cached_m0_max_compartment_seq === state.cachedM0MaxCompartmentSeq && row.cached_m0_max_memory_id === state.cachedM0MaxMemoryId && row.cached_m0_max_mutation_id === state.cachedM0MaxMutationId && row.cached_m0_max_memory_mutation_id === state.cachedM0MaxMemoryMutationId && row.cached_m0_materialized_at === state.cachedM0MaterializedAt && row.cached_m0_session_facts_version === state.cachedM0SessionFactsVersion && (row.cached_m0_upgrade_state ?? null) === (state.cachedM0UpgradeState ?? null) && (row.cached_m0_system_hash ?? "") === (state.cachedM0SystemHash ?? "") && (row.cached_m0_model_key ?? "") === (state.cachedM0ModelKey ?? "");
+  return bufferEqualsNullable(row.cached_m0_bytes, state.cachedM0Bytes) && row.cached_m0_project_memory_epoch === state.cachedM0ProjectMemoryEpoch && (row.cached_m0_workspace_fingerprint ?? null) === (state.cachedM0WorkspaceFingerprint ?? null) && row.cached_m0_project_user_profile_version === state.cachedM0ProjectUserProfileVersion && row.cached_m0_max_compartment_seq === state.cachedM0MaxCompartmentSeq && row.cached_m0_max_memory_id === state.cachedM0MaxMemoryId && row.cached_m0_max_mutation_id === state.cachedM0MaxMutationId && row.cached_m0_max_memory_mutation_id === state.cachedM0MaxMemoryMutationId && row.cached_m0_materialized_at === state.cachedM0MaterializedAt && row.cached_m0_session_facts_version === state.cachedM0SessionFactsVersion && (row.cached_m0_upgrade_state ?? null) === (state.cachedM0UpgradeState ?? null) && (row.cached_m0_system_hash ?? "") === (state.cachedM0SystemHash ?? "") && (row.cached_m0_model_key ?? "") === (state.cachedM0ModelKey ?? "") && (row.cached_m0_project_identity ?? null) === (state.cachedM0ProjectIdentity ?? null);
 }
 function applyCachedRowToState(state, row) {
   const markers = markersFromCachedRow(row);
@@ -179606,6 +179909,7 @@ function applyCachedRowToState(state, row) {
   state.cachedM0UpgradeState = markers.upgradeState;
   state.cachedM0SystemHash = markers.systemHash;
   state.cachedM0ModelKey = markers.modelKey;
+  state.cachedM0ProjectIdentity = markers.projectIdentity;
   state.snapshotMarkers = markers;
 }
 function replayCachedM1(state) {
@@ -180600,6 +180904,43 @@ function semanticSnapBoundary(args) {
   }
   return snapped;
 }
+function snapWrapupBoundaryToUser(args) {
+  const { messages, index, candidate, offset, triggerBudget } = args;
+  if (candidate <= offset)
+    return candidate;
+  const snapTokenLimit = Math.min(Math.max(triggerBudget, 2000), 48000);
+  for (let ordinal = candidate;ordinal >= offset; ordinal -= 1) {
+    const message = messages.find((m) => m.ordinal === ordinal);
+    if (!message)
+      continue;
+    if (message.role !== "user" || !hasMeaningfulUserText(message.parts))
+      continue;
+    const extraTokens = index.rangeTokens(ordinal, candidate);
+    if (extraTokens <= snapTokenLimit)
+      return ordinal;
+    return candidate;
+  }
+  return candidate;
+}
+function fenceWrapupBoundaryForToolArcs(args) {
+  let boundary = args.candidate;
+  const maxPasses = args.arcs.length + 1;
+  for (let pass = 0;pass < maxPasses; pass += 1) {
+    let next = boundary;
+    for (const arc of args.arcs) {
+      if (arc.resOrdinal === null) {
+        continue;
+      }
+      if (arc.invOrdinal >= args.lastCompartmentEndOrdinal + 1 && arc.invOrdinal < next && next <= arc.resOrdinal) {
+        next = arc.invOrdinal;
+      }
+    }
+    if (next === boundary)
+      return boundary;
+    boundary = next;
+  }
+  return boundary;
+}
 function applyHeadCap(args) {
   const { index, protectedTailStart, offset, arcs, capTokens, recentOpenArcCutoff } = args;
   if (offset >= protectedTailStart)
@@ -180855,6 +181196,124 @@ function resolveBoundaryContext(args) {
 function resolveOpenCodeProtectedTailBoundary(args) {
   return resolveProtectedTailBoundary(resolveBoundaryContext(args));
 }
+function resolveWrapupProtectedTailBoundary(args) {
+  const ctx = resolveBoundaryContext({ ...args, mode: "manual-wrapup" });
+  const createdAt = ctx.createdAt ?? Date.now();
+  const messages = readRawSessionMessages(ctx.sessionId);
+  const absoluteMessageCount = getCachedAbsoluteMessageCount(ctx.sessionId) ?? undefined;
+  const index = buildTrueRawTokenIndex(ctx.sessionId, messages, {
+    providerShapeVersion: ctx.providerShapeVersion,
+    cacheNamespace: ctx.cacheNamespace,
+    absoluteMessageCount,
+    storedTotalForMessage: ctx.storedTokenTotals ? (m) => {
+      const value = ctx.storedTokenTotals?.get(m.id);
+      return value === undefined ? null : value;
+    } : undefined
+  });
+  const rawMessageCount = index.rawMessageCount;
+  const offset = Math.max(1, ctx.lastCompartmentEndOrdinal + 1);
+  const anchorRawMessageCount = Math.max(0, Math.min(rawMessageCount, Math.floor(args.anchorRawMessageCount ?? rawMessageCount)));
+  const usagePercentage = clampPercentage(ctx.usage?.percentage ?? 0);
+  const usageInputTokens = Math.max(0, Math.round(ctx.usage?.inputTokens ?? 0));
+  const rawMessagesAboveLastCompartment = Math.max(0, anchorRawMessageCount - offset + 1);
+  const keep = Math.max(1, Math.floor(args.messagesToKeep));
+  let targetProtectedTailStart = offset;
+  let boundaryReason = "manual-wrapup-empty";
+  if (rawMessageCount === 0 || rawMessagesAboveLastCompartment <= keep) {
+    targetProtectedTailStart = offset;
+    boundaryReason = rawMessageCount === 0 ? "manual-wrapup-empty" : "manual-wrapup-within-keep";
+  } else {
+    targetProtectedTailStart = anchorRawMessageCount - keep + 1;
+    boundaryReason = "manual-wrapup-keep-watermark";
+    const arcs = buildToolArcs(messages);
+    const fenced = fenceWrapupBoundaryForToolArcs({
+      candidate: targetProtectedTailStart,
+      arcs,
+      lastCompartmentEndOrdinal: ctx.lastCompartmentEndOrdinal
+    });
+    if (fenced !== targetProtectedTailStart)
+      boundaryReason = "manual-wrapup-tool-arc";
+    targetProtectedTailStart = fenced;
+    const snapped = snapWrapupBoundaryToUser({
+      messages,
+      index,
+      candidate: targetProtectedTailStart,
+      offset,
+      triggerBudget: ctx.triggerBudget
+    });
+    if (snapped !== targetProtectedTailStart)
+      boundaryReason = "manual-wrapup-user-snap";
+    targetProtectedTailStart = snapped;
+    const refenced = fenceWrapupBoundaryForToolArcs({
+      candidate: targetProtectedTailStart,
+      arcs,
+      lastCompartmentEndOrdinal: ctx.lastCompartmentEndOrdinal
+    });
+    if (refenced !== targetProtectedTailStart)
+      boundaryReason = "manual-wrapup-tool-arc";
+    targetProtectedTailStart = refenced;
+  }
+  targetProtectedTailStart = clampOrdinal(targetProtectedTailStart, rawMessageCount);
+  const target = deriveProtectedTailTokenTarget({
+    contextLimit: ctx.contextLimit,
+    executeThresholdPercentage: ctx.executeThresholdPercentage,
+    usagePercentage,
+    triggerBudget: ctx.triggerBudget
+  });
+  const perRunCap = selectPerRunCap({
+    usagePercentage,
+    N: target.N,
+    contextLimit: ctx.contextLimit,
+    executeThresholdPercentage: ctx.executeThresholdPercentage
+  });
+  const head = applyHeadCap({
+    index,
+    protectedTailStart: targetProtectedTailStart,
+    offset,
+    arcs: buildToolArcs(messages),
+    lastCompartmentEndOrdinal: ctx.lastCompartmentEndOrdinal,
+    capTokens: perRunCap,
+    recentOpenArcCutoff: targetProtectedTailStart
+  });
+  const eligibleEndOrdinal = Math.min(head.eligibleEndOrdinal, targetProtectedTailStart);
+  const rawRangeFingerprint = computeRawRangeFingerprint(messages, offset, eligibleEndOrdinal);
+  const snapshot = {
+    sessionId: ctx.sessionId,
+    mode: "manual-wrapup",
+    offset,
+    offsetMessageId: boundaryMessageId(index, offset),
+    protectedTailStart: targetProtectedTailStart,
+    protectedTailStartMessageId: boundaryMessageId(index, targetProtectedTailStart),
+    eligibleEndOrdinal,
+    eligibleEndMessageId: boundaryMessageId(index, eligibleEndOrdinal - 1),
+    rawMessageCountAtTrigger: rawMessageCount,
+    rawLastMessageIdAtTrigger: boundaryMessageId(index, rawMessageCount),
+    N: keep,
+    usagePercentage,
+    usageInputTokens,
+    usageSource: ctx.usageSource,
+    contextLimit: ctx.contextLimit,
+    executeThresholdPercentage: ctx.executeThresholdPercentage,
+    triggerBudget: ctx.triggerBudget,
+    priorBoundaryOrdinal: ctx.priorBoundaryOrdinal,
+    migrationFloorActive: ctx.migrationFloorActive,
+    emergencyTailScale: ctx.emergencyTailScale,
+    providerShapeVersion: ctx.providerShapeVersion,
+    cacheNamespace: ctx.cacheNamespace,
+    createdAt,
+    rawRangeFingerprint,
+    trueRawEligibleTokens: index.rangeTokens(offset, targetProtectedTailStart),
+    oversizeAtomicUnit: head.oversizeAtomicUnit,
+    boundaryReason
+  };
+  return {
+    snapshot,
+    rawMessagesAboveLastCompartment,
+    anchorRawMessageCount,
+    targetProtectedTailStart,
+    targetEligibleEndOrdinal: targetProtectedTailStart
+  };
+}
 function getRawHistoryEligibility(db, sessionId) {
   const lastCompartmentEnd = getLastCompartmentEndMessage(db, sessionId);
   const offset = Math.max(1, lastCompartmentEnd + 1);
@@ -183082,7 +183541,7 @@ async function runCompartmentAgent(deps) {
       currentContextLimit: deps.currentContextLimit ?? boundarySnapshot.contextLimit
     }) : { ok: true };
     if (!validation.ok && validation.reason === "stale_snapshot") {
-      const refreshed = resolveOpenCodeProtectedTailBoundary({
+      const refreshed = deps.refreshBoundarySnapshot ? deps.refreshBoundarySnapshot(boundarySnapshot, validation) : resolveOpenCodeProtectedTailBoundary({
         db,
         sessionId,
         mode: "incremental-runner",
@@ -183095,7 +183554,7 @@ async function runCompartmentAgent(deps) {
         usageSource: boundarySnapshot.usageSource,
         emergencyTailScale: boundarySnapshot.emergencyTailScale
       });
-      if (hasRunnableCompartmentWindow(refreshed)) {
+      if (refreshed && hasRunnableCompartmentWindow(refreshed)) {
         sessionLog(sessionId, `historian: refreshed stale protected-tail snapshot at run time (was: ${validation.detail ?? "stale"}) — eligible head ${refreshed.offset}-${refreshed.eligibleEndOrdinal - 1}`);
         boundarySnapshot = refreshed;
         validation = { ok: true };
@@ -183113,7 +183572,8 @@ async function runCompartmentAgent(deps) {
     if (protectedTailStart <= offset || eligibleEndOrdinal <= offset) {
       sessionLog(sessionId, `historian no-op: protectedTailStart=${protectedTailStart} eligibleEnd=${eligibleEndOrdinal} <= offset=${offset} — nothing to compact`);
       if (boundarySnapshot.usagePercentage < 80 && !boundarySnapshot.emergencyTailScale) {
-        clearEmergencyRecovery(db, sessionId);
+        if (!isWrapupInProgress(db, sessionId))
+          clearEmergencyRecovery(db, sessionId);
       } else {
         const count = recordHighPressureNoEligibleHead(db, boundarySnapshot);
         sessionLog(sessionId, `historian high-pressure no-op: recovery remains armed (noEligibleHeadCount=${count})`);
@@ -183126,7 +183586,7 @@ async function runCompartmentAgent(deps) {
     }
     const perRunCap = selectPerRunCap(boundarySnapshot);
     const usable = Math.max(1, Math.round(boundarySnapshot.contextLimit * boundarySnapshot.executeThresholdPercentage / 100));
-    const reserve = reserveProtectedTailDrainTokens({
+    const reserve = deps.forceDrainQuota ? { ok: true, reservation: null } : reserveProtectedTailDrainTokens({
       db,
       sessionId,
       runId: crypto.randomUUID(),
@@ -183144,12 +183604,14 @@ async function runCompartmentAgent(deps) {
     }
     drainReservation = reserve.reservation;
     const chunk = readSessionChunk(sessionId, historianChunkTokens, offset, eligibleEndOrdinal);
+    const forceKeepLastCompartmentForChunk = deps.forceKeepLastCompartment === true && !chunk.hasMore;
     telemetry.chunkStartOrdinal = chunk.startIndex;
     telemetry.chunkEndOrdinal = chunk.endIndex;
     if (!chunk.text || chunk.messageCount === 0) {
       sessionLog(sessionId, `historian no-op: chunk empty after filtering (messageCount=${chunk.messageCount}, textLen=${chunk.text?.length ?? 0}) range=${offset}-${eligibleEndOrdinal - 1}`);
       if (boundarySnapshot.usagePercentage < 80 && !boundarySnapshot.emergencyTailScale) {
-        clearEmergencyRecovery(db, sessionId);
+        if (!isWrapupInProgress(db, sessionId))
+          clearEmergencyRecovery(db, sessionId);
       } else {
         recordHighPressureNoEligibleHead(db, boundarySnapshot);
       }
@@ -183223,7 +183685,7 @@ ${chunkText}`,
     const BOUNDARY_HEALING_SLACK = 2;
     const inEmergency = getOverflowState(db, sessionId).needsEmergencyRecovery;
     let persistedCompartments = emittedCompartments;
-    if (!inEmergency && emittedCompartments.length >= 2) {
+    if (!inEmergency && !forceKeepLastCompartmentForChunk && emittedCompartments.length >= 2) {
       const lastEmitted = emittedCompartments[emittedCompartments.length - 1];
       const lookaheadMargin = chunk.endIndex - lastEmitted.endMessage;
       if (lookaheadMargin <= BOUNDARY_HEALING_SLACK) {
@@ -183247,10 +183709,21 @@ ${chunkText}`,
     const lastNewEndMessageId = newCompartments[newCompartments.length - 1]?.endMessageId;
     const promotionDirectory = sessionDirectory || deps.directory;
     const discardedLast = persistedCompartments.length < emittedCompartments.length;
+    const weakLookaheadFinalCompartment = forceKeepLastCompartmentForChunk;
+    const skipUnanchoredPromotion = discardedLast || weakLookaheadFinalCompartment;
     const embeddingActive = !!promotionDirectory && deps.memoryEnabled !== false;
     const promotionActive = embeddingActive && deps.autoPromote !== false;
     const promotionProjectIdentity = promotionDirectory ? resolveProjectIdentity(promotionDirectory) : "";
-    const publishableEvents = (validatedPass.events ?? []).filter((e) => e.atCompartment == null || e.atCompartment <= persistedCompartments.length);
+    const publishableEvents = (validatedPass.events ?? []).filter((e) => {
+      if (typeof e.atCompartment !== "number")
+        return !weakLookaheadFinalCompartment;
+      if (e.atCompartment > persistedCompartments.length)
+        return false;
+      if (weakLookaheadFinalCompartment && e.atCompartment >= emittedCompartments.length) {
+        return false;
+      }
+      return true;
+    });
     let promotedFactRefs = [];
     let persistedIds = [];
     const holderId = deps.compartmentLeaseHolderId;
@@ -183270,7 +183743,7 @@ ${chunkText}`,
       }
       appendCompartments(db, sessionId, persistedCompartments);
       persistedIds = getCompartments(db, sessionId).slice(-persistedCompartments.length).map((c) => c.id);
-      if (promotionActive && !discardedLast) {
+      if (promotionActive && !skipUnanchoredPromotion) {
         promotedFactRefs = promoteSessionFactsDurable(db, sessionId, promotionProjectIdentity, validatedPass.facts ?? []);
       }
       if (publishableEvents.length > 0) {
@@ -183285,7 +183758,8 @@ ${chunkText}`,
       clearHistorianFailureState(db, sessionId);
       clearHistorianDrainFailure(db, sessionId);
       recordProtectedTailPublicationFloor(db, sessionId, lastCompartmentEnd + 1);
-      clearEmergencyRecovery(db, sessionId);
+      if (!isWrapupInProgress(db, sessionId))
+        clearEmergencyRecovery(db, sessionId);
       drainReservation = null;
       if (deferMarkerApplication && lastNewEndMessageId) {
         setPendingCompactionMarkerState(db, sessionId, {
@@ -183357,7 +183831,7 @@ ${chunkText}`,
         }
       })();
     }
-    if (deps.experimentalUserMemories === true && !discardedLast && validatedPass.userObservations && validatedPass.userObservations.length > 0) {
+    if (deps.experimentalUserMemories === true && !skipUnanchoredPromotion && validatedPass.userObservations && validatedPass.userObservations.length > 0) {
       try {
         const lastNew = newCompartments[newCompartments.length - 1];
         insertUserMemoryCandidates(db, validatedPass.userObservations.map((obs) => ({
@@ -183371,7 +183845,7 @@ ${chunkText}`,
         sessionLog(sessionId, "failed to store user memory candidates:", error51);
       }
     }
-    if (!discardedLast && promotionProjectIdentity && validatedPass.primerCandidates && validatedPass.primerCandidates.length > 0) {
+    if (!skipUnanchoredPromotion && promotionProjectIdentity && validatedPass.primerCandidates && validatedPass.primerCandidates.length > 0) {
       try {
         const firstNew = newCompartments[0];
         const lastNew = newCompartments[newCompartments.length - 1];
@@ -184238,6 +184712,21 @@ function markActiveCompartmentRunPublished(sessionId) {
   if (activeRun)
     activeRun.published = true;
 }
+function registerActiveCompartmentRun(sessionId, promise2, kind = "other") {
+  const activeRun = {
+    promise: Promise.resolve(),
+    published: false,
+    kind
+  };
+  const wrapped = promise2.finally(() => {
+    if (activeRuns.get(sessionId)?.promise === wrapped) {
+      activeRuns.delete(sessionId);
+    }
+  });
+  activeRun.promise = wrapped;
+  activeRuns.set(sessionId, activeRun);
+  return activeRun;
+}
 function withPublishedCallback(deps) {
   return {
     ...deps,
@@ -184249,8 +184738,12 @@ function withPublishedCallback(deps) {
 }
 function startLeaseRenewal(deps, holderId) {
   return setInterval(() => {
-    if (!renewCompartmentLease(deps.db, deps.sessionId, holderId)) {
-      sessionLog(deps.sessionId, "compartment lease renewal failed; publish will be skipped if holder is stale");
+    try {
+      if (!renewCompartmentLease(deps.db, deps.sessionId, holderId)) {
+        sessionLog(deps.sessionId, "compartment lease renewal failed; publish will be skipped if holder is stale");
+      }
+    } catch (err) {
+      sessionLog(deps.sessionId, `compartment lease renewal threw; publish will be skipped if holder is stale (${err instanceof Error ? err.message : String(err)})`);
     }
   }, COMPARTMENT_LEASE_RENEWAL_MS);
 }
@@ -184259,6 +184752,11 @@ function startCompartmentAgent(deps) {
   if (existing) {
     return;
   }
+  if (isWrapupInProgress(deps.db, deps.sessionId)) {
+    sessionLog(deps.sessionId, "compartment agent skipped: /ctx-wrapup is active");
+    updateSessionMeta(deps.db, deps.sessionId, { compartmentInProgress: false });
+    return;
+  }
   const holderId = crypto.randomUUID();
   const lease = acquireCompartmentLease(deps.db, deps.sessionId, holderId);
   if (!lease) {
@@ -184266,6 +184764,12 @@ function startCompartmentAgent(deps) {
     updateSessionMeta(deps.db, deps.sessionId, { compartmentInProgress: false });
     return;
   }
+  if (isWrapupInProgress(deps.db, deps.sessionId)) {
+    sessionLog(deps.sessionId, "compartment agent skipped: /ctx-wrapup became active");
+    releaseCompartmentLease(deps.db, deps.sessionId, holderId);
+    updateSessionMeta(deps.db, deps.sessionId, { compartmentInProgress: false });
+    return;
+  }
   const renewal = startLeaseRenewal(deps, holderId);
   let realRunStarted = false;
   const runnerDeps = withPublishedCallback({
@@ -184287,13 +184791,19 @@ function startCompartmentAgent(deps) {
       activeRuns.delete(deps.sessionId);
     }
   });
-  activeRuns.set(deps.sessionId, { promise: promise2, published: false });
+  activeRuns.set(deps.sessionId, { promise: promise2, published: false, kind: "incremental" });
   if (!realRunStarted && activeRuns.get(deps.sessionId)?.promise === promise2) {
     activeRuns.delete(deps.sessionId);
   }
 }
 async function executeContextRecompWithResult(deps, options = {}) {
   const { sessionId } = deps;
+  if (isWrapupInProgress(deps.db, sessionId)) {
+    return {
+      message: "## Magic Recomp — Skipped\n\n/ctx-wrapup is already compacting this session. Wait for it to finish, then try `/ctx-recomp` again.",
+      published: false
+    };
+  }
   if (activeRuns.has(sessionId)) {
     return {
       message: "## Magic Recomp — Skipped\n\nHistorian is already running for this session. Wait for it to finish, then try `/ctx-recomp` again.",
@@ -184317,7 +184827,7 @@ async function executeContextRecompWithResult(deps, options = {}) {
   }).catch((err) => {
     sessionLog(sessionId, "compartment agent: recomp unhandled rejection:", err);
   });
-  activeRuns.set(sessionId, { promise: wrappedPromise, published: false });
+  activeRuns.set(sessionId, { promise: wrappedPromise, published: false, kind: "recomp" });
   try {
     const message = await promise2;
     const published = activeRuns.get(sessionId)?.published === true;
@@ -184745,6 +185255,13 @@ Recomp crashed: ${String(error51)}`;
   }
 }
 async function runManagedUpgrade(ctx, sessionId) {
+  if (isWrapupInProgress(ctx.db, sessionId)) {
+    const message = "/ctx-wrapup is already compacting this session. Wait for it to finish, then try `/ctx-session-upgrade` again.";
+    setRecompTerminal(ctx.liveSessionState, sessionId, "skipped", message);
+    return `## Session Upgrade — Skipped
+
+${message}`;
+  }
   setRecompStarting(ctx.liveSessionState, sessionId, "Starting upgrade…", "upgrade");
   try {
     const compartments = getCompartments(ctx.db, sessionId);
@@ -184899,13 +185416,14 @@ function shouldShowAnnouncement() {
   }
   return ordering > 0;
 }
-var ANNOUNCEMENT_VERSION = "0.30.4", ANNOUNCEMENT_FEATURES, ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/F2uWxjGnU", STATE_FILENAME = "last_announced_version";
+var ANNOUNCEMENT_VERSION = "0.31.0", ANNOUNCEMENT_FEATURES, ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/F2uWxjGnU", STATE_FILENAME = "last_announced_version";
 var init_announcement = __esm(() => {
   init_data_path();
   ANNOUNCEMENT_FEATURES = [
-    "Pi: fixed historian and dreamer failing when your model comes from a provider extension (Antigravity, Anthropic OAuth, etc.). Subagents now load your extensions.",
-    "Pi: fixed the retrospective and refresh-primers dreamer tasks reading sessions through the wrong API.",
-    "OpenCode: the plugin no longer re-adds its TUI sidebar entry on startup, so removing it from tui.jsonc now sticks."
+    "New /ctx-wrapup command: compact older history on demand, keeping the newest N messages raw. Run it before switching to a smaller-context model.",
+    "ctx_search now also searches your session notes and smart notes.",
+    "Project identity now survives transient git failures (slow disks, dubious ownership) without splitting your project memory.",
+    "Removed the ctx_reduce_enabled setting; agent-controlled reduction is always on. Caveman text compression is now independent (caveman_text_compression.enabled)."
   ];
 });
 
@@ -186333,6 +186851,10 @@ function getMagicContextBuiltinCommands() {
       template: "ctx-recomp",
       description: "Rebuild compartments and facts from raw history (full or <start>-<end> range)"
     },
+    "ctx-wrapup": {
+      template: "ctx-wrapup",
+      description: "Compact older live history while keeping the newest messages raw"
+    },
     "ctx-session-upgrade": {
       template: "ctx-session-upgrade",
       description: "Upgrade this session to the latest history format: rebuild compartments and migrate project memories"
@@ -186692,7 +187214,7 @@ init_project_identity();
 init_logger();
 init_project_identity();
 init_session_project_storage();
-import { existsSync as existsSync8 } from "node:fs";
+import { existsSync as existsSync9 } from "node:fs";
 var LEASE_TTL_MS = 10 * 60 * 1000;
 var SESSION_QUERY_CHUNK_SIZE = 250;
 var YIELD_EVERY_NEW_DIRECTORIES = 10;
@@ -186848,7 +187370,7 @@ async function runSessionProjectBackfill(db, sessions, options = {}) {
       result.skippedEmptyDirectories += 1;
       continue;
     }
-    const stillExists = existenceCache.get(session.directory) ?? existsSync8(session.directory);
+    const stillExists = existenceCache.get(session.directory) ?? existsSync9(session.directory);
     existenceCache.set(session.directory, stillExists);
     if (!stillExists) {
       result.skippedDeadDirectories += 1;
@@ -187037,7 +187559,7 @@ await init_storage_db();
 init_logger();
 init_project_identity();
 import { createHash as createHash5 } from "node:crypto";
-import { realpathSync } from "node:fs";
+import { realpathSync as realpathSync2 } from "node:fs";
 import path5 from "node:path";
 
 // src/features/magic-context/memory/relocate-memory.ts
@@ -187071,7 +187593,10 @@ function countFailures(db) {
 }
 function classifyBackfillError(error51) {
   if (error51 instanceof ProjectIdentityError) {
-    return { errorClass: error51.errorClass, errorMessage: error51.message };
+    return {
+      errorClass: error51.errorClass === "dubious_ownership" ? "unknown" : error51.errorClass,
+      errorMessage: error51.message
+    };
   }
   if (error51 instanceof Error) {
     return { errorClass: "unknown", errorMessage: error51.message };
@@ -187091,7 +187616,7 @@ function resolveBackfillIdentity(rawProjectPath) {
 function computeLegacyRustDirIdentity(rawProjectPath) {
   let canonical;
   try {
-    canonical = realpathSync(rawProjectPath);
+    canonical = realpathSync2(rawProjectPath);
   } catch {
     canonical = path5.isAbsolute(rawProjectPath) ? rawProjectPath : path5.join(process.cwd(), rawProjectPath);
   }
@@ -187264,20 +187789,20 @@ async function runDeferredV22Backfill(db, options = {}) {
 
 // src/hooks/auto-update-checker/index.ts
 init_logger();
-import { existsSync as existsSync14, mkdirSync as mkdirSync5, readFileSync as readFileSync9, renameSync as renameSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync5, readFileSync as readFileSync9, renameSync as renameSync3, writeFileSync as writeFileSync5 } from "node:fs";
 import { dirname as dirname7, join as join10 } from "node:path";
 
 // src/hooks/auto-update-checker/cache.ts
 init_logger();
 var import_comment_json2 = __toESM(require_src2(), 1);
 import { spawn } from "node:child_process";
-import { existsSync as existsSync13, readFileSync as readFileSync8, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync14, readFileSync as readFileSync8, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "node:fs";
 import { basename as basename2, dirname as dirname6, join as join9 } from "node:path";
 
 // src/hooks/auto-update-checker/checker.ts
 init_logger();
 var import_comment_json = __toESM(require_src2(), 1);
-import { existsSync as existsSync12, readFileSync as readFileSync7, renameSync as renameSync2, statSync as statSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync13, readFileSync as readFileSync7, renameSync as renameSync2, statSync as statSync4, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
 import { dirname as dirname5, isAbsolute as isAbsolute3, join as join8, resolve as resolve2 } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -187387,7 +187912,7 @@ function findPackageJsonUp(startPath) {
     let dir = stat.isDirectory() ? startPath : dirname5(startPath);
     for (let i = 0;i < 10; i++) {
       const pkgPath = join8(dir, "package.json");
-      if (existsSync12(pkgPath)) {
+      if (existsSync13(pkgPath)) {
         try {
           const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync7(pkgPath, "utf-8")));
           if (pkg.success && pkg.data.name === PACKAGE_NAME)
@@ -187405,7 +187930,7 @@ function findPackageJsonUp(startPath) {
 function getLocalDevPath(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!existsSync12(configPath))
+      if (!existsSync13(configPath))
         continue;
       const rawConfig = parseJsonConfig(readFileSync7(configPath, "utf-8"));
       const plugins = getPluginEntries(rawConfig);
@@ -187451,7 +187976,7 @@ function getCurrentRuntimePackageJsonPath(currentModuleUrl = import.meta.url) {
 function findPluginEntry(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!existsSync12(configPath))
+      if (!existsSync13(configPath))
         continue;
       const rawConfig = parseJsonConfig(readFileSync7(configPath, "utf-8"));
       const plugins = getPluginEntries(rawConfig);
@@ -187489,7 +188014,7 @@ function getCachedVersion(spec) {
   ].filter(isString);
   for (const packageJsonPath of candidates) {
     try {
-      if (!existsSync12(packageJsonPath))
+      if (!existsSync13(packageJsonPath))
         continue;
       const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync7(packageJsonPath, "utf-8")));
       if (pkg.success && pkg.data.version) {
@@ -187544,7 +188069,7 @@ function stripPackageNameFromPath(pathValue, packageName) {
 }
 function removeFromPackageLock(installDir, packageName) {
   const lockPath = join9(installDir, "package-lock.json");
-  if (!existsSync13(lockPath))
+  if (!existsSync14(lockPath))
     return false;
   try {
     const lock = import_comment_json2.parse(readFileSync8(lockPath, "utf-8"));
@@ -187570,7 +188095,7 @@ function removeFromPackageLock(installDir, packageName) {
   }
 }
 function ensureDependencyVersion(packageJsonPath, packageName, version2) {
-  if (!existsSync13(packageJsonPath))
+  if (!existsSync14(packageJsonPath))
     return false;
   try {
     const raw = import_comment_json2.parse(readFileSync8(packageJsonPath, "utf-8"));
@@ -187593,7 +188118,7 @@ function ensureDependencyVersion(packageJsonPath, packageName, version2) {
 }
 function removeInstalledPackage(installDir, packageName) {
   const packageDir = join9(installDir, "node_modules", packageName);
-  if (!existsSync13(packageDir))
+  if (!existsSync14(packageDir))
     return false;
   try {
     rmSync2(packageDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
@@ -187615,7 +188140,7 @@ function resolveInstallContext(runtimePackageJsonPath = getCurrentRuntimePackage
     if (nodeModulesDir && basename2(nodeModulesDir) === "node_modules") {
       const installDir = dirname6(nodeModulesDir);
       const packageJsonPath = join9(installDir, "package.json");
-      if (!existsSync13(packageJsonPath)) {
+      if (!existsSync14(packageJsonPath)) {
         try {
           writeFileSync4(packageJsonPath, `${JSON.stringify({ private: true, dependencies: {} }, null, 2)}
 `);
@@ -187630,7 +188155,7 @@ function resolveInstallContext(runtimePackageJsonPath = getCurrentRuntimePackage
     return null;
   }
   const legacyPackageJsonPath = join9(dirname6(CACHE_DIR), "package.json");
-  if (existsSync13(legacyPackageJsonPath)) {
+  if (existsSync14(legacyPackageJsonPath)) {
     return { installDir: dirname6(CACHE_DIR), packageJsonPath: legacyPackageJsonPath };
   }
   return null;
@@ -187755,7 +188280,7 @@ function claimCheckSlot(storageDir, intervalMs) {
     return true;
   try {
     const file2 = join10(storageDir, TIMESTAMP_FILENAME);
-    if (existsSync14(file2)) {
+    if (existsSync15(file2)) {
       try {
         const raw = JSON.parse(readFileSync9(file2, "utf-8"));
         const last = typeof raw.lastCheckedMs === "number" ? raw.lastCheckedMs : 0;
@@ -188483,7 +189008,7 @@ init_task_config();
 
 // src/features/magic-context/dreamer/task-executor.ts
 import { createHash as createHash10 } from "node:crypto";
-import { existsSync as existsSync19 } from "node:fs";
+import { existsSync as existsSync20 } from "node:fs";
 
 // src/agents/dreamer.ts
 var DREAMER_AGENT = "dreamer";
@@ -190570,7 +191095,7 @@ Output exactly JSON: {"met": false}`;
 
 // src/features/magic-context/dreamer/maintain-docs-protected-enforcement.ts
 init_logger();
-import { existsSync as existsSync17, readFileSync as readFileSync11, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync18, readFileSync as readFileSync11, writeFileSync as writeFileSync6 } from "node:fs";
 import { join as join15 } from "node:path";
 
 // src/features/magic-context/dreamer/protected-regions.ts
@@ -190674,7 +191199,7 @@ function snapshotMaintainDocsFiles(docsDir) {
   for (const name2 of MAINTAIN_DOCS_SNAPSHOT_FILES) {
     const path8 = join15(docsDir, name2);
     try {
-      if (existsSync17(path8)) {
+      if (existsSync18(path8)) {
         snapshot.set(name2, readFileSync11(path8, "utf8"));
       }
     } catch {}
@@ -190706,7 +191231,7 @@ init_memory();
 init_subagent_token_capture();
 
 // src/features/magic-context/dreamer/map-memories-prompt.ts
-import { existsSync as existsSync18, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync19, statSync as statSync6 } from "node:fs";
 import path8 from "node:path";
 var MAP_MEMORIES_SYSTEM_PROMPT = `You are a memory mapper for the magic-context system. You map project memories to the repository files that back them.
 
@@ -190744,7 +191269,7 @@ function extractMemoryCandidatePaths(content, repoDir) {
     if (!abs.startsWith(`${root}/`))
       continue;
     try {
-      if (existsSync18(abs) && statSync6(abs).isFile())
+      if (existsSync19(abs) && statSync6(abs).isFile())
         found.add(rel);
     } catch {}
     if (found.size >= MAX_SEED_PATHS_PER_MEMORY)
@@ -192573,8 +193098,8 @@ async function runAgenticTask(config2, ctx, helpers) {
   const lastRunAt = getTaskScheduleState(db, projectIdentity, config2.task)?.lastRunAt ?? null;
   const maintainDocsSnapshot = task === "maintain-docs" ? snapshotMaintainDocsFiles(docsDir) : undefined;
   const existingDocs = task === "maintain-docs" ? {
-    architecture: existsSync19(`${docsDir}/ARCHITECTURE.md`),
-    structure: existsSync19(`${docsDir}/STRUCTURE.md`)
+    architecture: existsSync20(`${docsDir}/ARCHITECTURE.md`),
+    structure: existsSync20(`${docsDir}/STRUCTURE.md`)
   } : undefined;
   const userMemories = task === "curate" ? getActiveUserMemories(db).map((um) => ({ id: um.id, content: um.content })) : undefined;
   let curateMemories;
@@ -194741,6 +195266,17 @@ ${c.content}
 init_send_session_notification();
 var recompConfirmationBySession = new Map;
 var RECOMP_CONFIRMATION_WINDOW_MS = 60000;
+function isSubagentSession(db, sessionId) {
+  const meta3 = getOrCreateSessionMeta(db, sessionId);
+  if (meta3.isSubagent)
+    return true;
+  try {
+    const row = db.prepare("SELECT is_subagent FROM session_meta WHERE session_id = ?").get(sessionId);
+    return row?.is_subagent === 1 || row?.is_subagent === true;
+  } catch {
+    return false;
+  }
+}
 var RECOMP_USAGE = [
   "Usage:",
   "- `/ctx-recomp` — full rebuild from message 1 to the protected tail",
@@ -194779,6 +195315,22 @@ ${RECOMP_USAGE}`
   }
   return { kind: "partial", range: { start, end } };
 }
+function parseWrapupArgs(raw) {
+  const trimmed = raw.trim();
+  if (trimmed === "")
+    return { ok: true, messagesToKeep: 20 };
+  if (!/^\d+$/.test(trimmed)) {
+    return {
+      ok: false,
+      message: "Usage: `/ctx-wrapup [messages_to_keep]` where messages_to_keep is a positive integer."
+    };
+  }
+  const messagesToKeep = Number.parseInt(trimmed, 10);
+  if (!Number.isSafeInteger(messagesToKeep) || messagesToKeep <= 0) {
+    return { ok: false, message: "messages_to_keep must be a positive integer." };
+  }
+  return { ok: true, messagesToKeep };
+}
 var SENTINEL_PREFIX = "__CONTEXT_MANAGEMENT_";
 var HTTP_SERVER_RESPONSE_TYPE_ID = "~effect/http/HttpServerResponse";
 var HTTP_COOKIES_TYPE_ID = "~effect/http/Cookies";
@@ -194920,6 +195472,7 @@ function createMagicContextCommandHandler(deps) {
   const isStatusCommand = (command) => command === "ctx-status";
   const isFlushCommand = (command) => command === "ctx-flush";
   const isRecompCommand = (command) => command === "ctx-recomp";
+  const isWrapupCommand = (command) => command === "ctx-wrapup";
   const isAugCommand = (command) => command === "ctx-aug";
   const isDreamCommand = (command) => command === "ctx-dream";
   const isSessionUpgradeCommand = (command) => command === "ctx-session-upgrade";
@@ -194929,11 +195482,12 @@ function createMagicContextCommandHandler(deps) {
       const isStatus = isStatusCommand(input.command);
       const isFlush = isFlushCommand(input.command);
       const isRecomp = isRecompCommand(input.command);
+      const isWrapup = isWrapupCommand(input.command);
       const isAug = isAugCommand(input.command);
       const isDream = isDreamCommand(input.command);
       const isSessionUpgrade = isSessionUpgradeCommand(input.command);
       const isEmbed = isEmbedCommand(input.command);
-      if (!isStatus && !isFlush && !isRecomp && !isAug && !isDream && !isSessionUpgrade && !isEmbed) {
+      if (!isStatus && !isFlush && !isRecomp && !isWrapup && !isAug && !isDream && !isSessionUpgrade && !isEmbed) {
         return;
       }
       const sessionId = input.sessionID;
@@ -195003,6 +195557,26 @@ Embedding status is unavailable.`;
 
 ${statusOutput}` : statusOutput;
       }
+      if (isWrapup) {
+        const parsed = parseWrapupArgs(input.arguments);
+        if (isSubagentSession(deps.db, sessionId)) {
+          result = `## Magic Wrapup — Skipped
+
+/ctx-wrapup is only available in primary sessions.`;
+        } else if (!parsed.ok) {
+          result = `## Magic Wrapup — Invalid Arguments
+
+${parsed.message}`;
+        } else if (!deps.executeWrapup) {
+          result = `## Magic Wrapup
+
+/ctx-wrapup is unavailable because the historian handler is not configured.`;
+        } else {
+          result = await deps.executeWrapup(sessionId, {
+            messagesToKeep: parsed.messagesToKeep
+          });
+        }
+      }
       if (isRecomp) {
         const parsedArgs = parseRecompArgs(input.arguments);
         if (parsedArgs.kind === "error") {
@@ -195309,7 +195883,8 @@ var canonicalReasons = new Set([
   "first_render",
   "pressure_refold",
   "upgrade_state",
-  "cached_m1_missing"
+  "cached_m1_missing",
+  "project_change"
 ]);
 var piReasonAliases = {
   project_memory_change: "project_memory_epoch",
@@ -196240,35 +196815,31 @@ function resolveCtxReduceAvailabilityFromMessages(sessionId, messages) {
   for (const message of messages) {
     if (message.info?.role !== "user")
       continue;
-    const verdict = verdictFromToolsMap(message.info.tools);
-    if (verdict !== null) {
-      availabilityBySession.set(sessionId, verdict);
-      return verdict;
-    }
-    break;
+    const verdict = verdictFromToolsMap(message.info.tools) ?? true;
+    availabilityBySession.set(sessionId, verdict);
+    return verdict;
   }
-  availabilityBySession.set(sessionId, true);
   return true;
 }
 function resolveCtxReduceAvailability(sessionId) {
   const cached2 = availabilityBySession.get(sessionId);
   if (cached2 !== undefined)
-    return cached2;
+    return { callable: cached2, frozen: true };
   if (!openCodeDbExists())
-    return true;
+    return { callable: true, frozen: true };
   try {
     const row = withReadOnlySessionDb((db) => db.prepare(`SELECT json_extract(data, '$.tools') AS tools FROM message
                           WHERE session_id = ? AND json_extract(data, '$.role') = 'user'
                           ORDER BY time_created ASC LIMIT 1`).get(sessionId));
     if (!row)
-      return true;
+      return { callable: true, frozen: false };
     const verdict = row.tools === null ? null : verdictFromToolsMap(JSON.parse(row.tools));
     const resolved = verdict ?? true;
     availabilityBySession.set(sessionId, resolved);
-    return resolved;
+    return { callable: resolved, frozen: true };
   } catch (error51) {
     sessionLog(sessionId, "ctx_reduce availability read failed (fail-open):", error51);
-    return true;
+    return { callable: true, frozen: false };
   }
 }
 
@@ -197957,6 +198528,7 @@ function containsProbeVerbatim(text, probes) {
 init_memory();
 init_embedding();
 init_storage_memory_fts();
+init_storage_notes();
 init_storage_primers();
 init_workspaces();
 var DEFAULT_UNIFIED_SEARCH_LIMIT = 10;
@@ -198360,6 +198932,147 @@ function searchMessages(args) {
     role: entry.row.role
   }));
 }
+var NOTE_SEARCHABLE_STATUSES = ["active", "pending", "ready", "dismissed"];
+function noteSearchText(note) {
+  const reason = note.readyReason?.trim();
+  return reason ? `${note.content}
+Reason: ${reason}` : note.content;
+}
+function tokenizeKeywordNeedle(text) {
+  const matches = text.toLowerCase().match(/[a-z0-9/._:-]+/g) ?? [];
+  const seen = new Set;
+  const tokens = [];
+  for (const match of matches) {
+    if (match.length <= 1 || !/[a-z0-9]/.test(match) || seen.has(match)) {
+      continue;
+    }
+    seen.add(match);
+    tokens.push(match);
+  }
+  return tokens;
+}
+function rankNotesForNeedle(notes, needle) {
+  const normalizedNeedle = needle.trim().toLowerCase();
+  if (normalizedNeedle.length === 0) {
+    return [];
+  }
+  const needleTokens = tokenizeKeywordNeedle(normalizedNeedle);
+  const ranked = [];
+  for (const note of notes) {
+    const text = noteSearchText(note);
+    const normalizedText = text.toLowerCase();
+    const noteTokens = new Set(tokenizeKeywordNeedle(normalizedText));
+    const exact = normalizedText.includes(normalizedNeedle);
+    const matchedTokens = needleTokens.filter((token) => noteTokens.has(token)).length;
+    if (!exact && matchedTokens === 0) {
+      continue;
+    }
+    const coverage = needleTokens.length > 0 ? matchedTokens / needleTokens.length : 0;
+    const score = (exact ? 2 : 0) + coverage + (needleTokens.length > 1 && matchedTokens === needleTokens.length ? 0.5 : 0);
+    ranked.push({ note, score, text });
+  }
+  return ranked.sort((left, right) => {
+    if (right.score !== left.score) {
+      return right.score - left.score;
+    }
+    if (right.note.createdAt !== left.note.createdAt) {
+      return right.note.createdAt - left.note.createdAt;
+    }
+    return left.note.id - right.note.id;
+  });
+}
+function searchNotes(args) {
+  if (args.limit <= 0) {
+    return [];
+  }
+  const notes = [
+    ...getNotes(args.db, {
+      sessionId: args.sessionId,
+      type: "session",
+      status: NOTE_SEARCHABLE_STATUSES
+    }),
+    ...getNotes(args.db, {
+      projectPath: args.projectPath,
+      type: "smart",
+      status: NOTE_SEARCHABLE_STATUSES
+    })
+  ];
+  if (notes.length === 0) {
+    return [];
+  }
+  const baseList = rankNotesForNeedle(notes, args.query);
+  const probes = args.probes ?? [];
+  if (probes.length === 0) {
+    const ranked2 = baseList.slice(0, args.limit);
+    return ranked2.map((entry, rank) => ({
+      source: "note",
+      content: previewText(entry.text),
+      score: linearDecayScore(rank, ranked2.length),
+      noteId: entry.note.id,
+      status: entry.note.status,
+      createdAt: entry.note.createdAt,
+      anchorOrdinal: entry.note.anchorOrdinal,
+      sourceSessionId: entry.note.sessionId
+    }));
+  }
+  const queryLists = [];
+  if (baseList.length > 0) {
+    queryLists.push({ rows: baseList, weight: 1 });
+  }
+  const probeWeights = new Map;
+  for (const probe of probes) {
+    const rows = rankNotesForNeedle(notes, probe);
+    if (rows.length === 0) {
+      continue;
+    }
+    const weight = probeDiscriminationWeight(rows.length, notes.length);
+    probeWeights.set(probe, weight);
+    queryLists.push({ rows, weight });
+  }
+  const fused = new Map;
+  for (const list of queryLists) {
+    list.rows.forEach((row, rank) => {
+      const rrf = list.weight / (RRF_K + rank);
+      const existing = fused.get(row.note.id);
+      if (existing) {
+        existing.score += rrf;
+      } else {
+        fused.set(row.note.id, { entry: row, score: rrf });
+      }
+    });
+  }
+  for (const match of fused.values()) {
+    let best = 0;
+    for (const probe of probes) {
+      const weight = probeWeights.get(probe) ?? 0;
+      if (weight > best && containsProbeVerbatim(match.entry.text, [probe])) {
+        best = weight;
+      }
+    }
+    if (best > 0) {
+      match.score += best * VERBATIM_RANK_BONUS;
+    }
+  }
+  const ranked = [...fused.values()].sort((left, right) => {
+    if (right.score !== left.score) {
+      return right.score - left.score;
+    }
+    if (right.entry.note.createdAt !== left.entry.note.createdAt) {
+      return right.entry.note.createdAt - left.entry.note.createdAt;
+    }
+    return left.entry.note.id - right.entry.note.id;
+  }).slice(0, args.limit);
+  return ranked.map((entry, rank) => ({
+    source: "note",
+    content: previewText(entry.entry.text),
+    score: linearDecayScore(rank, ranked.length),
+    noteId: entry.entry.note.id,
+    status: entry.entry.note.status,
+    createdAt: entry.entry.note.createdAt,
+    anchorOrdinal: entry.entry.note.anchorOrdinal,
+    sourceSessionId: entry.entry.note.sessionId
+  }));
+}
 function searchCompartmentChunks(args) {
   if (!args.queryEmbedding || args.limit <= 0 || !args.modelId || args.modelId === "off")
     return [];
@@ -198445,6 +199158,8 @@ function getSourceBoost(result) {
       return GIT_COMMIT_SOURCE_BOOST;
     case "primer":
       return PRIMER_SOURCE_BOOST;
+    case "note":
+      return 1;
   }
 }
 function compareUnifiedResults(left, right) {
@@ -198468,6 +199183,9 @@ function compareUnifiedResults(left, right) {
   if (left.source === "primer" && right.source === "primer") {
     return right.support - left.support || left.primerId - right.primerId;
   }
+  if (left.source === "note" && right.source === "note") {
+    return right.createdAt - left.createdAt || left.noteId - right.noteId;
+  }
   return 0;
 }
 function toGitCommitResult(hit) {
@@ -198535,11 +199253,11 @@ function searchPrimers(args) {
 }
 function resolveSources(sources) {
   if (sources === undefined) {
-    return new Set(["memory", "message", "git_commit", "primer"]);
+    return new Set(["memory", "message", "git_commit", "primer", "note"]);
   }
   const set2 = new Set;
   for (const source of sources) {
-    if (source === "memory" || source === "message" || source === "git_commit" || source === "primer") {
+    if (source === "memory" || source === "message" || source === "git_commit" || source === "primer" || source === "note") {
       set2.add(source);
     }
   }
@@ -198562,6 +199280,7 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
   const runMessages = activeSources.has("message");
   const runGitCommits = activeSources.has("git_commit") && gitCommitsEnabled;
   const runPrimers = activeSources.has("primer") && memoryFeatureEnabled;
+  const runNotes = activeSources.has("note");
   const runCompartmentChunks = runMessages && memoryFeatureEnabled && embeddingEnabled;
   const needsEmbedding = (runMemory || runGitCommits || runCompartmentChunks || runPrimers) && embeddingEnabled && isEmbeddingRuntimeEnabled();
   const queryEmbeddingPromise = needsEmbedding ? embedQuery(trimmedQuery, options.signal).catch((error51) => {
@@ -198597,7 +199316,7 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
     compartments: compartmentResults,
     limit: tierLimit
   });
-  const [memoryResults, gitCommitResults, primerResults] = await Promise.all([
+  const [memoryResults, gitCommitResults, primerResults, noteResults] = await Promise.all([
     runMemory ? searchMemories({
       db,
       projectPath,
@@ -198624,9 +199343,23 @@ async function unifiedSearch(db, sessionId, projectPath, query, options = {}) {
       limit: tierLimit,
       queryEmbedding,
       queryModelId: embeddingModelId && embeddingModelId !== "off" ? embeddingModelId : null
+    })) : Promise.resolve([]),
+    runNotes ? Promise.resolve(searchNotes({
+      db,
+      sessionId,
+      projectPath,
+      query: trimmedQuery,
+      limit: tierLimit,
+      probes: messageProbes
     })) : Promise.resolve([])
   ]);
-  const results = [...memoryResults, ...primerResults, ...messageLikeResults, ...gitCommitResults].sort(compareUnifiedResults).slice(0, limit);
+  const results = [
+    ...memoryResults,
+    ...primerResults,
+    ...messageLikeResults,
+    ...gitCommitResults,
+    ...noteResults
+  ].sort(compareUnifiedResults).slice(0, limit);
   const countRetrievals = options.countRetrievals ?? true;
   if (countRetrievals) {
     const memoryIds = results.filter((result) => result.source === "memory").map((result) => result.memoryId);
@@ -198699,6 +199432,10 @@ function renderFragment(result, charCap) {
       const compressed = cavemanCompress(result.content, "ultra");
       return truncate(compressed, charCap);
     }
+    case "note": {
+      const compressed = cavemanCompress(result.content, "ultra");
+      return truncate(compressed, charCap);
+    }
   }
 }
 function buildAutoSearchHint(results, options = {}) {
@@ -199565,6 +200302,13 @@ var degradedCacheCountBySession = new BoundedSessionMap(100);
 function resetDegradedCacheCount(sessionId) {
   degradedCacheCountBySession.delete(sessionId);
 }
+function pendingMarkerCoveredByConsumedBoundary(pending, injection) {
+  if (!injection)
+    return false;
+  if (pending.endMessageId === injection.compartmentEndMessageId)
+    return true;
+  return pending.ordinal <= injection.compartmentEndMessage;
+}
 function clearPendingCompactionMarkerAfterSuccessfulDrain(args) {
   if (clearPendingCompactionMarkerStateIf(args.db, args.sessionId, args.pending)) {
     return "cleared";
@@ -199963,24 +200707,29 @@ async function runPostTransformPhase(args) {
   if (historyWasConsumedThisPass && args.deferredHistoryWasPendingAtPassStart) {
     const pending = getPendingCompactionMarkerState(args.db, args.sessionId);
     if (pending) {
-      const outcome = applyDeferredCompactionMarker(args.db, args.sessionId, pending, args.sessionDirectory);
-      switch (outcome.kind) {
-        case "applied":
-        case "already-current":
-        case "stale-skip":
-          if (clearPendingCompactionMarkerAfterSuccessfulDrain({
-            db: args.db,
-            sessionId: args.sessionId,
-            pending,
-            deferredHistoryRefreshSessions: args.deferredHistoryRefreshSessions
-          }) === "cas-lost-newer-pending") {
+      if (!pendingMarkerCoveredByConsumedBoundary(pending, args.pendingCompartmentInjection)) {
+        suppressV12HistoryDrain = true;
+        sessionLog(args.sessionId, `compaction-marker drain: pending ordinal ${pending.ordinal} is newer than consumed boundary ${args.pendingCompartmentInjection?.compartmentEndMessage ?? "<none>"}; preserving deferred history refresh signal`);
+      } else {
+        const outcome = applyDeferredCompactionMarker(args.db, args.sessionId, pending, args.sessionDirectory);
+        switch (outcome.kind) {
+          case "applied":
+          case "already-current":
+          case "stale-skip":
+            if (clearPendingCompactionMarkerAfterSuccessfulDrain({
+              db: args.db,
+              sessionId: args.sessionId,
+              pending,
+              deferredHistoryRefreshSessions: args.deferredHistoryRefreshSessions
+            }) === "cas-lost-newer-pending") {
+              suppressV12HistoryDrain = true;
+            }
+            break;
+          case "retryable-failure":
+            sessionLog(args.sessionId, "compaction-marker drain: retryable failure; preserving deferred history refresh signal", outcome.error);
             suppressV12HistoryDrain = true;
-          }
-          break;
-        case "retryable-failure":
-          sessionLog(args.sessionId, "compaction-marker drain: retryable failure; preserving deferred history refresh signal", outcome.error);
-          suppressV12HistoryDrain = true;
-          break;
+            break;
+        }
       }
     }
   }
@@ -200085,6 +200834,16 @@ function getMessageTokensCache(sessionId) {
   }
   return cache;
 }
+function maybeSendProjectIdentityWarning(deps, sessionId, directory, notificationParams) {
+  if (!deps.client)
+    return;
+  const warning = takeDubiousOwnershipProjectIdentityWarning(directory);
+  if (!warning)
+    return;
+  sendIgnoredMessage(deps.client, sessionId, warning, notificationParams).catch((error51) => {
+    sessionLog(sessionId, `project identity warning delivery failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
+  });
+}
 function clearMessageTokensCache(sessionId, messageId) {
   if (messageId === undefined) {
     messageTokensBySession.delete(sessionId);
@@ -200159,7 +200918,7 @@ function createTransform(deps) {
     }
     const reducedMode = sessionMeta.isSubagent;
     const fullFeatureMode = !reducedMode;
-    const ctxReduceEnabledEffective = deps.ctxReduceEnabled !== false && resolveCtxReduceAvailabilityFromMessages(sessionId, messages);
+    const ctxReduceCallable = resolveCtxReduceAvailabilityFromMessages(sessionId, messages);
     let sessionDirectory = deps.directory ?? "";
     let sessionDirectoryResolvedFromHost = false;
     const cachedDirectory = deps.sessionDirectoryBySession?.get(sessionId);
@@ -200442,8 +201201,15 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       }
     }
     logTransformTiming(sessionId, "emergencyRecoveryBlock", tFirstPass);
-    const projectIdentity = deps.memoryConfig?.enabled ? resolveProjectIdentity(compartmentDirectory || process.cwd()) : undefined;
+    const memoryProjectDirectory = compartmentDirectory || process.cwd();
+    const projectIdentity = deps.memoryConfig?.enabled ? resolveProjectIdentity(memoryProjectDirectory) : undefined;
+    if (deps.memoryConfig?.enabled) {
+      maybeSendProjectIdentityWarning(deps, sessionId, memoryProjectDirectory, notificationParams);
+    }
     const sessionProjectIdentity = projectIdentity ?? (sessionDirectory ? resolveProjectIdentity(sessionDirectory) : deps.projectPath);
+    if (sessionDirectory) {
+      maybeSendProjectIdentityWarning(deps, sessionId, sessionDirectory, notificationParams);
+    }
     if (sessionProjectIdentity && sessionDirectoryResolvedFromHost && recordedSessionProjectIdentity.get(sessionId) !== sessionProjectIdentity) {
       recordSessionProjectIdentity(db, sessionId, sessionProjectIdentity);
       recordedSessionProjectIdentity.set(sessionId, sessionProjectIdentity);
@@ -200501,7 +201267,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       const tInitFromDb = performance.now();
       deps.tagger.initFromDb(sessionId, db, taggerFloor);
       logTransformTiming(sessionId, "tag.initFromDb", tInitFromDb);
-      const skipPrefixInjection = !ctxReduceEnabledEffective;
+      const skipPrefixInjection = !ctxReduceCallable;
       const result = tagMessages(sessionId, messages, deps.tagger, db, {
         skipPrefixInjection
       });
@@ -200558,7 +201324,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       }
       logTransformTiming(sessionId, "replayReasoningClearing", tReplay);
     }
-    if (!deps.ctxReduceEnabled && !reducedMode && deps.cavemanTextCompression?.enabled) {
+    if (!reducedMode && deps.cavemanTextCompression?.enabled) {
       const tCavemanReplay = performance.now();
       const replayedCaveman = replayCavemanCompression(sessionId, db, targets, targetsSliceTags);
       if (replayedCaveman > 0) {
@@ -200688,7 +201454,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
       projectPath: sessionProjectIdentity,
       sessionDirectory,
       autoSearch: deps.autoSearch,
-      cavemanTextCompression: deps.ctxReduceEnabled === false && !reducedMode ? deps.cavemanTextCompression : undefined,
+      cavemanTextCompression: !reducedMode ? deps.cavemanTextCompression : undefined,
       smartDrops: deps.smartDrops === true,
       resolvedProviderID,
       historyRefreshSessions: deps.historyRefreshSessions,
@@ -200844,7 +201610,7 @@ Historian previously failed ${historianFailureState.failureCount} time(s), so Ma
         sessionLog(sessionId, "conversation_tokens UPDATE failed:", error51);
       }
     }
-    if (ctxReduceEnabledEffective && deps.channel1StateBySession) {
+    if (ctxReduceCallable && deps.channel1StateBySession) {
       try {
         const resolvedExecuteThresholdPct = resolveExecuteThreshold(deps.executeThresholdPercentage ?? 65, deps.getModelKey?.(sessionId), 65, {
           tokensConfig: deps.executeThresholdTokens,
@@ -201329,6 +202095,343 @@ function createTextCompleteHandler() {
   };
 }
 
+// src/hooks/magic-context/wrapup-orchestrator.ts
+init_compartment_lease();
+init_compartment_storage();
+init_logger();
+init_rpc_notifications();
+init_send_session_notification();
+await __promiseAll([
+  init_storage(),
+  init_compartment_runner(),
+  init_compartment_runner_incremental(),
+  init_protected_tail_boundary(),
+  init_recomp_orchestrator()
+]);
+import * as crypto3 from "node:crypto";
+var WAIT_FOR_LEASE_MS = 1000;
+function sleep2(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+function plural(value, word) {
+  return `${value} ${word}${value === 1 ? "" : "s"}`;
+}
+function formatAlreadyRunningMessage(state) {
+  if (!state)
+    return "/ctx-wrapup is already running for this session.";
+  const chunk = state.expectedChunks > 0 ? ` chunk ${state.chunkIndex}/${state.expectedChunks}` : "";
+  const through = state.lastCompartmentEnd > 0 ? ` through message ${state.lastCompartmentEnd}` : "";
+  return `/ctx-wrapup is already running for this session${chunk}${through}. Wait for it to finish, then run /ctx-wrapup again if more history remains.`;
+}
+function appendFlushHint(ctx, sessionId, message) {
+  if (ctx.hasPendingNaturalBust?.(sessionId))
+    return message;
+  return `${message} If you want it applied on the very next message, run /ctx-flush first.`;
+}
+function buildPlan(ctx, sessionId, messagesToKeep, anchorRawMessageCount) {
+  return resolveWrapupProtectedTailBoundary({
+    db: ctx.db,
+    sessionId,
+    mode: "manual-wrapup",
+    contextLimit: ctx.contextLimit,
+    executeThresholdPercentage: ctx.executeThresholdPercentage,
+    usage: null,
+    usageSource: "manual-none",
+    providerShapeVersion: "opencode-v1",
+    cacheNamespace: `opencode:${sessionId}`,
+    messagesToKeep,
+    anchorRawMessageCount
+  });
+}
+function emitWrapupProgress(ctx, sessionId, progress) {
+  const current = ctx.liveSessionState.recompProgressBySession.get(sessionId);
+  ctx.liveSessionState.recompProgressBySession.set(sessionId, {
+    sessionId,
+    kind: "wrapup",
+    phase: "recomp",
+    processedMessages: progress.processedMessages ?? current?.processedMessages ?? 0,
+    totalMessages: progress.totalMessages ?? current?.totalMessages ?? 0,
+    passCount: progress.passCount ?? current?.passCount ?? 0,
+    compartmentsCreated: progress.compartmentsCreated ?? current?.compartmentsCreated ?? 0,
+    startedAt: current?.startedAt ?? Date.now(),
+    updatedAt: Date.now(),
+    note: progress.note
+  });
+}
+async function waitForExistingIncrementalRun(sessionId) {
+  const active = getActiveCompartmentRun(sessionId);
+  if (!active)
+    return "ok";
+  if (active.kind === "recomp" || active.kind === "wrapup")
+    return "busy";
+  try {
+    await active.promise;
+  } catch {}
+  return "ok";
+}
+async function acquireCompartmentLeaseForWrapup(ctx, sessionId, renewWrapupMarker) {
+  const holderId = crypto3.randomUUID();
+  for (;; ) {
+    const active = getActiveCompartmentRun(sessionId);
+    if (active?.kind === "recomp" || active?.kind === "wrapup")
+      return null;
+    if (active) {
+      emitWrapupProgress(ctx, sessionId, { note: "Waiting for the active historian run…" });
+      try {
+        await active.promise;
+      } catch {}
+      continue;
+    }
+    const lease = acquireCompartmentLease(ctx.db, sessionId, holderId);
+    if (lease)
+      return holderId;
+    emitWrapupProgress(ctx, sessionId, { note: "Waiting for the compartment-state lease…" });
+    if (!renewWrapupMarker({}))
+      return null;
+    await sleep2(WAIT_FOR_LEASE_MS);
+  }
+}
+async function runOneWrapupIteration(args) {
+  const { ctx, sessionId, plan, messagesToKeep, anchorRawMessageCount } = args;
+  const leaseHolderId = await acquireCompartmentLeaseForWrapup(ctx, sessionId, args.renewWrapupMarker);
+  if (!leaseHolderId)
+    return false;
+  const renewal = setInterval(() => {
+    try {
+      if (!renewCompartmentLease(ctx.db, sessionId, leaseHolderId)) {
+        sessionLog(sessionId, "wrapup: compartment lease renewal failed");
+      }
+    } catch (err) {
+      sessionLog(sessionId, `wrapup: compartment lease renewal threw; continuing (${err instanceof Error ? err.message : String(err)})`);
+    }
+  }, COMPARTMENT_LEASE_RENEWAL_MS);
+  const runCompartmentAgentForWrapup = ctx.runCompartmentAgentForWrapup ?? runCompartmentAgent;
+  const runnerPromise = runCompartmentAgentForWrapup({
+    client: ctx.client,
+    db: ctx.db,
+    sessionId,
+    historianChunkTokens: ctx.historianChunkTokens,
+    historianTimeoutMs: ctx.historianTimeoutMs,
+    boundarySnapshot: plan.snapshot,
+    currentContextLimit: ctx.contextLimit,
+    directory: ctx.directory,
+    fallbackModels: ctx.fallbackModels,
+    fallbackModelId: ctx.fallbackModelId,
+    language: ctx.language,
+    historianTwoPass: ctx.historianTwoPass,
+    memoryEnabled: ctx.memoryEnabled,
+    autoPromote: ctx.autoPromote,
+    ensureProjectRegistered: ctx.ensureProjectRegistered,
+    getNotificationParams: () => ctx.getNotificationParams(sessionId),
+    preserveInjectionCacheUntilConsumed: true,
+    compartmentLeaseHolderId: leaseHolderId,
+    forceDrainQuota: true,
+    forceKeepLastCompartment: true,
+    refreshBoundarySnapshot: () => buildPlan(ctx, sessionId, messagesToKeep, anchorRawMessageCount).snapshot,
+    onCompartmentStatePublished: (sid) => {
+      markActiveCompartmentRunPublished(sid);
+      ctx.liveSessionState.deferredHistoryRefreshSessions.add(sid);
+      ctx.liveSessionState.deferredMaterializationSessions.add(sid);
+    },
+    onDeferredMarkerPending: (sid) => {
+      ctx.liveSessionState.deferredHistoryRefreshSessions.add(sid);
+    }
+  });
+  registerActiveCompartmentRun(sessionId, runnerPromise, "wrapup");
+  try {
+    await runnerPromise;
+    return true;
+  } finally {
+    clearInterval(renewal);
+    releaseCompartmentLease(ctx.db, sessionId, leaseHolderId);
+  }
+}
+async function runManagedWrapup(ctx, sessionId, options) {
+  const messagesToKeep = Math.max(1, Math.floor(options.messagesToKeep));
+  setRecompStarting(ctx.liveSessionState, sessionId, "Estimating wrapup…", "wrapup");
+  const existingWrapup = getWrapupInProgressState(ctx.db, sessionId);
+  if (existingWrapup) {
+    const message2 = formatAlreadyRunningMessage(existingWrapup);
+    setRecompTerminal(ctx.liveSessionState, sessionId, "skipped", message2);
+    return `## Magic Wrapup — Skipped
+
+${message2}`;
+  }
+  const initialPlan = buildPlan(ctx, sessionId, messagesToKeep);
+  if (initialPlan.rawMessagesAboveLastCompartment <= messagesToKeep || !hasRunnableCompartmentWindow(initialPlan.snapshot)) {
+    const message2 = `Nothing to wrap up — only ${initialPlan.rawMessagesAboveLastCompartment} messages above the last compartment.`;
+    setRecompTerminal(ctx.liveSessionState, sessionId, "done", message2);
+    return message2;
+  }
+  const expectedChunks = Math.max(1, Math.ceil(initialPlan.snapshot.trueRawEligibleTokens / Math.max(1, ctx.historianChunkTokens)));
+  const wrapupHolderId = crypto3.randomUUID();
+  const acquired = acquireWrapupInProgress(ctx.db, sessionId, {
+    holderId: wrapupHolderId,
+    messagesToKeep,
+    anchorRawMessageCount: initialPlan.anchorRawMessageCount,
+    targetEligibleEndOrdinal: initialPlan.targetEligibleEndOrdinal,
+    lastCompartmentEnd: getLastCompartmentEndMessage(ctx.db, sessionId),
+    chunkIndex: 0,
+    expectedChunks
+  });
+  if (!acquired.ok) {
+    const message2 = formatAlreadyRunningMessage(acquired.state);
+    setRecompTerminal(ctx.liveSessionState, sessionId, "skipped", message2);
+    return `## Magic Wrapup — Skipped
+
+${message2}`;
+  }
+  const startLastEnd = getLastCompartmentEndMessage(ctx.db, sessionId);
+  const startCompartmentCount = getCompartments(ctx.db, sessionId).length;
+  let chunkIndex = 0;
+  let lastEnd = startLastEnd;
+  let stoppedForFailure = false;
+  let stoppedReason = "";
+  let ownershipLost = false;
+  const ownershipLostReason = "another process took over this session's wrapup.";
+  const markOwnershipLost = () => {
+    if (ownershipLost)
+      return;
+    ownershipLost = true;
+    sessionLog(sessionId, "wrapup: durable marker ownership lost; aborting loop");
+  };
+  const renewWrapupMarker = (updates) => {
+    const updated = updateWrapupInProgress(ctx.db, sessionId, wrapupHolderId, updates);
+    if (!updated) {
+      markOwnershipLost();
+      return false;
+    }
+    return true;
+  };
+  const markerRenewal = setInterval(() => {
+    try {
+      renewWrapupMarker({
+        lastCompartmentEnd: getLastCompartmentEndMessage(ctx.db, sessionId),
+        chunkIndex
+      });
+    } catch (err) {
+      sessionLog(sessionId, `wrapup: marker renewal threw; continuing (${err instanceof Error ? err.message : String(err)})`);
+    }
+  }, 60000);
+  markerRenewal.unref?.();
+  try {
+    const activeAtStart = await waitForExistingIncrementalRun(sessionId);
+    if (activeAtStart === "busy") {
+      const message2 = "Another Magic Context rebuild is already running for this session.";
+      setRecompTerminal(ctx.liveSessionState, sessionId, "skipped", message2);
+      return `## Magic Wrapup — Skipped
+
+${message2}`;
+    }
+    try {
+      sendIgnoredMessage(ctx.client, sessionId, `Magic Wrapup started — compacting about ${plural(expectedChunks, "chunk")} of history. This can take a few minutes; the result posts here when done.`, ctx.getNotificationParams(sessionId));
+    } catch {}
+    try {
+      pushNotification("action", { action: "wrapup-progress-kick" }, sessionId);
+    } catch {}
+    if (ownershipLost) {
+      stoppedForFailure = true;
+      stoppedReason = ownershipLostReason;
+    } else {
+      emitWrapupProgress(ctx, sessionId, {
+        processedMessages: Math.max(0, lastEnd),
+        totalMessages: Math.max(0, initialPlan.targetEligibleEndOrdinal - 1),
+        passCount: 0,
+        compartmentsCreated: 0,
+        note: `Eligible ${plural(initialPlan.snapshot.trueRawEligibleTokens, "token")} across about ${plural(expectedChunks, "chunk")}.`
+      });
+      for (;; ) {
+        if (ownershipLost) {
+          stoppedForFailure = true;
+          stoppedReason = ownershipLostReason;
+          break;
+        }
+        if (!renewWrapupMarker({
+          lastCompartmentEnd: getLastCompartmentEndMessage(ctx.db, sessionId),
+          chunkIndex,
+          expectedChunks
+        })) {
+          stoppedForFailure = true;
+          stoppedReason = ownershipLostReason;
+          break;
+        }
+        const plan = buildPlan(ctx, sessionId, messagesToKeep, initialPlan.anchorRawMessageCount);
+        lastEnd = getLastCompartmentEndMessage(ctx.db, sessionId);
+        if (lastEnd + 1 >= plan.targetEligibleEndOrdinal)
+          break;
+        chunkIndex += 1;
+        emitWrapupProgress(ctx, sessionId, {
+          processedMessages: Math.max(0, lastEnd),
+          totalMessages: Math.max(0, plan.targetEligibleEndOrdinal - 1),
+          passCount: chunkIndex - 1,
+          compartmentsCreated: Math.max(0, getCompartments(ctx.db, sessionId).length - startCompartmentCount),
+          note: `Chunk ${chunkIndex}/${expectedChunks}: messages ${plan.snapshot.offset}-${plan.snapshot.eligibleEndOrdinal - 1}…`
+        });
+        if (!renewWrapupMarker({
+          lastCompartmentEnd: lastEnd,
+          chunkIndex,
+          expectedChunks,
+          targetEligibleEndOrdinal: plan.targetEligibleEndOrdinal
+        })) {
+          stoppedForFailure = true;
+          stoppedReason = ownershipLostReason;
+          break;
+        }
+        const beforeEnd = lastEnd;
+        const beforeFailures = getHistorianFailureState(ctx.db, sessionId).failureCount;
+        const ran = await runOneWrapupIteration({
+          ctx,
+          sessionId,
+          plan,
+          messagesToKeep,
+          anchorRawMessageCount: initialPlan.anchorRawMessageCount,
+          renewWrapupMarker
+        });
+        if (!ran) {
+          stoppedForFailure = true;
+          stoppedReason = ownershipLost ? ownershipLostReason : "Another Magic Context rebuild started while wrapup was waiting.";
+          break;
+        }
+        const afterEnd = getLastCompartmentEndMessage(ctx.db, sessionId);
+        const afterFailures = getHistorianFailureState(ctx.db, sessionId).failureCount;
+        if (afterEnd <= beforeEnd) {
+          stoppedForFailure = true;
+          stoppedReason = afterFailures > beforeFailures ? "The historian failed on the current chunk." : "The historian made no forward progress on the current chunk.";
+          break;
+        }
+        lastEnd = afterEnd;
+        emitWrapupProgress(ctx, sessionId, {
+          processedMessages: Math.max(0, lastEnd),
+          totalMessages: Math.max(0, plan.targetEligibleEndOrdinal - 1),
+          passCount: chunkIndex,
+          compartmentsCreated: Math.max(0, getCompartments(ctx.db, sessionId).length - startCompartmentCount),
+          note: `Wrapped through message ${lastEnd}.`
+        });
+      }
+    }
+  } finally {
+    clearInterval(markerRenewal);
+    releaseWrapupInProgress(ctx.db, sessionId, wrapupHolderId);
+  }
+  const finalEnd = getLastCompartmentEndMessage(ctx.db, sessionId);
+  const compartmentsCreated = Math.max(0, getCompartments(ctx.db, sessionId).length - startCompartmentCount);
+  const messagesWrapped = Math.max(0, finalEnd - Math.max(0, startLastEnd));
+  if (stoppedForFailure) {
+    const message2 = `Wrapped up through message ${Math.max(0, finalEnd)} (${plural(messagesWrapped, "message")} into ${plural(compartmentsCreated, "compartment")}). ${stoppedReason} Run /ctx-wrapup again to continue.`;
+    setRecompTerminal(ctx.liveSessionState, sessionId, "failed", message2);
+    return `## Magic Wrapup — Partial
+
+${message2}`;
+  }
+  try {
+    clearEmergencyRecovery(ctx.db, sessionId);
+  } catch {}
+  const base = `Wrapped up ${messagesWrapped} messages into ${compartmentsCreated} compartments. The compacted history is queued and materializes on your next message.`;
+  const message = appendFlushHint(ctx, sessionId, base);
+  setRecompTerminal(ctx.liveSessionState, sessionId, "done", message);
+  return message;
+}
+
 // src/hooks/magic-context/hook.ts
 await init_compaction_marker_manager();
 
@@ -201667,7 +202770,7 @@ Drop silently — do not narrate it. NEVER drop large ranges blindly (e.g., "1-5
 Older tool calls may show \`[dropped §N§]\` sentinels; that is normal context management, not a pattern to copy. ALWAYS make fresh real tool calls when you need data again; never fabricate or inline tool output.`;
 var CAVEMAN_COMPRESSION_WARNING = `
 **BEWARE**: History compression is on; older user AND assistant text — including your own earlier responses — has been deterministically rewritten in a terse caveman style (dropped articles, missing auxiliaries, \`//\` instead of connectives like \`because\`). This is automatic context compression that runs after the fact, not your actual prior wording or the user's. **DO NOT mimic this style in new turns.** Write fresh responses in normal prose. If you notice your output drifting into caveman cadence, that drift is in-context-learning bleeding from the compressed history — consciously revert to full sentences.`;
-function buildMagicContextSection(_agent, protectedTags, ctxReduceEnabled = true, dreamerEnabled = false, temporalAwarenessEnabled = false, cavemanTextCompressionEnabled = false, subagentMode = false, language, memoryEnabled = true) {
+function buildMagicContextSection(_agent, protectedTags, ctxReduceCallable = true, dreamerEnabled = false, temporalAwarenessEnabled = false, cavemanTextCompressionEnabled = false, subagentMode = false, language, memoryEnabled = true) {
   if (subagentMode) {
     return `## Magic Context
 
@@ -201678,12 +202781,12 @@ When \`surface_condition\` is provided with \`write\`, the note becomes a projec
 The dreamer evaluates smart note conditions during nightly runs and surfaces them when conditions are met.
 Example: \`ctx_note(action="write", content="Implement X because Y", surface_condition="When PR #42 is merged in this repo")\`` : "";
   const temporalGuidance = temporalAwarenessEnabled ? TEMPORAL_AWARENESS_GUIDANCE : "";
-  const cavemanWarning = cavemanTextCompressionEnabled && !ctxReduceEnabled ? CAVEMAN_COMPRESSION_WARNING : "";
+  const cavemanWarning = cavemanTextCompressionEnabled ? CAVEMAN_COMPRESSION_WARNING : "";
   const languageDirective = buildPrimaryLanguageDirective(language);
   const languageGuidance = languageDirective ? `
 
 ${languageDirective}` : "";
-  if (!ctxReduceEnabled) {
+  if (!ctxReduceCallable) {
     return `## Magic Context
 
 ${LONG_TERM_PARTNER_FRAME}
@@ -201696,7 +202799,7 @@ ${BASE_INTRO_NO_REDUCE(memoryEnabled)}${smartNoteGuidance}${temporalGuidance}${c
 ${LONG_TERM_PARTNER_FRAME}
 ${PARTNER_FRAME_CLOSER_REDUCE}
 
-${BASE_INTRO(protectedTags, memoryEnabled)}${smartNoteGuidance}${temporalGuidance}
+${BASE_INTRO(protectedTags, memoryEnabled)}${smartNoteGuidance}${temporalGuidance}${cavemanWarning}
 ${GENERIC_SECTION}
 
 Prefer many small targeted operations over one large blanket operation, and keep the working set tidy as routine maintenance.${languageGuidance}`;
@@ -201749,17 +202852,18 @@ function createSystemPromptHashHandler(deps) {
     } catch (error51) {
       sessionLog(sessionId, "system-prompt-hash session meta load failed:", error51);
     }
-    const isSubagentSession = sessionMetaEarly?.isSubagent === true;
-    const ctxReduceCallable = resolveCtxReduceAvailability(sessionId);
-    const subagentReduceMode = isSubagentSession && deps.ctxReduceEnabled !== false && ctxReduceCallable;
-    const effectiveCtxReduceEnabled = isSubagentSession ? false : deps.ctxReduceEnabled !== false && ctxReduceCallable;
-    const skipGuidanceForDisabledSubagent = isSubagentSession && (deps.ctxReduceEnabled === false || !ctxReduceCallable);
+    const isSubagentSession2 = sessionMetaEarly?.isSubagent === true;
+    const availability = resolveCtxReduceAvailability(sessionId);
+    const ctxReduceCallable = availability.callable;
+    const subagentReduceMode = isSubagentSession2 && ctxReduceCallable;
+    const effectiveCtxReduceEnabled = isSubagentSession2 ? false : ctxReduceCallable;
+    const skipGuidanceForDisabledSubagent = isSubagentSession2 && !ctxReduceCallable;
     const fullPrompt = output.system.join(`
 `);
     if (fullPrompt.length > 0 && !fullPrompt.includes(MAGIC_CONTEXT_MARKER) && !skipGuidanceForDisabledSubagent) {
       const guidance = buildMagicContextSection(null, deps.protectedTags, effectiveCtxReduceEnabled, deps.dreamerEnabled, deps.experimentalTemporalAwareness, deps.experimentalCavemanTextCompression, subagentReduceMode, deps.language, deps.memoryEnabled !== false);
       output.system.push(guidance);
-      sessionLog(sessionId, `injected generic guidance into system prompt (ctxReduce=${effectiveCtxReduceEnabled}, subagent=${isSubagentSession}, subagentReduceMode=${subagentReduceMode})`);
+      sessionLog(sessionId, `injected generic guidance into system prompt (ctxReduce=${effectiveCtxReduceEnabled}, subagent=${isSubagentSession2}, subagentReduceMode=${subagentReduceMode})`);
     }
     const isCacheBusting = deps.systemPromptRefreshSessions.has(sessionId);
     const DATE_PATTERN = /Today's date: .+/;
@@ -201786,6 +202890,8 @@ function createSystemPromptHashHandler(deps) {
 `);
     if (systemContent.length === 0)
       return;
+    if (!availability.frozen)
+      return;
     const currentHash = createHash13("md5").update(systemContent).digest("hex");
     if (!sessionMetaEarly) {
       return;
@@ -201974,7 +203080,7 @@ function createMagicContextHook(deps) {
     notifyMagicContextDisabled(deps.client, reason);
     return null;
   }
-  const projectPath = resolveProjectIdentity(deps.directory);
+  const projectPath = resolveProjectIdentityOrFallback(deps.directory);
   try {
     checkCompactionMarkerConsistency(db);
   } catch (error51) {
@@ -201985,20 +203091,21 @@ function createMagicContextHook(deps) {
   const historianFallbackModels = resolveFallbackChain(deps.config.historian?.fallback_models);
   const historyRefreshSessions = deps.liveSessionState?.historyRefreshSessions ?? new Set;
   const deferredHistoryRefreshSessions = deps.liveSessionState?.deferredHistoryRefreshSessions ?? new Set;
+  const systemPromptRefreshSessions = deps.liveSessionState?.systemPromptRefreshSessions ?? new Set;
+  const pendingMaterializationSessions = deps.liveSessionState?.pendingMaterializationSessions ?? new Set;
+  const deferredMaterializationSessions = deps.liveSessionState?.deferredMaterializationSessions ?? new Set;
   try {
     const sessionsWithPending = getSessionsWithPendingMarker(db);
     if (sessionsWithPending.length > 0) {
       for (const sid of sessionsWithPending) {
         deferredHistoryRefreshSessions.add(sid);
+        deferredMaterializationSessions.add(sid);
       }
       log(`[magic-context] rehydrated ${sessionsWithPending.length} session(s) with pending compaction-marker drain at hook init`);
     }
   } catch (error51) {
     log("[magic-context] hook init: pending-marker rehydration failed:", error51);
   }
-  const systemPromptRefreshSessions = deps.liveSessionState?.systemPromptRefreshSessions ?? new Set;
-  const pendingMaterializationSessions = deps.liveSessionState?.pendingMaterializationSessions ?? new Set;
-  const deferredMaterializationSessions = deps.liveSessionState?.deferredMaterializationSessions ?? new Set;
   const lastHeuristicsTurnId = new Map;
   const commitSeenLastPass = new Map;
   const variantBySession = deps.liveSessionState?.variantBySession ?? new Map;
@@ -202019,7 +203126,15 @@ function createMagicContextHook(deps) {
     }
     return;
   };
-  const ctxReduceEnabled = deps.config.ctx_reduce_enabled !== false;
+  const maybeSendProjectIdentitySessionWarning = (sessionId, directory) => {
+    const warning = takeDubiousOwnershipProjectIdentityWarning(directory);
+    if (!warning)
+      return;
+    const notificationParams = getLiveNotificationParams(sessionId, liveModelBySession, variantBySession, agentBySession, deps.config.toast_duration_ms);
+    sendIgnoredMessage(deps.client, sessionId, warning, notificationParams).catch((error51) => {
+      log(`[magic-context] failed to send project identity warning for ${directory}: ${getErrorMessage(error51)}`);
+    });
+  };
   const dreamerRunnable = isDreamerRunnable(deps.config);
   const dreamerConfig = dreamerRunnable ? deps.config.dreamer : undefined;
   const historianRunnable = isHistorianRunnable(deps.config);
@@ -202056,6 +203171,23 @@ function createMagicContextHook(deps) {
     ensureProjectRegistered: ensureProjectRegisteredFromOpenCodeDirectory,
     getNotificationParams: (sid) => getLiveNotificationParams(sid, liveModelBySession, variantBySession, agentBySession, deps.config.toast_duration_ms)
   });
+  const buildManagedWrapupCtx = (sessionId) => ({
+    ...buildManagedRecompCtx(sessionId),
+    contextLimit: (() => {
+      const model = resolveLiveModel(sessionId);
+      return model ? resolveContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : 128000;
+    })(),
+    executeThresholdPercentage: (() => {
+      const model = resolveLiveModel(sessionId);
+      const contextLimit = model ? resolveContextLimit(model.providerID, model.modelID, { db, sessionID: sessionId }) : 128000;
+      return resolveExecuteThresholdDetail(deps.config.execute_threshold_percentage ?? 65, model ? `${model.providerID}/${model.modelID}` : undefined, 65, {
+        tokensConfig: deps.config.execute_threshold_tokens,
+        contextLimit,
+        sessionId
+      }).percentage;
+    })(),
+    hasPendingNaturalBust: (sid) => historyRefreshSessions.has(sid) || systemPromptRefreshSessions.has(sid) || pendingMaterializationSessions.has(sid)
+  });
   const executeEmbedHistory = async (sessionId, options) => {
     if (deps.config.memory?.enabled === false) {
       return "Memory is disabled for this project, so there is no semantic embedding to backfill.";
@@ -202066,7 +203198,8 @@ function createMagicContextHook(deps) {
       return "Embedding is already running for this session.";
     }
     await ensureProjectRegisteredFromOpenCodeDirectory(directory, db);
-    const sessionProjectIdentity = resolveProjectIdentity(directory);
+    const sessionProjectIdentity = resolveProjectIdentityOrFallback(directory);
+    maybeSendProjectIdentitySessionWarning(sessionId, directory);
     embedPauseBySession.delete(sessionId);
     const prior = embedRunStateBySession.get(sessionId);
     if (prior)
@@ -202131,13 +203264,15 @@ function createMagicContextHook(deps) {
     if (ctrl)
       ctrl.abort();
     const directory = sessionDirectoryBySession.get(sessionId) ?? deps.directory;
-    const sessionProjectIdentity = resolveProjectIdentity(directory);
+    const sessionProjectIdentity = resolveProjectIdentityOrFallback(directory);
+    maybeSendProjectIdentitySessionWarning(sessionId, directory);
     const cov = getEmbeddingCoverageStatus(db, sessionProjectIdentity, sessionId);
     return `Paused at ${cov.session.embedded}/${cov.session.total} compartments embedded.`;
   };
   const getEmbedStatusText = (sessionId) => {
     const directory = sessionDirectoryBySession.get(sessionId) ?? deps.directory;
-    const sessionProjectIdentity = resolveProjectIdentity(directory);
+    const sessionProjectIdentity = resolveProjectIdentityOrFallback(directory);
+    maybeSendProjectIdentitySessionWarning(sessionId, directory);
     const coverage = getEmbeddingCoverageStatus(db, sessionProjectIdentity, sessionId);
     const progress = recompProgressBySession.get(sessionId);
     const drainUi = getEmbedDrainUiStatus(sessionId, progress);
@@ -202160,7 +203295,8 @@ function createMagicContextHook(deps) {
       try {
         await new Promise((resolve4) => setTimeout(resolve4, 0));
         await ensureProjectRegisteredFromOpenCodeDirectory(directory, db);
-        const sessionProjectIdentity = resolveProjectIdentity(directory);
+        const sessionProjectIdentity = resolveProjectIdentityOrFallback(directory);
+        maybeSendProjectIdentitySessionWarning(sessionId, directory);
         const coverage = getEmbeddingCoverageStatus(db, sessionProjectIdentity, sessionId);
         if (!coverage.enabled)
           return;
@@ -202194,7 +203330,6 @@ function createMagicContextHook(deps) {
     db,
     channel1StateBySession,
     protectedTags: deps.config.protected_tags,
-    ctxReduceEnabled,
     smartDrops: deps.config.smart_drops === true,
     clearReasoningAge: deps.config.clear_reasoning_age ?? 50,
     commitClusterTrigger: deps.config.commit_cluster_trigger,
@@ -202243,7 +203378,7 @@ function createMagicContextHook(deps) {
       directory: deps.directory,
       ensureProjectRegistered: ensureProjectRegisteredFromOpenCodeDirectory
     } : undefined,
-    cavemanTextCompression: ctxReduceEnabled === false && deps.config.caveman_text_compression?.enabled === true ? {
+    cavemanTextCompression: deps.config.caveman_text_compression?.enabled === true ? {
       enabled: true,
       minChars: deps.config.caveman_text_compression.min_chars ?? 500
     } : undefined,
@@ -202331,6 +203466,7 @@ function createMagicContextHook(deps) {
       systemPromptRefreshSessions.add(sessionId);
       pendingMaterializationSessions.add(sessionId);
     },
+    executeWrapup: historianRunnable ? async (sessionId, options) => runManagedWrapup(buildManagedWrapupCtx(sessionId), sessionId, options) : undefined,
     executeRecomp: historianRunnable ? async (sessionId, options) => runManagedRecomp(buildManagedRecompCtx(sessionId), sessionId, options) : undefined,
     runUpgrade: historianRunnable ? async (sessionId) => runManagedUpgrade(buildManagedRecompCtx(sessionId), sessionId) : undefined,
     executeEmbedHistory,
@@ -202374,7 +203510,6 @@ function createMagicContextHook(deps) {
   const systemPromptHash = createSystemPromptHashHandler({
     db,
     protectedTags: deps.config.protected_tags,
-    ctxReduceEnabled,
     dreamerEnabled: dreamerRunnable,
     memoryEnabled: deps.config.memory?.enabled !== false,
     language: deps.config.language,
@@ -202389,7 +203524,7 @@ function createMagicContextHook(deps) {
     internalChildSessions,
     experimentalUserMemories: userMemoryCollectionEnabled(deps.config.dreamer),
     experimentalTemporalAwareness: deps.config.temporal_awareness === true,
-    experimentalCavemanTextCompression: ctxReduceEnabled === false && deps.config.caveman_text_compression?.enabled === true
+    experimentalCavemanTextCompression: deps.config.caveman_text_compression?.enabled === true
   });
   const systemPromptHashHandler = systemPromptHash.handler;
   const eventHook = createEventHook({
@@ -202408,8 +203543,7 @@ function createMagicContextHook(deps) {
     lastHeuristicsTurnId,
     commitSeenLastPass,
     client: deps.client,
-    protectedTags: deps.config.protected_tags,
-    ctxReduceEnabled
+    protectedTags: deps.config.protected_tags
   });
   return {
     "experimental.chat.messages.transform": transform2,
@@ -202424,7 +203558,6 @@ function createMagicContextHook(deps) {
       systemPromptRefreshSessions,
       pendingMaterializationSessions,
       lastHeuristicsTurnId,
-      ctxReduceEnabled,
       upgradeReminder: historianRunnable ? (sessionId) => maybeSendUpgradeReminder({
         client: deps.client,
         db,
@@ -202456,7 +203589,6 @@ function createMagicContextHook(deps) {
 function buildMagicContextHookConfig(pluginConfig) {
   return {
     protected_tags: pluginConfig.protected_tags ?? DEFAULT_PROTECTED_TAGS,
-    ctx_reduce_enabled: pluginConfig.ctx_reduce_enabled,
     cache_ttl: pluginConfig.cache_ttl,
     clear_reasoning_age: pluginConfig.clear_reasoning_age,
     toast_duration_ms: pluginConfig.toast_duration_ms,
@@ -202977,7 +204109,6 @@ function buildSidebarSnapshot(db, sessionId, directory, liveSessionState, inject
     contextLimit: 0,
     systemPromptTokens: 0,
     compartmentCount: 0,
-    factCount: 0,
     memoryCount: 0,
     memoryBlockCount: 0,
     pendingOpsCount: 0,
@@ -203016,7 +204147,6 @@ function buildSidebarSnapshot(db, sessionId, directory, liveSessionState, inject
     const memoryBlockCount = meta3 ? Number(meta3.memory_block_count ?? 0) : 0;
     const compartmentRow = db.prepare("SELECT COUNT(*) as count FROM compartments WHERE session_id = ?").get(sessionId);
     const compartmentCount = compartmentRow?.count ?? 0;
-    const factCount = 0;
     let memoryCount = 0;
     if (projectIdentity) {
       const memRow = db.prepare("SELECT COUNT(*) as count FROM memories WHERE project_path = ? AND status = 'active'").get(projectIdentity);
@@ -203123,7 +204253,6 @@ function buildSidebarSnapshot(db, sessionId, directory, liveSessionState, inject
       contextLimit,
       systemPromptTokens: calibrated.systemTokens,
       compartmentCount,
-      factCount,
       memoryCount,
       memoryBlockCount,
       pendingOpsCount,
@@ -204136,8 +205265,8 @@ function createCtxMemoryTool(deps) {
           }
         });
         const idList = targets.map((t) => t.memoryId).join(", ");
-        const plural = targets.length > 1 ? "memories" : "memory";
-        return args.reason?.trim() ? `Archived ${plural} [ID: ${idList}] (${args.reason.trim()}).` : `Archived ${plural} [ID: ${idList}].`;
+        const plural2 = targets.length > 1 ? "memories" : "memory";
+        return args.reason?.trim() ? `Archived ${plural2} [ID: ${idList}] (${args.reason.trim()}).` : `Archived ${plural2} [ID: ${idList}].`;
       }
       return "Error: Unknown action.";
     }
@@ -204542,10 +205671,12 @@ Sources (omit for a broad search across all):
 - memory: curated cross-session project knowledge — rules, constraints, conventions.
 - message: the raw conversation behind your compacted history. Hits include message ordinals — expand the surrounding exchange with ctx_expand(start=N-10, end=N+5).
 - git_commit: this repository's commit history.
+- note: parked decisions, follow-ups, and dismissed notes with their recorded text.
 
 Picking sources:
 - "when did this change / was this working before" → ["git_commit", "message"]
 - "did we discuss this earlier" → ["message"]
+- "did we decide something about this / leave a follow-up" → ["note"]
 - "what's our convention / rule for X" → ["memory"]`;
 var DEFAULT_CTX_SEARCH_LIMIT = 10;
 // src/tools/ctx-search/tools.ts
@@ -204557,7 +205688,8 @@ var VALID_SOURCES = new Set([
   "memory",
   "message",
   "git_commit",
-  "primer"
+  "primer",
+  "note"
 ]);
 function normalizeLimit3(limit) {
   if (typeof limit !== "number" || !Number.isFinite(limit)) {
@@ -204600,7 +205732,8 @@ function formatAge2(committedAtMs) {
   const years = Math.floor(days / 365);
   return years === 1 ? "1y ago" : `${years}y ago`;
 }
-function formatResult(result, index) {
+var NOTE_EXPAND_HINT = "Use ctx_expand(start=N-10, end=N) around any note @msg anchor above to read the surrounding conversation context.";
+function formatResult(result, index, currentSessionId) {
   if (result.source === "memory") {
     const source = result.sourceName ? ` source=${result.sourceName}` : "";
     return [
@@ -204621,6 +205754,14 @@ function formatResult(result, index) {
       `[${index}] [primer] score=${result.score.toFixed(2)} id=${result.primerId} support=${result.support} match=${result.matchType}`,
       result.content
     ].join(`
+`);
+  }
+  if (result.source === "note") {
+    const anchor = result.anchorOrdinal !== null && result.sourceSessionId === currentSessionId ? ` @msg ${result.anchorOrdinal}` : "";
+    return [
+      `[${index}] [note] score=${result.score.toFixed(2)} id=#${result.noteId} status=${result.status} ${formatAge2(result.createdAt)}${anchor}`,
+      result.content
+    ].join(`
 `);
   }
   if (result.source === "compartment") {
@@ -204638,14 +205779,17 @@ function formatResult(result, index) {
   ].join(`
 `);
 }
-function formatSearchResults(query, results) {
+function formatSearchResults(query, results, currentSessionId) {
   if (results.length === 0) {
-    return `No results found for "${query}" across memories, primers, git commits, or message history.`;
+    return `No results found for "${query}" across notes, memories, primers, git commits, or message history.`;
   }
-  const bodyParts = results.map((result, index) => formatResult(result, index + 1));
+  const bodyParts = results.map((result, index) => formatResult(result, index + 1, currentSessionId));
   if (results.some((result) => result.source === "message" || result.source === "compartment")) {
     bodyParts.push("Use ctx_expand(start, end) with the range from any message result above to read the full conversation context.");
   }
+  if (results.some((result) => result.source === "note" && result.anchorOrdinal !== null && result.sourceSessionId === currentSessionId)) {
+    bodyParts.push(NOTE_EXPAND_HINT);
+  }
   const body = bodyParts.join(`
 
 `);
@@ -204659,7 +205803,7 @@ function createCtxSearchTool(deps) {
     args: {
       query: tool5.schema.string().describe("Search query. Matches against memory content, Primers, git commit messages, and raw user/assistant message text."),
       limit: tool5.schema.number().optional().describe("Maximum results to return (default: 10)"),
-      sources: tool5.schema.array(tool5.schema.enum(["memory", "message", "git_commit", "primer"])).optional().describe('Optional. Restrict to specific sources. Examples: ["primer"] for standing project explanations, ["git_commit"] for "when did we change X", ["memory"] for naming conventions, ["message"] for "did we discuss this earlier", ["git_commit","message"] for regression hunts. Omit for a broad search across all enabled sources.')
+      sources: tool5.schema.array(tool5.schema.enum(["memory", "message", "git_commit", "primer", "note"])).optional().describe('Optional. Restrict to specific sources. Examples: ["primer"] for standing project explanations, ["git_commit"] for "when did we change X", ["memory"] for naming conventions, ["message"] for "did we discuss this earlier", ["note"] for parked decisions or follow-ups, ["git_commit","message"] for regression hunts. Omit for a broad search across all enabled sources.')
     },
     async execute(args, toolContext) {
       const query = args.query?.trim();
@@ -204691,7 +205835,7 @@ function createCtxSearchTool(deps) {
         visibleMemoryIds,
         explicitSearch: true
       });
-      return formatSearchResults(query, results);
+      return formatSearchResults(query, results, toolContext.sessionID);
     }
   });
 }
@@ -204748,14 +205892,13 @@ function createToolRegistry(args) {
     return {};
   }
   ensureProjectRegisteredFromOpenCodeDirectory(ctx.directory, db);
-  const resolveProjectPath = (directory) => resolveProjectIdentity(directory);
-  const ctxReduceEnabled = pluginConfig.ctx_reduce_enabled !== false;
+  const resolveProjectPath = (directory) => resolveProjectIdentityOrFallback(directory);
   const memoryEnabled = pluginConfig.memory?.enabled !== false;
   const allTools = {
-    ...ctxReduceEnabled ? createCtxReduceTools({
+    ...createCtxReduceTools({
       db,
       protectedTags: pluginConfig.protected_tags ?? DEFAULT_PROTECTED_TAGS
-    }) : {},
+    }),
     ...createCtxExpandTools({ db }),
     ...createCtxNoteTools({
       db,
@@ -205198,7 +206341,7 @@ var server = async (ctx) => {
     const dreamerRunnable = isDreamerRunnable(pluginConfig);
     const timerRegistration = {
       directory: ctx.directory,
-      projectIdentity: resolveProjectIdentity(ctx.directory),
+      projectIdentity: resolveProjectIdentityOrFallback(ctx.directory),
       client: ctx.client,
       dreamerConfig: dreamerRunnable ? pluginConfig.dreamer : undefined,
       language: pluginConfig.language,