@cortexkit/pi-magic-context 0.21.0 → 0.21.1

package/dist/index.js

@@ -143698,6 +143698,13 @@ function getDefaultHistorianFailureState() {
     lastFailureAt: null
   };
 }
+function setPersistedReasoningWatermark(db, sessionId, tagNumber) {
+  ensureSessionMetaRow(db, sessionId);
+  db.prepare("UPDATE session_meta SET cleared_reasoning_through_tag = ? WHERE session_id = ?").run(tagNumber, sessionId);
+}
+function clearPersistedReasoningWatermark(db, sessionId) {
+  setPersistedReasoningWatermark(db, sessionId, 0);
+}
 function getPersistedStickyTurnReminder(db, sessionId) {
   const result = db.prepare("SELECT sticky_turn_reminder_text, sticky_turn_reminder_message_id FROM session_meta WHERE session_id = ?").get(sessionId);
   if (!isPersistedStickyTurnReminderRow(result)) {
@@ -143939,6 +143946,12 @@ function clearEmergencyRecovery(db, sessionId) {
     db.prepare("UPDATE session_meta SET needs_emergency_recovery = 0 WHERE session_id = ?").run(sessionId);
   })();
 }
+function clearDetectedContextLimit(db, sessionId) {
+  db.transaction(() => {
+    ensureSessionMetaRow(db, sessionId);
+    db.prepare("UPDATE session_meta SET detected_context_limit = 0 WHERE session_id = ?").run(sessionId);
+  })();
+}
 function getPersistedCompactionMarkerState(db, sessionId) {
   const row = db.prepare("SELECT compaction_marker_state FROM session_meta WHERE session_id = ?").get(sessionId);
   const raw = row?.compaction_marker_state;
@@ -145455,10 +145468,10 @@ class PiSubagentRunner {
             });
             return;
           }
