@cortexkit/pi-magic-context 0.21.2 → 0.21.5

package/dist/index.js

@@ -141906,6 +141906,10 @@ function getLastCompartmentEndMessage(db, sessionId) {
   const row = db.prepare("SELECT MAX(end_message) as max_end FROM compartments WHERE session_id = ?").get(sessionId);
   return row?.max_end ?? -1;
 }
+function getCompartmentsByEndMessageId(db, sessionId, endMessageId) {
+  const rows = db.prepare("SELECT * FROM compartments WHERE session_id = ? AND end_message_id = ? ORDER BY sequence ASC").all(sessionId, endMessageId).filter(isCompartmentRow);
+  return rows.map(toCompartment);
+}
 function appendCompartments(db, sessionId, compartments) {
   if (compartments.length === 0)
     return;
@@ -142015,7 +142019,7 @@ function promoteRecompStaging(db, sessionId) {
     insertFactRows(db, sessionId, staging.facts, now);
     db.prepare("DELETE FROM recomp_compartments WHERE session_id = ?").run(sessionId);
     db.prepare("DELETE FROM recomp_facts WHERE session_id = ?").run(sessionId);
-    db.prepare("UPDATE session_meta SET memory_block_cache = '' WHERE session_id = ?").run(sessionId);
+    db.prepare("UPDATE session_meta SET memory_block_cache = '', memory_block_ids = '' WHERE session_id = ?").run(sessionId);
     return { compartments: staging.compartments, facts: staging.facts };
   })();
 }