-          if (finalStopReason === "error" || finalStopReason === "aborted") {
+          if (finalStopReason === "error" || finalStopReason === "aborted" || finalStopReason === "length") {
             settle({
               ok: false,
-              reason: "model_failed",
+              reason: finalStopReason === "length" ? "truncated" : "model_failed",
               error: finalErrorMessage ?? `pi assistant stopped with reason "${finalStopReason}"`,
               durationMs: Date.now() - startTime,
               meta: { stderr: stderr.length > 0 ? stderr : undefined }
@@ -145580,10 +145593,18 @@ function parsePiEventLine(line) {
   }
 }
 function terminateChild(child) {
+  let exited = false;
+  child.once("close", () => {
+    exited = true;
+  });
+  child.once("exit", () => {
+    exited = true;
+  });
   child.kill("SIGTERM");
   const killHandle = setTimeout(() => {
-    if (!child.killed)
+    if (!exited && child.exitCode === null && child.signalCode === null) {
       child.kill("SIGKILL");
+    }
   }, 2000);
   if (typeof killHandle.unref === "function") {
     killHandle.unref();
@@ -164952,7 +164973,6 @@ function loadPiConfigDetailed(opts = {}) {
 // src/embedding-bootstrap.ts
 async function ensureProjectRegisteredFromPiDirectory(directory, db) {
   const projectIdentity = resolveProjectIdentity(directory);
-  invalidateProject(projectIdentity);
   const detailed = loadPiConfigDetailed({ cwd: directory });
   if (isConfigLoadUntrusted(detailed)) {
     handleUntrustedLoad(db, projectIdentity, directory, detailed);
@@ -164971,6 +164991,7 @@ var sessionsById = new Map;
 var inFlightDreams = new Set;
 var sessionCounter = 0;
 var piSubagentRunnerFactory = () => new PiSubagentRunner;
+var startDreamScheduleTimerFn = startDreamScheduleTimer;
 function registerPiDreamerProject(opts) {
   if (!opts.config.enabled) {
     return;
@@ -164991,7 +165012,8 @@ function registerPiDreamerProject(opts) {
     min_reads: opts.config.pin_key_files.min_reads
   } : undefined;
   let cleanup;
-  startDreamScheduleTimer({
+  let cancelled = false;
+  startDreamScheduleTimerFn({
     directory: opts.projectDir,
     projectIdentity: opts.projectIdentity,
     client,
@@ -165001,6 +165023,10 @@ function registerPiDreamerProject(opts) {
     gitCommitIndexing: opts.gitCommitIndexing,
     ensureRegistered: ensureProjectRegisteredFromPiDirectory
   }).then((timerCleanup) => {
+    if (cancelled) {
+      timerCleanup?.();
+      return;
+    }
     cleanup = timerCleanup;
   });
   const runOnce = async () => processDreamQueue({
@@ -165014,7 +165040,10 @@ function registerPiDreamerProject(opts) {
     projectIdentity: opts.projectIdentity
   });
   registeredProjects2.set(opts.projectIdentity, {
-    cleanup: () => cleanup?.(),
+    cleanup: () => {
+      cancelled = true;
+      cleanup?.();
+    },
     runOnce
   });
 }
@@ -165086,6 +165115,7 @@ function createPiDreamerClient(opts) {
             { type: "text", text: result.assistantText }
           ])
         ];
+        opts.onAdjunctsRefreshNeeded?.(opts.projectIdentity);
       } finally {
         inFlightDreams.delete(runPromise);
       }
@@ -165189,21 +165219,37 @@ function sendCtxStatusMessage(pi, content, details) {
 function registerCtxDreamCommand(pi, deps) {
   pi.registerCommand("ctx-dream", {
     description: "Run a Magic Context dreamer cycle for this project now",
-    handler: async () => {
-      const enqueued = enqueueDream(deps.db, deps.projectIdentity, "manual");
+    handler: async (_args, ctx) => {
+      const project = deps.resolveProject?.(ctx) ?? {
+        projectDir: deps.projectDir,
+        projectIdentity: deps.projectIdentity
+      };
+      deps.onProjectSeen?.(project.projectIdentity);
+      if (deps.dreamerEnabled === false) {
+        sendCtxStatusMessage(pi, {
+          title: "/ctx-dream",
+          text: "## /ctx-dream\n\nDreamer is not configured for this project (`dreamer.enabled=false`).",
+          level: "info"
+        }, {
+          projectDir: project.projectDir,
+          projectIdentity: project.projectIdentity
+        });
+        return;
+      }
+      const enqueued = enqueueDream(deps.db, project.projectIdentity, "manual", true);
       if (!enqueued) {
         sendCtxStatusMessage(pi, {
           title: "/ctx-dream",
           text: [
             "## /ctx-dream",
             "",
-            `Dream already queued or running for ${deps.projectIdentity}.`
+            `Dream already queued or running for ${project.projectIdentity}.`
           ].join(`
 `),
           level: "info"
         }, {
-          projectDir: deps.projectDir,
-          projectIdentity: deps.projectIdentity,
+          projectDir: project.projectDir,
+          projectIdentity: project.projectIdentity,
           entry: null
         });
         return;
@@ -165213,18 +165259,18 @@ function registerCtxDreamCommand(pi, deps) {
         text: [
           "## /ctx-dream",
           "",
-          `Starting dream run #${enqueued.id} for ${deps.projectIdentity}…`,
-          `Project directory: ${deps.projectDir}`
+          `Starting dream run #${enqueued.id} for ${project.projectIdentity}…`,
+          `Project directory: ${project.projectDir}`
         ].join(`
 `),
         level: "info"
       }, {
-        projectDir: deps.projectDir,
-        projectIdentity: deps.projectIdentity,
+        projectDir: project.projectDir,
+        projectIdentity: project.projectIdentity,
         entry: enqueued
       });
       try {
-        const result = await runPiDreamForProject(deps.projectIdentity);
+        const result = await runPiDreamForProject(project.projectIdentity);
         let summary;
         if (!result) {
           summary = "Dream queued, but another worker is already processing the queue.";
@@ -165250,13 +165296,13 @@ function registerCtxDreamCommand(pi, deps) {
 `),
           level: result ? "success" : "info"
         }, {
-          projectDir: deps.projectDir,
-          projectIdentity: deps.projectIdentity,
+          projectDir: project.projectDir,
+          projectIdentity: project.projectIdentity,
           entry: enqueued
         });
       } catch (error51) {
         const message = error51 instanceof Error ? error51.message : String(error51);
-        sessionLog(deps.projectIdentity, `/ctx-dream failed to drain queue: ${message}`);
+        sessionLog(project.projectIdentity, `/ctx-dream failed to drain queue: ${message}`);
         sendCtxStatusMessage(pi, {
           title: "/ctx-dream",
           text: [
@@ -165268,8 +165314,8 @@ function registerCtxDreamCommand(pi, deps) {
 `),
           level: "error"
         }, {
-          projectDir: deps.projectDir,
-          projectIdentity: deps.projectIdentity,
+          projectDir: project.projectDir,
+          projectIdentity: project.projectIdentity,
           entry: enqueued
         });
       }
@@ -167526,8 +167572,31 @@ function collectUserPromptParts(message) {
 function hasStackedAugmentation(rawText) {
   return rawText.includes("<sidekick-augmentation>") || rawText.includes("<ctx-search-hint>") || rawText.includes("<ctx-search-auto>");
 }
+function stripNestedSystemReminders(text) {
+  const OPEN = "<system-reminder>";
+  const CLOSE = "</system-reminder>";
+  let result = "";
+  let depth = 0;
+  let i = 0;
+  while (i < text.length) {
+    if (text.startsWith(OPEN, i)) {
+      depth += 1;
+      i += OPEN.length;
+    } else if (text.startsWith(CLOSE, i)) {
+      if (depth > 0)
+        depth -= 1;
+      i += CLOSE.length;
+    } else if (depth === 0) {
+      result += text[i];
+      i += 1;
+    } else {
+      i += 1;
+    }
+  }
+  return result;
+}
 function extractUserPromptText(message) {
-  return collectUserPromptParts(message).replace(/§\d+§\s*/g, "").replace(/<!--\s*\+[\d\s.hmdw]+\s*-->/g, "").replace(/<!--\s*OMO_INTERNAL_INITIATOR[\s\S]*?-->/g, "").replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "").replace(/<ctx-search-hint>[\s\S]*?<\/ctx-search-hint>/g, "").replace(/<ctx-search-auto>[\s\S]*?<\/ctx-search-auto>/g, "").replace(/<instruction[^>]*>[\s\S]*?<\/instruction>/g, "").replace(/<sidekick-augmentation>[\s\S]*?<\/sidekick-augmentation>/g, "").replace(/[ \t]+\n/g, `
+  return stripNestedSystemReminders(collectUserPromptParts(message)).replace(/§\d+§\s*/g, "").replace(/<!--\s*\+[\d\s.hmdw]+\s*-->/g, "").replace(/<!--\s*OMO_INTERNAL_INITIATOR[\s\S]*?-->/g, "").replace(/<!--\s*ALFONSO_INTERNAL_INITIATOR[\s\S]*?-->/g, "").replace(/<ctx-search-hint>[\s\S]*?<\/ctx-search-hint>/g, "").replace(/<ctx-search-auto>[\s\S]*?<\/ctx-search-auto>/g, "").replace(/<instruction[^>]*>[\s\S]*?<\/instruction>/g, "").replace(/<sidekick-augmentation>[\s\S]*?<\/sidekick-augmentation>/g, "").replace(/[ \t]+\n/g, `
 `).replace(/\n{3,}/g, `
 
 `).trim();
@@ -167769,7 +167838,8 @@ var DEDUP_SAFE_TOOLS = new Set([
 ]);
 function buildPiToolFingerprints(messages) {
   const fingerprints2 = new Map;
-  for (const message of messages) {
+  for (let i = 0;i < messages.length; i++) {
+    const message = messages[i];
     if (!message || typeof message !== "object")
       continue;
     const msg = message;
@@ -167777,6 +167847,7 @@ function buildPiToolFingerprints(messages) {
       continue;
     if (!Array.isArray(msg.content))
       continue;
+    const ownerMsgId = typeof msg.timestamp === "number" ? `pi-msg-${i}-${msg.timestamp}-assistant` : `pi-msg-${i}-assistant`;
     for (const part of msg.content) {
       if (!part || typeof part !== "object")
         continue;
@@ -167799,7 +167870,9 @@ function buildPiToolFingerprints(messages) {
       } catch {
         continue;
       }
-      fingerprints2.set(p.id, `${p.name}:${serialized}`);
+      const fingerprint = `${ownerMsgId}:${p.name}:${serialized}`;
+      const compositeKey = `${ownerMsgId}\x00${p.id}`;
+      fingerprints2.set(compositeKey, fingerprint);
     }
   }
   return fingerprints2;
@@ -167917,15 +167990,16 @@ function applyPiHeuristicCleanup(sessionId, db, targets, piMessages, config2, pr
   })();
   const toolFingerprints = buildPiToolFingerprints(piMessages);
   if (toolFingerprints.size > 0) {
-    const tagsByMessageId = new Map;
+    const tagsByCompositeKey = new Map;
     for (const tag of tags) {
       if (tag.type === "tool" && tag.status === "active" && tag.messageId) {
-        tagsByMessageId.set(tag.messageId, tag);
+        const key = tag.toolOwnerMessageId ? `${tag.toolOwnerMessageId}\x00${tag.messageId}` : tag.messageId;
+        tagsByCompositeKey.set(key, tag);
       }
     }
     const fingerprintGroups = new Map;
-    for (const [callId, fingerprint] of toolFingerprints) {
-      const tag = tagsByMessageId.get(callId);
+    for (const [compositeKey, fingerprint] of toolFingerprints) {
+      const tag = tagsByCompositeKey.get(compositeKey);
       if (!tag || tag.tagNumber > protectedCutoff)
         continue;
       const group = fingerprintGroups.get(fingerprint) ?? [];
@@ -169877,8 +169951,18 @@ function injectSyntheticTodowriteForPi(args) {
 }
 
 // src/reasoning-replay-pi.ts
-var INLINE_THINKING_PATTERN = /<thinking>[\s\S]*?<\/thinking>\s*/gi;
+var INLINE_THINKING_PATTERNS = [
+  /<thinking>[\s\S]*?<\/thinking>\s*/gi,
+  /<think>[\s\S]*?<\/think>\s*/gi
+];
 var CLEARED = "[cleared]";
+function stripInlineThinkingMarkup(text) {
+  let cleaned = text;
+  for (const pattern of INLINE_THINKING_PATTERNS) {
+    cleaned = cleaned.replace(pattern, "");
+  }
+  return cleaned;
+}
 function buildMessageIdToMaxTag(targets) {
   const out = new Map;
   for (const [tagNumber, target] of targets) {
@@ -169931,6 +170015,51 @@ function clearOldReasoningPi(args) {
   }
   return { cleared, newWatermark };
 }
+function stripInlineThinkingPi(args) {
+  const { messages, messageIdToMaxTag, clearReasoningAge, piMessageStableId } = args;
+  let maxTag = 0;
+  for (const t of messageIdToMaxTag.values())
+    if (t > maxTag)
+      maxTag = t;
+  if (maxTag === 0)
+    return { stripped: 0, newWatermark: 0 };
+  const ageCutoff = maxTag - clearReasoningAge;
+  if (ageCutoff <= 0)
+    return { stripped: 0, newWatermark: 0 };
+  let stripped = 0;
+  let newWatermark = 0;
+  for (let i = 0;i < messages.length; i++) {
+    const raw = messages[i];
+    if (!raw || typeof raw !== "object")
+      continue;
+    const msg = raw;
+    if (msg.role !== "assistant" || !Array.isArray(msg.content))
+      continue;
+    const id = piMessageStableId(raw, i);
+    if (!id)
+      continue;
+    const msgTag = messageIdToMaxTag.get(id) ?? 0;
+    if (msgTag === 0 || msgTag > ageCutoff)
+      continue;
+    let strippedThisMessage = false;
+    for (const part of msg.content) {
+      if (part && typeof part === "object" && part.type === "text") {
+        const tp = part;
+        if (typeof tp.text !== "string")
+          continue;
+        const cleaned = stripInlineThinkingMarkup(tp.text);
+        if (cleaned !== tp.text) {
+          tp.text = cleaned;
+          stripped++;
+          strippedThisMessage = true;
+        }
+      }
+    }
+    if (strippedThisMessage && msgTag > newWatermark)
+      newWatermark = msgTag;
+  }
+  return { stripped, newWatermark };
+}
 function replayClearedReasoningPi(args) {
   const { db, sessionId, messages, messageIdToMaxTag, piMessageStableId } = args;
   const meta3 = getOrCreateSessionMeta(db, sessionId);
@@ -169988,7 +170117,7 @@ function replayStrippedInlineThinkingPi(args) {
         const tp = part;
         if (typeof tp.text !== "string")
           continue;
-        const cleaned = tp.text.replace(INLINE_THINKING_PATTERN, "");
+        const cleaned = stripInlineThinkingMarkup(tp.text);
         if (cleaned !== tp.text) {
           tp.text = cleaned;
           stripped++;
@@ -170079,6 +170208,408 @@ function stripPiDroppedPlaceholderMessages(args) {
   return { removed, discovered };
 }
 
+// src/system-prompt.ts
+import { createHash as createHash8 } from "node:crypto";
+import { existsSync as existsSync11, readFileSync as readFileSync8 } from "node:fs";
+import { join as join15 } from "node:path";
+
+// ../plugin/src/agents/magic-context-prompt.ts
+function getToolHistoryGuidance(dropToolStructure) {
+  if (dropToolStructure) {
+    return `Compressed history intentionally omits tool calls and their outputs — summaries like "I edited file X" are historian records, not patterns to replicate. In the live conversation, older tool calls and their results are cleaned up to save context — you may see your own past messages referencing actions without the corresponding tool call or result visible. This is normal context management. ALWAYS use real tool calls; never simulate, fabricate, or inline tool outputs in your text. If there is no tool result message, the action did not happen. NEVER simulate, hallucinate or claim tool calls, command output, search results, file edits, or diffs in plain text as if they actually occurred.`;
+  }
+  return `Older tool calls in your conversation show truncated inputs and [truncated] outputs — this is normal context management, not a pattern to follow. The original tool calls executed successfully with full inputs and produced real outputs that were later cleaned up to save context. ALWAYS use real tool calls with complete arguments; never copy truncated patterns like "filePa...[truncated]" into your tool inputs. If you need to re-read a file or re-run a command, make a fresh tool call.`;
+}
+var BASE_INTRO = (protectedTags, dropToolStructure) => `Messages and tool outputs are tagged with §N§ identifiers (e.g., §1§, §42§).
+Use \`ctx_reduce\` to manage context size. It supports one operation:
+- \`drop\`: Remove entirely (best for tool outputs you already acted on).
+Syntax: "3-5", "1,2,9", or "1-5,8,12-15". Last ${protectedTags} tags are protected.
+Use \`ctx_note\` for deferred intentions — things to tackle later, not right now. NOT for task tracking (use todos). Notes survive context compression and you'll be reminded at natural work boundaries (after commits, historian runs, todo completion).
+Use \`ctx_memory\` to manage cross-session project memories. Write new memories or delete stale ones. Memories persist across sessions and are automatically injected into new sessions.
+**Save to memory proactively**: If you spent multiple turns finding something (a file path, a DB location, a config pattern, a workaround), save it with \`ctx_memory\` so future sessions don't repeat the search. Examples:
+- Found a project's source code path after searching → \`ctx_memory(action="write", category="ENVIRONMENT", content="OpenCode source is at ~/Work/OSS/opencode")\`
+- Discovered a non-obvious build/test command → \`ctx_memory(action="write", category="WORKFLOW_RULES", content="Always use scripts/release.sh for releases")\`
+- Learned a constraint the hard way → \`ctx_memory(action="write", category="CONSTRAINTS", content="Dashboard Tauri build needs RGBA PNGs, not grayscale")\`
+Use \`ctx_search\` to search across project memories, session facts, and conversation history from one query.
+Use \`ctx_expand\` to decompress a compartment range to see the original conversation transcript. Use \`start\`/\`end\` from \`<compartment start="N" end="M">\` attributes. Returns the compacted U:/A: transcript for that message range, capped at ~15K tokens.
+**Search before asking the user**: If you can't remember or don't know something that might have been discussed before or stored in project memory, use \`ctx_search\` before asking the user. Examples:
+- Can't remember where a related codebase or dependency lives → \`ctx_search(query="opencode source code path")\`
+- Forgot a prior architectural decision or constraint → \`ctx_search(query="why did we choose SQLite over postgres")\`
+- Need a config value, API key location, or environment detail → \`ctx_search(query="embedding provider configuration")\`
+- Looking for how something was implemented previously → \`ctx_search(query="how does the dreamer lease work")\`
+- Want to recall what was decided in an earlier conversation → \`ctx_search(query="dashboard release signing setup")\`
+\`ctx_search\` returns ranked results from memories, session facts, and raw message history. Use message ordinals from results with \`ctx_expand\` to retrieve surrounding conversation context.
+${getToolHistoryGuidance(dropToolStructure)}
+NEVER drop large ranges blindly (e.g., "1-50"). Review each tag before deciding.
+NEVER drop user messages — they are short and will be summarized by compartmentalization automatically. Dropping them loses context the historian needs.
+NEVER drop assistant text messages unless they are exceptionally large. Your conversation messages are lightweight; only large tool outputs are worth dropping.
+Before your turn finishes, consider using \`ctx_reduce\` to drop large tool outputs you no longer need.`;
+var BASE_INTRO_NO_REDUCE = (dropToolStructure) => `Use \`ctx_note\` for deferred intentions — things to tackle later, not right now. NOT for task tracking (use todos). Notes survive context compression and you'll be reminded at natural work boundaries (after commits, historian runs, todo completion).
+Use \`ctx_memory\` to manage cross-session project memories. Write new memories or delete stale ones. Memories persist across sessions and are automatically injected into new sessions.
+**Save to memory proactively**: If you spent multiple turns finding something (a file path, a DB location, a config pattern, a workaround), save it with \`ctx_memory\` so future sessions don't repeat the search. Examples:
+- Found a project's source code path after searching → \`ctx_memory(action="write", category="ENVIRONMENT", content="OpenCode source is at ~/Work/OSS/opencode")\`
+- Discovered a non-obvious build/test command → \`ctx_memory(action="write", category="WORKFLOW_RULES", content="Always use scripts/release.sh for releases")\`
+- Learned a constraint the hard way → \`ctx_memory(action="write", category="CONSTRAINTS", content="Dashboard Tauri build needs RGBA PNGs, not grayscale")\`
+Use \`ctx_search\` to search across project memories, session facts, and conversation history from one query.
+Use \`ctx_expand\` to decompress a compartment range to see the original conversation transcript. Use \`start\`/\`end\` from \`<compartment start="N" end="M">\` attributes. Returns the compacted U:/A: transcript for that message range, capped at ~15K tokens.
+**Search before asking the user**: If you can't remember or don't know something that might have been discussed before or stored in project memory, use \`ctx_search\` before asking the user. Examples:
+- Can't remember where a related codebase or dependency lives → \`ctx_search(query="opencode source code path")\`
+- Forgot a prior architectural decision or constraint → \`ctx_search(query="why did we choose SQLite over postgres")\`
+- Need a config value, API key location, or environment detail → \`ctx_search(query="embedding provider configuration")\`
+- Looking for how something was implemented previously → \`ctx_search(query="how does the dreamer lease work")\`
+- Want to recall what was decided in an earlier conversation → \`ctx_search(query="dashboard release signing setup")\`
+\`ctx_search\` returns ranked results from memories, session facts, and raw message history. Use message ordinals from results with \`ctx_expand\` to retrieve surrounding conversation context.
+${getToolHistoryGuidance(dropToolStructure)}`;
+var GENERIC_SECTION = `
+### Reduction Triggers
+- After reading files or search results you already acted on — drop raw outputs.
+- After completing a logical step — drop intermediate outputs from that step.
+- Between major context switches — when moving to a new task area.
+
+### What to Drop
+- Large file reads, grep results, and tool outputs you already used.
+- Large build/test output after you analyzed and acted on it.
+- Old diagnostic or exploration results that are no longer relevant.
+
+### What to Keep
+- ALL user messages and assistant conversation text — these are cheap and compartmentalized automatically.
+- Your current task requirements and constraints.
+- Recent errors and unresolved decisions.
+- Active work context and files being edited.`;
+var TEMPORAL_AWARENESS_GUIDANCE = `
+**Temporal awareness**: User messages may be preceded by HTML comments like \`<!-- +12m -->\`, \`<!-- +2h 15m -->\`, or \`<!-- +3d 4h -->\` indicating time elapsed since the previous message's completion. Compartments in \`<session-history>\` carry \`start-date\` and \`end-date\` attributes (YYYY-MM-DD) showing real-time boundaries. Use these when reasoning about workflow pacing, log durations, build times, or how long ago something happened.`;
+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, dropToolStructure = true, temporalAwarenessEnabled = false, cavemanTextCompressionEnabled = false) {
+  const smartNoteGuidance = dreamerEnabled ? `
+When \`surface_condition\` is provided with \`write\`, the note becomes a project-scoped smart note.
+The dreamer evaluates smart note conditions during nightly runs and surfaces them when conditions are met.
+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 : "";
+  if (!ctxReduceEnabled) {
+    return `## Magic Context
+
+${BASE_INTRO_NO_REDUCE(dropToolStructure)}${smartNoteGuidance}${temporalGuidance}${cavemanWarning}`;
+  }
+  return `## Magic Context
+
+${BASE_INTRO(protectedTags, dropToolStructure)}${smartNoteGuidance}${temporalGuidance}
+${GENERIC_SECTION}
+
+Prefer many small targeted operations over one large blanket operation. Compress early and often — don't wait for warnings.`;
+}
+
+// ../plugin/src/hooks/magic-context/key-files-block.ts
+import { readFileSync as readFileSync7, realpathSync as realpathSync3 } from "node:fs";
+import { join as join14, sep as sep2 } from "node:path";
+init_logger();
+var cachedKeyFilesBySession = new Map;
+var staleUpdates = new Map;
+function staleKey(update) {
+  return `${update.projectPath}\x00${update.path}\x00${update.generatedAtWitness}\x00${update.staleReason}`;
+}
+function queueStaleUpdate(projectPath, path5, generatedAtWitness, staleReason) {
+  const update = { projectPath, path: path5, generatedAtWitness, staleReason };
+  staleUpdates.set(staleKey(update), update);
+}
+function flushStaleUpdates(db) {
+  if (staleUpdates.size === 0)
+    return 0;
+  const updates = [...staleUpdates.values()];
+  staleUpdates.clear();
+  const stmt = db.prepare(`UPDATE project_key_files
+            SET stale_reason = ?1
+          WHERE project_path = ?2
+            AND path = ?3
+            AND generated_at = ?4
+            AND (stale_reason IS NULL OR stale_reason != ?1)`);
+  let changed = 0;
+  for (const update of updates) {
+    try {
+      changed += stmt.run(update.staleReason, update.projectPath, update.path, update.generatedAtWitness).changes;
+    } catch (error51) {
+      log("[key-files] flushStaleUpdates failed:", error51);
+    }
+  }
+  return changed;
+}
+function clearKeyFilesCacheForSession(sessionId) {
+  cachedKeyFilesBySession.delete(sessionId);
+}
+function isUnderProject(projectPath, absPath) {
+  const root = realpathSync3(projectPath);
+  return absPath.startsWith(root + sep2) || absPath === root;
+}
+function buildKeyFilesBlock(db, projectPath, config2 = { enabled: true, tokenBudget: 1e4 }) {
+  if (!config2.enabled)
+    return null;
+  if (!isAftAvailable())
+    return null;
+  const rows = readCurrentKeyFiles(db, projectPath);
+  if (rows.length === 0)
+    return null;
+  for (const row of rows) {
+    if (row.staleReason !== null)
+      continue;
+    let nextStale = null;
+    let observed = false;
+    try {
+      const absPath = join14(projectPath, row.path);
+      const real = realpathSync3(absPath);
+      if (!isUnderProject(projectPath, real)) {
+        nextStale = "missing";
+        observed = true;
+      } else {
+        const diskHash = sha256(readFileSync7(real));
+        if (diskHash !== row.contentHash)
+          nextStale = "content_drift";
+        observed = true;
+      }
+    } catch (error51) {
+      const code = error51?.code;
+      if (code === "ENOENT" || code === "ELOOP") {
+        nextStale = "missing";
+        observed = true;
+      } else {
+        log(`[key-files] freshness check transient failure: ${row.path}: ${error51 instanceof Error ? error51.message : String(error51)}`);
+      }
+    }
+    if (observed && nextStale !== null) {
+      queueStaleUpdate(row.projectPath, row.path, row.generatedAt, nextStale);
+    }
+  }
+  const blocks = [];
+  let used = 0;
+  for (const row of rows) {
+    if (used + row.localTokenEstimate > config2.tokenBudget)
+      break;
+    blocks.push(`  <key-file path="${escapeXmlAttr(row.path)}">
+${escapeXmlContent(row.content)}
+  </key-file>`);
+    used += row.localTokenEstimate;
+  }
+  if (blocks.length === 0)
+    return null;
+  const rendered = `<key-files>
+${blocks.join(`
+`)}
+</key-files>`;
+  flushStaleUpdates(db);
+  return rendered;
+}
+function readVersionedKeyFiles(args) {
+  const config2 = args.config ?? { enabled: true, tokenBudget: 1e4 };
+  if (args.sessionMeta.isSubagent)
+    return null;
+  if (!config2.enabled)
+    return null;
+  if (!isAftAvailable())
+    return null;
+  const projectPath = resolveProjectPath(args.directory ?? args.sessionMeta.sessionId);
+  if (!projectPath)
+    return null;
+  const currentVersion = getKeyFilesVersion(args.db, projectPath);
+  if (args.sessionId) {
+    const cached2 = cachedKeyFilesBySession.get(args.sessionId);
+    if (cached2 && !args.isCacheBusting && cached2.version === currentVersion) {
+      return cached2.value;
+    }
+  }
+  const value = buildKeyFilesBlock(args.db, projectPath, config2);
+  if (args.sessionId) {
+    cachedKeyFilesBySession.set(args.sessionId, { value, version: currentVersion });
+    if (value)
+      sessionLog(args.sessionId, `loaded key-files block (v${currentVersion}, ${value.length} chars)`);
+  }
+  return value;
+}
+
+// src/system-prompt.ts
+init_logger();
+var PROJECT_DOCS_MARKER = "<project-docs>";
+var USER_PROFILE_MARKER = "<user-profile>";
+var KEY_FILES_MARKER = "<key-files>";
+var MAGIC_CONTEXT_MARKER = "## Magic Context";
+var stickyDateBySession = new Map;
+var cachedDocsBySession = new Map;
+var cachedUserProfileBySession = new Map;
+var DOC_FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
+function readProjectDocs(directory) {
+  const sections = [];
+  for (const filename of DOC_FILES) {
+    const filePath = join15(directory, filename);
+    try {
+      if (existsSync11(filePath)) {
+        const content = readFileSync8(filePath, "utf-8").trim();
+        if (content.length > 0) {
+          sections.push(`<${filename}>
+${escapeXmlContent(content)}
+</${filename}>`);
+        }
+      }
+    } catch (error51) {
+      log(`[magic-context-pi] failed to read ${filename}:`, error51);
+    }
+  }
+  if (sections.length === 0)
+    return null;
+  return `${PROJECT_DOCS_MARKER}
+${sections.join(`
+
+`)}
+</project-docs>`;
+}
+function buildUserProfileBlock(db) {
+  const memories = getActiveUserMemories(db);
+  if (memories.length === 0)
+    return null;
+  const items = memories.map((m) => `- ${escapeXmlContent(m.content)}`).join(`
+`);
+  return `${USER_PROFILE_MARKER}
+${items}
+</user-profile>`;
+}
+function buildMagicContextBlock(opts) {
+  const sections = [];
+  const sessionId = opts.sessionId;
+  const isCacheBusting = opts.isCacheBusting ?? false;
+  const existing = opts.existingSystemPrompt ?? "";
+  if (opts.injectDocs && !existing.includes(PROJECT_DOCS_MARKER)) {
+    const docsBlock = readCachedAdjunct({
+      cache: cachedDocsBySession,
+      sessionId,
+      isCacheBusting,
+      compute: () => readProjectDocs(opts.cwd),
+      describe: "project docs"
+    });
+    if (docsBlock)
+      sections.push(docsBlock);
+  }
+  if (opts.userMemoriesEnabled && !existing.includes(USER_PROFILE_MARKER)) {
+    const profileBlock = readCachedAdjunct({
+      cache: cachedUserProfileBySession,
+      sessionId,
+      isCacheBusting,
+      compute: () => buildUserProfileBlock(opts.db),
+      describe: "user profile"
+    });
+    if (profileBlock)
+      sections.push(profileBlock);
+  }
+  if (opts.pinKeyFilesEnabled && sessionId && !existing.includes(KEY_FILES_MARKER)) {
+    let sessionMeta = null;
+    try {
+      sessionMeta = getOrCreateSessionMeta(opts.db, sessionId);
+    } catch (error51) {
+      sessionLog(sessionId, "Pi key-files session meta load failed:", error51);
+    }
+    const keyFilesBlock = sessionMeta ? readVersionedKeyFiles({
+      db: opts.db,
+      sessionId,
+      sessionMeta,
+      directory: opts.cwd,
+      isCacheBusting,
+      config: {
+        enabled: opts.pinKeyFilesEnabled,
+        tokenBudget: opts.pinKeyFilesTokenBudget ?? 1e4
+      }
+    }) : null;
+    if (keyFilesBlock)
+      sections.push(keyFilesBlock);
+  }
+  const dataBlock = sections.length > 0 ? `<magic-context>
+${sections.join(`
+
+`)}
+</magic-context>` : null;
+  const includeGuidance = (opts.includeGuidance ?? true) && !existing.includes(MAGIC_CONTEXT_MARKER);
+  if (!includeGuidance) {
+    return dataBlock;
+  }
+  const guidance = buildMagicContextSection(null, opts.protectedTags ?? 20, opts.ctxReduceEnabled ?? true, opts.dreamerEnabled ?? false, opts.dropToolStructure ?? true, opts.temporalAwarenessEnabled ?? false, opts.cavemanTextCompressionEnabled ?? false);
+  if (dataBlock) {
+    return `${guidance}
+
+${dataBlock}`;
+  }
+  return guidance;
+}
+function readCachedAdjunct(args) {
+  const { cache, sessionId, isCacheBusting, compute, describe: describe3 } = args;
+  if (!sessionId) {
+    return compute();
+  }
+  const hasCached = cache.has(sessionId);
+  if (!hasCached || isCacheBusting) {
+    const value = compute();
+    cache.set(sessionId, value);
+    if (value && !hasCached) {
+      sessionLog(sessionId, `loaded ${describe3} (${value.length} chars)`);
+    } else if (value && isCacheBusting) {
+      sessionLog(sessionId, `refreshed ${describe3} (cache-busting pass)`);
+    }
+    return value;
+  }
+  return cache.get(sessionId) ?? null;
+}
+var DATE_PATTERN = /Today's date: .+/;
+function processSystemPromptForCache(args) {
+  const { db, sessionId, systemPrompt, isCacheBusting } = args;
+  let sessionMeta;
+  try {
+    sessionMeta = getOrCreateSessionMeta(db, sessionId);
+  } catch (error51) {
+    sessionLog(sessionId, "system-prompt-hash session meta load failed:", error51);
+  }
+  const previousHash = sessionMeta?.systemPromptHash ?? "";
+  const isFirstHash = previousHash === "" || previousHash === "0";
+  let frozenPrompt = systemPrompt;
+  const dateMatch = systemPrompt.match(DATE_PATTERN);
+  const liveDate = dateMatch ? dateMatch[0] : null;
+  const stickyDate = stickyDateBySession.get(sessionId);
+  if (liveDate && !stickyDate) {
+    stickyDateBySession.set(sessionId, liveDate);
+  } else if (liveDate && stickyDate && liveDate !== stickyDate) {
+    if (isCacheBusting) {
+      stickyDateBySession.set(sessionId, liveDate);
+      sessionLog(sessionId, `system prompt date updated: ${stickyDate} → ${liveDate} (cache-busting pass)`);
+    } else {
+      frozenPrompt = systemPrompt.replace(DATE_PATTERN, stickyDate);
+      sessionLog(sessionId, `system prompt date frozen: real=${liveDate}, using=${stickyDate} (cache-stable pass)`);
+    }
+  }
+  const currentHash = createHash8("md5").update(frozenPrompt).digest("hex");
+  const hashChanged = !isFirstHash && currentHash !== previousHash;
+  if (hashChanged) {
+    sessionLog(sessionId, `system prompt hash changed: ${previousHash} → ${currentHash} (len=${frozenPrompt.length})`);
+  } else if (isFirstHash) {
+    sessionLog(sessionId, `system prompt hash initialized: ${currentHash} (len=${frozenPrompt.length})`);
+  }
+  const systemPromptTokens = estimateTokens(frozenPrompt);
+  if (sessionMeta) {
+    if (currentHash !== previousHash) {
+      updateSessionMeta(db, sessionId, {
+        systemPromptHash: currentHash,
+        systemPromptTokens
+      });
+    } else if (Math.abs(sessionMeta.systemPromptTokens - systemPromptTokens) > 50) {
+      updateSessionMeta(db, sessionId, { systemPromptTokens });
+    }
+  }
+  return {
+    systemPrompt: frozenPrompt,
+    hashChanged,
+    currentHash
+  };
+}
+function clearPiSystemPromptSession(sessionId) {
+  stickyDateBySession.delete(sessionId);
+  cachedDocsBySession.delete(sessionId);
+  cachedUserProfileBySession.delete(sessionId);
+  clearKeyFilesCacheForSession(sessionId);
+}
+
 // src/temporal-awareness-pi.ts
 function injectPiTemporalMarkers(messages) {
   let injected = 0;
@@ -170639,6 +171170,12 @@ var commitSeenLastPass = new Map;
 var historyRefreshSessions = new Set;
 var systemPromptRefreshSessions = new Set;
 var pendingMaterializationSessions = new Set;
+var deferredHistoryRefreshSessions = new Set;
+var deferredMaterializationSessions = new Set;
+var sessionsByProject = new Map;
+var lastSeenProjectIdentityBySession = new Map;
+var rawMessageProviderUnregistersBySession = new Map;
+var lastHeuristicsTurnIdBySession = new Map;
 var firstContextPassSeenBySession = new Set;
 var recentReduceBySession = new Map;
 var liveModelBySession = new Map;
@@ -170672,6 +171209,50 @@ function signalPiSystemPromptRefresh(sessionId) {
 function signalPiPendingMaterialization(sessionId) {
   pendingMaterializationSessions.add(sessionId);
 }
+function signalPiDeferredHistoryRefresh(sessionId) {
+  deferredHistoryRefreshSessions.add(sessionId);
+}
+function signalPiDeferredMaterialization(sessionId) {
+  deferredMaterializationSessions.add(sessionId);
+}
+function consumeDeferredHistoryRefresh(sessionId) {
+  const wasSet = deferredHistoryRefreshSessions.has(sessionId);
+  deferredHistoryRefreshSessions.delete(sessionId);
+  return wasSet;
+}
+function consumeDeferredMaterialization(sessionId) {
+  const wasSet = deferredMaterializationSessions.has(sessionId);
+  deferredMaterializationSessions.delete(sessionId);
+  return wasSet;
+}
+function trackSessionForProject(projectIdentity, sessionId) {
+  let sessions = sessionsByProject.get(projectIdentity);
+  if (!sessions) {
+    sessions = new Set;
+    sessionsByProject.set(projectIdentity, sessions);
+  }
+  sessions.add(sessionId);
+}
+function updateSessionProjectTracking(sessionId, projectIdentity) {
+  const prev = lastSeenProjectIdentityBySession.get(sessionId);
+  if (prev && prev !== projectIdentity) {
+    const prevSessions = sessionsByProject.get(prev);
+    prevSessions?.delete(sessionId);
+    if (prevSessions?.size === 0)
+      sessionsByProject.delete(prev);
+    clearPiSystemPromptSession(sessionId);
+  }
+  trackSessionForProject(projectIdentity, sessionId);
+  lastSeenProjectIdentityBySession.set(sessionId, projectIdentity);
+}
+function signalPiSystemPromptRefreshForProject(projectIdentity) {
+  const sessions = sessionsByProject.get(projectIdentity);
+  if (!sessions)
+    return;
+  for (const sessionId of sessions) {
+    systemPromptRefreshSessions.add(sessionId);
+  }
+}
 function recordPiLiveModel(sessionId, modelKey) {
   liveModelBySession.set(sessionId, modelKey);
 }
@@ -170849,8 +171430,6 @@ function collectMessageEntryIdsStrict(ctx, expectedLength, sessionId) {
 }
 function registerPiContextHandler(pi, options) {
   const tagger = createTagger();
-  const projectDirectory = process.cwd();
-  const projectIdentity = resolveProjectIdentity(projectDirectory);
   const schedulerConfig = options.scheduler ?? {
     executeThresholdPercentage: 65
   };
@@ -170876,12 +171455,17 @@ function registerPiContextHandler(pi, options) {
         return;
       }
       sessionIdForError = sessionId;
+      const projectDirectory = ctx.cwd;
+      const projectIdentity = resolveProjectIdentity(projectDirectory);
+      updateSessionProjectTracking(sessionId, projectIdentity);
       logTransformTiming(sessionId, "findSessionId", tFindSession, `messages=${event.messages.length}`);
       const rawMessageProvider = {
         readMessages: () => readPiSessionMessages(ctx),
         readMessageById: (messageId) => readPiSessionMessageById(ctx, messageId)
       };
-      setRawMessageProvider(sessionId, rawMessageProvider);
+      rawMessageProviderUnregistersBySession.get(sessionId)?.();
+      const unregisterRaw = setRawMessageProvider(sessionId, rawMessageProvider);
+      rawMessageProviderUnregistersBySession.set(sessionId, unregisterRaw);
       scheduleReconciliation(options.db, sessionId, readRawSessionMessages);
       const strictEntryIds = collectMessageEntryIdsStrict(ctx, event.messages.length, sessionId);
       const tLastUser = performance.now();
@@ -170916,12 +171500,18 @@ function registerPiContextHandler(pi, options) {
           lastContextPercentage: 0,
           lastInputTokens: 0,
           observedSafeInputTokens: 0,
-          cacheAlertSent: false
+          cacheAlertSent: false,
+          clearedReasoningThroughTag: 0
         });
+        clearHistorianFailureState(options.db, sessionId);
+        clearPersistedReasoningWatermark(options.db, sessionId);
+        clearDetectedContextLimit(options.db, sessionId);
+        clearEmergencyRecovery(options.db, sessionId);
         sessionMetaForUsage.lastContextPercentage = 0;
         sessionMetaForUsage.lastInputTokens = 0;
         sessionMetaForUsage.observedSafeInputTokens = 0;
         sessionMetaForUsage.cacheAlertSent = false;
+        sessionMetaForUsage.clearedReasoningThroughTag = 0;
       }
       let usagePercentage = 0;
       let usageInputTokens = 0;
@@ -171050,11 +171640,25 @@ function registerPiContextHandler(pi, options) {
           isCacheBusting,
           usagePercentage,
           usageInputTokens,
-          usageContextLimit
+          usageContextLimit,
+          schedulerDecision
         });
       }
       const tPostTransform = performance.now();
       let outputMessages = result.messages;
+      try {
+        const cacheBustingPass = isCacheBusting || result.executedWorkThisPass;
+        outputMessages = applyStickyTurnReminder({
+          sessionId,
+          db: options.db,
+          messages: outputMessages,
+          entryIds: entryIds ?? null,
+          hasRecentReduceCall: recentReduceBySession.has(sessionId),
+          isCacheBustingPass: cacheBustingPass
+        });
+      } catch (err) {
+        sessionLog(sessionId, `sticky turn reminder failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
       if (nudgerFn && options.nudge) {
         try {
           const tNudge = performance.now();
@@ -171168,7 +171772,7 @@ function maybeFireCompressor(args) {
   const compressor = historian.compressor;
   if (!compressor?.enabled)
     return;
-  if (!args.isCacheBusting)
+  if (!args.isCacheBusting && args.schedulerDecision !== "execute")
     return;
   if (inFlightHistorian.has(sessionId) || inFlightCompressor.has(sessionId)) {
     sessionLog(sessionId, "compressor trigger eval: in-flight historian/compressor, skipping");
@@ -171188,7 +171792,6 @@ function maybeFireCompressor(args) {
   });
   if (!historyBudgetTokens || historyBudgetTokens <= 0)
     return;
-  markPiCompressorRun(sessionId);
   const runPromise = runPiCompressionPassIfNeeded({
     db,
     sessionId,
@@ -171204,10 +171807,14 @@ function maybeFireCompressor(args) {
     maxCompartmentsPerPass: compressor.maxCompartmentsPerPass,
     graceCompartments: compressor.graceCompartments,
     onPublished: () => {
-      signalPiHistoryRefresh(sessionId);
-      signalPiPendingMaterialization(sessionId);
+      signalPiDeferredHistoryRefresh(sessionId);
+      signalPiDeferredMaterialization(sessionId);
       historian.onStatusChange?.(ctx, sessionId);
     }
+  }).then((didPublish) => {
+    if (didPublish === true) {
+      markPiCompressorRun(sessionId);
+    }
   }).catch((err) => {
     sessionLog(sessionId, `compressor failed in background: ${err instanceof Error ? err.message : String(err)}`);
   }).finally(() => {
@@ -171262,8 +171869,8 @@ function spawnPiHistorianRun(args) {
       } catch (err) {
         sessionLog(sessionId, `historian: clearEmergencyRecovery failed: ${err instanceof Error ? err.message : String(err)}`);
       }
-      signalPiHistoryRefresh(sessionId);
-      signalPiPendingMaterialization(sessionId);
+      signalPiDeferredHistoryRefresh(sessionId);
+      signalPiDeferredMaterialization(sessionId);
       historian.onStatusChange?.(ctx, sessionId);
     }
   }).finally(() => {
@@ -171393,6 +172000,12 @@ async function runPipeline(args) {
     logTransformTiming(args.sessionId, "injectTemporalMarkers", tTemporal);
   }
   const transcript = createPiTranscript(args.messages, args.sessionId);
+  const currentTurnId = (() => {
+    const ids = buildPiMessageIdByIndex(args.messages, args.entryIds ?? null);
+    return findLatestUserMessageIdPi(args.messages, ids)?.messageId ?? null;
+  })();
+  const alreadyRanHeuristicsThisTurn = currentTurnId !== null && lastHeuristicsTurnIdBySession.get(args.sessionId) === currentTurnId;
+  const shouldRunHeuristics = args.heuristics !== undefined && (args.forceMaterialization === true || args.schedulerDecision === "execute" && !alreadyRanHeuristicsThisTurn);
   const tTag = performance.now();
   const { targets } = tagTranscript(args.sessionId, transcript, args.tagger, args.db, {
     skipPrefixInjection: !args.ctxReduceEnabled
@@ -171413,10 +172026,16 @@ async function runPipeline(args) {
     sessionLog(args.sessionId, `commit-detect failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
   }
   const hasPendingMaterializeSignal = hasPendingMaterialization(args.sessionId);
+  const deferredMaterializationWasPending = deferredMaterializationSessions.has(args.sessionId);
+  const deferredHistoryRefreshWasPending = deferredHistoryRefreshSessions.has(args.sessionId);
   const pendingOps = getPendingOps(args.db, args.sessionId);
-  const shouldApplyPendingOps = args.schedulerDecision === "execute" || args.forceMaterialization || hasPendingMaterializeSignal;
+  const baseShouldApplyPendingOps = args.schedulerDecision === "execute" || args.forceMaterialization || hasPendingMaterializeSignal;
+  const canConsumeDeferredLate = baseShouldApplyPendingOps || shouldRunHeuristics;
+  const deferredMaterialize = canConsumeDeferredLate && deferredMaterializationWasPending;
+  const deferredHistoryRefresh = canConsumeDeferredLate && deferredHistoryRefreshWasPending;
+  const shouldApplyPendingOps = baseShouldApplyPendingOps || deferredMaterialize;
   if (shouldApplyPendingOps) {
-    const applyReason = hasPendingMaterializeSignal ? "explicit_flush" : args.forceMaterialization ? "force_materialization" : `scheduler_execute (scheduler=${args.schedulerDecision})`;
+    const applyReason = hasPendingMaterializeSignal ? "explicit_flush" : deferredMaterialize ? "deferred_publication" : args.forceMaterialization ? "force_materialization" : `scheduler_execute (scheduler=${args.schedulerDecision})`;
     sessionLog(args.sessionId, `pending ops WILL APPLY — reason=${applyReason}, pendingOps=${pendingOps.length}, context=${args.contextUsage.percentage.toFixed(1)}%`);
     try {
       const tApplyPending = performance.now();
@@ -171426,6 +172045,9 @@ async function runPipeline(args) {
       if (hasPendingMaterializeSignal) {
         consumePendingMaterialization(args.sessionId);
       }
+      if (deferredMaterialize) {
+        consumeDeferredMaterialization(args.sessionId);
+      }
     } catch (err) {
       sessionLog(args.sessionId, `pending operations failed: ${err instanceof Error ? err.message : String(err)}`);
       throw err;
@@ -171482,7 +172104,6 @@ async function runPipeline(args) {
   const tActiveTags = performance.now();
   const activeTags = getActiveTagsBySession(args.db, args.sessionId);
   logTransformTiming(args.sessionId, "getActiveTagsBySession", tActiveTags, `count=${activeTags.length}`);
-  const shouldRunHeuristics = args.heuristics !== undefined && (args.schedulerDecision === "execute" || args.forceMaterialization === true);
   if (shouldRunHeuristics) {
     const reason = args.forceMaterialization ? "force_materialization" : `scheduler_execute (pendingOps=${pendingOps.length}, scheduler=${args.schedulerDecision})`;
     sessionLog(args.sessionId, `heuristics WILL RUN — reason=${reason}, context=${args.contextUsage.percentage.toFixed(1)}%, turn=n/a`);
@@ -171502,6 +172123,9 @@ async function runPipeline(args) {
       }, activeTags);
       heuristicsExecuted = true;
       executedWorkThisPass = true;
+      if (currentTurnId !== null) {
+        lastHeuristicsTurnIdBySession.set(args.sessionId, currentTurnId);
+      }
       logTransformTiming(args.sessionId, "applyHeuristicCleanup", tHeuristic, `droppedTools=${heuristicsResult.droppedTools} deduplicatedTools=${heuristicsResult.deduplicatedTools} droppedInjections=${heuristicsResult.droppedInjections} compressedTextTags=${heuristicsResult.compressedTextTags}`);
     } catch (err) {
       sessionLog(args.sessionId, `heuristic cleanup failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
@@ -171510,21 +172134,26 @@ async function runPipeline(args) {
   if (args.reasoningClearing && (args.schedulerDecision === "execute" || args.forceMaterialization === true)) {
     try {
       const tClearReasoning = performance.now();
+      const meta3 = getOrCreateSessionMeta(args.db, args.sessionId);
+      const prevWatermark = meta3.clearedReasoningThroughTag ?? 0;
       const clearOutcome = clearOldReasoningPi({
         messages: args.messages,
         messageIdToMaxTag,
         clearReasoningAge: args.reasoningClearing.clearReasoningAge,
         piMessageStableId
       });
-      const meta3 = getOrCreateSessionMeta(args.db, args.sessionId);
-      const prevWatermark = meta3.clearedReasoningThroughTag ?? 0;
-      if (clearOutcome.cleared > 0 && clearOutcome.newWatermark > 0) {
-        if (clearOutcome.newWatermark > prevWatermark) {
-          updateSessionMeta(args.db, args.sessionId, {
-            clearedReasoningThroughTag: clearOutcome.newWatermark
-          });
-          sessionLog(args.sessionId, `reasoning cleanup: cleared=${clearOutcome.cleared} inlineStripped=0 watermark=${prevWatermark}→${clearOutcome.newWatermark}`);
-        }
+      const stripOutcome = stripInlineThinkingPi({
+        messages: args.messages,
+        messageIdToMaxTag,
+        clearReasoningAge: args.reasoningClearing.clearReasoningAge,
+        piMessageStableId
+      });
+      const combinedWatermark = Math.max(clearOutcome.newWatermark, stripOutcome.newWatermark);
+      if (combinedWatermark > prevWatermark) {
+        updateSessionMeta(args.db, args.sessionId, {
+          clearedReasoningThroughTag: combinedWatermark
+        });
+        sessionLog(args.sessionId, `reasoning cleanup: cleared=${clearOutcome.cleared} inlineStripped=${stripOutcome.stripped} watermark=${prevWatermark}→${combinedWatermark}`);
       }
       logTransformTiming(args.sessionId, "clearOldReasoning", tClearReasoning);
       logTransformTiming(args.sessionId, "watermarkCleanup", tClearReasoning);
@@ -171538,10 +172167,13 @@ async function runPipeline(args) {
   if (args.injection) {
     try {
       const tInjection = performance.now();
-      injectionResult = injectSessionHistoryIntoPi(args.db, args.sessionId, args.messages, args.isCacheBusting, args.projectIdentity, args.injection.injectionBudgetTokens, args.injection.temporalAwareness, args.entryIds);
+      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);
       }
+      if (deferredHistoryRefresh) {
+        consumeDeferredHistoryRefresh(args.sessionId);
+      }
       logTransformTiming(args.sessionId, "prepareCompartmentInjection", tInjection);
       logTransformTiming(args.sessionId, "compartmentPhase", tInjection);
     } catch (err) {
@@ -171604,6 +172236,29 @@ function applyRollingNudge(args) {
     return messages;
   return injectPiNudge(messages, nudge);
 }
+function applyStickyTurnReminder(args) {
+  const reminder = getPersistedStickyTurnReminder(args.db, args.sessionId);
+  if (!reminder)
+    return args.messages;
+  if (args.hasRecentReduceCall && args.isCacheBustingPass) {
+    clearPersistedStickyTurnReminder(args.db, args.sessionId);
+    return args.messages;
+  }
+  const messageIdByIndex = buildPiMessageIdByIndex(args.messages, args.entryIds);
+  if (reminder.messageId) {
+    const reinjected = appendReminderToUserMessageByIdPi(args.messages, messageIdByIndex, reminder.messageId, reminder.text);
+    if (!reinjected && args.isCacheBustingPass) {
+      clearPersistedStickyTurnReminder(args.db, args.sessionId);
+    }
+    return args.messages;
+  }
+  const latest = findLatestUserMessageIdPi(args.messages, messageIdByIndex);
+  if (latest) {
+    appendReminderToPiUserMessage(args.messages[latest.index], reminder.text);
+    setPersistedStickyTurnReminder(args.db, args.sessionId, reminder.text, latest.messageId);
+  }
+  return args.messages;
+}
 function applyNoteNudges(args) {
   const { sessionId, db, messages, projectIdentity, entryIds, isCacheBusting } = args;
   const messageIdByIndex = buildPiMessageIdByIndex(messages, entryIds);
@@ -171743,12 +172398,26 @@ function clearContextHandlerSession(sessionId) {
   historyRefreshSessions.delete(sessionId);
   pendingMaterializationSessions.delete(sessionId);
   systemPromptRefreshSessions.delete(sessionId);
+  deferredHistoryRefreshSessions.delete(sessionId);
+  deferredMaterializationSessions.delete(sessionId);
   firstContextPassSeenBySession.delete(sessionId);
   commitSeenLastPass.delete(sessionId);
   recentReduceBySession.delete(sessionId);
   liveModelBySession.delete(sessionId);
   toolUsageSinceUserTurn.delete(sessionId);
   latestUserMessageBySession.delete(sessionId);
+  lastHeuristicsTurnIdBySession.delete(sessionId);
+  lastSeenProjectIdentityBySession.delete(sessionId);
+  for (const [projectIdentity, sessions] of sessionsByProject) {
+    sessions.delete(sessionId);
+    if (sessions.size === 0)
+      sessionsByProject.delete(projectIdentity);
+  }
+  const unregister = rawMessageProviderUnregistersBySession.get(sessionId);
+  if (unregister) {
+    unregister();
+    rawMessageProviderUnregistersBySession.delete(sessionId);
+  }
   clearSessionTracking(sessionId);
   clearPiCompressorState(sessionId);
 }
@@ -171799,7 +172468,7 @@ init_logger();
 init_data_path();
 init_logger();
 await init_sqlite();
-import { join as join14 } from "node:path";
+import { join as join16 } from "node:path";
 var BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 function randomBase62(length) {
   const chars = [];
@@ -171820,7 +172489,7 @@ function generatePartId(timestampMs, counter = 0n) {
   return generateId("prt", timestampMs, counter);
 }
 function getOpenCodeDbPath3() {
-  return join14(getDataDir(), "opencode", "opencode.db");
+  return join16(getDataDir(), "opencode", "opencode.db");
 }
 var cachedWriteDb = null;
 var REQUIRED_MESSAGE_COLUMNS = ["id", "session_id", "time_created", "time_updated", "data"];
@@ -172378,7 +173047,7 @@ async function runCompressorPass2(args) {
 
 // ../plugin/src/hooks/magic-context/compartment-runner-historian.ts
 import { mkdirSync as mkdirSync6, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join15 } from "node:path";
+import { join as join17 } from "node:path";
 init_data_path();
 function historianResponseDumpDir(directory) {
   return getProjectMagicContextHistorianDir(directory);
@@ -172632,7 +173301,7 @@ function dumpHistorianResponse(sessionId, directory, label, text) {
     mkdirSync6(dumpDir, { recursive: true });
     const safeSessionId = sanitizeDumpName(sessionId);
     const safeLabel = sanitizeDumpName(label);
-    const dumpPath = join15(dumpDir, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
+    const dumpPath = join17(dumpDir, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
     writeFileSync3(dumpPath, text, "utf8");
     sessionLog(sessionId, "compartment agent: historian response dumped", {
       label,
@@ -173838,7 +174507,7 @@ import {
 // package.json
 var package_default = {
   name: "@cortexkit/pi-magic-context",
-  version: "0.21.0",
+  version: "0.21.1",
   type: "module",
   description: "Pi coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -174290,6 +174959,8 @@ function registerCtxStatusCommand(pi, deps) {
   pi.registerCommand("ctx-status", {
     description: "Show Magic Context status for the current Pi session",
     handler: async (_args, ctx) => {
+      const projectIdentity = deps.resolveProject?.(ctx).projectIdentity ?? deps.projectIdentity;
+      const currentDeps = { ...deps, projectIdentity };
       const sessionId = resolveSessionId(ctx);
       if (!sessionId) {
         sendCtxStatusMessage(pi, {
@@ -174303,13 +174974,13 @@ No active Pi session is available.`,
       }
       try {
         if (ctx.hasUI) {
-          await showStatusDialog(pi, ctx, deps);
+          await showStatusDialog(pi, ctx, currentDeps);
           return;
         }
         const usage = ctx.getContextUsage?.();
         const modelKey = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined;
-        const statusText = executeStatus(deps.db, sessionId, deps.protectedTags ?? 20, deps.nudgeIntervalTokens, deps.executeThresholdPercentage, modelKey, deps.historyBudgetPercentage, deps.commitClusterTrigger, deps.executeThresholdTokens, usage?.contextWindow);
-        const details = buildStatusDetails(deps, sessionId);
+        const statusText = executeStatus(currentDeps.db, sessionId, currentDeps.protectedTags ?? 20, currentDeps.nudgeIntervalTokens, currentDeps.executeThresholdPercentage, modelKey, currentDeps.historyBudgetPercentage, currentDeps.commitClusterTrigger, currentDeps.executeThresholdTokens, usage?.contextWindow);
+        const details = buildStatusDetails(currentDeps, sessionId);
         sendCtxStatusMessage(pi, { title: "/ctx-status", text: statusText, level: "info" }, details);
       } catch (error51) {
         sendCtxStatusMessage(pi, {
@@ -174434,405 +175105,6 @@ function stripTagPrefixFromAssistantMessage(message) {
   return mutated;
 }
 
-// src/system-prompt.ts
-import { createHash as createHash8 } from "node:crypto";
-import { existsSync as existsSync11, readFileSync as readFileSync8 } from "node:fs";
-import { join as join17 } from "node:path";
-
-// ../plugin/src/agents/magic-context-prompt.ts
-function getToolHistoryGuidance(dropToolStructure) {
-  if (dropToolStructure) {
-    return `Compressed history intentionally omits tool calls and their outputs — summaries like "I edited file X" are historian records, not patterns to replicate. In the live conversation, older tool calls and their results are cleaned up to save context — you may see your own past messages referencing actions without the corresponding tool call or result visible. This is normal context management. ALWAYS use real tool calls; never simulate, fabricate, or inline tool outputs in your text. If there is no tool result message, the action did not happen. NEVER simulate, hallucinate or claim tool calls, command output, search results, file edits, or diffs in plain text as if they actually occurred.`;
-  }
-  return `Older tool calls in your conversation show truncated inputs and [truncated] outputs — this is normal context management, not a pattern to follow. The original tool calls executed successfully with full inputs and produced real outputs that were later cleaned up to save context. ALWAYS use real tool calls with complete arguments; never copy truncated patterns like "filePa...[truncated]" into your tool inputs. If you need to re-read a file or re-run a command, make a fresh tool call.`;
-}
-var BASE_INTRO = (protectedTags, dropToolStructure) => `Messages and tool outputs are tagged with §N§ identifiers (e.g., §1§, §42§).
-Use \`ctx_reduce\` to manage context size. It supports one operation:
-- \`drop\`: Remove entirely (best for tool outputs you already acted on).
-Syntax: "3-5", "1,2,9", or "1-5,8,12-15". Last ${protectedTags} tags are protected.
-Use \`ctx_note\` for deferred intentions — things to tackle later, not right now. NOT for task tracking (use todos). Notes survive context compression and you'll be reminded at natural work boundaries (after commits, historian runs, todo completion).
-Use \`ctx_memory\` to manage cross-session project memories. Write new memories or delete stale ones. Memories persist across sessions and are automatically injected into new sessions.
-**Save to memory proactively**: If you spent multiple turns finding something (a file path, a DB location, a config pattern, a workaround), save it with \`ctx_memory\` so future sessions don't repeat the search. Examples:
-- Found a project's source code path after searching → \`ctx_memory(action="write", category="ENVIRONMENT", content="OpenCode source is at ~/Work/OSS/opencode")\`
-- Discovered a non-obvious build/test command → \`ctx_memory(action="write", category="WORKFLOW_RULES", content="Always use scripts/release.sh for releases")\`
-- Learned a constraint the hard way → \`ctx_memory(action="write", category="CONSTRAINTS", content="Dashboard Tauri build needs RGBA PNGs, not grayscale")\`
-Use \`ctx_search\` to search across project memories, session facts, and conversation history from one query.
-Use \`ctx_expand\` to decompress a compartment range to see the original conversation transcript. Use \`start\`/\`end\` from \`<compartment start="N" end="M">\` attributes. Returns the compacted U:/A: transcript for that message range, capped at ~15K tokens.
-**Search before asking the user**: If you can't remember or don't know something that might have been discussed before or stored in project memory, use \`ctx_search\` before asking the user. Examples:
-- Can't remember where a related codebase or dependency lives → \`ctx_search(query="opencode source code path")\`
-- Forgot a prior architectural decision or constraint → \`ctx_search(query="why did we choose SQLite over postgres")\`
-- Need a config value, API key location, or environment detail → \`ctx_search(query="embedding provider configuration")\`
-- Looking for how something was implemented previously → \`ctx_search(query="how does the dreamer lease work")\`
-- Want to recall what was decided in an earlier conversation → \`ctx_search(query="dashboard release signing setup")\`
-\`ctx_search\` returns ranked results from memories, session facts, and raw message history. Use message ordinals from results with \`ctx_expand\` to retrieve surrounding conversation context.
-${getToolHistoryGuidance(dropToolStructure)}
-NEVER drop large ranges blindly (e.g., "1-50"). Review each tag before deciding.
-NEVER drop user messages — they are short and will be summarized by compartmentalization automatically. Dropping them loses context the historian needs.
-NEVER drop assistant text messages unless they are exceptionally large. Your conversation messages are lightweight; only large tool outputs are worth dropping.
-Before your turn finishes, consider using \`ctx_reduce\` to drop large tool outputs you no longer need.`;
-var BASE_INTRO_NO_REDUCE = (dropToolStructure) => `Use \`ctx_note\` for deferred intentions — things to tackle later, not right now. NOT for task tracking (use todos). Notes survive context compression and you'll be reminded at natural work boundaries (after commits, historian runs, todo completion).
-Use \`ctx_memory\` to manage cross-session project memories. Write new memories or delete stale ones. Memories persist across sessions and are automatically injected into new sessions.
-**Save to memory proactively**: If you spent multiple turns finding something (a file path, a DB location, a config pattern, a workaround), save it with \`ctx_memory\` so future sessions don't repeat the search. Examples:
-- Found a project's source code path after searching → \`ctx_memory(action="write", category="ENVIRONMENT", content="OpenCode source is at ~/Work/OSS/opencode")\`
-- Discovered a non-obvious build/test command → \`ctx_memory(action="write", category="WORKFLOW_RULES", content="Always use scripts/release.sh for releases")\`
-- Learned a constraint the hard way → \`ctx_memory(action="write", category="CONSTRAINTS", content="Dashboard Tauri build needs RGBA PNGs, not grayscale")\`
-Use \`ctx_search\` to search across project memories, session facts, and conversation history from one query.
-Use \`ctx_expand\` to decompress a compartment range to see the original conversation transcript. Use \`start\`/\`end\` from \`<compartment start="N" end="M">\` attributes. Returns the compacted U:/A: transcript for that message range, capped at ~15K tokens.
-**Search before asking the user**: If you can't remember or don't know something that might have been discussed before or stored in project memory, use \`ctx_search\` before asking the user. Examples:
-- Can't remember where a related codebase or dependency lives → \`ctx_search(query="opencode source code path")\`
-- Forgot a prior architectural decision or constraint → \`ctx_search(query="why did we choose SQLite over postgres")\`
-- Need a config value, API key location, or environment detail → \`ctx_search(query="embedding provider configuration")\`
-- Looking for how something was implemented previously → \`ctx_search(query="how does the dreamer lease work")\`
-- Want to recall what was decided in an earlier conversation → \`ctx_search(query="dashboard release signing setup")\`
-\`ctx_search\` returns ranked results from memories, session facts, and raw message history. Use message ordinals from results with \`ctx_expand\` to retrieve surrounding conversation context.
-${getToolHistoryGuidance(dropToolStructure)}`;
-var GENERIC_SECTION = `
-### Reduction Triggers
-- After reading files or search results you already acted on — drop raw outputs.
-- After completing a logical step — drop intermediate outputs from that step.
-- Between major context switches — when moving to a new task area.
-
-### What to Drop
-- Large file reads, grep results, and tool outputs you already used.
-- Large build/test output after you analyzed and acted on it.
-- Old diagnostic or exploration results that are no longer relevant.
-
-### What to Keep
-- ALL user messages and assistant conversation text — these are cheap and compartmentalized automatically.
-- Your current task requirements and constraints.
-- Recent errors and unresolved decisions.
-- Active work context and files being edited.`;
-var TEMPORAL_AWARENESS_GUIDANCE = `
-**Temporal awareness**: User messages may be preceded by HTML comments like \`<!-- +12m -->\`, \`<!-- +2h 15m -->\`, or \`<!-- +3d 4h -->\` indicating time elapsed since the previous message's completion. Compartments in \`<session-history>\` carry \`start-date\` and \`end-date\` attributes (YYYY-MM-DD) showing real-time boundaries. Use these when reasoning about workflow pacing, log durations, build times, or how long ago something happened.`;
-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, dropToolStructure = true, temporalAwarenessEnabled = false, cavemanTextCompressionEnabled = false) {
-  const smartNoteGuidance = dreamerEnabled ? `
-When \`surface_condition\` is provided with \`write\`, the note becomes a project-scoped smart note.
-The dreamer evaluates smart note conditions during nightly runs and surfaces them when conditions are met.
-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 : "";
-  if (!ctxReduceEnabled) {
-    return `## Magic Context
-
-${BASE_INTRO_NO_REDUCE(dropToolStructure)}${smartNoteGuidance}${temporalGuidance}${cavemanWarning}`;
-  }
-  return `## Magic Context
-
-${BASE_INTRO(protectedTags, dropToolStructure)}${smartNoteGuidance}${temporalGuidance}
-${GENERIC_SECTION}
-
-Prefer many small targeted operations over one large blanket operation. Compress early and often — don't wait for warnings.`;
-}
-
-// ../plugin/src/hooks/magic-context/key-files-block.ts
-import { readFileSync as readFileSync7, realpathSync as realpathSync3 } from "node:fs";
-import { join as join16, sep as sep2 } from "node:path";
-init_logger();
-var cachedKeyFilesBySession = new Map;
-var staleUpdates = new Map;
-function staleKey(update) {
-  return `${update.projectPath}\x00${update.path}\x00${update.generatedAtWitness}\x00${update.staleReason}`;
-}
-function queueStaleUpdate(projectPath, path5, generatedAtWitness, staleReason) {
-  const update = { projectPath, path: path5, generatedAtWitness, staleReason };
-  staleUpdates.set(staleKey(update), update);
-}
-function flushStaleUpdates(db) {
-  if (staleUpdates.size === 0)
-    return 0;
-  const updates = [...staleUpdates.values()];
-  staleUpdates.clear();
-  const stmt = db.prepare(`UPDATE project_key_files
-            SET stale_reason = ?1
-          WHERE project_path = ?2
-            AND path = ?3
-            AND generated_at = ?4
-            AND (stale_reason IS NULL OR stale_reason != ?1)`);
-  let changed = 0;
-  for (const update of updates) {
-    try {
-      changed += stmt.run(update.staleReason, update.projectPath, update.path, update.generatedAtWitness).changes;
-    } catch (error51) {
-      log("[key-files] flushStaleUpdates failed:", error51);
-    }
-  }
-  return changed;
-}
-function clearKeyFilesCacheForSession(sessionId) {
-  cachedKeyFilesBySession.delete(sessionId);
-}
-function isUnderProject(projectPath, absPath) {
-  const root = realpathSync3(projectPath);
-  return absPath.startsWith(root + sep2) || absPath === root;
-}
-function buildKeyFilesBlock(db, projectPath, config2 = { enabled: true, tokenBudget: 1e4 }) {
-  if (!config2.enabled)
-    return null;
-  if (!isAftAvailable())
-    return null;
-  const rows = readCurrentKeyFiles(db, projectPath);
-  if (rows.length === 0)
-    return null;
-  for (const row of rows) {
-    if (row.staleReason !== null)
-      continue;
-    let nextStale = null;
-    let observed = false;
-    try {
-      const absPath = join16(projectPath, row.path);
-      const real = realpathSync3(absPath);
-      if (!isUnderProject(projectPath, real)) {
-        nextStale = "missing";
-        observed = true;
-      } else {
-        const diskHash = sha256(readFileSync7(real));
-        if (diskHash !== row.contentHash)
-          nextStale = "content_drift";
-        observed = true;
-      }
-    } catch (error51) {
-      const code = error51?.code;
-      if (code === "ENOENT" || code === "ELOOP") {
-        nextStale = "missing";
-        observed = true;
-      } else {
-        log(`[key-files] freshness check transient failure: ${row.path}: ${error51 instanceof Error ? error51.message : String(error51)}`);
-      }
-    }
-    if (observed && nextStale !== null) {
-      queueStaleUpdate(row.projectPath, row.path, row.generatedAt, nextStale);
-    }
-  }
-  const blocks = [];
-  let used = 0;
-  for (const row of rows) {
-    if (used + row.localTokenEstimate > config2.tokenBudget)
-      break;
-    blocks.push(`  <key-file path="${escapeXmlAttr(row.path)}">
-${escapeXmlContent(row.content)}
-  </key-file>`);
-    used += row.localTokenEstimate;
-  }
-  if (blocks.length === 0)
-    return null;
-  const rendered = `<key-files>
-${blocks.join(`
-`)}
-</key-files>`;
-  flushStaleUpdates(db);
-  return rendered;
-}
-function readVersionedKeyFiles(args) {
-  const config2 = args.config ?? { enabled: true, tokenBudget: 1e4 };
-  if (args.sessionMeta.isSubagent)
-    return null;
-  if (!config2.enabled)
-    return null;
-  if (!isAftAvailable())
-    return null;
-  const projectPath = resolveProjectPath(args.directory ?? args.sessionMeta.sessionId);
-  if (!projectPath)
-    return null;
-  const currentVersion = getKeyFilesVersion(args.db, projectPath);
-  if (args.sessionId) {
-    const cached2 = cachedKeyFilesBySession.get(args.sessionId);
-    if (cached2 && !args.isCacheBusting && cached2.version === currentVersion) {
-      return cached2.value;
-    }
-  }
-  const value = buildKeyFilesBlock(args.db, projectPath, config2);
-  if (args.sessionId) {
-    cachedKeyFilesBySession.set(args.sessionId, { value, version: currentVersion });
-    if (value)
-      sessionLog(args.sessionId, `loaded key-files block (v${currentVersion}, ${value.length} chars)`);
-  }
-  return value;
-}
-
-// src/system-prompt.ts
-init_logger();
-var PROJECT_DOCS_MARKER = "<project-docs>";
-var USER_PROFILE_MARKER = "<user-profile>";
-var stickyDateBySession = new Map;
-var cachedDocsBySession = new Map;
-var cachedUserProfileBySession = new Map;
-var DOC_FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
-function readProjectDocs(directory) {
-  const sections = [];
-  for (const filename of DOC_FILES) {
-    const filePath = join17(directory, filename);
-    try {
-      if (existsSync11(filePath)) {
-        const content = readFileSync8(filePath, "utf-8").trim();
-        if (content.length > 0) {
-          sections.push(`<${filename}>
-${content}
-</${filename}>`);
-        }
-      }
-    } catch (error51) {
-      log(`[magic-context-pi] failed to read ${filename}:`, error51);
-    }
-  }
-  if (sections.length === 0)
-    return null;
-  return `${PROJECT_DOCS_MARKER}
-${sections.join(`
-
-`)}
-</project-docs>`;
-}
-function buildUserProfileBlock(db) {
-  const memories = getActiveUserMemories(db);
-  if (memories.length === 0)
-    return null;
-  const items = memories.map((m) => `- ${m.content}`).join(`
-`);
-  return `${USER_PROFILE_MARKER}
-${items}
-</user-profile>`;
-}
-function buildMagicContextBlock(opts) {
-  const sections = [];
-  const sessionId = opts.sessionId;
-  const isCacheBusting = opts.isCacheBusting ?? false;
-  if (opts.injectDocs) {
-    const docsBlock = readCachedAdjunct({
-      cache: cachedDocsBySession,
-      sessionId,
-      isCacheBusting,
-      compute: () => readProjectDocs(opts.cwd),
-      describe: "project docs"
-    });
-    if (docsBlock)
-      sections.push(docsBlock);
-  }
-  if (opts.userMemoriesEnabled) {
-    const profileBlock = readCachedAdjunct({
-      cache: cachedUserProfileBySession,
-      sessionId,
-      isCacheBusting,
-      compute: () => buildUserProfileBlock(opts.db),
-      describe: "user profile"
-    });
-    if (profileBlock)
-      sections.push(profileBlock);
-  }
-  if (opts.pinKeyFilesEnabled && sessionId) {
-    let sessionMeta = null;
-    try {
-      sessionMeta = getOrCreateSessionMeta(opts.db, sessionId);
-    } catch (error51) {
-      sessionLog(sessionId, "Pi key-files session meta load failed:", error51);
-    }
-    const keyFilesBlock = sessionMeta ? readVersionedKeyFiles({
-      db: opts.db,
-      sessionId,
-      sessionMeta,
-      directory: opts.cwd,
-      isCacheBusting,
-      config: {
-        enabled: opts.pinKeyFilesEnabled,
-        tokenBudget: opts.pinKeyFilesTokenBudget ?? 1e4
-      }
-    }) : null;
-    if (keyFilesBlock)
-      sections.push(keyFilesBlock);
-  }
-  const dataBlock = sections.length > 0 ? `<magic-context>
-${sections.join(`
-
-`)}
-</magic-context>` : null;
-  const includeGuidance = opts.includeGuidance ?? true;
-  if (!includeGuidance) {
-    return dataBlock;
-  }
-  const guidance = buildMagicContextSection(null, opts.protectedTags ?? 20, opts.ctxReduceEnabled ?? true, opts.dreamerEnabled ?? false, opts.dropToolStructure ?? true, opts.temporalAwarenessEnabled ?? false, opts.cavemanTextCompressionEnabled ?? false);
-  if (dataBlock) {
-    return `${guidance}
-
-${dataBlock}`;
-  }
-  return guidance;
-}
-function readCachedAdjunct(args) {
-  const { cache, sessionId, isCacheBusting, compute, describe: describe3 } = args;
-  if (!sessionId) {
-    return compute();
-  }
-  const hasCached = cache.has(sessionId);
-  if (!hasCached || isCacheBusting) {
-    const value = compute();
-    cache.set(sessionId, value);
-    if (value && !hasCached) {
-      sessionLog(sessionId, `loaded ${describe3} (${value.length} chars)`);
-    } else if (value && isCacheBusting) {
-      sessionLog(sessionId, `refreshed ${describe3} (cache-busting pass)`);
-    }
-    return value;
-  }
-  return cache.get(sessionId) ?? null;
-}
-var DATE_PATTERN = /Today's date: .+/;
-function processSystemPromptForCache(args) {
-  const { db, sessionId, systemPrompt, isCacheBusting } = args;
-  let sessionMeta;
-  try {
-    sessionMeta = getOrCreateSessionMeta(db, sessionId);
-  } catch (error51) {
-    sessionLog(sessionId, "system-prompt-hash session meta load failed:", error51);
-  }
-  const previousHash = sessionMeta?.systemPromptHash ?? "";
-  const isFirstHash = previousHash === "" || previousHash === "0";
-  let frozenPrompt = systemPrompt;
-  const dateMatch = systemPrompt.match(DATE_PATTERN);
-  const liveDate = dateMatch ? dateMatch[0] : null;
-  const stickyDate = stickyDateBySession.get(sessionId);
-  if (liveDate && !stickyDate) {
-    stickyDateBySession.set(sessionId, liveDate);
-  } else if (liveDate && stickyDate && liveDate !== stickyDate) {
-    if (isCacheBusting) {
-      stickyDateBySession.set(sessionId, liveDate);
-      sessionLog(sessionId, `system prompt date updated: ${stickyDate} → ${liveDate} (cache-busting pass)`);
-    } else {
-      frozenPrompt = systemPrompt.replace(DATE_PATTERN, stickyDate);
-      sessionLog(sessionId, `system prompt date frozen: real=${liveDate}, using=${stickyDate} (cache-stable pass)`);
-    }
-  }
-  const currentHash = createHash8("md5").update(frozenPrompt).digest("hex");
-  const hashChanged = !isFirstHash && currentHash !== previousHash;
-  if (hashChanged) {
-    sessionLog(sessionId, `system prompt hash changed: ${previousHash} → ${currentHash} (len=${frozenPrompt.length})`);
-  } else if (isFirstHash) {
-    sessionLog(sessionId, `system prompt hash initialized: ${currentHash} (len=${frozenPrompt.length})`);
-  }
-  const systemPromptTokens = estimateTokens(frozenPrompt);
-  if (sessionMeta) {
-    if (currentHash !== previousHash) {
-      updateSessionMeta(db, sessionId, {
-        systemPromptHash: currentHash,
-        systemPromptTokens
-      });
-    } else if (Math.abs(sessionMeta.systemPromptTokens - systemPromptTokens) > 50) {
-      updateSessionMeta(db, sessionId, { systemPromptTokens });
-    }
-  }
-  return {
-    systemPrompt: frozenPrompt,
-    hashChanged,
-    currentHash
-  };
-}
-function clearPiSystemPromptSession(sessionId) {
-  stickyDateBySession.delete(sessionId);
-  cachedDocsBySession.delete(sessionId);
-  cachedUserProfileBySession.delete(sessionId);
-  clearKeyFilesCacheForSession(sessionId);
-}
-
 // ../plugin/src/tools/ctx-expand/constants.ts
 var CTX_EXPAND_DESCRIPTION = "Decompress a compartment range to see the original conversation transcript. " + 'Use start/end from <compartment start="N" end="M"> attributes. ' + "Returns the compacted U:/A: transcript for that message range, capped at ~15K tokens.";
 var CTX_EXPAND_TOKEN_BUDGET = 15000;
@@ -178974,6 +179246,7 @@ var ALL_ACTIONS = [
   "archive"
 ];
 var DREAMER_ONLY_ACTIONS = new Set([
+  "list",
   "update",
   "merge",
   "archive"
@@ -179062,7 +179335,7 @@ function queueEmbedding(args) {
 }
 function createCtxMemoryTool(deps) {
   const dreamerAllowed = deps.allowDreamerActions === true;
-  const description = dreamerAllowed ? "Manage cross-session project memories. Memories persist across sessions and are " + "shared with OpenCode sessions on the same project. " + "Supported actions: write, delete, list, update, merge, archive." : "Manage cross-session project memories. Memories persist across sessions and are " + "shared with OpenCode sessions on the same project. " + "Supported actions: write, delete, list.";
+  const description = dreamerAllowed ? "Manage cross-session project memories. Memories persist across sessions and are " + "shared with OpenCode sessions on the same project. " + "Supported actions: write, delete, list, update, merge, archive." : "Manage cross-session project memories. Memories persist across sessions and are " + "shared with OpenCode sessions on the same project. " + "Supported actions: write, delete.";
   return {
     name: "ctx_memory",
     label: "Magic Context: Memory",
@@ -179655,8 +179928,10 @@ function formatResult(result, index) {
     ].join(`
 `);
   }
+  const expandStart = Math.max(1, result.messageOrdinal - 3);
+  const expandEnd = result.messageOrdinal + 3;
   return [
-    `[${index}] [message] score=${result.score.toFixed(2)} ordinal=${result.messageOrdinal} role=${result.role}`,
+    `[${index}] [message] score=${result.score.toFixed(2)} ordinal=${result.messageOrdinal} range=${expandStart}-${expandEnd} role=${result.role}`,
     result.content
   ].join(`
 `);
@@ -179665,7 +179940,11 @@ function formatSearchResults(query, results) {
   if (results.length === 0) {
     return `No results found for "${query}" across memories, git commits, or message history.`;
   }
-  const body = results.map((result, index) => formatResult(result, index + 1)).join(`
+  const bodyParts = results.map((result, index) => formatResult(result, index + 1));
+  if (results.some((result) => result.source === "message")) {
+    bodyParts.push("Use ctx_expand(start, end) with the range from any message result above to read the full conversation context.");
+  }
+  const body = bodyParts.join(`
 
 `);
   return `Found ${results.length} result${results.length === 1 ? "" : "s"} for "${query}":
@@ -179825,6 +180104,11 @@ function registerMagicContextTools(pi, opts) {
 
 // src/index.ts
 var PREFIX2 = "[magic-context][pi]";
+function resolveCurrentProject(ctx) {
+  const projectDir = ctx.cwd;
+  const projectIdentity = resolveProjectIdentity(projectDir);
+  return { projectDir, projectIdentity };
+}
 function persistPiMessageEndModelMeta(args) {
   if (!args.message || typeof args.message !== "object")
     return;
@@ -180015,6 +180299,7 @@ async function src_default2(pi) {
   }
   const projectDir = process.cwd();
   const projectIdentity = resolveProjectIdentity(projectDir);
+  const seenDreamerProjectIdentities = new Set([projectIdentity]);
   info(`loaded v${PLUGIN_VERSION} | harness=pi | db=${dbPath} | ` + `project=${projectIdentity} | dir=${projectDir}`);
   const { config: config2, warnings, loadedFromPaths } = loadPiConfig({
     cwd: projectDir
@@ -180045,7 +180330,10 @@ async function src_default2(pi) {
   const historianConfig = resolveHistorianFromConfig(config2);
   if (historianConfig) {
     historianConfig.onStatusChange = (ctx) => {
-      updateStatusLine(ctx, { db, projectIdentity });
+      updateStatusLine(ctx, {
+        db,
+        projectIdentity: resolveCurrentProject(ctx).projectIdentity
+      });
     };
   }
   const nudgeConfig = resolveNudgeFromConfig(config2);
@@ -180084,12 +180372,17 @@ async function src_default2(pi) {
   registerCtxStatusCommand(pi, {
     db,
     projectIdentity,
+    resolveProject: resolveCurrentProject,
     protectedTags: config2.protected_tags,
     nudgeIntervalTokens: config2.nudge_interval_tokens,
     executeThresholdPercentage: config2.execute_threshold_percentage,
     historyBudgetPercentage: config2.history_budget_percentage,
     commitClusterTrigger: config2.commit_cluster_trigger,
-    executeThresholdTokens: config2.execute_threshold_tokens
+    executeThresholdTokens: config2.execute_threshold_tokens,
+    dreamer: {
+      enabled: config2.dreamer?.enabled ?? false,
+      schedule: config2.dreamer?.schedule
+    }
   });
   info("registered /ctx-status");
   registerStatusLine(pi, { db, projectIdentity });
@@ -180111,7 +180404,10 @@ async function src_default2(pi) {
   registerCtxDreamCommand(pi, {
     db,
     projectDir,
-    projectIdentity
+    projectIdentity,
+    resolveProject: resolveCurrentProject,
+    dreamerEnabled: config2.dreamer?.enabled ?? false,
+    onProjectSeen: (identity) => seenDreamerProjectIdentities.add(identity)
   });
   info("registered /ctx-dream");
   const dreamerConfig = resolveDreamerFromConfig(config2);
@@ -180123,7 +180419,8 @@ async function src_default2(pi) {
       config: dreamerConfig,
       embeddingConfig: config2.embedding,
       memoryEnabled: config2.memory.enabled,
-      gitCommitIndexing: config2.experimental.git_commit_indexing
+      gitCommitIndexing: config2.experimental.git_commit_indexing,
+      onAdjunctsRefreshNeeded: signalPiSystemPromptRefreshForProject
     });
     info(dreamerConfig.enabled ? `registered dreamer (schedule=${dreamerConfig.schedule}, tasks=[${dreamerConfig.tasks.join(",")}])` : "registered dreamer: DISABLED (dreamer.enabled=false)");
   } else {
@@ -180131,6 +180428,8 @@ async function src_default2(pi) {
   }
   pi.on("before_agent_start", async (event, ctx) => {
     try {
+      const currentProject = resolveCurrentProject(ctx);
+      seenDreamerProjectIdentities.add(currentProject.projectIdentity);
       const sm = ctx.sessionManager;
       let sessionId;
       if (sm !== undefined) {
@@ -180143,10 +180442,20 @@ async function src_default2(pi) {
           } catch {}
         }
       }
+      if (sessionId) {
+        trackSessionForProject(currentProject.projectIdentity, sessionId);
+      }
+      if (config2.system_prompt_injection?.enabled === false) {
+        return;
+      }
+      const skipSigs = config2.system_prompt_injection?.skip_signatures ?? [];
+      if (skipSigs.some((sig) => sig.length > 0 && event.systemPrompt.includes(sig))) {
+        return;
+      }
       const isCacheBusting = sessionId ? hasSystemPromptRefresh(sessionId) : true;
       const block = buildMagicContextBlock({
         db,
-        cwd: ctx.cwd,
+        cwd: currentProject.projectDir,
         sessionId,
         memoryEnabled: config2.memory.enabled,
         injectDocs: config2.dreamer?.inject_docs ?? true,
@@ -180160,7 +180469,8 @@ async function src_default2(pi) {
         userMemoriesEnabled: (config2.dreamer?.enabled ?? false) && (config2.dreamer?.user_memories?.enabled ?? false),
         pinKeyFilesEnabled: (config2.dreamer?.enabled ?? false) && (config2.dreamer?.pin_key_files?.enabled ?? false),
         pinKeyFilesTokenBudget: config2.dreamer?.pin_key_files?.token_budget ?? 1e4,
-        isCacheBusting
+        isCacheBusting,
+        existingSystemPrompt: event.systemPrompt
       });
       const composedPrompt = block ? `${event.systemPrompt}
 
@@ -180252,10 +180562,13 @@ ${block}` : event.systemPrompt;
       const sessionId = sm?.getSessionId?.();
       if (typeof sessionId !== "string" || sessionId.length === 0)
         return;
-      const rawMessages = readPiSessionMessages(ctx);
-      const latest = rawMessages[rawMessages.length - 1];
-      if (latest?.role === "assistant" && latest.id.length > 0) {
-        scheduleIncrementalIndex(db, sessionId, latest.id, () => latest);
+      const endedMsg = event.message;
+      if (endedMsg?.role === "assistant" && typeof endedMsg.id === "string" && endedMsg.id.length > 0) {
+        const messageId = endedMsg.id;
+        scheduleIncrementalIndex(db, sessionId, messageId, () => {
+          const rawMessages = readPiSessionMessages(ctx);
+          return rawMessages.find((message) => message.id === messageId) ?? null;
+        });
       }
       persistPiMessageEndModelMeta({
         db,
@@ -180358,7 +180671,9 @@ ${block}` : event.systemPrompt;
       warn("shutdown: dreamer drain threw:", err5);
     }
     try {
-      unregisterPiDreamerProject({ projectIdentity });
+      for (const identity of seenDreamerProjectIdentities) {
+        unregisterPiDreamerProject({ projectIdentity: identity });
+      }
     } catch (err5) {
       warn("shutdown: unregisterPiDreamerProject threw:", err5);
     }