@@ -142245,8 +142249,10 @@ function deleteOrphanProjectKeyFiles(db, now = Date.now()) {
     if (existsSync2(row.projectPath))
       continue;
     try {
-      db.prepare("DELETE FROM project_key_files WHERE project_path = ?").run(row.projectPath);
-      db.prepare("DELETE FROM project_key_files_version WHERE project_path = ?").run(row.projectPath);
+      db.transaction(() => {
+        db.prepare("DELETE FROM project_key_files WHERE project_path = ?").run(row.projectPath);
+        db.prepare("DELETE FROM project_key_files_version WHERE project_path = ?").run(row.projectPath);
+      })();
       deletedProjects++;
     } catch (error) {
       log(`[key-files] orphan GC failed for ${row.projectPath}:`, error);
@@ -142653,6 +142659,16 @@ var MIGRATIONS = [
                 WHERE auto_search_hint_decisions IS NULL
             `);
     }
+  },
+  {
+    version: 18,
+    description: "Add pending_pi_compaction_marker_state column for Pi deferred marker drain",
+    up: (db) => {
+      const cols = db.prepare("PRAGMA table_info(session_meta)").all();
+      if (!cols.some((c) => c.name === "pending_pi_compaction_marker_state")) {
+        db.exec("ALTER TABLE session_meta ADD COLUMN pending_pi_compaction_marker_state TEXT");
+      }
+    }
   }
 ];
 function ensureMigrationsTable(db) {
@@ -142668,7 +142684,7 @@ function getCurrentVersion(db) {
   const row = db.prepare("SELECT MAX(version) as version FROM schema_migrations").get();
   return row?.version ?? 0;
 }
-function isSiblingMigrationConflict(error, version) {
+function isSiblingMigrationConflict(db, error, version) {
   if (!(error instanceof Error))
     return false;
   const code = error.code;
@@ -142680,7 +142696,8 @@ function isSiblingMigrationConflict(error, version) {
     return false;
   if (!msg.toLowerCase().includes("version"))
     return false;
-  return true;
+  const confirmed = db.prepare("SELECT 1 FROM schema_migrations WHERE version = ?").get(version);
+  return confirmed != null;
 }
 function runMigrations(db) {
   ensureMigrationsTable(db);
@@ -142701,7 +142718,7 @@ function runMigrations(db) {
       log(`[migrations] applied v${migration.version}: ${migration.description}`);
       migrationIndex += 1;
     } catch (error) {
-      if (isSiblingMigrationConflict(error, migration.version)) {
+      if (isSiblingMigrationConflict(db, error, migration.version)) {
         log(`[migrations] v${migration.version} already applied by sibling instance — resuming with re-read version`);
         const reReadVersion = getCurrentVersion(db);
         if (reReadVersion <= currentVersion) {
@@ -143298,6 +143315,11 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       -- Excluded from healNullTextColumns. Readers filter IS NOT NULL AND
       -- != empty-string defensively. Plan v6 section 3.
       pending_compaction_marker_state TEXT,
+      -- pending_pi_compaction_marker_state: intentionally NULLABLE without a
+      -- default. Absence of a deferred Pi-native marker is SQL NULL; presence
+      -- is a valid JSON blob written via setPendingPiCompactionMarkerState.
+      -- Excluded from healNullTextColumns.
+      pending_pi_compaction_marker_state TEXT,
       -- deferred_execute_state: intentionally NULLABLE without a default.
       -- Absence is SQL NULL; presence is a JSON blob written via
       -- setDeferredExecutePendingIfAbsent. Excluded from healNullTextColumns.
@@ -143394,6 +143416,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "session_meta", "detected_context_limit", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "needs_emergency_recovery", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "pending_compaction_marker_state", "TEXT");
+  ensureColumn(db, "session_meta", "pending_pi_compaction_marker_state", "TEXT");
   ensureColumn(db, "session_meta", "deferred_execute_state", "TEXT");
   ensureColumn(db, "tags", "harness", "TEXT NOT NULL DEFAULT 'opencode'");
   ensureColumn(db, "pending_ops", "harness", "TEXT NOT NULL DEFAULT 'opencode'");
@@ -144009,6 +144032,39 @@ function clearPendingCompactionMarkerStateIf(db, sessionId, expected) {
              WHERE session_id = ? AND pending_compaction_marker_state = ?`).run(sessionId, expectedBlob);
   return result.changes > 0;
 }
+function isPendingPiCompactionMarker(value) {
+  return typeof value === "object" && value !== null && typeof value.firstKeptEntryId === "string" && typeof value.endMessageId === "string" && typeof value.ordinal === "number" && typeof value.tokensBefore === "number" && typeof value.summary === "string" && typeof value.publishedAt === "number";
+}
+function getPendingPiCompactionMarkerState(db, sessionId) {
+  const row = db.prepare("SELECT pending_pi_compaction_marker_state FROM session_meta WHERE session_id = ?").get(sessionId);
+  const raw = row?.pending_pi_compaction_marker_state;
+  if (raw === null || raw === undefined || raw === "")
+    return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (isPendingPiCompactionMarker(parsed)) {
+      return parsed;
+    }
+  } catch {}
+  return null;
+}
+function setPendingPiCompactionMarkerState(db, sessionId, state) {
+  ensureSessionMetaRow(db, sessionId);
+  const blob = state ? stableStringify(state) : null;
+  db.prepare("UPDATE session_meta SET pending_pi_compaction_marker_state = ? WHERE session_id = ?").run(blob, sessionId);
+}
+function clearPendingPiCompactionMarkerStateIf(db, sessionId, expected) {
+  const expectedBlob = stableStringify(expected);
+  const result = db.prepare(`UPDATE session_meta SET pending_pi_compaction_marker_state = NULL
+             WHERE session_id = ? AND pending_pi_compaction_marker_state = ?`).run(sessionId, expectedBlob);
+  return result.changes > 0;
+}
+function getSessionsWithPendingPiMarker(db) {
+  const rows = db.prepare(`SELECT session_id FROM session_meta
+             WHERE pending_pi_compaction_marker_state IS NOT NULL
+               AND pending_pi_compaction_marker_state != ''`).all();
+  return rows.map((r) => r.session_id);
+}
 function peekDeferredExecutePending(db, sessionId) {
   const row = db.prepare("SELECT deferred_execute_state FROM session_meta WHERE session_id = ?").get(sessionId);
   const raw = row?.deferred_execute_state;
@@ -144129,6 +144185,12 @@ function getNoteById(db, noteId) {
   const row = db.prepare("SELECT * FROM notes WHERE id = ?").get(noteId);
   return isNoteRow(row) ? toNote(row) : null;
 }
+function noteBelongsToScope(note, scope) {
+  if (note.type === "session") {
+    return note.sessionId === scope.sessionId;
+  }
+  return note.projectPath === scope.projectPath;
+}
 function buildStatusClause(status) {
   if (status === undefined) {
     return null;
@@ -144190,9 +144252,9 @@ function getPendingSmartNotes(db, projectPath) {
 function getReadySmartNotes(db, projectPath) {
   return getSmartNotes(db, projectPath, "ready");
 }
-function updateNote(db, noteId, updates) {
+function updateNote(db, noteId, updates, scope) {
   const existing = getNoteById(db, noteId);
-  if (!existing) {
+  if (!existing || !noteBelongsToScope(existing, scope)) {
     return null;
   }
   const now = Date.now();
@@ -144239,7 +144301,11 @@ function updateNote(db, noteId, updates) {
   const result = db.prepare(`UPDATE notes SET ${sets.join(", ")} WHERE id = ? RETURNING *`).get(...params);
   return isNoteRow(result) ? toNote(result) : null;
 }
-function dismissNote(db, noteId) {
+function dismissNote(db, noteId, scope) {
+  const existing = getNoteById(db, noteId);
+  if (!existing || !noteBelongsToScope(existing, scope)) {
+    return false;
+  }
   const result = db.prepare("UPDATE notes SET status = 'dismissed', updated_at = ? WHERE id = ? AND status != 'dismissed'").run(Date.now(), noteId);
   return result.changes > 0;
 }
@@ -144901,7 +144967,21 @@ function resolveHistorianContextLimit(historianModelOverride) {
 
 // ../plugin/src/hooks/magic-context/event-resolvers.ts
 init_logger();
+var DEFAULT_CONTEXT_LIMIT = 128000;
 var MAX_EXECUTE_THRESHOLD = 80;
+function resolveContextLimit(providerID, modelID, ctx) {
+  const fromModelsDev = providerID && modelID ? getModelsDevContextLimit(providerID, modelID) : undefined;
+  const baseline = fromModelsDev ?? DEFAULT_CONTEXT_LIMIT;
+  if (ctx?.db && ctx.sessionID) {
+    try {
+      const overflow = getOverflowState(ctx.db, ctx.sessionID);
+      if (overflow.detectedContextLimit > 0 && overflow.detectedContextLimit < baseline) {
+        return overflow.detectedContextLimit;
+      }
+    } catch {}
+  }
+  return baseline;
+}
 function resolveCacheTtl(cacheTtl, modelKey) {
   if (typeof cacheTtl === "string") {
     return cacheTtl;
@@ -145269,6 +145349,14 @@ class PiSubagentRunner {
   }
   async run(options) {
     const startTime = Date.now();
+    if (options.signal?.aborted) {
+      return {
+        ok: false,
+        reason: "abort",
+        error: "pi subagent aborted by caller",
+        durationMs: Date.now() - startTime
+      };
+    }
     const args = buildArgs(options);
     return new Promise((resolve2) => {
       let settled = false;
@@ -145301,6 +145389,16 @@ class PiSubagentRunner {
         });
         return;
       }
+      if (options.signal?.aborted) {
+        terminateChild(child);
+        settle({
+          ok: false,
+          reason: "abort",
+          error: "pi subagent aborted by caller",
+          durationMs: Date.now() - startTime
+        });
+        return;
+      }
       emitProgress({ type: "spawned", argv: args, pid: child.pid });
       let stderr = "";
       child.stderr?.on("data", (chunk) => {
@@ -146297,6 +146395,43 @@ function normalizeProjectRelativePath(projectPath, filePath) {
     return null;
   return rel;
 }
+function isDocumentationOrMetaFile(rel) {
+  const lower = rel.toLowerCase();
+  if (lower.endsWith(".md") || lower.endsWith(".mdx") || lower.endsWith(".rst"))
+    return true;
+  if (lower.endsWith(".txt"))
+    return true;
+  const base = lower.split("/").pop() ?? "";
+  const baseNoExt = base.replace(/\.[^.]+$/, "");
+  const META_BASENAMES = new Set([
+    "license",
+    "licence",
+    "notice",
+    "copying",
+    "authors",
+    "contributors",
+    "changelog",
+    "changes",
+    "history",
+    "readme",
+    "contributing",
+    "code_of_conduct",
+    "security",
+    "support",
+    "maintainers",
+    "governance",
+    "package-lock",
+    "bun.lock",
+    "bun.lockb",
+    "yarn.lock",
+    "pnpm-lock",
+    "cargo.lock",
+    "uv.lock",
+    "poetry.lock",
+    "gemfile.lock"
+  ]);
+  return META_BASENAMES.has(base) || META_BASENAMES.has(baseNoExt);
+}
 function primarySessionIds(db) {
   try {
     const rows = db.prepare("SELECT session_id AS sessionId FROM session_meta WHERE is_subagent = 0").all();
@@ -146328,6 +146463,8 @@ function collectKeyFileCandidates(args) {
     const rel = normalizeProjectRelativePath(args.projectPath, row.file_path);
     if (!rel)
       continue;
+    if (isDocumentationOrMetaFile(rel))
+      continue;
     const timestamp = toMs(row.time_created);
     const candidate = byPath.get(rel) ?? {
       path: rel,
@@ -146464,7 +146601,8 @@ Rules:
 - Total approx_token_estimate must be < ${args.config.token_budget}.
 - path must be relative, no .., no absolute paths, no symlinks escaping project root.
 - path must be unique case-sensitively and case-insensitively.
-- content must be plain text; no XML tags inside.`;
+- content must be plain text; no XML tags inside.
+- DO NOT pick prose documentation (README.md, CONTRIBUTING.md, CHANGELOG, LICENSE, *.md/*.mdx/*.rst/*.txt) or lockfiles. Key files are project SOURCE the agent needs repeated orientation context on, not reference docs. Project docs are surfaced through a separate injection path.`;
 }
 function validateLlmOutput(raw, config, projectPath) {
   let obj;
@@ -148269,6 +148407,13 @@ async function evaluateSmartNotes(args) {
 For each note below, determine whether its surface condition has been met.
 You have access to tools like GitHub CLI (gh), web search, and the local codebase to verify conditions.
 
+You DO NOT have access to:
+- Any conversation between the user and the original agent that wrote the note
+- The state of any active session, including whether messages have been sent
+- The current task, mood, or intent of the human user
+
+If a condition references conversation context the user is having ("When the user mentions X", "When they ask to do Y", "When we revisit Z", "When relevant to current discussion", etc.), it is UNEVALUATABLE — skip it (do not include in results) so the note stays pending. These are misuse cases that should never have been written as smart notes; leaving them pending is the correct outcome, the dreamer's archive-stale task will eventually retire them.
+
 ## Pending Smart Notes
 
 ${noteDescriptions}
@@ -148277,7 +148422,8 @@ ${noteDescriptions}
 
 1. Check each condition using the tools available to you.
 2. Be conservative — only mark a condition as met when you have clear evidence.
-3. Respond with a JSON array of results:
+3. Skip conditions that depend on session/conversation context you cannot observe — do not invent a "false" verdict for them, just omit them from your response.
+4. Respond with a JSON array of results:
 
 \`\`\`json
 [
@@ -148285,7 +148431,7 @@ ${noteDescriptions}
 ]
 \`\`\`
 
-Only include notes whose conditions you could definitively evaluate. Skip notes where you cannot determine the status (they will be re-evaluated next run).`;
+Only include notes whose conditions you could definitively evaluate against external signals. Skip notes where you cannot determine the status (they will be re-evaluated next run, or eventually archived as stale).`;
   const taskStartedAt = Date.now();
   let agentSessionId = null;
   const abortController = new AbortController;
@@ -163039,7 +163185,6 @@ var MagicContextConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(true),
     min_clusters: exports_external.number().min(1).default(3)
   }).default({ enabled: true, min_clusters: 3 }),
-  compaction_markers: exports_external.boolean().default(true),
   system_prompt_injection: exports_external.object({
     enabled: exports_external.boolean().default(true),
     skip_signatures: exports_external.array(exports_external.string()).default(["<!-- magic-context: skip -->"])
@@ -164703,6 +164848,21 @@ var FILE_PATTERN = /\{file:([^}]+)\}/g;
 function substituteConfigVariables(input) {
   const warnings = [];
   let text = input.text;
+  if (input.isProjectConfig) {
+    const hasEnvTokens = ENV_PATTERN.test(text);
+    const hasFileTokens = FILE_PATTERN.test(text);
+    ENV_PATTERN.lastIndex = 0;
+    FILE_PATTERN.lastIndex = 0;
+    if (hasEnvTokens || hasFileTokens) {
+      const tokenTypes = [
+        hasEnvTokens ? "{env:}" : undefined,
+        hasFileTokens ? "{file:}" : undefined
+      ].filter(Boolean).join(" and ");
+      warnings.push(`Project-level config no longer supports ${tokenTypes} tokens for security reasons; leaving tokens literal. Move secret expansion to user-level config.`);
+    }
+    return { text, warnings };
+  }
+  text = stripJsonComments(text);
   text = text.replace(ENV_PATTERN, (_, rawName) => {
     const varName = rawName.trim();
     const value = varName ? process.env[varName] : undefined;
@@ -164710,7 +164870,7 @@ function substituteConfigVariables(input) {
       warnings.push(`Environment variable ${varName} is not set (referenced via {env:${varName}}); using empty string`);
       return "";
     }
-    return value;
+    return JSON.stringify(value).slice(1, -1);
   });
   const fileMatches = Array.from(text.matchAll(FILE_PATTERN));
   if (fileMatches.length === 0) {
@@ -166148,8 +166308,7 @@ var FORCE_COMPARTMENT_PERCENTAGE = 80;
 function getProactiveCompartmentTriggerPercentage(executeThresholdPercentage) {
   return Math.max(0, executeThresholdPercentage - PROACTIVE_TRIGGER_OFFSET_PERCENTAGE);
 }
-function estimateProjectedPostDropPercentage(db, sessionId, usage, autoDropToolAge, protectedTags, clearReasoningAge, clearedReasoningThroughTag, dropToolStructure = true) {
-  const activeTags = getTagsBySession(db, sessionId).filter((tag) => tag.status === "active");
+function estimateProjectedPostDropPercentage(db, sessionId, usage, activeTags, autoDropToolAge, protectedTags, clearReasoningAge, clearedReasoningThroughTag, dropToolStructure = true) {
   const totalActiveBytes = activeTags.reduce((sum, tag) => sum + tag.byteSize + tag.reasoningByteSize, 0);
   if (totalActiveBytes === 0)
     return null;
@@ -166236,15 +166395,24 @@ function getUnsummarizedTailInfo(db, sessionId, triggerBudget) {
     }
   });
 }
-function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPercentage, executeThresholdPercentage, triggerBudget, autoDropToolAge, protectedTagCount, clearReasoningAge, dropToolStructure = true, commitClusterTrigger) {
+function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPercentage, executeThresholdPercentage, triggerBudget, autoDropToolAge, protectedTagCount, clearReasoningAge, dropToolStructure = true, commitClusterTrigger, preloadedActiveTags) {
   if (sessionMeta.compartmentInProgress) {
+    sessionLog(sessionId, `compartment trigger: skipped — historian already in progress (usage=${usage.percentage.toFixed(1)}%)`);
     return { shouldFire: false };
   }
   const tailInfo = getUnsummarizedTailInfo(db, sessionId, triggerBudget);
   if (!tailInfo.hasNewRawHistory) {
+    try {
+      const lastCompartmentEnd = getLastCompartmentEndMessage(db, sessionId);
+      const rawMessageCount = getRawSessionMessageCount(sessionId);
+      const protectedTailStart = getProtectedTailStartOrdinal(sessionId);
+      sessionLog(sessionId, `compartment trigger: skipped — no new raw history (usage=${usage.percentage.toFixed(1)}% nextStartOrdinal=${tailInfo.nextStartOrdinal} lastCompartmentEnd=${lastCompartmentEnd} rawMessageCount=${rawMessageCount} protectedTailStart=${protectedTailStart})`);
+    } catch (error51) {
+      sessionLog(sessionId, `compartment trigger: skipped — no new raw history (usage=${usage.percentage.toFixed(1)}% nextStartOrdinal=${tailInfo.nextStartOrdinal} diagnostic-collection-failed: ${error51 instanceof Error ? error51.message : String(error51)})`);
+    }
     return { shouldFire: false };
   }
-  const projectedPostDropPercentage = estimateProjectedPostDropPercentage(db, sessionId, usage, autoDropToolAge, protectedTagCount, clearReasoningAge, sessionMeta.clearedReasoningThroughTag, dropToolStructure);
+  const projectedPostDropPercentage = estimateProjectedPostDropPercentage(db, sessionId, usage, preloadedActiveTags ?? getActiveTagsBySession(db, sessionId), autoDropToolAge, protectedTagCount, clearReasoningAge, sessionMeta.clearedReasoningThroughTag, dropToolStructure);
   const relativePostDropTarget = executeThresholdPercentage * POST_DROP_TARGET_RATIO;
   if (usage.percentage >= FORCE_COMPARTMENT_PERCENTAGE) {
     if (projectedPostDropPercentage !== null && projectedPostDropPercentage <= relativePostDropTarget) {
@@ -166266,6 +166434,7 @@ function checkCompartmentTrigger(db, sessionId, sessionMeta, usage, _previousPer
   }
   const proactiveTriggerPercentage = getProactiveCompartmentTriggerPercentage(executeThresholdPercentage);
   if (usage.percentage < proactiveTriggerPercentage) {
+    sessionLog(sessionId, `compartment trigger: not firing at ${usage.percentage.toFixed(1)}% — below proactive floor (${proactiveTriggerPercentage}%)`);
     return { shouldFire: false };
   }
   if (projectedPostDropPercentage !== null && projectedPostDropPercentage <= relativePostDropTarget) {
@@ -167667,11 +167836,12 @@ async function runAutoSearchHintForPi(args) {
   }) : args.entryIds;
   if (!options.enabled)
     return messages;
-  if (entryIds === null) {
-    sessionLog(sessionId, "Pi auto-search: strict entry-id resolution failed; skipping fresh decision");
-    return messages;
-  }
-  const found = findLatestMeaningfulUserMessage(messages, entryIds);
+  const strictResolutionFailed = entryIds === null;
+  const effectiveEntryIds = strictResolutionFailed ? messages.map((message) => {
+    const id = message.id;
+    return typeof id === "string" ? id : undefined;
+  }) : entryIds;
+  const found = findLatestMeaningfulUserMessage(messages, effectiveEntryIds);
   if (found === null)
     return messages;
   const { message: userMsg, messageId: userMsgId } = found;
@@ -167683,6 +167853,10 @@ async function runAutoSearchHintForPi(args) {
     }
     return messages;
   }
+  if (strictResolutionFailed) {
+    sessionLog(sessionId, "Pi auto-search: strict entry-id resolution failed; replayed persisted decisions only");
+    return messages;
+  }
   const writeNoHintAndReconcile = (reason) => {
     const outcome2 = appendAutoSearchHintDecision(db, sessionId, {
       messageId: userMsgId,
@@ -167769,6 +167943,59 @@ ${hintText}`;
 }
 function clearAutoSearchForPiSession(_sessionId) {}
 
+// src/compaction-marker-manager-pi.ts
+init_logger();
+function applyDeferredPiCompactionMarker(deps, sessionId, pending) {
+  try {
+    const matches = getCompartmentsByEndMessageId(deps.db, sessionId, pending.endMessageId);
+    if (matches.length === 0 || matches.length > 1) {
+      if (matches.length > 1) {
+        sessionLog(sessionId, `Pi compaction-marker drain: ${matches.length} compartments share endMessageId=${pending.endMessageId}; treating as stale`);
+      }
+      return { kind: "stale-skip", reason: "compartment-removed" };
+    }
+    if (matches[0]?.endMessage !== pending.ordinal) {
+      return { kind: "stale-skip", reason: "target-superseded" };
+    }
+    const branchEntries = deps.readBranchEntries();
+    if (!branchEntries.some((entry) => getEntryId(entry) === pending.firstKeptEntryId)) {
+      return { kind: "stale-skip", reason: "entry-removed" };
+    }
+    const latestFirstKept = findLatestCompactionFirstKept(branchEntries);
+    if (latestFirstKept === pending.firstKeptEntryId) {
+      return { kind: "already-current" };
+    }
+    deps.appendCompaction(pending.summary, pending.firstKeptEntryId, pending.tokensBefore, {
+      source: "magic-context",
+      lastCompactedOrdinal: pending.ordinal
+    }, true);
+    sessionLog(sessionId, `Pi compaction-marker drain: applied firstKept=${pending.firstKeptEntryId} tokensBefore=${pending.tokensBefore}`);
+    return { kind: "applied", firstKeptEntryId: pending.firstKeptEntryId };
+  } catch (err) {
+    const error51 = err instanceof Error ? err : new Error(String(err));
+    sessionLog(sessionId, `Pi compaction-marker drain: retryable failure for ordinal ${pending.ordinal}:`, error51);
+    return { kind: "retryable-failure", error: error51 };
+  }
+}
+function findLatestCompactionFirstKept(branchEntries) {
+  for (let i = branchEntries.length - 1;i >= 0; i--) {
+    const entry = branchEntries[i];
+    if (entry === null || typeof entry !== "object")
+      continue;
+    const record2 = entry;
+    if (record2.type === "compaction" && typeof record2.firstKeptEntryId === "string") {
+      return record2.firstKeptEntryId;
+    }
+  }
+  return null;
+}
+function getEntryId(entry) {
+  if (entry === null || typeof entry !== "object")
+    return null;
+  const id = entry.id;
+  return typeof id === "string" ? id : null;
+}
+
 // src/detect-recent-commit.ts
 var COMMIT_LOOKBACK = 5;
 var COMMIT_HASH_PATTERN2 = /\b[0-9a-f]{7,12}\b/;
@@ -169549,7 +169776,6 @@ async function runPiHistorian(deps) {
     memoryEnabled,
     autoPromote,
     onPublished,
-    appendCompaction,
     readBranchEntries,
     notifyIssue
   } = deps;
@@ -169722,20 +169948,34 @@ ${chunk.text}`, { stateFilePath });
         await notify(`Historian failed: ${errorMsg}`);
         return;
       }
+      const markerSummary = buildPiCompactionSummary(newCompartments);
+      const lastNewEndMessageId = newCompartments[newCompartments.length - 1]?.endMessageId;
+      let firstKeptEntryId = null;
+      if (readBranchEntries) {
+        try {
+          firstKeptEntryId = findFirstKeptEntryId(readBranchEntries(), lastNewEnd);
+          if (!firstKeptEntryId) {
+            sessionLog(sessionId, `historian: native compaction queue skipped; no firstKeptEntryId after ordinal ${lastNewEnd}`);
+          }
+        } catch (error51) {
+          sessionLog(sessionId, `historian: native compaction queue lookup failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
+        }
+      }
       db.transaction(() => {
         appendCompartments(db, sessionId, newCompartments);
         replaceSessionFacts(db, sessionId, validatedPass.facts ?? []);
         clearHistorianFailureState(db, sessionId);
+        if (firstKeptEntryId && lastNewEndMessageId) {
+          setPendingPiCompactionMarkerState(db, sessionId, {
+            firstKeptEntryId,
+            endMessageId: lastNewEndMessageId,
+            ordinal: lastNewEnd,
+            tokensBefore: chunk.tokenEstimate,
+            summary: markerSummary,
+            publishedAt: Date.now()
+          });
+        }
       })();
-      appendPiNativeCompaction({
-        sessionId,
-        appendCompaction,
-        readBranchEntries,
-        lastCompactedOrdinal: lastNewEnd,
-        tokensBefore: chunk.tokenEstimate,
-        summary: buildPiCompactionSummary(newCompartments)
-      });
-      clearInjectionCache(sessionId);
       onNoteTrigger(db, sessionId, "historian_complete");
       onPublished?.();
       if (memoryEnabled !== false && autoPromote !== false) {
@@ -169796,25 +170036,6 @@ function buildPiCompactionSummary(compartments) {
   }
   return `Magic Context compacted: ${titles.join("; ")}`;
 }
-function appendPiNativeCompaction(args) {
-  const { appendCompaction, readBranchEntries } = args;
-  if (!appendCompaction || !readBranchEntries)
-    return;
-  try {
-    const firstKeptEntryId = findFirstKeptEntryId(readBranchEntries(), args.lastCompactedOrdinal);
-    if (!firstKeptEntryId) {
-      sessionLog(args.sessionId, `historian: native compaction skipped; no firstKeptEntryId after ordinal ${args.lastCompactedOrdinal}`);
-      return;
-    }
-    appendCompaction(args.summary, firstKeptEntryId, args.tokensBefore, {
-      source: "magic-context",
-      lastCompactedOrdinal: args.lastCompactedOrdinal
-    }, true);
-    sessionLog(args.sessionId, `historian: appended native compaction firstKept=${firstKeptEntryId} tokensBefore=${args.tokensBefore}`);
-  } catch (error51) {
-    sessionLog(args.sessionId, `historian: native compaction append failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
-  }
-}
 function findFirstKeptEntryId(entries, lastCompactedOrdinal) {
   const rawMessages = convertEntriesToRawMessages(entries);
   const target = lastCompactedOrdinal + 1;
@@ -170695,6 +170916,19 @@ function stripTagPrefix2(text) {
   return text.slice(match[0].length);
 }
 
+// src/timeout.ts
+function withTimeout(p, ms) {
+  let handle;
+  const timeout = new Promise((resolve4) => {
+    handle = setTimeout(() => resolve4(undefined), ms);
+    handle.unref?.();
+  });
+  return Promise.race([p, timeout]).finally(() => {
+    if (handle)
+      clearTimeout(handle);
+  });
+}
+
 // src/tokenize-pi-messages.ts
 function tokenizePiMessages(messages) {
   let conversation = 0;
@@ -171197,6 +171431,7 @@ var deferredMaterializationSessions = new Set;
 var sessionsByProject = new Map;
 var lastSeenProjectIdentityBySession = new Map;
 var rawMessageProviderUnregistersBySession = new Map;
+var activeContextHandlerSessions = new Set;
 var lastHeuristicsTurnIdBySession = new Map;
 var firstContextPassSeenBySession = new Set;
 var recentReduceBySession = new Map;
@@ -171248,6 +171483,7 @@ function consumeDeferredMaterialization(sessionId) {
   return wasSet;
 }
 function trackSessionForProject(projectIdentity, sessionId) {
+  activeContextHandlerSessions.add(sessionId);
   let sessions = sessionsByProject.get(projectIdentity);
   if (!sessions) {
     sessions = new Set;
@@ -171255,6 +171491,9 @@ function trackSessionForProject(projectIdentity, sessionId) {
   }
   sessions.add(sessionId);
 }
+function isContextHandlerSessionActive(sessionId) {
+  return activeContextHandlerSessions.has(sessionId);
+}
 function updateSessionProjectTracking(sessionId, projectIdentity) {
   const prev = lastSeenProjectIdentityBySession.get(sessionId);
   if (prev && prev !== projectIdentity) {
@@ -171351,20 +171590,26 @@ function resolveSessionId2(ctx) {
     return;
   }
 }
-function collectMessageEntryIdsByRef(ctx, messages, sessionId) {
-  const sm = ctx.sessionManager;
-  if (typeof sm?.getBranch !== "function")
-    return null;
+function collectMessageEntryIdsByRef(ctx, messages, sessionId, preloadedBranchEntries) {
   let entries;
-  try {
-    entries = sm.getBranch.call(sm);
-  } catch (error51) {
-    sessionLog(sessionId ?? "pi", `collectMessageEntryIdsByRef getBranch failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
-    return null;
+  if (preloadedBranchEntries !== undefined) {
+    entries = preloadedBranchEntries;
+  } else {
+    const sm = ctx.sessionManager;
+    if (typeof sm?.getBranch !== "function")
+      return null;
+    try {
+      const branch = sm.getBranch.call(sm);
+      if (!Array.isArray(branch))
+        return null;
+      entries = branch;
+    } catch (error51) {
+      sessionLog(sessionId ?? "pi", `collectMessageEntryIdsByRef getBranch failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
+      return null;
+    }
   }
-  if (!Array.isArray(entries))
-    return null;
   const entryIdByMsgRef = new Map;
+  const entryIdsByFingerprint = new Map;
   for (const entry of entries) {
     if (!entry || typeof entry !== "object")
       continue;
@@ -171375,10 +171620,21 @@ function collectMessageEntryIdsByRef(ctx, messages, sessionId) {
       continue;
     if (!e.message || typeof e.message !== "object")
       continue;
-    entryIdByMsgRef.set(e.message, e.id);
+    const message = e.message;
+    entryIdByMsgRef.set(message, e.id);
+    const fingerprint = piMessageEntryFingerprint(e.message);
+    if (fingerprint) {
+      const bucket = entryIdsByFingerprint.get(fingerprint);
+      if (bucket)
+        bucket.push(e.id);
+      else
+        entryIdsByFingerprint.set(fingerprint, [e.id]);
+    }
   }
   const result = new Array(messages.length);
   let resolved = 0;
+  let fingerprintResolved = 0;
+  const consumedFingerprintIds = new Set;
   for (let i = 0;i < messages.length; i++) {
     const msg = messages[i];
     if (!msg || typeof msg !== "object") {
@@ -171389,15 +171645,67 @@ function collectMessageEntryIdsByRef(ctx, messages, sessionId) {
     if (typeof id === "string") {
       result[i] = id;
       resolved += 1;
+      continue;
+    }
+    const fingerprint = piMessageEntryFingerprint(msg);
+    const fingerprintId = fingerprint ? entryIdsByFingerprint.get(fingerprint)?.find((candidate) => !consumedFingerprintIds.has(candidate)) : undefined;
+    if (typeof fingerprintId === "string") {
+      consumedFingerprintIds.add(fingerprintId);
+      result[i] = fingerprintId;
+      resolved += 1;
+      fingerprintResolved += 1;
     } else {
       result[i] = undefined;
     }
   }
   if (resolved < messages.length) {
-    log(`[magic-context][pi]${sessionId ? `[${sessionId}]` : ""} ` + `collectMessageEntryIdsByRef: resolved=${resolved}/${messages.length} ` + `(branchEntries=${entries.length}, messageEntries=${entryIdByMsgRef.size}) — ` + `unmapped slots fall through to synthesized ids; boundary lookup still works ` + `for any compartment whose start/end message is among the resolved set`);
+    log(`[magic-context][pi]${sessionId ? `[${sessionId}]` : ""} ` + `collectMessageEntryIdsByRef: resolved=${resolved}/${messages.length} ` + `(fingerprint=${fingerprintResolved}, branchEntries=${entries.length}, messageEntries=${entryIdByMsgRef.size}) — ` + `unmapped slots fall through to synthesized ids; boundary lookup still works ` + `for any compartment whose start/end message is among the resolved set`);
   }
   return result;
 }
+function readPiBranchEntriesForContext(ctx, sessionId) {
+  const sm = ctx.sessionManager;
+  if (typeof sm?.getBranch !== "function")
+    return null;
+  try {
+    const entries = sm.getBranch.call(sm);
+    return Array.isArray(entries) ? entries : null;
+  } catch (error51) {
+    sessionLog(sessionId, `Pi branch pre-read failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
+    return null;
+  }
+}
+function piMessageEntryFingerprint(message) {
+  if (!message || typeof message !== "object")
+    return null;
+  const record2 = message;
+  if (typeof record2.role !== "string")
+    return null;
+  const firstText = firstPiTextContent(record2.content);
+  const firstTextHash = crypto2.createHash("sha256").update(firstText ?? "").digest("hex").slice(0, 16);
+  return JSON.stringify([
+    typeof record2.responseId === "string" ? record2.responseId : null,
+    typeof record2.timestamp === "number" || typeof record2.timestamp === "string" ? record2.timestamp : null,
+    record2.role,
+    typeof record2.toolCallId === "string" ? record2.toolCallId : null,
+    firstTextHash
+  ]);
+}
+function firstPiTextContent(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return null;
+  for (const part of content) {
+    if (!part || typeof part !== "object")
+      continue;
+    const record2 = part;
+    if (record2.type === "text" && typeof record2.text === "string") {
+      return record2.text;
+    }
+  }
+  return null;
+}
 function registerPiContextHandler(pi, options) {
   const tagger = createTagger();
   const schedulerConfig = options.scheduler ?? {
@@ -171429,15 +171737,16 @@ function registerPiContextHandler(pi, options) {
       const projectIdentity = resolveProjectIdentity(projectDirectory);
       updateSessionProjectTracking(sessionId, projectIdentity);
       logTransformTiming(sessionId, "findSessionId", tFindSession, `messages=${event.messages.length}`);
+      const branchEntries = readPiBranchEntriesForContext(ctx, sessionId);
       const rawMessageProvider = {
-        readMessages: () => readPiSessionMessages(ctx),
+        readMessages: () => branchEntries !== null ? convertEntriesToRawMessages([...branchEntries]) : readPiSessionMessages(ctx),
         readMessageById: (messageId) => readPiSessionMessageById(ctx, messageId)
       };
       rawMessageProviderUnregistersBySession.get(sessionId)?.();
       const unregisterRaw = setRawMessageProvider(sessionId, rawMessageProvider);
       rawMessageProviderUnregistersBySession.set(sessionId, unregisterRaw);
       scheduleReconciliation(options.db, sessionId, readRawSessionMessages);
-      const strictEntryIds = collectMessageEntryIdsByRef(ctx, event.messages, sessionId);
+      const strictEntryIds = branchEntries === null ? null : collectMessageEntryIdsByRef(ctx, event.messages, sessionId, branchEntries);
       const tLastUser = performance.now();
       const latestUser = findLatestUserMessageIdPi(event.messages, buildPiMessageIdByIndex(event.messages, strictEntryIds));
       logTransformTiming(sessionId, "findLastUserMessageId", tLastUser);
@@ -171559,10 +171868,7 @@ function registerPiContextHandler(pi, options) {
         const histPromise = inFlightHistorian.get(sessionId);
         if (histPromise) {
           try {
-            await Promise.race([
-              histPromise,
-              new Promise((resolve4) => setTimeout(resolve4, 30000))
-            ]);
+            await withTimeout(histPromise, 30000);
             sessionLog(sessionId, "EMERGENCY: historian wait completed (or timed out)");
           } catch {}
         }
@@ -171570,7 +171876,7 @@ function registerPiContextHandler(pi, options) {
       const isCacheBusting = historyRefreshSessions.has(sessionId);
       sessionLog(sessionId, `transform: usage=${usagePercentage.toFixed(1)}% (${usageInputTokens} tokens, limit=${usageContextLimit ?? "?"}) decision=${schedulerDecision}${forceMaterialization ? " force=true" : ""}${isEmergency ? " EMERGENCY=true" : ""}${isCacheBusting ? " busting=true" : ""}`);
       logTransformTiming(sessionId, "emergencyRecoveryBlock", tEmergencyRecovery);
-      const entryIds = collectMessageEntryIdsByRef(ctx, event.messages, sessionId) ?? undefined;
+      const entryIds = strictEntryIds ?? undefined;
       const result = await runPipeline({
         db: options.db,
         tagger,
@@ -171592,7 +171898,9 @@ function registerPiContextHandler(pi, options) {
         reasoningClearing: {
           clearReasoningAge: options.heuristics?.clearReasoningAge ?? DEFAULT_CLEAR_REASONING_AGE
         },
-        temporalAwareness: options.injection?.temporalAwareness === true
+        temporalAwareness: options.injection?.temporalAwareness === true,
+        appendCompaction: resolvePiAppendCompaction(ctx),
+        readBranchEntries: resolvePiReadBranchEntries(ctx)
       });
       if (options.historian) {
         maybeFireHistorian({
@@ -171600,7 +171908,9 @@ function registerPiContextHandler(pi, options) {
           sessionId,
           db: options.db,
           historian: options.historian,
-          isFirstContextPassForSession
+          isFirstContextPassForSession,
+          activeTags: result.activeTags,
+          rawMessageProvider
         });
         maybeFireCompressor({
           ctx,
@@ -171719,6 +172029,43 @@ async function awaitInFlightHistorians() {
   ];
   await Promise.allSettled(promises);
 }
+function splitModelKeyForPi(modelKey) {
+  if (!modelKey)
+    return { providerID: undefined, modelID: undefined };
+  const slash = modelKey.indexOf("/");
+  if (slash <= 0 || slash === modelKey.length - 1) {
+    return { providerID: undefined, modelID: undefined };
+  }
+  return {
+    providerID: modelKey.slice(0, slash),
+    modelID: modelKey.slice(slash + 1)
+  };
+}
+function resolvePiHistorianTriggerInputs(args) {
+  const { providerID, modelID } = splitModelKeyForPi(args.modelKey);
+  let contextLimit = resolveContextLimit(providerID, modelID, {
+    db: args.db,
+    sessionID: args.sessionId
+  });
+  if ((providerID === undefined || modelID === undefined) && typeof args.usageContextLimit === "number" && Number.isFinite(args.usageContextLimit) && args.usageContextLimit > 0) {
+    contextLimit = args.usageContextLimit;
+  }
+  const executeThresholdPercentage = resolveExecuteThreshold(args.historian.executeThresholdPercentage ?? 65, args.modelKey, 65, {
+    tokensConfig: args.historian.executeThresholdTokens,
+    contextLimit,
+    sessionId: args.sessionId
+  });
+  return {
+    executeThresholdPercentage,
+    triggerBudget: deriveTriggerBudget(contextLimit, executeThresholdPercentage),
+    autoDropToolAge: args.historian.autoDropToolAge ?? 100,
+    protectedTags: args.historian.protectedTags,
+    clearReasoningAge: args.historian.clearReasoningAge ?? DEFAULT_CLEAR_REASONING_AGE,
+    dropToolStructure: args.historian.dropToolStructure ?? true,
+    commitClusterTrigger: args.historian.commitClusterTrigger,
+    contextLimit
+  };
+}
 function resolveHistoryBudgetTokensForPi(args) {
   const {
     historyBudgetPercentage,
@@ -171777,6 +172124,10 @@ function maybeFireCompressor(args) {
     maxCompartmentsPerPass: compressor.maxCompartmentsPerPass,
     graceCompartments: compressor.graceCompartments,
     onPublished: () => {
+      if (!isContextHandlerSessionActive(sessionId)) {
+        sessionLog(sessionId, "compressor publication ignored: session was cleared");
+        return;
+      }
       signalPiDeferredHistoryRefresh(sessionId);
       signalPiDeferredMaterialization(sessionId);
       historian.onStatusChange?.(ctx, sessionId);
@@ -171789,7 +172140,9 @@ function maybeFireCompressor(args) {
     sessionLog(sessionId, `compressor failed in background: ${err instanceof Error ? err.message : String(err)}`);
   }).finally(() => {
     inFlightCompressor.delete(sessionId);
-    historian.onStatusChange?.(ctx, sessionId);
+    if (isContextHandlerSessionActive(sessionId)) {
+      historian.onStatusChange?.(ctx, sessionId);
+    }
   });
   inFlightCompressor.set(sessionId, runPromise);
 }
@@ -171834,6 +172187,10 @@ function spawnPiHistorianRun(args) {
     memoryEnabled: historian.memoryEnabled,
     autoPromote: historian.autoPromote,
     onPublished: () => {
+      if (!isContextHandlerSessionActive(sessionId)) {
+        sessionLog(sessionId, "historian publication ignored: session was cleared");
+        return;
+      }
       try {
         clearEmergencyRecovery(db, sessionId);
       } catch (err) {
@@ -171846,7 +172203,9 @@ function spawnPiHistorianRun(args) {
   }).finally(() => {
     inFlightHistorian.delete(sessionId);
     unregister();
-    historian.onStatusChange?.(ctx, sessionId);
+    if (isContextHandlerSessionActive(sessionId)) {
+      historian.onStatusChange?.(ctx, sessionId);
+    }
   });
   inFlightHistorian.set(sessionId, runPromise);
   historian.onStatusChange?.(ctx, sessionId);
@@ -171877,7 +172236,10 @@ function maybeFireHistorian(args) {
     return;
   }
   let usage;
+  let usageContextLimit;
   try {
+    const piUsage = ctx.getContextUsage?.();
+    usageContextLimit = typeof piUsage?.contextWindow === "number" && piUsage.contextWindow > 0 ? piUsage.contextWindow : undefined;
     const sessionMetaForUsage = getOrCreateSessionMeta(db, sessionId);
     if (sessionMetaForUsage.lastContextPercentage > 0 && sessionMetaForUsage.lastInputTokens > 0) {
       usage = {
@@ -171886,7 +172248,6 @@ function maybeFireHistorian(args) {
       };
       sessionLog(sessionId, `historian trigger eval: usage=${usage.percentage.toFixed(1)}% (${usage.inputTokens} tokens) [from session_meta], checking trigger...`);
     } else {
-      const piUsage = ctx.getContextUsage?.();
       if (!piUsage || piUsage.tokens === null || piUsage.percent === null || piUsage.contextWindow === 0) {
         sessionLog(sessionId, `historian trigger eval: no usage info yet (tokens=${piUsage?.tokens ?? "<no piUsage>"}, percent=${piUsage?.percent ?? "<no piUsage>"}, contextWindow=${piUsage?.contextWindow ?? "<no piUsage>"})`);
         return;
@@ -171901,7 +172262,7 @@ function maybeFireHistorian(args) {
     sessionLog(sessionId, `historian trigger eval: getContextUsage threw: ${err instanceof Error ? err.message : String(err)}`);
     return;
   }
-  const provider2 = {
+  const provider2 = args.rawMessageProvider ?? {
     readMessages: () => readPiSessionMessages(ctx)
   };
   const unregister = setRawMessageProvider(sessionId, provider2);
@@ -171933,7 +172294,15 @@ Historian previously failed ${failureState.failureCount} time(s), so magic-conte
       }
     }
     const sessionMeta = getOrCreateSessionMeta(db, sessionId);
-    const trigger = checkCompartmentTrigger(db, sessionId, sessionMeta, usage, 0, resolveExecuteThreshold(historian.executeThresholdPercentage ?? 65, liveModelBySession.get(sessionId), 65), historian.triggerBudget ?? 8000);
+    const modelKey = liveModelBySession.get(sessionId);
+    const triggerInputs = resolvePiHistorianTriggerInputs({
+      db,
+      sessionId,
+      historian,
+      modelKey,
+      usageContextLimit
+    });
+    const trigger = checkCompartmentTrigger(db, sessionId, sessionMeta, usage, 0, triggerInputs.executeThresholdPercentage, triggerInputs.triggerBudget, triggerInputs.autoDropToolAge, triggerInputs.protectedTags, triggerInputs.clearReasoningAge, triggerInputs.dropToolStructure, triggerInputs.commitClusterTrigger, args.activeTags);
     if (!trigger.shouldFire) {
       sessionLog(sessionId, `historian trigger eval: shouldFire=false (no trigger condition met)`);
       return;
@@ -171951,12 +172320,17 @@ Historian previously failed ${failureState.failureCount} time(s), so magic-conte
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     sessionLog(sessionId, `historian trigger eval failed: ${message}`);
+  } finally {
     if (!triggered)
       unregister();
   }
 }
 async function runPipeline(args) {
   let executedWorkThisPass = false;
+  let historyWasConsumedThisPass = false;
+  let suppressDeferredHistoryDrain = false;
+  let casLost = false;
+  const deferredHistoryWasPendingAtPassStart = deferredHistoryRefreshSessions.has(args.sessionId);
   if (args.temporalAwareness) {
     const tTemporal = performance.now();
     try {
@@ -171997,7 +172371,7 @@ async function runPipeline(args) {
   }
   const hasPendingMaterializeSignal = hasPendingMaterialization(args.sessionId);
   const deferredMaterializationWasPending = deferredMaterializationSessions.has(args.sessionId);
-  const deferredHistoryRefreshWasPending = deferredHistoryRefreshSessions.has(args.sessionId);
+  const deferredHistoryRefreshWasPending = deferredHistoryWasPendingAtPassStart;
   const pendingOps = getPendingOps(args.db, args.sessionId);
   const baseShouldApplyPendingOps = args.schedulerDecision === "execute" || args.forceMaterialization || hasPendingMaterializeSignal;
   const canConsumeDeferredLate = baseShouldApplyPendingOps || shouldRunHeuristics;
@@ -172140,9 +172514,10 @@ async function runPipeline(args) {
       injectionResult = injectSessionHistoryIntoPi(args.db, args.sessionId, args.messages, args.isCacheBusting || deferredHistoryRefresh, args.projectIdentity, args.injection.injectionBudgetTokens, args.injection.temporalAwareness, args.entryIds);
       if (args.isCacheBusting) {
         historyRefreshSessions.delete(args.sessionId);
+        historyWasConsumedThisPass = true;
       }
       if (deferredHistoryRefresh) {
-        consumeDeferredHistoryRefresh(args.sessionId);
+        historyWasConsumedThisPass = true;
       }
       logTransformTiming(args.sessionId, "prepareCompartmentInjection", tInjection);
       logTransformTiming(args.sessionId, "compartmentPhase", tInjection);
@@ -172156,6 +172531,34 @@ async function runPipeline(args) {
     messages: args.messages,
     isCacheBusting: args.isCacheBusting
   });
+  const deferredHistoryDrainEligible = historyWasConsumedThisPass && deferredHistoryWasPendingAtPassStart && !suppressDeferredHistoryDrain && !casLost;
+  if (deferredHistoryDrainEligible) {
+    try {
+      const pending = getPendingPiCompactionMarkerState(args.db, args.sessionId);
+      if (!pending) {
+        consumeDeferredHistoryRefresh(args.sessionId);
+      } else if (!args.appendCompaction || !args.readBranchEntries) {
+        suppressDeferredHistoryDrain = true;
+        sessionLog(args.sessionId, "Pi compaction-marker drain skipped: sessionManager appendCompaction/getBranch unavailable; preserving deferred-history signal");
+      } else {
+        const outcome = applyDeferredPiCompactionMarker({
+          db: args.db,
+          appendCompaction: args.appendCompaction,
+          readBranchEntries: args.readBranchEntries
+        }, args.sessionId, pending);
+        if (outcome.kind === "retryable-failure") {
+          sessionLog(args.sessionId, `Pi compaction-marker drain retryable failure: ${outcome.error.message}`);
+        } else if (clearPendingPiCompactionMarkerStateIf(args.db, args.sessionId, pending)) {
+          consumeDeferredHistoryRefresh(args.sessionId);
+        } else {
+          casLost = true;
+          sessionLog(args.sessionId, "CAS-clear failed (newer blob written or another actor cleared); preserving deferred-history signal");
+        }
+      }
+    } catch (err) {
+      sessionLog(args.sessionId, `Pi compaction-marker drain failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
   if (executedWorkThisPass) {
     try {
       const currentFlag = peekDeferredExecutePending(args.db, args.sessionId);
@@ -172185,7 +172588,8 @@ async function runPipeline(args) {
     heuristicsResult,
     injectionResult,
     targetCount: targets.size,
-    reasoningWatermark: getOrCreateSessionMeta(args.db, args.sessionId).clearedReasoningThroughTag ?? 0
+    reasoningWatermark: getOrCreateSessionMeta(args.db, args.sessionId).clearedReasoningThroughTag ?? 0,
+    activeTags
   };
 }
 function applyRollingNudge(args) {
@@ -172217,11 +172621,15 @@ function applyStickyTurnReminder(args) {
   const messageIdByIndex = buildPiMessageIdByIndex(args.messages, args.entryIds);
   if (reminder.messageId) {
     const reinjected = appendReminderToUserMessageByIdPi(args.messages, messageIdByIndex, reminder.messageId, reminder.text);
-    if (!reinjected && args.isCacheBustingPass) {
+    if (!reinjected && args.isCacheBustingPass && args.entryIds !== null) {
       clearPersistedStickyTurnReminder(args.db, args.sessionId);
     }
     return args.messages;
   }
+  if (args.entryIds === null) {
+    sessionLog(args.sessionId, "Pi sticky turn reminder: strict resolution failed; replay-only until next pass");
+    return args.messages;
+  }
   const latest = findLatestUserMessageIdPi(args.messages, messageIdByIndex);
   if (latest) {
     appendReminderToPiUserMessage(args.messages[latest.index], reminder.text);
@@ -172303,8 +172711,6 @@ function buildPiMessageIdByIndex(messages, entryIds) {
     const messageId = messages[index]?.id;
     if (typeof messageId === "string") {
       ids.set(index, messageId);
-    } else if (entryIds === null) {
-      ids.set(index, `pi:${index}:${readTimestamp(messages[index])}`);
     }
   }
   return ids;
@@ -172333,10 +172739,6 @@ function appendReminderToUserMessageByIdPi(messages, messageIdByIndex, messageId
   }
   return false;
 }
-function readTimestamp(message) {
-  const ts = message.timestamp;
-  return typeof ts === "number" && Number.isFinite(ts) ? String(ts) : "no-ts";
-}
 function appendReminderToPiUserMessage(message, reminder) {
   if (message.role !== "user")
     return;
@@ -172363,6 +172765,7 @@ function appendReminderToPiUserMessage(message, reminder) {
   contentArr.push({ type: "text", text: reminder.trimStart() });
 }
 function clearContextHandlerSession(sessionId) {
+  activeContextHandlerSessions.delete(sessionId);
   clearAutoSearchForPiSession(sessionId);
   lastEmergencyNotificationAtMs.delete(sessionId);
   historyRefreshSessions.delete(sessionId);
@@ -173501,7 +173904,7 @@ async function executePartialRecompInternal(deps, range) {
       }
       deps.onCompartmentStatePublished?.(sessionId);
       const lastEnd = merged[merged.length - 1]?.endMessage ?? snapEnd;
-      if (deps.experimentalCompactionMarkers && lastEnd > 0) {
+      if (lastEnd > 0) {
         updateCompactionMarkerAfterPublication(db, sessionId, lastEnd, deps.directory);
         const stalePending = getPendingCompactionMarkerState(db, sessionId);
         if (stalePending) {
@@ -173760,7 +174163,7 @@ Found ${existingStaging.compartments.length} staged compartment(s) from ${existi
       if (lastCompartmentEnd2 > 0) {
         queueDropsForCompartmentalizedMessages(db, sessionId, lastCompartmentEnd2);
       }
-      if (deps.experimentalCompactionMarkers && lastCompartmentEnd2 > 0) {
+      if (lastCompartmentEnd2 > 0) {
         updateCompactionMarkerAfterPublication(db, sessionId, lastCompartmentEnd2, deps.directory);
         const stalePending = getPendingCompactionMarkerState(db, sessionId);
         if (stalePending) {
@@ -174184,6 +174587,7 @@ Historian recomp started. Rebuilding compartments and facts from raw Pi session
           text: result,
           level: inferLevel(result)
         });
+        queueAndApplyPiRecompMarker({ db: deps.db, sessionId, ctx });
         signalPiHistoryRefresh(sessionId);
         signalPiPendingMaterialization(sessionId);
         clearPiCompressorState(sessionId);
@@ -174206,6 +174610,60 @@ ${describeError(error51).brief}`,
     }
   });
 }
+function queueAndApplyPiRecompMarker(args) {
+  const appendCompaction = resolvePiAppendCompaction2(args.ctx);
+  const readBranchEntries = resolvePiReadBranchEntries2(args.ctx);
+  if (!appendCompaction || !readBranchEntries)
+    return;
+  const compartments = getCompartments(args.db, args.sessionId);
+  const last = compartments[compartments.length - 1];
+  if (!last)
+    return;
+  let firstKeptEntryId = null;
+  try {
+    firstKeptEntryId = findFirstKeptEntryId(readBranchEntries(), last.endMessage);
+  } catch {
+    firstKeptEntryId = null;
+  }
+  if (!firstKeptEntryId || last.endMessageId.length === 0)
+    return;
+  const pending = {
+    firstKeptEntryId,
+    endMessageId: last.endMessageId,
+    ordinal: last.endMessage,
+    tokensBefore: 0,
+    summary: buildPiCompactionSummary(compartments),
+    publishedAt: Date.now()
+  };
+  setPendingPiCompactionMarkerState(args.db, args.sessionId, pending);
+  const outcome = applyDeferredPiCompactionMarker({ db: args.db, appendCompaction, readBranchEntries }, args.sessionId, pending);
+  if (outcome.kind === "retryable-failure") {
+    signalPiDeferredHistoryRefresh(args.sessionId);
+    return;
+  }
+  if (!clearPendingPiCompactionMarkerStateIf(args.db, args.sessionId, pending)) {
+    signalPiDeferredHistoryRefresh(args.sessionId);
+  }
+}
+function resolvePiAppendCompaction2(ctx) {
+  const sm = ctx?.sessionManager;
+  if (typeof sm?.appendCompaction !== "function")
+    return;
+  return sm.appendCompaction.bind(sm);
+}
+function resolvePiReadBranchEntries2(ctx) {
+  const sm = ctx?.sessionManager;
+  if (typeof sm?.getBranch !== "function")
+    return;
+  return () => {
+    try {
+      const entries = sm.getBranch?.call(sm);
+      return Array.isArray(entries) ? entries : [];
+    } catch {
+      return [];
+    }
+  };
+}
 function parseRecompArgs(raw) {
   const trimmed = raw.trim();
   if (trimmed.length === 0)
@@ -174477,7 +174935,7 @@ import {
 // package.json
 var package_default = {
   name: "@cortexkit/pi-magic-context",
-  version: "0.21.2",
+  version: "0.21.5",
   type: "module",
   description: "Pi coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -179579,8 +180037,15 @@ function createCtxNoteTool(deps) {
         if (typeof params.note_id !== "number") {
           return err3("Error: 'note_id' is required when action is 'dismiss'.");
         }
-        const dismissed = dismissNote(deps.db, params.note_id);
-        return ok3(dismissed ? `Note #${params.note_id} dismissed.` : `Note #${params.note_id} not found or already dismissed.`);
+        const projectIdentity = resolveProjectIdentity(ctx.cwd);
+        if (!projectIdentity) {
+          return err3("Error: Could not resolve project identity for note dismiss.");
+        }
+        const dismissed = dismissNote(deps.db, params.note_id, {
+          projectPath: projectIdentity,
+          sessionId
+        });
+        return dismissed ? ok3(`Note #${params.note_id} dismissed.`) : err3(`Error: Note #${params.note_id} not found in your session/project or already dismissed.`);
       }
       if (action2 === "update") {
         if (typeof params.note_id !== "number") {
@@ -179594,9 +180059,16 @@ function createCtxNoteTool(deps) {
         if (!updates.content && !updates.surfaceCondition) {
           return err3("Error: Provide 'content' and/or 'surface_condition' to update.");
         }
-        const updated = updateNote(deps.db, params.note_id, updates);
+        const projectIdentity = resolveProjectIdentity(ctx.cwd);
+        if (!projectIdentity) {
+          return err3("Error: Could not resolve project identity for note update.");
+        }
+        const updated = updateNote(deps.db, params.note_id, updates, {
+          projectPath: projectIdentity,
+          sessionId
+        });
         if (!updated) {
-          return err3(`Note #${params.note_id} not found.`);
+          return err3(`Error: Note #${params.note_id} not found in your session/project.`);
         }
         const parts = [];
         if (updates.content)
@@ -180207,7 +180679,6 @@ function resolveHistorianFromConfig(config2) {
   if (!model || model.length === 0)
     return;
   const historianContextLimit = resolveHistorianContextLimit(model);
-  const triggerBudget = deriveTriggerBudget(historianContextLimit, 65);
   const historianChunkTokens = deriveHistorianChunkTokens(historianContextLimit);
   const fbRaw = historian?.fallback_models;
   const fallbackModels = typeof fbRaw === "string" ? [fbRaw] : fbRaw;
@@ -180220,7 +180691,12 @@ function resolveHistorianFromConfig(config2) {
     twoPass: historian?.two_pass === true,
     thinkingLevel: historian?.thinking_level,
     executeThresholdPercentage: config2.execute_threshold_percentage,
-    triggerBudget,
+    executeThresholdTokens: config2.execute_threshold_tokens,
+    commitClusterTrigger: config2.commit_cluster_trigger,
+    autoDropToolAge: config2.auto_drop_tool_age,
+    protectedTags: config2.protected_tags,
+    clearReasoningAge: config2.clear_reasoning_age,
+    dropToolStructure: config2.drop_tool_structure,
     historyBudgetPercentage: config2.history_budget_percentage,
     compressor: {
       enabled: config2.compressor.enabled,
@@ -180270,6 +180746,17 @@ async function src_default2(pi) {
   const projectDir = process.cwd();
   const projectIdentity = resolveProjectIdentity(projectDir);
   const seenDreamerProjectIdentities = new Set([projectIdentity]);
+  try {
+    const pendingPiMarkerSessions = getSessionsWithPendingPiMarker(db);
+    for (const sid of pendingPiMarkerSessions) {
+      signalPiDeferredHistoryRefresh(sid);
+    }
+    if (pendingPiMarkerSessions.length > 0) {
+      log(`${PREFIX2} rehydrated ${pendingPiMarkerSessions.length} Pi deferred compaction marker session(s)`);
+    }
+  } catch (err5) {
+    warn(`Magic Context (pi) failed to rehydrate deferred Pi compaction markers: ${err5 instanceof Error ? err5.message : String(err5)}`);
+  }
   info(`loaded v${PLUGIN_VERSION} | harness=pi | db=${dbPath} | ` + `project=${projectIdentity} | dir=${projectDir}`);
   const { config: config2, warnings, loadedFromPaths } = loadPiConfig({
     cwd: projectDir
@@ -180625,18 +181112,12 @@ ${block}` : event.systemPrompt;
   pi.on("session_shutdown", async (_event, ctx) => {
     const SHUTDOWN_DRAIN_MS = 5000;
     try {
-      await Promise.race([
-        awaitInFlightHistorians(),
-        new Promise((resolve4) => setTimeout(resolve4, SHUTDOWN_DRAIN_MS))
-      ]);
+      await withTimeout(awaitInFlightHistorians(), SHUTDOWN_DRAIN_MS);
     } catch (err5) {
       warn("shutdown: historian drain threw:", err5);
     }
     try {
-      await Promise.race([
-        awaitInFlightDreamers(),
-        new Promise((resolve4) => setTimeout(resolve4, SHUTDOWN_DRAIN_MS))
-      ]);
+      await withTimeout(awaitInFlightDreamers(), SHUTDOWN_DRAIN_MS);
     } catch (err5) {
       warn("shutdown: dreamer drain threw:", err5);
     }