@wolfx/opencode-magic-context 0.21.8-patch.1 → 0.21.8-patch.4

package/dist/index.js

@@ -14924,7 +14924,6 @@ var init_magic_context = __esm(() => {
   });
   MagicContextConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(true),
-    auto_update: exports_external.boolean().optional(),
     ctx_reduce_enabled: exports_external.boolean().default(true),
     historian: HistorianConfigSchema,
     dreamer: DreamerConfigSchema.optional(),
@@ -14986,6 +14985,10 @@ var init_magic_context = __esm(() => {
         score_threshold: exports_external.number().min(0.3).max(0.95).default(0.6),
         min_prompt_chars: exports_external.number().min(5).max(500).default(20)
       }).default({ enabled: false, score_threshold: 0.6, min_prompt_chars: 20 }),
+      text_complete_strip: exports_external.object({
+        enabled: exports_external.boolean().default(true),
+        patterns: exports_external.array(exports_external.string()).optional()
+      }).optional(),
       caveman_text_compression: exports_external.object({
         enabled: exports_external.boolean().default(false),
         min_chars: exports_external.number().min(100).max(1e4).default(500)
@@ -152939,6 +152942,907 @@ var init_subagent_token_capture = __esm(() => {
   init_logger();
 });
 
+// src/hooks/magic-context/compartment-prompt.ts
+function buildHistorianEditorPrompt(draft) {
+  return [
+    "This is a historian draft. Clean it up following the rules in your system prompt.",
+    "",
+    "<draft>",
+    draft,
+    "</draft>",
+    "",
+    "Return the cleaned draft as valid XML matching the original structure."
+  ].join(`
+`);
+}
+function buildCompressorPrompt(compartments, currentTokens, targetTokens, outputDepth, outputCount) {
+  const lines = [];
+  const densityLabel = outputDepth === 1 ? "MERGE ONLY" : outputDepth === 2 ? "LITE TIGHTEN" : outputDepth === 3 ? "FULL CONDENSE" : "ULTRA TELEGRAPH";
+  const resolvedOutputCount = outputCount ?? Math.max(1, Math.ceil(compartments.length / 2));
+  lines.push(`Density target: LEVEL ${outputDepth} (${densityLabel}). See system prompt for level rules.`);
+  lines.push(`Input: ${compartments.length} compartments, ~${currentTokens} tokens. Target output: exactly ${resolvedOutputCount} compartments, ~${targetTokens} tokens total.`);
+  lines.push("");
+  if (outputDepth === 1) {
+    lines.push("Merge only. Preserve narrative and all U: lines. Drop only genuine duplicate sentences spanning compartments.");
+  } else if (outputDepth === 2) {
+    lines.push("Merge + drop filler words and hedging. Keep grammar, keep U: lines verbatim.");
+  } else if (outputDepth === 3) {
+    lines.push("Merge into single-paragraph compartments. Drop articles and weak auxiliaries. Keep only IRREPLACEABLE U: lines.");
+  } else {
+    lines.push("Merge into telegraphic fragments with symbol connectives (→ + // |). U: lines only if truly irreplaceable.");
+  }
+  lines.push("");
+  lines.push("Preserved literally at all levels: commit hashes, file paths, URLs, code spans.");
+  lines.push("");
+  for (const c of compartments) {
+    lines.push(`<compartment start="${c.startMessage}" end="${c.endMessage}" title="${escapeXmlAttr(c.title)}">`);
+    lines.push(escapeXmlContent(c.content));
+    lines.push("</compartment>");
+    lines.push("");
+  }
+  lines.push("Return merged compartments as XML.");
+  return lines.join(`
+`);
+}
+function buildCompartmentAgentPrompt(existingState, inputSource, options) {
+  const existingStateBlock = options?.stateFilePath ? `Read the existing session state from this file before proceeding:
+${options.stateFilePath}
+
+The file contains the full XML existing state (compartments, facts, memories). Read it first, then process the new messages below.` : existingState;
+  return [
+    "Existing state (read-only context for continuity and fact normalization — do NOT re-emit these compartments):",
+    existingStateBlock,
+    "",
+    "<new_messages>",
+    inputSource,
+    "</new_messages>",
+    "",
+    "Instructions:",
+    "- Return ONLY new compartments for the messages inside <new_messages>, plus the full normalized fact list.",
+    "- Use the exact absolute raw ordinals from the input ranges for every compartment start/end and for <unprocessed_from>.",
+    "- Rewrite every fact into terse, present-tense operational form. Merge semantic duplicates within each category.",
+    "- Drop any session fact already covered by a project memory in the existing state.",
+    "- Do not preserve prior narrative wording verbatim; if a fact is already canonical and still correct, keep or lightly normalize it.",
+    "- Drop obsolete or task-local facts.",
+    ...options?.userMemoriesEnabled ? [
+      "- Also emit <user_observations> with universal behavioral observations about the user (see system prompt for rules)."
+    ] : []
+  ].join(`
+`);
+}
+var COMPARTMENT_AGENT_SYSTEM_PROMPT = `You condense long AI coding sessions into two outputs:
+
+1. compartments: completed logical work units
+2. facts: persistent cross-cutting information for future work
+
+Compartment rules:
+- A compartment is one contiguous completed work unit: investigation, fix, refactor, docs update, feature, or decision.
+- Start a new compartment only when the work clearly pivots to a different objective.
+- If one broad effort contains multiple completed sub-pivots with distinct outcomes, prefer multiple smaller compartments over one umbrella compartment with many U: lines.
+- Do not create compartments for magic-context commands or tool-only noise.
+- If the input ends mid-topic, leave it out and report its first message index in <unprocessed_from>.
+- All compartment start/end ordinals and <unprocessed_from> must use the absolute raw message numbers shown in the input. Never renumber relative to this chunk.
+- Every displayed raw message ordinal in the input MUST appear in exactly one compartment. Gaps between compartments are invalid. When a displayed block is pure tool noise (e.g. a long "TC: ..." run with no narrative text), do NOT skip it — extend the preceding compartment's \`end\` to absorb the range, or include it inside the current compartment if the block falls within an ongoing work unit. Never create a dedicated compartment just to cover a tool-only run.
+- Only emit NEW compartments for the new messages. Do not re-emit existing compartments from the existing state.
+- Write comprehensive, detailed compartments. Include file paths, function names, commit hashes, config keys, and values when they matter.
+- Do not list every changed file. Do not narrate tool calls. Do not preserve dead-end exploration beyond a brief clause when needed.
+
+# Construction order (MANDATORY)
+
+For each compartment, build in this exact order:
+
+1. Write the narrative summary first — what was done, why, and the outcome. This is 1–4 sentences covering the work unit completely.
+2. Re-read your narrative. Ask: does the summary already convey all important decisions and constraints from this work unit?
+3. If yes, the compartment is DONE with zero U: lines. Move on.
+4. If no, identify the specific signal the narrative cannot capture. Add U: lines ONLY for those signals.
+5. Before writing each U: line, run the CROSS-COMPARTMENT CHECK (see below).
+
+Zero U: lines in a compartment is normal and expected. Most compartments should have 0–2 U: lines. Compartments with 3–5 are rare and must be justified by genuinely distinct durable signals.
+
+# DROP rules (check these first — if any match, drop without exception)
+
+- Questions in ANY form: "should I X?", "what about Y?", "do you think Z?", "isn't it better to A?", "why don't we B?", "any ideas?" — the resolved answer belongs in narrative only. If it feels important to keep the question, you are wrong: keep the answer in narrative.
+- Agreements and acknowledgments: "yes", "okay", "sure", "thanks", "go ahead", "looks good", "perfect", "I agree", "sounds good", "great".
+- Pure pacing and sequencing: "let's start", "continue", "let's do all", "now we can X", "let's commit", "first do A then B", "before that", "in the meantime".
+- Tactical observations: "I just noticed X", "we recently did Y", "I'm seeing Z right now", "this seems wrong".
+- Debugging status: "context is at 78%", "I'm restarting", "the last build failed".
+- Dogfooding/restart loops: "I restarted, can you check?", "okay we should have updated versions now", "let me try again".
+- Pasted error output or logs as U: line — capture the underlying problem in narrative, not the raw paste.
+- Examples and illustrations: "mine was when an agent wants to see X" — convert the underlying intent into a directive or drop.
+- Hype with embedded directive: ALL-CAPS pleas, "PLEASE PLEASE PLEASE just do X" — extract only the underlying directive into narrative; drop the hype.
+- Social signals, banter, emoji-only, enthusiasm.
+- Deferred ideas: "for later", "we can do X later", "another idea for the future".
+- Mid-process status: "running Y", "checking Z".
+- Superseded drafts once a later message gives the final decision.
+- Standing workflow rules ("always run lint before push") — these belong in WORKFLOW_RULES facts, not U: lines.
+
+# Wording rule (default: verbatim)
+
+By default, U: lines use the user's actual wording. The user's exact phrasing often carries negotiation context, emphasis, or technical specificity that paraphrase loses.
+
+Paraphrase ONLY in these cases:
+- **Strip agreement prefixes**: "Yes X", "Okay X", "Sure X" → keep only the substantive part of X, in the user's original wording.
+- **Split compound directives**: If one message contains two distinct durable directives, split into two U: lines — each preserving the user's wording for its part.
+- **Drop conversational noise, keep core**: If a message wraps a directive in exploratory phrasing ("so I was thinking, maybe... but actually..."), drop the exploration and keep the core directive in the user's remaining words. Don't invent new phrasing.
+
+NEVER:
+- Rewrite a clear user directive into a formal constraint statement. ("We need tool count at ~8" stays as-is; do NOT convert to "Tool count must be capped at 8.")
+- Synthesize a directive from multiple messages into one canonical statement. If the signal needs synthesis, it belongs in narrative, not a U: line.
+- Add technical specificity the user didn't state (file paths, function names, constant names). Canonical technical specificity belongs in narrative or facts, not in U: lines attributed to the user.
+
+Good example:
+  Original user message: "Yes let's do this. But we need to also make sure that we limit by message count as some sessions have quite a lot of messages."
+  Correct U: line: "We need to also make sure that we limit by message count as some sessions have quite a lot of messages."
+  (Stripped agreement prefix; kept the user's actual wording.)
+
+Bad example (do not do this):
+  Incorrect U: line: "Cap session history retrieval at a maximum message count to prevent memory issues on large sessions."
+  (Rewrote the user directive into formal language and invented specificity.)
+
+# KEEP rules (U: line survives only if ALL pass)
+
+1. DURABLE: The signal matters after the immediate turn.
+2. SPECIFIC: Concrete goal, hard constraint, design decision, rejection, rationale, threshold, source-of-truth correction, or future-work directive.
+3. OUTCOME-BACKED: This compartment's narrative clearly states what was done, decided, or changed because of the message.
+4. NON-REDUNDANT: Not captured by another U: line (see CROSS-COMPARTMENT CHECK), by a fact, or by the narrative.
+5. IRREPLACEABLE: The user's wording adds signal that narrative paraphrase cannot preserve. If the same information could appear as narrative without losing meaning, it should.
+
+Categories of KEEP:
+- Hard gates, thresholds, config defaults, percentages, byte sizes with concrete values.
+- Accepted designs and explicit decisions.
+- Rejections and negative constraints: "X is wrong because Y", "we should NOT do Z".
+- Source-of-truth corrections: "follow the code, not the README".
+- Implementation pivots stated in future tense: "instead of X let's do Y", "switch to Z".
+- Durable rationale that explains WHY an approach was chosen.
+- Specific feature requirements stated as durable goals.
+
+# PIVOT vs OBSERVATION test
+
+A pivot is FUTURE-TENSE and changes the plan: "instead of X, let's do Y", "switch this to Z", "actually, let's not do A".
+An observation is PAST-TENSE or PRESENT-TENSE and reports state: "we recently did X", "I just noticed Y", "this is broken right now".
+Observations may frame narrative context but are NOT pivots and NOT durable. Drop them as U: lines.
+
+# CROSS-COMPARTMENT CHECK (forward-looking)
+
+Before writing ANY U: line in the current compartment:
+1. Scan U: lines you have ALREADY written in previous compartments in this response.
+2. If any prior U: line expresses the same intent, decision, constraint, or rationale — even in different words — do NOT write the new U: line.
+3. Let the narrative in the current compartment carry the signal instead.
+
+This is a forward operation: you only need to check what you already wrote, not revisit past compartments.
+
+Examples of same-intent pairs to collapse:
+- "X shouldn't cause cache bust" + "X must not bust cache by itself" → keep only the first, in its original compartment.
+- "Let's use monorepo" + "Yes, monorepo is the right call" → keep only the first.
+- "Add logging" + "We need logs here too" → keep only the first.
+
+Never keep two U: lines for the same underlying directive across compartments.
+
+# Budget
+
+- HARD LIMIT: 3–5 U: lines per compartment. 0–2 is typical.
+- If you have more than 5 candidate U: lines in one compartment, that is a signal to split into two compartments at a natural pivot, not to stuff more.
+- Every U: line must be immediately followed by 1–3 sentences describing the outcome, decision, or effect. Never stack two U: lines without intervening outcome text.
+
+# Example: CORRECT preservation (narrative-first, verbatim U: line)
+
+<compartment start="50" end="120" title="Built the auth layer">
+Implemented JWT auth with hard 60-minute exp claim and refresh-token rotation. Chose Bearer tokens over cookies after finding cookie-based auth broke the SPA flow. Added session_expiry config (read-only at runtime). Commits: a3f891, b22c4e.
+U: We need session expiry capped at 1 hour, no exceptions
+Hardcoded the 60-minute cap at the JWT-issuer layer so runtime overrides cannot extend it.
+</compartment>
+
+Notice: only one U: line, kept verbatim from the user's actual message. The cookie-to-Bearer pivot is narrative because paraphrase captures the signal fully.
+
+# Example: OVER-PRESERVATION (avoid)
+
+<compartment start="200" end="350" title="Refactored data layer">
+U: Okay let's start on the data layer
+U: What about transactions?
+U: Yes that approach looks good
+U: Actually wait, maybe we need write-ahead logging
+U: I just noticed the previous commit broke a test
+U: Let's commit and ship it
+Refactored data layer with WAL mode and connection pooling.
+</compartment>
+
+Problems: pacing, question, agreement, observation, pacing again. Only one message carries signal, and even that is narrative-capturable.
+
+# CORRECT version of the above
+
+<compartment start="200" end="350" title="Refactored data layer">
+Refactored data layer to use WAL mode plus connection pooling. Chose WAL over plain connections for concurrent read performance under sustained write load.
+</compartment>
+
+Zero U: lines. The pivot to WAL is clear in narrative.
+
+Fact rules:
+- Facts are editable state, not append-only notes. Rewrite, normalize, deduplicate, or drop existing facts whenever needed.
+- Before emitting any fact, check all existing facts in the same category for semantic duplicates. If two facts describe the same decision, constraint, or default with different wording, merge them into one canonical statement. Never emit two facts that could be answered by the same question.
+- When project memories are provided as read-only reference, drop any session fact that is already covered by a project memory. Project memories are the canonical cross-session source; session facts must not duplicate them.
+- Facts must be durable and actionable after the conversation ends.
+- A fact is either a stable invariant/default or a reusable operating rule. If it mainly explains what happened, it belongs in a compartment, not a fact.
+- Facts belong only in these categories when relevant: WORKFLOW_RULES, ARCHITECTURE_DECISIONS, CONSTRAINTS, CONFIG_DEFAULTS, KNOWN_ISSUES, ENVIRONMENT, NAMING, USER_PREFERENCES, USER_DIRECTIVES.
+- Keep only high-signal facts. Omit greetings, acknowledgements, temporary status, one-off sequencing, branch-local tactics, and task-local cleanup notes.
+- When a user message carries durable goals, constraints, preferences, or decision rationale, add a USER_DIRECTIVES fact when future agents should follow it after the session is compacted.
+- Do not turn task-local details into facts.
+- Do not keep stale facts. Rewrite or drop them even if the new input only implies they are obsolete.
+- Keep existing ARCHITECTURE_DECISIONS and CONSTRAINTS facts when they are still valid and uncontradicted; rewrite them into canonical form instead of dropping them.
+- Facts must be present tense and operational. Do not use chronology or provenance wording such as: initially, currently, remained, previously, later, then, was implemented, we changed, used to.
+- One fact bullet must contain exactly one rule/default/constraint/preference. If a candidate fact mixes history with guidance, keep the guidance and drop the history.
+- Durability test: a future agent should still act correctly on the fact next session, after merge/restart, without rereading the conversation.
+- Category guide:
+  - WORKFLOW_RULES: standing repeatable process only. Prefer Do/When form: When <condition>, <action>. Do not store one-off branch strategy or task-specific sequencing unless it is standing policy.
+  - ARCHITECTURE_DECISIONS: stable design choice. Use: <component> uses <choice> because <reason>.
+  - CONSTRAINTS: hard must/must-not rule or invariant. Use: <thing> must/must not <action> because <reason>.
+  - CONFIG_DEFAULTS: stable default only. Use: <key>=<value>.
+  - KNOWN_ISSUES: unresolved recurring problem only. Do not store solved-issue stories.
+  - ENVIRONMENT: stable setup fact that affects future work.
+  - NAMING: canonical term choice. Use: Use <term>; avoid <term>.
+  - USER_PREFERENCES: durable user preference. Prefer Do/When form.
+  - USER_DIRECTIVES: durable user-stated goal, constraint, preference, or rationale. Keep the user's wording when it carries meaning, but narrow it to 1-3 sentences and remove filler.
+- Fact dedup examples:
+  - These are DUPLICATES (merge into one): "Plugin config uses layered JSONC files" and "AFT plugin config uses layered JSONC files at ~/.config/opencode/aft.jsonc and <project>/.opencode/aft.jsonc, with project values deep-merging over user values." → keep the longer, more specific version only.
+  - These are NOT duplicates (keep both): "AFT uses 1-based line numbers" and "AFT converts to LSP 0-based UTF-16 at the protocol boundary" → different aspects of the same system.
+- Fact rewrite examples:
+  - Bad ARCHITECTURE_DECISIONS: The new tool-heavy \`ctx_reduce\` reminder was initially implemented as a hidden instruction appended to the latest user message in \`transform\`.
+  - Good ARCHITECTURE_DECISIONS: \`ctx_reduce\` turn reminders are injected into the latest user message in \`transform\`.
+  - Bad WORKFLOW_RULES: Current local workflow remained feat -> integrate -> build for code changes.
+  - Good WORKFLOW_RULES (only if this is standing policy): For magic-context changes, commit on \`feat/magic-context\`, cherry-pick to \`integrate/athena-magic-context\`, run \`bun run build\` on integrate, then return to \`feat/magic-context\`.
+
+Input notes:
+- [N] or [N-M] is a stable raw OpenCode message range.
+- U: means user.
+- A: means assistant.
+- TC: means tool call — a compact summary of what the agent did (e.g., "TC: Fix lint errors", "TC: read(src/index.ts)", "TC: grep(ctx_memory)"). TC lines appear when there is no text describing the action. Use them to understand what happened between text blocks, but do not copy them verbatim into compartments — incorporate their meaning into the narrative.
+- commits: ... on an assistant block lists commit hashes mentioned in that work unit; keep the relevant ones in the compartment summary when they matter.
+
+Output valid XML only in this shape:
+<output>
+<compartments>
+<compartment start="FIRST" end="LAST" title="short title">
+U: Verbatim high-signal user message
+Summary text describing what was done and why.
+U: Another high-signal user message if applicable
+More summary text.
+</compartment>
+</compartments>
+<facts>
+<WORKFLOW_RULES>
+* Fact text
+</WORKFLOW_RULES>
+</facts>
+<meta>
+<messages_processed>FIRST-LAST</messages_processed>
+<unprocessed_from>INDEX</unprocessed_from>
+</meta>
+</output>
+
+Omit empty fact categories. Compartments must be ordered, contiguous for the ranges they cover, and non-overlapping.`, HISTORIAN_EDITOR_SYSTEM_PROMPT = `You are an editor refining a historian draft. The draft was produced by a first-pass historian and may contain noise — low-signal U: lines, redundant quotes across compartments, and weak preservation decisions.
+
+Your job is to clean the draft without changing its structure:
+
+1. DROP low-signal U: lines:
+   - Questions in any form — resolved decision goes in narrative only.
+   - Pacing/agreement: "let's go", "yes", "okay", "sounds good", "I agree".
+   - Pasted error output, debugging status, mid-process observations.
+   - Tactical micro-direction: "now look at X", "first check Y".
+
+2. DROP cross-compartment duplicates:
+   - Scan U: lines across ALL compartments in the draft.
+   - If two U: lines express the same intent/decision, keep only ONE — in the compartment where the outcome is actually described.
+
+3. STRIP agreement prefixes:
+   - "Yes we should X" → keep only the directive content, or drop entirely if nothing substantive remains after "Yes".
+
+4. PREFER verbatim over paraphrase:
+   - If the draft rephrased a user directive into formal constraint language, restore the user's wording if available.
+   - Do not invent technical specificity (file paths, function names, constants) the user did not state.
+
+5. FOLD into narrative when possible:
+   - If a U: line's signal is already captured in the surrounding narrative, drop the U: line.
+   - Narrative should not need the U: line to be understood.
+
+6. KEEP as U: lines ONLY:
+   - Hard constraints with concrete values (thresholds, byte sizes, timeouts).
+   - Explicit rejections ("X is wrong because Y", "NOT Z").
+   - Implementation pivots in future-tense ("instead of A, do B").
+   - Source-of-truth corrections.
+
+Do NOT change:
+- Compartment titles, ranges, or ordering.
+- Narrative summary text unless it directly references a U: line you dropped (in which case integrate the signal into the narrative).
+- Facts — leave the facts section untouched.
+- <meta> section — leave messages_processed and unprocessed_from exactly as the draft has them.
+
+Output the cleaned version as valid XML matching the original structure. Preserve all XML tags, compartment ranges, meta, and facts.`, USER_OBSERVATIONS_APPENDIX = `
+
+User observation rules (EXPERIMENTAL):
+- After outputting compartments and facts, also output a <user_observations> section.
+- User observations capture UNIVERSAL behavioral patterns about the human user — not project-specific or technical.
+- Good observations: communication preferences, review focus areas, expertise level, decision-making patterns, frustration triggers, working style.
+- Bad observations (DO NOT emit): project-specific preferences, framework choices, coding language preferences, one-off moods, task-local frustration.
+- Each observation must be a single concise sentence in present tense.
+- Only emit observations you have strong evidence for from the conversation. Do not speculate.
+- Emit 0-5 observations per run. Zero is fine if nothing stands out.
+- The output shape inside <output> gains an additional section:
+<user_observations>
+* User prefers terse communication and dislikes verbose explanations.
+* User is technically deep — understands cache invalidation, SQLite internals, and prompt engineering.
+</user_observations>
+If no observations, omit the <user_observations> section entirely.`;
+var init_compartment_prompt = __esm(() => {
+  init_compartment_storage();
+});
+
+// src/shared/opencode-config-dir.ts
+import { homedir as homedir4 } from "node:os";
+import { join as join8, resolve as resolve3 } from "node:path";
+function getCliConfigDir() {
+  const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
+  if (envConfigDir) {
+    return resolve3(envConfigDir);
+  }
+  if (process.platform === "win32") {
+    return join8(homedir4(), ".config", "opencode");
+  }
+  return join8(process.env.XDG_CONFIG_HOME || join8(homedir4(), ".config"), "opencode");
+}
+function getOpenCodeConfigDir(_options) {
+  return getCliConfigDir();
+}
+function getOpenCodeConfigPaths(options) {
+  const configDir = getOpenCodeConfigDir(options);
+  return {
+    configDir,
+    configJson: join8(configDir, "opencode.json"),
+    configJsonc: join8(configDir, "opencode.jsonc"),
+    packageJson: join8(configDir, "package.json"),
+    omoConfig: join8(configDir, "magic-context.jsonc")
+  };
+}
+var init_opencode_config_dir = () => {};
+
+// src/shared/conflict-detector.ts
+import { join as join9 } from "node:path";
+function detectConflicts(directory) {
+  const conflicts = {
+    compactionAuto: false,
+    compactionPrune: false,
+    dcpPlugin: false,
+    omoPreemptiveCompaction: false,
+    omoContextWindowMonitor: false,
+    omoAnthropicRecovery: false
+  };
+  const reasons = [];
+  const compactionResult = checkCompaction(directory);
+  if (compactionResult.auto) {
+    conflicts.compactionAuto = true;
+    reasons.push("OpenCode auto-compaction is enabled (compaction.auto=true)");
+  }
+  if (compactionResult.prune) {
+    conflicts.compactionPrune = true;
+    reasons.push("OpenCode prune is enabled (compaction.prune=true)");
+  }
+  const dcpFound = checkDcpPlugin(directory);
+  if (dcpFound) {
+    conflicts.dcpPlugin = true;
+    reasons.push("opencode-dcp plugin is installed — it conflicts with Magic Context's context management");
+  }
+  const omoResult = checkOmoHooks(directory);
+  if (omoResult.preemptiveCompaction) {
+    conflicts.omoPreemptiveCompaction = true;
+    reasons.push("oh-my-opencode preemptive-compaction hook is active — it triggers compaction that conflicts with historian");
+  }
+  if (omoResult.contextWindowMonitor) {
+    conflicts.omoContextWindowMonitor = true;
+    reasons.push("oh-my-opencode context-window-monitor hook is active — it injects usage warnings that overlap with Magic Context nudges");
+  }
+  if (omoResult.anthropicRecovery) {
+    conflicts.omoAnthropicRecovery = true;
+    reasons.push("oh-my-opencode anthropic-context-window-limit-recovery hook is active — it triggers emergency compaction that bypasses historian");
+  }
+  return {
+    hasConflict: reasons.length > 0,
+    reasons,
+    conflicts
+  };
+}
+function checkCompaction(directory) {
+  if (process.env.OPENCODE_DISABLE_AUTOCOMPACT) {
+    return { auto: false, prune: false };
+  }
+  const projectResult = readProjectCompaction(directory);
+  if (projectResult.resolved)
+    return projectResult;
+  const userResult = readUserCompaction();
+  if (userResult.resolved)
+    return userResult;
+  return { auto: true, prune: false };
+}
+function readProjectCompaction(directory) {
+  const dotOcJsonc = join9(directory, ".opencode", "opencode.jsonc");
+  const dotOcJson = join9(directory, ".opencode", "opencode.json");
+  const dotOcConfig = readJsoncFile(dotOcJsonc) ?? readJsoncFile(dotOcJson);
+  if (dotOcConfig?.compaction) {
+    const c = dotOcConfig.compaction;
+    if (c.auto !== undefined || c.prune !== undefined) {
+      return { auto: c.auto === true, prune: c.prune === true, resolved: true };
+    }
+  }
+  const rootJsonc = join9(directory, "opencode.jsonc");
+  const rootJson = join9(directory, "opencode.json");
+  const rootConfig = readJsoncFile(rootJsonc) ?? readJsoncFile(rootJson);
+  if (rootConfig?.compaction) {
+    const c = rootConfig.compaction;
+    if (c.auto !== undefined || c.prune !== undefined) {
+      return { auto: c.auto === true, prune: c.prune === true, resolved: true };
+    }
+  }
+  return { auto: false, prune: false, resolved: false };
+}
+function readUserCompaction() {
+  try {
+    const paths = getOpenCodeConfigPaths({ binary: "opencode" });
+    const config2 = readJsoncFile(paths.configJsonc) ?? readJsoncFile(paths.configJson);
+    if (config2?.compaction) {
+      const c = config2.compaction;
+      if (c.auto !== undefined || c.prune !== undefined) {
+        return { auto: c.auto === true, prune: c.prune === true, resolved: true };
+      }
+    }
+  } catch {}
+  return { auto: false, prune: false, resolved: false };
+}
+function checkDcpPlugin(directory) {
+  const plugins = collectPluginEntries(directory);
+  return plugins.some((p) => matchesPackageName(p, DCP_PACKAGE_NAMES));
+}
+function matchesPackageName(entry, canonicalNames) {
+  if (entry.startsWith("file:") || entry.startsWith("http:") || entry.startsWith("https:") || entry.startsWith("/") || entry.startsWith("./") || entry.startsWith("../")) {
+    return false;
+  }
+  const lastAt = entry.lastIndexOf("@");
+  const nameOnly = lastAt > 0 ? entry.slice(0, lastAt) : entry;
+  return canonicalNames.has(nameOnly);
+}
+function extractPluginName(entry) {
+  if (typeof entry === "string")
+    return entry;
+  if (Array.isArray(entry) && typeof entry[0] === "string")
+    return entry[0];
+  return null;
+}
+function collectPluginEntries(directory) {
+  const plugins = [];
+  const pushFrom = (entries) => {
+    if (!entries)
+      return;
+    for (const entry of entries) {
+      const name2 = extractPluginName(entry);
+      if (name2)
+        plugins.push(name2);
+    }
+  };
+  for (const configPath of [
+    join9(directory, ".opencode", "opencode.jsonc"),
+    join9(directory, ".opencode", "opencode.json"),
+    join9(directory, "opencode.jsonc"),
+    join9(directory, "opencode.json")
+  ]) {
+    const config2 = readJsoncFile(configPath);
+    pushFrom(config2?.plugin);
+  }
+  try {
+    const paths = getOpenCodeConfigPaths({ binary: "opencode" });
+    for (const configPath of [paths.configJsonc, paths.configJson]) {
+      const config2 = readJsoncFile(configPath);
+      pushFrom(config2?.plugin);
+    }
+  } catch {}
+  return plugins;
+}
+function checkOmoHooks(directory) {
+  const result = {
+    preemptiveCompaction: false,
+    contextWindowMonitor: false,
+    anthropicRecovery: false
+  };
+  const plugins = collectPluginEntries(directory);
+  const hasOmo = plugins.some((p) => matchesPackageName(p, OMO_PACKAGE_NAMES));
+  if (!hasOmo)
+    return result;
+  const disabledHooks = readOmoDisabledHooks(directory);
+  result.preemptiveCompaction = !disabledHooks.has("preemptive-compaction");
+  result.contextWindowMonitor = !disabledHooks.has("context-window-monitor");
+  result.anthropicRecovery = !disabledHooks.has("anthropic-context-window-limit-recovery");
+  return result;
+}
+function readOmoDisabledHooks(directory) {
+  const disabled = new Set;
+  const configNames = [
+    "oh-my-opencode.jsonc",
+    "oh-my-opencode.json",
+    "oh-my-openagent.jsonc",
+    "oh-my-openagent.json"
+  ];
+  try {
+    const paths = getOpenCodeConfigPaths({ binary: "opencode" });
+    for (const name2 of configNames) {
+      const configPath = join9(paths.configDir, name2);
+      const config2 = readJsoncFile(configPath);
+      if (config2?.disabled_hooks) {
+        for (const hook of config2.disabled_hooks) {
+          disabled.add(hook);
+        }
+      }
+    }
+  } catch {}
+  for (const name2 of configNames) {
+    const config2 = readJsoncFile(join9(directory, name2));
+    if (config2?.disabled_hooks) {
+      for (const hook of config2.disabled_hooks) {
+        disabled.add(hook);
+      }
+    }
+  }
+  return disabled;
+}
+function formatConflictShort(result) {
+  if (!result.hasConflict)
+    return "";
+  const lines = [
+    "⚠️ Magic Context is disabled due to conflicting configuration:",
+    "",
+    ...result.reasons.map((r) => `• ${r}`),
+    "",
+    "Fix: run `npx @wolfx/opencode-magic-context@latest doctor`"
+  ];
+  return lines.join(`
+`);
+}
+var DCP_PACKAGE_NAMES, OMO_PACKAGE_NAMES;
+var init_conflict_detector = __esm(() => {
+  init_jsonc_parser();
+  init_opencode_config_dir();
+  DCP_PACKAGE_NAMES = new Set(["@tarquinen/opencode-dcp"]);
+  OMO_PACKAGE_NAMES = new Set(["oh-my-opencode", "oh-my-openagent"]);
+});
+
+// src/plugin/conflict-warning-hook.ts
+var exports_conflict_warning_hook = {};
+__export(exports_conflict_warning_hook, {
+  sendTuiSetupNotification: () => sendTuiSetupNotification,
+  sendStartupAnnouncement: () => sendStartupAnnouncement,
+  sendConflictWarning: () => sendConflictWarning,
+  cleanupConflictWarnings: () => cleanupConflictWarnings
+});
+import { existsSync as existsSync8, readFileSync as readFileSync5 } from "node:fs";
+import { homedir as homedir5, platform } from "node:os";
+import { join as join10 } from "node:path";
+function getDesktopStatePath() {
+  const os2 = platform();
+  const home = homedir5();
+  if (os2 === "darwin") {
+    return join10(home, "Library", "Application Support", "ai.opencode.desktop", "opencode.global.dat");
+  }
+  if (os2 === "linux") {
+    const xdgConfig = process.env.XDG_CONFIG_HOME || join10(home, ".config");
+    return join10(xdgConfig, "ai.opencode.desktop", "opencode.global.dat");
+  }
+  if (os2 === "win32") {
+    const appData = process.env.APPDATA || join10(home, "AppData", "Roaming");
+    return join10(appData, "ai.opencode.desktop", "opencode.global.dat");
+  }
+  return null;
+}
+function readDesktopState(directory) {
+  const statePath = getDesktopStatePath();
+  if (!statePath || !existsSync8(statePath)) {
+    log(`[magic-context] conflict-warning: Desktop state file not found at ${statePath}`);
+    return { sessionId: null, sidecarUrl: null };
+  }
+  try {
+    const raw = readFileSync5(statePath, "utf-8");
+    const state = JSON.parse(raw);
+    let sidecarUrl = null;
+    const serverStr = state.server;
+    if (typeof serverStr === "string") {
+      try {
+        const serverState = JSON.parse(serverStr);
+        if (typeof serverState.currentSidecarUrl === "string") {
+          sidecarUrl = serverState.currentSidecarUrl;
+        }
+      } catch {}
+    }
+    let sessionId = null;
+    const layoutPage = state["layout.page"];
+    if (typeof layoutPage === "string") {
+      const parsed = JSON.parse(layoutPage);
+      const lastProjectSession = parsed.lastProjectSession;
+      if (lastProjectSession) {
+        const entry = lastProjectSession[directory];
+        sessionId = entry?.id ?? null;
+      }
+    }
+    return { sessionId, sidecarUrl };
+  } catch (error51) {
+    log(`[magic-context] conflict-warning: failed to read Desktop state: ${error51 instanceof Error ? error51.message : String(error51)}`);
+    return { sessionId: null, sidecarUrl: null };
+  }
+}
+function getDesktopState(directory) {
+  let cached2 = cachedDesktopStateByDir.get(directory);
+  if (!cached2) {
+    cached2 = readDesktopState(directory);
+    cachedDesktopStateByDir.set(directory, cached2);
+  }
+  return cached2;
+}
+async function deleteMessage(serverUrl, sessionId, messageId) {
+  const auth = getServerAuth();
+  const url2 = `${serverUrl}/session/${encodeURIComponent(sessionId)}/message/${encodeURIComponent(messageId)}`;
+  try {
+    const response = await fetch(url2, {
+      method: "DELETE",
+      headers: auth ? { Authorization: auth } : {},
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      log(`[magic-context] conflict-warning: DELETE failed status=${response.status} url=${url2}`);
+      return false;
+    }
+    return true;
+  } catch (error51) {
+    log(`[magic-context] conflict-warning: DELETE error (url=${serverUrl}): ${error51 instanceof Error ? error51.message : String(error51)}`);
+    return false;
+  }
+}
+function getServerAuth() {
+  const password = process.env.OPENCODE_SERVER_PASSWORD;
+  if (!password)
+    return;
+  const username = process.env.OPENCODE_SERVER_USERNAME ?? "opencode";
+  return `Basic ${Buffer.from(`${username}:${password}`, "utf8").toString("base64")}`;
+}
+async function getSessionMessages(client, sessionId) {
+  try {
+    const c = client;
+    if (typeof c.session?.messages === "function") {
+      const result = await c.session.messages({
+        path: { id: sessionId },
+        query: { limit: 50 }
+      });
+      return result?.data ?? [];
+    }
+  } catch (error51) {
+    log(`[magic-context] conflict-warning: failed to read messages: ${error51 instanceof Error ? error51.message : String(error51)}`);
+  }
+  return [];
+}
+async function sendConflictWarning(client, directory, conflictResult) {
+  const { sessionId } = getDesktopState(directory);
+  if (!sessionId) {
+    log("[magic-context] conflict-warning: could not find active session for Desktop warning");
+    return;
+  }
+  const warningText = formatConflictShort(conflictResult);
+  log(`[magic-context] sending conflict warning to session ${sessionId}: ${conflictResult.reasons.join(", ")}`);
+  try {
+    const c = client;
+    const promptInput = {
+      path: { id: sessionId },
+      body: {
+        noReply: true,
+        parts: [
+          {
+            type: "text",
+            text: warningText,
+            ignored: true
+          }
+        ]
+      }
+    };
+    if (typeof c.session?.prompt === "function") {
+      await Promise.resolve(c.session.prompt(promptInput));
+    } else if (typeof c.session?.promptAsync === "function") {
+      await c.session.promptAsync(promptInput);
+    } else {
+      log("[magic-context] conflict-warning: session prompt API unavailable");
+    }
+  } catch (error51) {
+    log(`[magic-context] conflict-warning: failed to send: ${error51 instanceof Error ? error51.message : String(error51)}`);
+  }
+}
+async function cleanupConflictWarnings(client, directory, serverUrl) {
+  const { sessionId } = getDesktopState(directory);
+  if (!sessionId) {
+    log("[magic-context] cleanup: no active Desktop session found");
+    return;
+  }
+  const messages = await getSessionMessages(client, sessionId);
+  if (messages.length === 0)
+    return;
+  const warningMessageIds = [];
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const msg = messages[i];
+    const msgId = msg.info?.id;
+    const msgRole = msg.info?.role;
+    if (!msgId || msgRole !== "user")
+      break;
+    const parts = msg.parts ?? [];
+    const isWarning = parts.length > 0 && parts.every((p) => p.ignored === true && p.type === "text" && typeof p.text === "string" && p.text.startsWith(CONFLICT_WARNING_MARKER));
+    if (isWarning) {
+      warningMessageIds.push(msgId);
+    } else {
+      break;
+    }
+  }
+  if (warningMessageIds.length === 0) {
+    await cleanupEnabledMessages(messages, serverUrl, sessionId);
+    return;
+  }
+  if (!serverUrl) {
+    log("[magic-context] cleanup: no serverUrl provided, cannot delete messages");
+    return;
+  }
+  log(`[magic-context] cleaning up ${warningMessageIds.length} conflict warning message(s) from session ${sessionId}`);
+  for (const messageId of warningMessageIds) {
+    const ok = await deleteMessage(serverUrl, sessionId, messageId);
+    if (ok) {
+      log(`[magic-context] deleted conflict warning message ${messageId}`);
+    }
+  }
+  const enabledText = `${ENABLED_MARKER}. Enjoy! ✨`;
+  try {
+    const c = client;
+    const promptInput = {
+      path: { id: sessionId },
+      body: {
+        noReply: true,
+        parts: [{ type: "text", text: enabledText, ignored: true }]
+      }
+    };
+    if (typeof c.session?.prompt === "function") {
+      await Promise.resolve(c.session.prompt(promptInput));
+    } else if (typeof c.session?.promptAsync === "function") {
+      await c.session.promptAsync(promptInput);
+    }
+  } catch {}
+  setTimeout(async () => {
+    try {
+      const freshMessages = await getSessionMessages(client, sessionId);
+      for (let i = freshMessages.length - 1;i >= 0; i--) {
+        const msg = freshMessages[i];
+        const msgId = msg.info?.id;
+        const msgRole = msg.info?.role;
+        if (!msgId || msgRole !== "user")
+          break;
+        const parts = msg.parts ?? [];
+        const isEnabled = parts.length > 0 && parts.every((p) => p.ignored === true && p.type === "text" && typeof p.text === "string" && p.text.startsWith(ENABLED_MARKER));
+        if (isEnabled) {
+          await deleteMessage(serverUrl, sessionId, msgId);
+        } else {
+          break;
+        }
+      }
+    } catch {}
+  }, 1000);
+}
+async function cleanupEnabledMessages(messages, serverUrl, sessionId) {
+  if (!serverUrl)
+    return;
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const msg = messages[i];
+    const msgId = msg.info?.id;
+    const msgRole = msg.info?.role;
+    if (!msgId || msgRole !== "user")
+      break;
+    const parts = msg.parts ?? [];
+    const isEnabled = parts.length > 0 && parts.every((p) => p.ignored === true && p.type === "text" && typeof p.text === "string" && p.text.startsWith(ENABLED_MARKER));
+    if (isEnabled) {
+      await deleteMessage(serverUrl, sessionId, msgId);
+    } else {
+      break;
+    }
+  }
+}
+async function sendTuiSetupNotification(client, directory, serverUrl) {
+  const { sessionId } = getDesktopState(directory);
+  if (!sessionId)
+    return;
+  const text = [
+    `${TUI_SETUP_MARKER}`,
+    "",
+    "Magic Context added its TUI plugin to your tui.json.",
+    "Restart OpenCode to see the sidebar with live context breakdown,",
+    "token usage, historian status, memory counts, and more."
+  ].join(`
+`);
+  try {
+    const c = client;
+    const promptInput = {
+      path: { id: sessionId },
+      body: {
+        noReply: true,
+        parts: [{ type: "text", text, ignored: true }]
+      }
+    };
+    if (typeof c.session?.prompt === "function") {
+      await Promise.resolve(c.session.prompt(promptInput));
+    } else if (typeof c.session?.promptAsync === "function") {
+      await c.session.promptAsync(promptInput);
+    }
+  } catch {
+    return;
+  }
+  if (!serverUrl)
+    return;
+  setTimeout(async () => {
+    try {
+      const msgs = await getSessionMessages(client, sessionId);
+      for (let i = msgs.length - 1;i >= 0; i--) {
+        const msg = msgs[i];
+        const msgId = msg.info?.id;
+        if (!msgId || msg.info?.role !== "user")
+          break;
+        const parts = msg.parts ?? [];
+        const isTuiSetup = parts.length > 0 && parts.every((p) => p.ignored === true && p.type === "text" && typeof p.text === "string" && p.text.startsWith(TUI_SETUP_MARKER));
+        if (isTuiSetup) {
+          await deleteMessage(serverUrl, sessionId, msgId);
+        } else {
+          break;
+        }
+      }
+    } catch {}
+  }, 1000);
+}
+async function sendStartupAnnouncement(client, directory, version2, features, footer, markSeen) {
+  if (!version2 || features.length === 0)
+    return;
+  const { sessionId } = getDesktopState(directory);
+  if (!sessionId) {
+    return;
+  }
+  const bullets = features.map((line) => `  • ${line}`).join(`
+`);
+  const sections = [`${ANNOUNCEMENT_MARKER} v${version2}:`, "", bullets];
+  if (footer && footer.trim().length > 0) {
+    sections.push("", footer);
+  }
+  const text = sections.join(`
+`);
+  log(`[magic-context] sending startup announcement for v${version2} to session ${sessionId}`);
+  try {
+    const c = client;
+    const promptInput = {
+      path: { id: sessionId },
+      body: {
+        noReply: true,
+        parts: [{ type: "text", text, ignored: true }]
+      }
+    };
+    if (typeof c.session?.prompt === "function") {
+      await Promise.resolve(c.session.prompt(promptInput));
+    } else if (typeof c.session?.promptAsync === "function") {
+      await c.session.promptAsync(promptInput);
+    } else {
+      log("[magic-context] announcement: session prompt API unavailable");
+      return;
+    }
+  } catch (error51) {
+    log(`[magic-context] announcement: failed to send: ${error51 instanceof Error ? error51.message : String(error51)}`);
+    return;
+  }
+  markSeen(version2);
+}
+var CONFLICT_WARNING_MARKER = "⚠️ Magic Context is disabled due to conflicting configuration:", ENABLED_MARKER = "✨ Magic Context is now enabled", TUI_SETUP_MARKER = "\uD83D\uDCCA Magic Context sidebar configured", ANNOUNCEMENT_MARKER = "✨ Magic Context — what's new in", cachedDesktopStateByDir;
+var init_conflict_warning_hook = __esm(() => {
+  init_conflict_detector();
+  init_logger();
+  cachedDesktopStateByDir = new Map;
+});
+
 // ../../node_modules/.bun/esprima@4.0.1/node_modules/esprima/dist/esprima.js
 var require_esprima = __commonJS((exports, module) => {
   (function webpackUniversalModuleDefinition(root, factory) {
@@ -160546,10 +161450,10 @@ var require_stringify = __commonJS((exports, module) => {
     replacer = null;
     indent = EMPTY;
   };
-  var join8 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one, gap)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
+  var join11 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one, gap)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
   var join_content = (inside, value, gap) => {
     const comment = process_comments(value, PREFIX_BEFORE, gap + indent, true);
-    return join8(comment, inside, gap);
+    return join11(comment, inside, gap);
   };
   var stringify_string = (holder, key, value) => {
     const raw = get_raw_string_literal(holder, key);
@@ -160571,13 +161475,13 @@ var require_stringify = __commonJS((exports, module) => {
       if (i !== 0) {
         inside += COMMA;
       }
-      const before = join8(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
+      const before = join11(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += stringify(i, value, deeper_gap) || STR_NULL;
       inside += process_comments(value, AFTER_VALUE(i), deeper_gap);
       after_comma = process_comments(value, AFTER(i), deeper_gap);
     }
-    inside += join8(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join11(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return BRACKET_OPEN + join_content(inside, value, gap) + BRACKET_CLOSE;
   };
   var object_stringify = (value, gap) => {
@@ -160598,13 +161502,13 @@ var require_stringify = __commonJS((exports, module) => {
         inside += COMMA;
       }
       first = false;
-      const before = join8(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
+      const before = join11(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += quote(key) + process_comments(value, AFTER_PROP(key), deeper_gap) + COLON + process_comments(value, AFTER_COLON(key), deeper_gap) + SPACE + sv + process_comments(value, AFTER_VALUE(key), deeper_gap);
       after_comma = process_comments(value, AFTER(key), deeper_gap);
     };
     keys.forEach(iteratee);
-    inside += join8(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join11(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return CURLY_BRACKET_OPEN + join_content(inside, value, gap) + CURLY_BRACKET_CLOSE;
   };
   function stringify(key, holder, gap) {
@@ -160696,907 +161600,6 @@ var require_src2 = __commonJS((exports, module) => {
   };
 });
 
-// src/hooks/magic-context/compartment-prompt.ts
-function buildHistorianEditorPrompt(draft) {
-  return [
-    "This is a historian draft. Clean it up following the rules in your system prompt.",
-    "",
-    "<draft>",
-    draft,
-    "</draft>",
-    "",
-    "Return the cleaned draft as valid XML matching the original structure."
-  ].join(`
-`);
-}
-function buildCompressorPrompt(compartments, currentTokens, targetTokens, outputDepth, outputCount) {
-  const lines = [];
-  const densityLabel = outputDepth === 1 ? "MERGE ONLY" : outputDepth === 2 ? "LITE TIGHTEN" : outputDepth === 3 ? "FULL CONDENSE" : "ULTRA TELEGRAPH";
-  const resolvedOutputCount = outputCount ?? Math.max(1, Math.ceil(compartments.length / 2));
-  lines.push(`Density target: LEVEL ${outputDepth} (${densityLabel}). See system prompt for level rules.`);
-  lines.push(`Input: ${compartments.length} compartments, ~${currentTokens} tokens. Target output: exactly ${resolvedOutputCount} compartments, ~${targetTokens} tokens total.`);
-  lines.push("");
-  if (outputDepth === 1) {
-    lines.push("Merge only. Preserve narrative and all U: lines. Drop only genuine duplicate sentences spanning compartments.");
-  } else if (outputDepth === 2) {
-    lines.push("Merge + drop filler words and hedging. Keep grammar, keep U: lines verbatim.");
-  } else if (outputDepth === 3) {
-    lines.push("Merge into single-paragraph compartments. Drop articles and weak auxiliaries. Keep only IRREPLACEABLE U: lines.");
-  } else {
-    lines.push("Merge into telegraphic fragments with symbol connectives (→ + // |). U: lines only if truly irreplaceable.");
-  }
-  lines.push("");
-  lines.push("Preserved literally at all levels: commit hashes, file paths, URLs, code spans.");
-  lines.push("");
-  for (const c of compartments) {
-    lines.push(`<compartment start="${c.startMessage}" end="${c.endMessage}" title="${escapeXmlAttr(c.title)}">`);
-    lines.push(escapeXmlContent(c.content));
-    lines.push("</compartment>");
-    lines.push("");
-  }
-  lines.push("Return merged compartments as XML.");
-  return lines.join(`
-`);
-}
-function buildCompartmentAgentPrompt(existingState, inputSource, options) {
-  const existingStateBlock = options?.stateFilePath ? `Read the existing session state from this file before proceeding:
-${options.stateFilePath}
-
-The file contains the full XML existing state (compartments, facts, memories). Read it first, then process the new messages below.` : existingState;
-  return [
-    "Existing state (read-only context for continuity and fact normalization — do NOT re-emit these compartments):",
-    existingStateBlock,
-    "",
-    "<new_messages>",
-    inputSource,
-    "</new_messages>",
-    "",
-    "Instructions:",
-    "- Return ONLY new compartments for the messages inside <new_messages>, plus the full normalized fact list.",
-    "- Use the exact absolute raw ordinals from the input ranges for every compartment start/end and for <unprocessed_from>.",
-    "- Rewrite every fact into terse, present-tense operational form. Merge semantic duplicates within each category.",
-    "- Drop any session fact already covered by a project memory in the existing state.",
-    "- Do not preserve prior narrative wording verbatim; if a fact is already canonical and still correct, keep or lightly normalize it.",
-    "- Drop obsolete or task-local facts.",
-    ...options?.userMemoriesEnabled ? [
-      "- Also emit <user_observations> with universal behavioral observations about the user (see system prompt for rules)."
-    ] : []
-  ].join(`
-`);
-}
-var COMPARTMENT_AGENT_SYSTEM_PROMPT = `You condense long AI coding sessions into two outputs:
-
-1. compartments: completed logical work units
-2. facts: persistent cross-cutting information for future work
-
-Compartment rules:
-- A compartment is one contiguous completed work unit: investigation, fix, refactor, docs update, feature, or decision.
-- Start a new compartment only when the work clearly pivots to a different objective.
-- If one broad effort contains multiple completed sub-pivots with distinct outcomes, prefer multiple smaller compartments over one umbrella compartment with many U: lines.
-- Do not create compartments for magic-context commands or tool-only noise.
-- If the input ends mid-topic, leave it out and report its first message index in <unprocessed_from>.
-- All compartment start/end ordinals and <unprocessed_from> must use the absolute raw message numbers shown in the input. Never renumber relative to this chunk.
-- Every displayed raw message ordinal in the input MUST appear in exactly one compartment. Gaps between compartments are invalid. When a displayed block is pure tool noise (e.g. a long "TC: ..." run with no narrative text), do NOT skip it — extend the preceding compartment's \`end\` to absorb the range, or include it inside the current compartment if the block falls within an ongoing work unit. Never create a dedicated compartment just to cover a tool-only run.
-- Only emit NEW compartments for the new messages. Do not re-emit existing compartments from the existing state.
-- Write comprehensive, detailed compartments. Include file paths, function names, commit hashes, config keys, and values when they matter.
-- Do not list every changed file. Do not narrate tool calls. Do not preserve dead-end exploration beyond a brief clause when needed.
-
-# Construction order (MANDATORY)
-
-For each compartment, build in this exact order:
-
-1. Write the narrative summary first — what was done, why, and the outcome. This is 1–4 sentences covering the work unit completely.
-2. Re-read your narrative. Ask: does the summary already convey all important decisions and constraints from this work unit?
-3. If yes, the compartment is DONE with zero U: lines. Move on.
-4. If no, identify the specific signal the narrative cannot capture. Add U: lines ONLY for those signals.
-5. Before writing each U: line, run the CROSS-COMPARTMENT CHECK (see below).
-
-Zero U: lines in a compartment is normal and expected. Most compartments should have 0–2 U: lines. Compartments with 3–5 are rare and must be justified by genuinely distinct durable signals.
-
-# DROP rules (check these first — if any match, drop without exception)
-
-- Questions in ANY form: "should I X?", "what about Y?", "do you think Z?", "isn't it better to A?", "why don't we B?", "any ideas?" — the resolved answer belongs in narrative only. If it feels important to keep the question, you are wrong: keep the answer in narrative.
-- Agreements and acknowledgments: "yes", "okay", "sure", "thanks", "go ahead", "looks good", "perfect", "I agree", "sounds good", "great".
-- Pure pacing and sequencing: "let's start", "continue", "let's do all", "now we can X", "let's commit", "first do A then B", "before that", "in the meantime".
-- Tactical observations: "I just noticed X", "we recently did Y", "I'm seeing Z right now", "this seems wrong".
-- Debugging status: "context is at 78%", "I'm restarting", "the last build failed".
-- Dogfooding/restart loops: "I restarted, can you check?", "okay we should have updated versions now", "let me try again".
-- Pasted error output or logs as U: line — capture the underlying problem in narrative, not the raw paste.
-- Examples and illustrations: "mine was when an agent wants to see X" — convert the underlying intent into a directive or drop.
-- Hype with embedded directive: ALL-CAPS pleas, "PLEASE PLEASE PLEASE just do X" — extract only the underlying directive into narrative; drop the hype.
-- Social signals, banter, emoji-only, enthusiasm.
-- Deferred ideas: "for later", "we can do X later", "another idea for the future".
-- Mid-process status: "running Y", "checking Z".
-- Superseded drafts once a later message gives the final decision.
-- Standing workflow rules ("always run lint before push") — these belong in WORKFLOW_RULES facts, not U: lines.
-
-# Wording rule (default: verbatim)
-
-By default, U: lines use the user's actual wording. The user's exact phrasing often carries negotiation context, emphasis, or technical specificity that paraphrase loses.
-
-Paraphrase ONLY in these cases:
-- **Strip agreement prefixes**: "Yes X", "Okay X", "Sure X" → keep only the substantive part of X, in the user's original wording.
-- **Split compound directives**: If one message contains two distinct durable directives, split into two U: lines — each preserving the user's wording for its part.
-- **Drop conversational noise, keep core**: If a message wraps a directive in exploratory phrasing ("so I was thinking, maybe... but actually..."), drop the exploration and keep the core directive in the user's remaining words. Don't invent new phrasing.
-
-NEVER:
-- Rewrite a clear user directive into a formal constraint statement. ("We need tool count at ~8" stays as-is; do NOT convert to "Tool count must be capped at 8.")
-- Synthesize a directive from multiple messages into one canonical statement. If the signal needs synthesis, it belongs in narrative, not a U: line.
-- Add technical specificity the user didn't state (file paths, function names, constant names). Canonical technical specificity belongs in narrative or facts, not in U: lines attributed to the user.
-
-Good example:
-  Original user message: "Yes let's do this. But we need to also make sure that we limit by message count as some sessions have quite a lot of messages."
-  Correct U: line: "We need to also make sure that we limit by message count as some sessions have quite a lot of messages."
-  (Stripped agreement prefix; kept the user's actual wording.)
-
-Bad example (do not do this):
-  Incorrect U: line: "Cap session history retrieval at a maximum message count to prevent memory issues on large sessions."
-  (Rewrote the user directive into formal language and invented specificity.)
-
-# KEEP rules (U: line survives only if ALL pass)
-
-1. DURABLE: The signal matters after the immediate turn.
-2. SPECIFIC: Concrete goal, hard constraint, design decision, rejection, rationale, threshold, source-of-truth correction, or future-work directive.
-3. OUTCOME-BACKED: This compartment's narrative clearly states what was done, decided, or changed because of the message.
-4. NON-REDUNDANT: Not captured by another U: line (see CROSS-COMPARTMENT CHECK), by a fact, or by the narrative.
-5. IRREPLACEABLE: The user's wording adds signal that narrative paraphrase cannot preserve. If the same information could appear as narrative without losing meaning, it should.
-
-Categories of KEEP:
-- Hard gates, thresholds, config defaults, percentages, byte sizes with concrete values.
-- Accepted designs and explicit decisions.
-- Rejections and negative constraints: "X is wrong because Y", "we should NOT do Z".
-- Source-of-truth corrections: "follow the code, not the README".
-- Implementation pivots stated in future tense: "instead of X let's do Y", "switch to Z".
-- Durable rationale that explains WHY an approach was chosen.
-- Specific feature requirements stated as durable goals.
-
-# PIVOT vs OBSERVATION test
-
-A pivot is FUTURE-TENSE and changes the plan: "instead of X, let's do Y", "switch this to Z", "actually, let's not do A".
-An observation is PAST-TENSE or PRESENT-TENSE and reports state: "we recently did X", "I just noticed Y", "this is broken right now".
-Observations may frame narrative context but are NOT pivots and NOT durable. Drop them as U: lines.
-
-# CROSS-COMPARTMENT CHECK (forward-looking)
-
-Before writing ANY U: line in the current compartment:
-1. Scan U: lines you have ALREADY written in previous compartments in this response.
-2. If any prior U: line expresses the same intent, decision, constraint, or rationale — even in different words — do NOT write the new U: line.
-3. Let the narrative in the current compartment carry the signal instead.
-
-This is a forward operation: you only need to check what you already wrote, not revisit past compartments.
-
-Examples of same-intent pairs to collapse:
-- "X shouldn't cause cache bust" + "X must not bust cache by itself" → keep only the first, in its original compartment.
-- "Let's use monorepo" + "Yes, monorepo is the right call" → keep only the first.
-- "Add logging" + "We need logs here too" → keep only the first.
-
-Never keep two U: lines for the same underlying directive across compartments.
-
-# Budget
-
-- HARD LIMIT: 3–5 U: lines per compartment. 0–2 is typical.
-- If you have more than 5 candidate U: lines in one compartment, that is a signal to split into two compartments at a natural pivot, not to stuff more.
-- Every U: line must be immediately followed by 1–3 sentences describing the outcome, decision, or effect. Never stack two U: lines without intervening outcome text.
-
-# Example: CORRECT preservation (narrative-first, verbatim U: line)
-
-<compartment start="50" end="120" title="Built the auth layer">
-Implemented JWT auth with hard 60-minute exp claim and refresh-token rotation. Chose Bearer tokens over cookies after finding cookie-based auth broke the SPA flow. Added session_expiry config (read-only at runtime). Commits: a3f891, b22c4e.
-U: We need session expiry capped at 1 hour, no exceptions
-Hardcoded the 60-minute cap at the JWT-issuer layer so runtime overrides cannot extend it.
-</compartment>
-
-Notice: only one U: line, kept verbatim from the user's actual message. The cookie-to-Bearer pivot is narrative because paraphrase captures the signal fully.
-
-# Example: OVER-PRESERVATION (avoid)
-
-<compartment start="200" end="350" title="Refactored data layer">
-U: Okay let's start on the data layer
-U: What about transactions?
-U: Yes that approach looks good
-U: Actually wait, maybe we need write-ahead logging
-U: I just noticed the previous commit broke a test
-U: Let's commit and ship it
-Refactored data layer with WAL mode and connection pooling.
-</compartment>
-
-Problems: pacing, question, agreement, observation, pacing again. Only one message carries signal, and even that is narrative-capturable.
-
-# CORRECT version of the above
-
-<compartment start="200" end="350" title="Refactored data layer">
-Refactored data layer to use WAL mode plus connection pooling. Chose WAL over plain connections for concurrent read performance under sustained write load.
-</compartment>
-
-Zero U: lines. The pivot to WAL is clear in narrative.
-
-Fact rules:
-- Facts are editable state, not append-only notes. Rewrite, normalize, deduplicate, or drop existing facts whenever needed.
-- Before emitting any fact, check all existing facts in the same category for semantic duplicates. If two facts describe the same decision, constraint, or default with different wording, merge them into one canonical statement. Never emit two facts that could be answered by the same question.
-- When project memories are provided as read-only reference, drop any session fact that is already covered by a project memory. Project memories are the canonical cross-session source; session facts must not duplicate them.
-- Facts must be durable and actionable after the conversation ends.
-- A fact is either a stable invariant/default or a reusable operating rule. If it mainly explains what happened, it belongs in a compartment, not a fact.
-- Facts belong only in these categories when relevant: WORKFLOW_RULES, ARCHITECTURE_DECISIONS, CONSTRAINTS, CONFIG_DEFAULTS, KNOWN_ISSUES, ENVIRONMENT, NAMING, USER_PREFERENCES, USER_DIRECTIVES.
-- Keep only high-signal facts. Omit greetings, acknowledgements, temporary status, one-off sequencing, branch-local tactics, and task-local cleanup notes.
-- When a user message carries durable goals, constraints, preferences, or decision rationale, add a USER_DIRECTIVES fact when future agents should follow it after the session is compacted.
-- Do not turn task-local details into facts.
-- Do not keep stale facts. Rewrite or drop them even if the new input only implies they are obsolete.
-- Keep existing ARCHITECTURE_DECISIONS and CONSTRAINTS facts when they are still valid and uncontradicted; rewrite them into canonical form instead of dropping them.
-- Facts must be present tense and operational. Do not use chronology or provenance wording such as: initially, currently, remained, previously, later, then, was implemented, we changed, used to.
-- One fact bullet must contain exactly one rule/default/constraint/preference. If a candidate fact mixes history with guidance, keep the guidance and drop the history.
-- Durability test: a future agent should still act correctly on the fact next session, after merge/restart, without rereading the conversation.
-- Category guide:
-  - WORKFLOW_RULES: standing repeatable process only. Prefer Do/When form: When <condition>, <action>. Do not store one-off branch strategy or task-specific sequencing unless it is standing policy.
-  - ARCHITECTURE_DECISIONS: stable design choice. Use: <component> uses <choice> because <reason>.
-  - CONSTRAINTS: hard must/must-not rule or invariant. Use: <thing> must/must not <action> because <reason>.
-  - CONFIG_DEFAULTS: stable default only. Use: <key>=<value>.
-  - KNOWN_ISSUES: unresolved recurring problem only. Do not store solved-issue stories.
-  - ENVIRONMENT: stable setup fact that affects future work.
-  - NAMING: canonical term choice. Use: Use <term>; avoid <term>.
-  - USER_PREFERENCES: durable user preference. Prefer Do/When form.
-  - USER_DIRECTIVES: durable user-stated goal, constraint, preference, or rationale. Keep the user's wording when it carries meaning, but narrow it to 1-3 sentences and remove filler.
-- Fact dedup examples:
-  - These are DUPLICATES (merge into one): "Plugin config uses layered JSONC files" and "AFT plugin config uses layered JSONC files at ~/.config/opencode/aft.jsonc and <project>/.opencode/aft.jsonc, with project values deep-merging over user values." → keep the longer, more specific version only.
-  - These are NOT duplicates (keep both): "AFT uses 1-based line numbers" and "AFT converts to LSP 0-based UTF-16 at the protocol boundary" → different aspects of the same system.
-- Fact rewrite examples:
-  - Bad ARCHITECTURE_DECISIONS: The new tool-heavy \`ctx_reduce\` reminder was initially implemented as a hidden instruction appended to the latest user message in \`transform\`.
-  - Good ARCHITECTURE_DECISIONS: \`ctx_reduce\` turn reminders are injected into the latest user message in \`transform\`.
-  - Bad WORKFLOW_RULES: Current local workflow remained feat -> integrate -> build for code changes.
-  - Good WORKFLOW_RULES (only if this is standing policy): For magic-context changes, commit on \`feat/magic-context\`, cherry-pick to \`integrate/athena-magic-context\`, run \`bun run build\` on integrate, then return to \`feat/magic-context\`.
-
-Input notes:
-- [N] or [N-M] is a stable raw OpenCode message range.
-- U: means user.
-- A: means assistant.
-- TC: means tool call — a compact summary of what the agent did (e.g., "TC: Fix lint errors", "TC: read(src/index.ts)", "TC: grep(ctx_memory)"). TC lines appear when there is no text describing the action. Use them to understand what happened between text blocks, but do not copy them verbatim into compartments — incorporate their meaning into the narrative.
-- commits: ... on an assistant block lists commit hashes mentioned in that work unit; keep the relevant ones in the compartment summary when they matter.
-
-Output valid XML only in this shape:
-<output>
-<compartments>
-<compartment start="FIRST" end="LAST" title="short title">
-U: Verbatim high-signal user message
-Summary text describing what was done and why.
-U: Another high-signal user message if applicable
-More summary text.
-</compartment>
-</compartments>
-<facts>
-<WORKFLOW_RULES>
-* Fact text
-</WORKFLOW_RULES>
-</facts>
-<meta>
-<messages_processed>FIRST-LAST</messages_processed>
-<unprocessed_from>INDEX</unprocessed_from>
-</meta>
-</output>
-
-Omit empty fact categories. Compartments must be ordered, contiguous for the ranges they cover, and non-overlapping.`, HISTORIAN_EDITOR_SYSTEM_PROMPT = `You are an editor refining a historian draft. The draft was produced by a first-pass historian and may contain noise — low-signal U: lines, redundant quotes across compartments, and weak preservation decisions.
-
-Your job is to clean the draft without changing its structure:
-
-1. DROP low-signal U: lines:
-   - Questions in any form — resolved decision goes in narrative only.
-   - Pacing/agreement: "let's go", "yes", "okay", "sounds good", "I agree".
-   - Pasted error output, debugging status, mid-process observations.
-   - Tactical micro-direction: "now look at X", "first check Y".
-
-2. DROP cross-compartment duplicates:
-   - Scan U: lines across ALL compartments in the draft.
-   - If two U: lines express the same intent/decision, keep only ONE — in the compartment where the outcome is actually described.
-
-3. STRIP agreement prefixes:
-   - "Yes we should X" → keep only the directive content, or drop entirely if nothing substantive remains after "Yes".
-
-4. PREFER verbatim over paraphrase:
-   - If the draft rephrased a user directive into formal constraint language, restore the user's wording if available.
-   - Do not invent technical specificity (file paths, function names, constants) the user did not state.
-
-5. FOLD into narrative when possible:
-   - If a U: line's signal is already captured in the surrounding narrative, drop the U: line.
-   - Narrative should not need the U: line to be understood.
-
-6. KEEP as U: lines ONLY:
-   - Hard constraints with concrete values (thresholds, byte sizes, timeouts).
-   - Explicit rejections ("X is wrong because Y", "NOT Z").
-   - Implementation pivots in future-tense ("instead of A, do B").
-   - Source-of-truth corrections.
-
-Do NOT change:
-- Compartment titles, ranges, or ordering.
-- Narrative summary text unless it directly references a U: line you dropped (in which case integrate the signal into the narrative).
-- Facts — leave the facts section untouched.
-- <meta> section — leave messages_processed and unprocessed_from exactly as the draft has them.
-
-Output the cleaned version as valid XML matching the original structure. Preserve all XML tags, compartment ranges, meta, and facts.`, USER_OBSERVATIONS_APPENDIX = `
-
-User observation rules (EXPERIMENTAL):
-- After outputting compartments and facts, also output a <user_observations> section.
-- User observations capture UNIVERSAL behavioral patterns about the human user — not project-specific or technical.
-- Good observations: communication preferences, review focus areas, expertise level, decision-making patterns, frustration triggers, working style.
-- Bad observations (DO NOT emit): project-specific preferences, framework choices, coding language preferences, one-off moods, task-local frustration.
-- Each observation must be a single concise sentence in present tense.
-- Only emit observations you have strong evidence for from the conversation. Do not speculate.
-- Emit 0-5 observations per run. Zero is fine if nothing stands out.
-- The output shape inside <output> gains an additional section:
-<user_observations>
-* User prefers terse communication and dislikes verbose explanations.
-* User is technically deep — understands cache invalidation, SQLite internals, and prompt engineering.
-</user_observations>
-If no observations, omit the <user_observations> section entirely.`;
-var init_compartment_prompt = __esm(() => {
-  init_compartment_storage();
-});
-
-// src/shared/opencode-config-dir.ts
-import { homedir as homedir6 } from "node:os";
-import { join as join12, resolve as resolve4 } from "node:path";
-function getCliConfigDir() {
-  const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
-  if (envConfigDir) {
-    return resolve4(envConfigDir);
-  }
-  if (process.platform === "win32") {
-    return join12(homedir6(), ".config", "opencode");
-  }
-  return join12(process.env.XDG_CONFIG_HOME || join12(homedir6(), ".config"), "opencode");
-}
-function getOpenCodeConfigDir(_options) {
-  return getCliConfigDir();
-}
-function getOpenCodeConfigPaths(options) {
-  const configDir = getOpenCodeConfigDir(options);
-  return {
-    configDir,
-    configJson: join12(configDir, "opencode.json"),
-    configJsonc: join12(configDir, "opencode.jsonc"),
-    packageJson: join12(configDir, "package.json"),
-    omoConfig: join12(configDir, "magic-context.jsonc")
-  };
-}
-var init_opencode_config_dir = () => {};
-
-// src/shared/conflict-detector.ts
-import { join as join13 } from "node:path";
-function detectConflicts(directory) {
-  const conflicts = {
-    compactionAuto: false,
-    compactionPrune: false,
-    dcpPlugin: false,
-    omoPreemptiveCompaction: false,
-    omoContextWindowMonitor: false,
-    omoAnthropicRecovery: false
-  };
-  const reasons = [];
-  const compactionResult = checkCompaction(directory);
-  if (compactionResult.auto) {
-    conflicts.compactionAuto = true;
-    reasons.push("OpenCode auto-compaction is enabled (compaction.auto=true)");
-  }
-  if (compactionResult.prune) {
-    conflicts.compactionPrune = true;
-    reasons.push("OpenCode prune is enabled (compaction.prune=true)");
-  }
-  const dcpFound = checkDcpPlugin(directory);
-  if (dcpFound) {
-    conflicts.dcpPlugin = true;
-    reasons.push("opencode-dcp plugin is installed — it conflicts with Magic Context's context management");
-  }
-  const omoResult = checkOmoHooks(directory);
-  if (omoResult.preemptiveCompaction) {
-    conflicts.omoPreemptiveCompaction = true;
-    reasons.push("oh-my-opencode preemptive-compaction hook is active — it triggers compaction that conflicts with historian");
-  }
-  if (omoResult.contextWindowMonitor) {
-    conflicts.omoContextWindowMonitor = true;
-    reasons.push("oh-my-opencode context-window-monitor hook is active — it injects usage warnings that overlap with Magic Context nudges");
-  }
-  if (omoResult.anthropicRecovery) {
-    conflicts.omoAnthropicRecovery = true;
-    reasons.push("oh-my-opencode anthropic-context-window-limit-recovery hook is active — it triggers emergency compaction that bypasses historian");
-  }
-  return {
-    hasConflict: reasons.length > 0,
-    reasons,
-    conflicts
-  };
-}
-function checkCompaction(directory) {
-  if (process.env.OPENCODE_DISABLE_AUTOCOMPACT) {
-    return { auto: false, prune: false };
-  }
-  const projectResult = readProjectCompaction(directory);
-  if (projectResult.resolved)
-    return projectResult;
-  const userResult = readUserCompaction();
-  if (userResult.resolved)
-    return userResult;
-  return { auto: true, prune: false };
-}
-function readProjectCompaction(directory) {
-  const dotOcJsonc = join13(directory, ".opencode", "opencode.jsonc");
-  const dotOcJson = join13(directory, ".opencode", "opencode.json");
-  const dotOcConfig = readJsoncFile(dotOcJsonc) ?? readJsoncFile(dotOcJson);
-  if (dotOcConfig?.compaction) {
-    const c = dotOcConfig.compaction;
-    if (c.auto !== undefined || c.prune !== undefined) {
-      return { auto: c.auto === true, prune: c.prune === true, resolved: true };
-    }
-  }
-  const rootJsonc = join13(directory, "opencode.jsonc");
-  const rootJson = join13(directory, "opencode.json");
-  const rootConfig = readJsoncFile(rootJsonc) ?? readJsoncFile(rootJson);
-  if (rootConfig?.compaction) {
-    const c = rootConfig.compaction;
-    if (c.auto !== undefined || c.prune !== undefined) {
-      return { auto: c.auto === true, prune: c.prune === true, resolved: true };
-    }
-  }
-  return { auto: false, prune: false, resolved: false };
-}
-function readUserCompaction() {
-  try {
-    const paths = getOpenCodeConfigPaths({ binary: "opencode" });
-    const config2 = readJsoncFile(paths.configJsonc) ?? readJsoncFile(paths.configJson);
-    if (config2?.compaction) {
-      const c = config2.compaction;
-      if (c.auto !== undefined || c.prune !== undefined) {
-        return { auto: c.auto === true, prune: c.prune === true, resolved: true };
-      }
-    }
-  } catch {}
-  return { auto: false, prune: false, resolved: false };
-}
-function checkDcpPlugin(directory) {
-  const plugins = collectPluginEntries(directory);
-  return plugins.some((p) => matchesPackageName(p, DCP_PACKAGE_NAMES));
-}
-function matchesPackageName(entry, canonicalNames) {
-  if (entry.startsWith("file:") || entry.startsWith("http:") || entry.startsWith("https:") || entry.startsWith("/") || entry.startsWith("./") || entry.startsWith("../")) {
-    return false;
-  }
-  const lastAt = entry.lastIndexOf("@");
-  const nameOnly = lastAt > 0 ? entry.slice(0, lastAt) : entry;
-  return canonicalNames.has(nameOnly);
-}
-function extractPluginName(entry) {
-  if (typeof entry === "string")
-    return entry;
-  if (Array.isArray(entry) && typeof entry[0] === "string")
-    return entry[0];
-  return null;
-}
-function collectPluginEntries(directory) {
-  const plugins = [];
-  const pushFrom = (entries) => {
-    if (!entries)
-      return;
-    for (const entry of entries) {
-      const name2 = extractPluginName(entry);
-      if (name2)
-        plugins.push(name2);
-    }
-  };
-  for (const configPath of [
-    join13(directory, ".opencode", "opencode.jsonc"),
-    join13(directory, ".opencode", "opencode.json"),
-    join13(directory, "opencode.jsonc"),
-    join13(directory, "opencode.json")
-  ]) {
-    const config2 = readJsoncFile(configPath);
-    pushFrom(config2?.plugin);
-  }
-  try {
-    const paths = getOpenCodeConfigPaths({ binary: "opencode" });
-    for (const configPath of [paths.configJsonc, paths.configJson]) {
-      const config2 = readJsoncFile(configPath);
-      pushFrom(config2?.plugin);
-    }
-  } catch {}
-  return plugins;
-}
-function checkOmoHooks(directory) {
-  const result = {
-    preemptiveCompaction: false,
-    contextWindowMonitor: false,
-    anthropicRecovery: false
-  };
-  const plugins = collectPluginEntries(directory);
-  const hasOmo = plugins.some((p) => matchesPackageName(p, OMO_PACKAGE_NAMES));
-  if (!hasOmo)
-    return result;
-  const disabledHooks = readOmoDisabledHooks(directory);
-  result.preemptiveCompaction = !disabledHooks.has("preemptive-compaction");
-  result.contextWindowMonitor = !disabledHooks.has("context-window-monitor");
-  result.anthropicRecovery = !disabledHooks.has("anthropic-context-window-limit-recovery");
-  return result;
-}
-function readOmoDisabledHooks(directory) {
-  const disabled = new Set;
-  const configNames = [
-    "oh-my-opencode.jsonc",
-    "oh-my-opencode.json",
-    "oh-my-openagent.jsonc",
-    "oh-my-openagent.json"
-  ];
-  try {
-    const paths = getOpenCodeConfigPaths({ binary: "opencode" });
-    for (const name2 of configNames) {
-      const configPath = join13(paths.configDir, name2);
-      const config2 = readJsoncFile(configPath);
-      if (config2?.disabled_hooks) {
-        for (const hook of config2.disabled_hooks) {
-          disabled.add(hook);
-        }
-      }
-    }
-  } catch {}
-  for (const name2 of configNames) {
-    const config2 = readJsoncFile(join13(directory, name2));
-    if (config2?.disabled_hooks) {
-      for (const hook of config2.disabled_hooks) {
-        disabled.add(hook);
-      }
-    }
-  }
-  return disabled;
-}
-function formatConflictShort(result) {
-  if (!result.hasConflict)
-    return "";
-  const lines = [
-    "⚠️ Magic Context is disabled due to conflicting configuration:",
-    "",
-    ...result.reasons.map((r) => `• ${r}`),
-    "",
-    "Fix: run `npx @wolfx/opencode-magic-context@latest doctor`"
-  ];
-  return lines.join(`
-`);
-}
-var DCP_PACKAGE_NAMES, OMO_PACKAGE_NAMES;
-var init_conflict_detector = __esm(() => {
-  init_jsonc_parser();
-  init_opencode_config_dir();
-  DCP_PACKAGE_NAMES = new Set(["@tarquinen/opencode-dcp"]);
-  OMO_PACKAGE_NAMES = new Set(["oh-my-opencode", "oh-my-openagent"]);
-});
-
-// src/plugin/conflict-warning-hook.ts
-var exports_conflict_warning_hook = {};
-__export(exports_conflict_warning_hook, {
-  sendTuiSetupNotification: () => sendTuiSetupNotification,
-  sendStartupAnnouncement: () => sendStartupAnnouncement,
-  sendConflictWarning: () => sendConflictWarning,
-  cleanupConflictWarnings: () => cleanupConflictWarnings
-});
-import { existsSync as existsSync11, readFileSync as readFileSync8 } from "node:fs";
-import { homedir as homedir7, platform as platform2 } from "node:os";
-import { join as join14 } from "node:path";
-function getDesktopStatePath() {
-  const os2 = platform2();
-  const home = homedir7();
-  if (os2 === "darwin") {
-    return join14(home, "Library", "Application Support", "ai.opencode.desktop", "opencode.global.dat");
-  }
-  if (os2 === "linux") {
-    const xdgConfig = process.env.XDG_CONFIG_HOME || join14(home, ".config");
-    return join14(xdgConfig, "ai.opencode.desktop", "opencode.global.dat");
-  }
-  if (os2 === "win32") {
-    const appData = process.env.APPDATA || join14(home, "AppData", "Roaming");
-    return join14(appData, "ai.opencode.desktop", "opencode.global.dat");
-  }
-  return null;
-}
-function readDesktopState(directory) {
-  const statePath = getDesktopStatePath();
-  if (!statePath || !existsSync11(statePath)) {
-    log(`[magic-context] conflict-warning: Desktop state file not found at ${statePath}`);
-    return { sessionId: null, sidecarUrl: null };
-  }
-  try {
-    const raw = readFileSync8(statePath, "utf-8");
-    const state = JSON.parse(raw);
-    let sidecarUrl = null;
-    const serverStr = state.server;
-    if (typeof serverStr === "string") {
-      try {
-        const serverState = JSON.parse(serverStr);
-        if (typeof serverState.currentSidecarUrl === "string") {
-          sidecarUrl = serverState.currentSidecarUrl;
-        }
-      } catch {}
-    }
-    let sessionId = null;
-    const layoutPage = state["layout.page"];
-    if (typeof layoutPage === "string") {
-      const parsed = JSON.parse(layoutPage);
-      const lastProjectSession = parsed.lastProjectSession;
-      if (lastProjectSession) {
-        const entry = lastProjectSession[directory];
-        sessionId = entry?.id ?? null;
-      }
-    }
-    return { sessionId, sidecarUrl };
-  } catch (error51) {
-    log(`[magic-context] conflict-warning: failed to read Desktop state: ${error51 instanceof Error ? error51.message : String(error51)}`);
-    return { sessionId: null, sidecarUrl: null };
-  }
-}
-function getDesktopState(directory) {
-  let cached2 = cachedDesktopStateByDir.get(directory);
-  if (!cached2) {
-    cached2 = readDesktopState(directory);
-    cachedDesktopStateByDir.set(directory, cached2);
-  }
-  return cached2;
-}
-async function deleteMessage(serverUrl, sessionId, messageId) {
-  const auth = getServerAuth();
-  const url2 = `${serverUrl}/session/${encodeURIComponent(sessionId)}/message/${encodeURIComponent(messageId)}`;
-  try {
-    const response = await fetch(url2, {
-      method: "DELETE",
-      headers: auth ? { Authorization: auth } : {},
-      signal: AbortSignal.timeout(1e4)
-    });
-    if (!response.ok) {
-      log(`[magic-context] conflict-warning: DELETE failed status=${response.status} url=${url2}`);
-      return false;
-    }
-    return true;
-  } catch (error51) {
-    log(`[magic-context] conflict-warning: DELETE error (url=${serverUrl}): ${error51 instanceof Error ? error51.message : String(error51)}`);
-    return false;
-  }
-}
-function getServerAuth() {
-  const password = process.env.OPENCODE_SERVER_PASSWORD;
-  if (!password)
-    return;
-  const username = process.env.OPENCODE_SERVER_USERNAME ?? "opencode";
-  return `Basic ${Buffer.from(`${username}:${password}`, "utf8").toString("base64")}`;
-}
-async function getSessionMessages(client, sessionId) {
-  try {
-    const c = client;
-    if (typeof c.session?.messages === "function") {
-      const result = await c.session.messages({
-        path: { id: sessionId },
-        query: { limit: 50 }
-      });
-      return result?.data ?? [];
-    }
-  } catch (error51) {
-    log(`[magic-context] conflict-warning: failed to read messages: ${error51 instanceof Error ? error51.message : String(error51)}`);
-  }
-  return [];
-}
-async function sendConflictWarning(client, directory, conflictResult) {
-  const { sessionId } = getDesktopState(directory);
-  if (!sessionId) {
-    log("[magic-context] conflict-warning: could not find active session for Desktop warning");
-    return;
-  }
-  const warningText = formatConflictShort(conflictResult);
-  log(`[magic-context] sending conflict warning to session ${sessionId}: ${conflictResult.reasons.join(", ")}`);
-  try {
-    const c = client;
-    const promptInput = {
-      path: { id: sessionId },
-      body: {
-        noReply: true,
-        parts: [
-          {
-            type: "text",
-            text: warningText,
-            ignored: true
-          }
-        ]
-      }
-    };
-    if (typeof c.session?.prompt === "function") {
-      await Promise.resolve(c.session.prompt(promptInput));
-    } else if (typeof c.session?.promptAsync === "function") {
-      await c.session.promptAsync(promptInput);
-    } else {
-      log("[magic-context] conflict-warning: session prompt API unavailable");
-    }
-  } catch (error51) {
-    log(`[magic-context] conflict-warning: failed to send: ${error51 instanceof Error ? error51.message : String(error51)}`);
-  }
-}
-async function cleanupConflictWarnings(client, directory, serverUrl) {
-  const { sessionId } = getDesktopState(directory);
-  if (!sessionId) {
-    log("[magic-context] cleanup: no active Desktop session found");
-    return;
-  }
-  const messages = await getSessionMessages(client, sessionId);
-  if (messages.length === 0)
-    return;
-  const warningMessageIds = [];
-  for (let i = messages.length - 1;i >= 0; i--) {
-    const msg = messages[i];
-    const msgId = msg.info?.id;
-    const msgRole = msg.info?.role;
-    if (!msgId || msgRole !== "user")
-      break;
-    const parts = msg.parts ?? [];
-    const isWarning = parts.length > 0 && parts.every((p) => p.ignored === true && p.type === "text" && typeof p.text === "string" && p.text.startsWith(CONFLICT_WARNING_MARKER));
-    if (isWarning) {
-      warningMessageIds.push(msgId);
-    } else {
-      break;
-    }
-  }
-  if (warningMessageIds.length === 0) {
-    await cleanupEnabledMessages(messages, serverUrl, sessionId);
-    return;
-  }
-  if (!serverUrl) {
-    log("[magic-context] cleanup: no serverUrl provided, cannot delete messages");
-    return;
-  }
-  log(`[magic-context] cleaning up ${warningMessageIds.length} conflict warning message(s) from session ${sessionId}`);
-  for (const messageId of warningMessageIds) {
-    const ok = await deleteMessage(serverUrl, sessionId, messageId);
-    if (ok) {
-      log(`[magic-context] deleted conflict warning message ${messageId}`);
-    }
-  }
-  const enabledText = `${ENABLED_MARKER}. Enjoy! ✨`;
-  try {
-    const c = client;
-    const promptInput = {
-      path: { id: sessionId },
-      body: {
-        noReply: true,
-        parts: [{ type: "text", text: enabledText, ignored: true }]
-      }
-    };
-    if (typeof c.session?.prompt === "function") {
-      await Promise.resolve(c.session.prompt(promptInput));
-    } else if (typeof c.session?.promptAsync === "function") {
-      await c.session.promptAsync(promptInput);
-    }
-  } catch {}
-  setTimeout(async () => {
-    try {
-      const freshMessages = await getSessionMessages(client, sessionId);
-      for (let i = freshMessages.length - 1;i >= 0; i--) {
-        const msg = freshMessages[i];
-        const msgId = msg.info?.id;
-        const msgRole = msg.info?.role;
-        if (!msgId || msgRole !== "user")
-          break;
-        const parts = msg.parts ?? [];
-        const isEnabled = parts.length > 0 && parts.every((p) => p.ignored === true && p.type === "text" && typeof p.text === "string" && p.text.startsWith(ENABLED_MARKER));
-        if (isEnabled) {
-          await deleteMessage(serverUrl, sessionId, msgId);
-        } else {
-          break;
-        }
-      }
-    } catch {}
-  }, 1000);
-}
-async function cleanupEnabledMessages(messages, serverUrl, sessionId) {
-  if (!serverUrl)
-    return;
-  for (let i = messages.length - 1;i >= 0; i--) {
-    const msg = messages[i];
-    const msgId = msg.info?.id;
-    const msgRole = msg.info?.role;
-    if (!msgId || msgRole !== "user")
-      break;
-    const parts = msg.parts ?? [];
-    const isEnabled = parts.length > 0 && parts.every((p) => p.ignored === true && p.type === "text" && typeof p.text === "string" && p.text.startsWith(ENABLED_MARKER));
-    if (isEnabled) {
-      await deleteMessage(serverUrl, sessionId, msgId);
-    } else {
-      break;
-    }
-  }
-}
-async function sendTuiSetupNotification(client, directory, serverUrl) {
-  const { sessionId } = getDesktopState(directory);
-  if (!sessionId)
-    return;
-  const text = [
-    `${TUI_SETUP_MARKER}`,
-    "",
-    "Magic Context added its TUI plugin to your tui.json.",
-    "Restart OpenCode to see the sidebar with live context breakdown,",
-    "token usage, historian status, memory counts, and more."
-  ].join(`
-`);
-  try {
-    const c = client;
-    const promptInput = {
-      path: { id: sessionId },
-      body: {
-        noReply: true,
-        parts: [{ type: "text", text, ignored: true }]
-      }
-    };
-    if (typeof c.session?.prompt === "function") {
-      await Promise.resolve(c.session.prompt(promptInput));
-    } else if (typeof c.session?.promptAsync === "function") {
-      await c.session.promptAsync(promptInput);
-    }
-  } catch {
-    return;
-  }
-  if (!serverUrl)
-    return;
-  setTimeout(async () => {
-    try {
-      const msgs = await getSessionMessages(client, sessionId);
-      for (let i = msgs.length - 1;i >= 0; i--) {
-        const msg = msgs[i];
-        const msgId = msg.info?.id;
-        if (!msgId || msg.info?.role !== "user")
-          break;
-        const parts = msg.parts ?? [];
-        const isTuiSetup = parts.length > 0 && parts.every((p) => p.ignored === true && p.type === "text" && typeof p.text === "string" && p.text.startsWith(TUI_SETUP_MARKER));
-        if (isTuiSetup) {
-          await deleteMessage(serverUrl, sessionId, msgId);
-        } else {
-          break;
-        }
-      }
-    } catch {}
-  }, 1000);
-}
-async function sendStartupAnnouncement(client, directory, version2, features, footer, markSeen) {
-  if (!version2 || features.length === 0)
-    return;
-  const { sessionId } = getDesktopState(directory);
-  if (!sessionId) {
-    return;
-  }
-  const bullets = features.map((line) => `  • ${line}`).join(`
-`);
-  const sections = [`${ANNOUNCEMENT_MARKER} v${version2}:`, "", bullets];
-  if (footer && footer.trim().length > 0) {
-    sections.push("", footer);
-  }
-  const text = sections.join(`
-`);
-  log(`[magic-context] sending startup announcement for v${version2} to session ${sessionId}`);
-  try {
-    const c = client;
-    const promptInput = {
-      path: { id: sessionId },
-      body: {
-        noReply: true,
-        parts: [{ type: "text", text, ignored: true }]
-      }
-    };
-    if (typeof c.session?.prompt === "function") {
-      await Promise.resolve(c.session.prompt(promptInput));
-    } else if (typeof c.session?.promptAsync === "function") {
-      await c.session.promptAsync(promptInput);
-    } else {
-      log("[magic-context] announcement: session prompt API unavailable");
-      return;
-    }
-  } catch (error51) {
-    log(`[magic-context] announcement: failed to send: ${error51 instanceof Error ? error51.message : String(error51)}`);
-    return;
-  }
-  markSeen(version2);
-}
-var CONFLICT_WARNING_MARKER = "⚠️ Magic Context is disabled due to conflicting configuration:", ENABLED_MARKER = "✨ Magic Context is now enabled", TUI_SETUP_MARKER = "\uD83D\uDCCA Magic Context sidebar configured", ANNOUNCEMENT_MARKER = "✨ Magic Context — what's new in", cachedDesktopStateByDir;
-var init_conflict_warning_hook = __esm(() => {
-  init_conflict_detector();
-  init_logger();
-  cachedDesktopStateByDir = new Map;
-});
-
 // src/features/magic-context/memory/storage-memory-embeddings.ts
 function isEmbeddingBlob(value) {
   return value instanceof Uint8Array || value instanceof ArrayBuffer;
@@ -162190,9 +162193,9 @@ var init_embedding_identity = __esm(() => {
 });
 
 // src/features/magic-context/memory/embedding-local.ts
-import { mkdirSync as mkdirSync5 } from "node:fs";
+import { mkdirSync as mkdirSync4 } from "node:fs";
 import { open, stat, unlink, writeFile } from "node:fs/promises";
-import { dirname as dirname7, join as join18 } from "node:path";
+import { dirname as dirname4, join as join14 } from "node:path";
 import { pathToFileURL } from "node:url";
 async function acquireModelLoadLock(lockPath) {
   const waitStart = Date.now();
@@ -162230,7 +162233,7 @@ async function acquireModelLoadLock(lockPath) {
         log("[magic-context] embedding-load lock wait exceeded, proceeding without lock");
         return async () => {};
       }
-      await new Promise((resolve6) => setTimeout(resolve6, LOCK_POLL_MS));
+      await new Promise((resolve5) => setTimeout(resolve5, LOCK_POLL_MS));
     }
   }
 }
@@ -162254,7 +162257,7 @@ async function injectWasmOrtForElectron() {
       const { createRequire: createRequireFn } = await import("node:module");
       const requireFn = createRequireFn(import.meta.url);
       const pkgPath = requireFn.resolve("onnxruntime-web/package.json");
-      const distDir = join18(dirname7(pkgPath), "dist");
+      const distDir = join14(dirname4(pkgPath), "dist");
       const wasmPathsPrefix = `${pathToFileURL(distDir).href}/`;
       if (ortWeb.env?.wasm) {
         ortWeb.env.wasm.wasmPaths = wasmPathsPrefix;
@@ -162365,15 +162368,15 @@ class LocalEmbeddingProvider {
         if (LogLevel && "ERROR" in LogLevel) {
           env.logLevel = LogLevel.ERROR;
         }
-        const modelCacheDir = join18(getMagicContextStorageDir(), "models");
+        const modelCacheDir = join14(getMagicContextStorageDir(), "models");
         try {
-          mkdirSync5(modelCacheDir, { recursive: true });
+          mkdirSync4(modelCacheDir, { recursive: true });
           env.cacheDir = modelCacheDir;
         } catch {
           log("[magic-context] could not create model cache dir, using library default");
         }
         const createPipeline = transformersModule.pipeline;
-        const lockPath = join18(modelCacheDir, ".load.lock");
+        const lockPath = join14(modelCacheDir, ".load.lock");
         const releaseLock = await acquireModelLoadLock(lockPath);
         const stopHeartbeat = startLockHeartbeat(lockPath);
         try {
@@ -162399,7 +162402,7 @@ class LocalEmbeddingProvider {
               }
               const delayMs = 300 * attempt + Math.floor(Math.random() * 200);
               log(`[magic-context] embedding model load attempt ${attempt}/${MAX_ATTEMPTS} failed transiently, retrying in ${delayMs}ms`);
-              await new Promise((resolve6) => setTimeout(resolve6, delayMs));
+              await new Promise((resolve5) => setTimeout(resolve5, delayMs));
             }
           }
           if (this.pipeline) {
@@ -162427,8 +162430,8 @@ class LocalEmbeddingProvider {
     if (this.inFlight === 0) {
       return Promise.resolve();
     }
-    return new Promise((resolve6) => {
-      this.inFlightWaiters.push(resolve6);
+    return new Promise((resolve5) => {
+      this.inFlightWaiters.push(resolve5);
     });
   }
   finishInFlight() {
@@ -163212,9 +163215,9 @@ var init_storage_memory_fts = __esm(() => {
 
 // src/shared/models-dev-cache.ts
 import { createHash as createHash7 } from "node:crypto";
-import { existsSync as existsSync14, readFileSync as readFileSync11 } from "node:fs";
-import { homedir as homedir9, platform as platform3 } from "node:os";
-import { join as join19 } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync8 } from "node:fs";
+import { homedir as homedir7, platform as platform2 } from "node:os";
+import { join as join15 } from "node:path";
 function hashFast(input) {
   return createHash7("sha1").update(input).digest("hex");
 }
@@ -163225,16 +163228,16 @@ function getModelsJsonPath() {
   const cacheBase = getCacheDir();
   const source = process.env.OPENCODE_MODELS_URL?.trim();
   const filename = source && source !== "https://models.dev" ? `models-${hashFast(source)}.json` : "models.json";
-  return join19(cacheBase, "opencode", filename);
+  return join15(cacheBase, "opencode", filename);
 }
 function getOpencodeConfigPath() {
   const envDir = process.env.OPENCODE_CONFIG_DIR?.trim();
-  const configDir = envDir ? envDir : platform3() === "win32" ? join19(homedir9(), ".config", "opencode") : join19(process.env.XDG_CONFIG_HOME || join19(homedir9(), ".config"), "opencode");
-  const jsonc = join19(configDir, "opencode.jsonc");
-  if (existsSync14(jsonc))
+  const configDir = envDir ? envDir : platform2() === "win32" ? join15(homedir7(), ".config", "opencode") : join15(process.env.XDG_CONFIG_HOME || join15(homedir7(), ".config"), "opencode");
+  const jsonc = join15(configDir, "opencode.jsonc");
+  if (existsSync11(jsonc))
     return jsonc;
-  const json2 = join19(configDir, "opencode.json");
-  if (existsSync14(json2))
+  const json2 = join15(configDir, "opencode.json");
+  if (existsSync11(json2))
     return json2;
   return null;
 }
@@ -163266,9 +163269,9 @@ function loadModelsDevMetadataFromFile() {
   const modelsJsonPath = getModelsJsonPath();
   let fileFound = false;
   try {
-    if (existsSync14(modelsJsonPath)) {
+    if (existsSync11(modelsJsonPath)) {
       fileFound = true;
-      const raw = readFileSync11(modelsJsonPath, "utf-8");
+      const raw = readFileSync8(modelsJsonPath, "utf-8");
       const data = JSON.parse(raw);
       for (const [providerId, provider2] of Object.entries(data)) {
         if (!provider2?.models || typeof provider2.models !== "object")
@@ -163283,8 +163286,8 @@ function loadModelsDevMetadataFromFile() {
   }
   try {
     const configPath = getOpencodeConfigPath();
-    if (configPath && existsSync14(configPath)) {
-      const config2 = parseJsonc(readFileSync11(configPath, "utf-8"));
+    if (configPath && existsSync11(configPath)) {
+      const config2 = parseJsonc(readFileSync8(configPath, "utf-8"));
       if (config2.provider && typeof config2.provider === "object") {
         for (const [providerId, provider2] of Object.entries(config2.provider)) {
           if (!provider2?.models || typeof provider2.models !== "object")
@@ -163382,7 +163385,7 @@ var init_rpc_notifications = __esm(() => {
 });
 
 // src/features/magic-context/compaction-marker.ts
-import { join as join20 } from "node:path";
+import { join as join16 } from "node:path";
 function randomBase62(length) {
   const chars = [];
   for (let i = 0;i < length; i++) {
@@ -163402,7 +163405,7 @@ function generatePartId(timestampMs, counter = 0n) {
   return generateId("prt", timestampMs, counter);
 }
 function getOpenCodeDbPath3() {
-  return join20(getDataDir(), "opencode", "opencode.db");
+  return join16(getDataDir(), "opencode", "opencode.db");
 }
 function isOpenCodeSchemaCompatible(db, dbPath) {
   if (cachedSchemaCompatible?.path === dbPath) {
@@ -163544,7 +163547,7 @@ var init_compaction_marker = __esm(async () => {
 });
 
 // src/hooks/magic-context/compaction-marker-manager.ts
-import { join as join21 } from "node:path";
+import { join as join17 } from "node:path";
 function validatePendingTarget(db, sessionId, pending) {
   const ocMessage = getOpenCodeMessageById(sessionId, pending.endMessageId);
   if (!ocMessage) {
@@ -163651,7 +163654,7 @@ function removeCompactionMarkerForSession(db, sessionId) {
   }
 }
 function checkCompactionMarkerConsistency(db) {
-  const opencodeDbPath = join21(getDataDir(), "opencode", "opencode.db");
+  const opencodeDbPath = join17(getDataDir(), "opencode", "opencode.db");
   let opencodeDb;
   try {
     opencodeDb = new Database(opencodeDbPath, { readonly: true });
@@ -163934,8 +163937,8 @@ var init_compartment_runner_validation = __esm(async () => {
 });
 
 // src/hooks/magic-context/compartment-runner-historian.ts
-import { mkdirSync as mkdirSync6, unlinkSync, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join22 } from "node:path";
+import { mkdirSync as mkdirSync5, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join18 } from "node:path";
 function historianResponseDumpDir(directory) {
   return getProjectMagicContextHistorianDir(directory);
 }
@@ -164198,8 +164201,8 @@ function isTransientHistorianPromptError(message) {
   ].some((token) => normalized.includes(token));
 }
 function sleep(ms) {
-  return new Promise((resolve6) => {
-    setTimeout(resolve6, ms);
+  return new Promise((resolve5) => {
+    setTimeout(resolve5, ms);
   });
 }
 function cleanupHistorianDump(sessionId, dumpPath) {
@@ -164217,11 +164220,11 @@ function cleanupHistorianDump(sessionId, dumpPath) {
 function dumpHistorianResponse(sessionId, directory, label, text) {
   try {
     const dumpDir = historianResponseDumpDir(directory);
-    mkdirSync6(dumpDir, { recursive: true });
+    mkdirSync5(dumpDir, { recursive: true });
     const safeSessionId = sanitizeDumpName(sessionId);
     const safeLabel = sanitizeDumpName(label);
-    const dumpPath = join22(dumpDir, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
-    writeFileSync5(dumpPath, text, "utf8");
+    const dumpPath = join18(dumpDir, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
+    writeFileSync2(dumpPath, text, "utf8");
     sessionLog(sessionId, "compartment agent: historian response dumped", {
       label,
       dumpPath
@@ -165592,16 +165595,16 @@ var init_caveman = __esm(() => {
 });
 
 // src/hooks/magic-context/historian-state-file.ts
-import { mkdirSync as mkdirSync7, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join23 } from "node:path";
+import { mkdirSync as mkdirSync6, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join19 } from "node:path";
 function maybeWriteHistorianStateFile(sessionId, existingState, directory) {
   if (existingState.length <= HISTORIAN_STATE_INLINE_THRESHOLD)
     return;
   try {
     const dir = getProjectMagicContextHistorianDir(directory);
-    mkdirSync7(dir, { recursive: true });
-    const path5 = join23(dir, `state-${sessionId}-${Date.now()}.xml`);
-    writeFileSync6(path5, existingState, "utf8");
+    mkdirSync6(dir, { recursive: true });
+    const path5 = join19(dir, `state-${sessionId}-${Date.now()}.xml`);
+    writeFileSync3(path5, existingState, "utf8");
     return path5;
   } catch {
     return;
@@ -167181,9 +167184,6 @@ function deepMergeRawConfig(base, override) {
   }
   return result;
 }
-function getProjectUserOnlyFields(config2) {
-  return "auto_update" in config2 ? ["auto_update"] : [];
-}
 function redactConfigValue(value) {
   if (value === undefined)
     return "<missing>";
@@ -167330,15 +167330,7 @@ function loadPluginConfig(directory) {
   }
   if (projectLoaded) {
     allWarnings.push(...projectLoaded.warnings.map((w) => `[project config] ${w}`));
-    const projectRaw = { ...projectLoaded.config };
-    const strippedUserOnlyFields = getProjectUserOnlyFields(projectRaw);
-    if (strippedUserOnlyFields.length > 0) {
-      for (const key of strippedUserOnlyFields) {
-        delete projectRaw[key];
-      }
-      allWarnings.push(`[project config] Ignoring ${strippedUserOnlyFields.join(", ")} from project config (security: these settings only honor user-level config)`);
-    }
-    mergedRaw = deepMergeRawConfig(mergedRaw, projectRaw);
+    mergedRaw = deepMergeRawConfig(mergedRaw, projectLoaded.config);
   }
   const config2 = parsePluginConfig(mergedRaw);
   if (config2.configWarnings?.length) {
@@ -167411,15 +167403,7 @@ function loadPluginConfigDetailed(directory) {
   }
   if (projectLoaded) {
     allWarnings.push(...projectLoaded.warnings.map((w) => `[project config] ${w}`));
-    const projectRaw = { ...projectLoaded.config };
-    const strippedUserOnlyFields = getProjectUserOnlyFields(projectRaw);
-    if (strippedUserOnlyFields.length > 0) {
-      for (const key of strippedUserOnlyFields) {
-        delete projectRaw[key];
-      }
-      allWarnings.push(`[project config] Ignoring ${strippedUserOnlyFields.join(", ")} from project config (security: these settings only honor user-level config)`);
-    }
-    mergedRaw = deepMergeRawConfig(mergedRaw, projectRaw);
+    mergedRaw = deepMergeRawConfig(mergedRaw, projectLoaded.config);
   }
   const recoveredTopLevelKeys = [];
   const config2 = parsePluginConfig(mergedRaw, recoveredTopLevelKeys);
@@ -167957,587 +167941,6 @@ async function runSidekick(deps) {
 
 // src/index.ts
 init_tool_definition_tokens();
-
-// src/hooks/auto-update-checker/index.ts
-init_logger();
-import { existsSync as existsSync10, mkdirSync as mkdirSync4, readFileSync as readFileSync7, renameSync, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname6, join as join11 } from "node:path";
-
-// src/hooks/auto-update-checker/cache.ts
-init_logger();
-var import_comment_json2 = __toESM(require_src2(), 1);
-import { spawn } from "node:child_process";
-import { existsSync as existsSync9, readFileSync as readFileSync6, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { basename, dirname as dirname5, join as join10 } from "node:path";
-
-// src/hooks/auto-update-checker/checker.ts
-init_logger();
-var import_comment_json = __toESM(require_src2(), 1);
-import { existsSync as existsSync8, readFileSync as readFileSync5, statSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { dirname as dirname4, isAbsolute as isAbsolute2, join as join9, resolve as resolve3 } from "node:path";
-import { fileURLToPath } from "node:url";
-
-// src/hooks/auto-update-checker/constants.ts
-import { homedir as homedir4, platform } from "node:os";
-import { join as join8 } from "node:path";
-var PACKAGE_NAME = "@wolfx/opencode-magic-context";
-var NPM_REGISTRY_URL = "https://registry.npmjs.org";
-var NPM_FETCH_TIMEOUT = 1e4;
-function getOpenCodeCacheRoot() {
-  if (platform() === "win32") {
-    return join8(process.env.LOCALAPPDATA ?? homedir4(), "opencode");
-  }
-  return join8(homedir4(), ".cache", "opencode");
-}
-function getOpenCodeConfigRoot() {
-  if (platform() === "win32") {
-    return join8(process.env.APPDATA ?? join8(homedir4(), "AppData", "Roaming"), "opencode");
-  }
-  return join8(process.env.XDG_CONFIG_HOME ?? join8(homedir4(), ".config"), "opencode");
-}
-var CACHE_DIR = join8(getOpenCodeCacheRoot(), "packages");
-var USER_OPENCODE_CONFIG = join8(getOpenCodeConfigRoot(), "opencode.json");
-var USER_OPENCODE_CONFIG_JSONC = join8(getOpenCodeConfigRoot(), "opencode.jsonc");
-
-// src/hooks/auto-update-checker/types.ts
-init_zod();
-var NpmPackageEnvelopeSchema = exports_external.object({
-  "dist-tags": exports_external.record(exports_external.string(), exports_external.string()).optional().default({})
-});
-var OpencodePluginTupleSchema = exports_external.tuple([exports_external.string(), exports_external.record(exports_external.string(), exports_external.unknown())]);
-var OpencodeConfigSchema = exports_external.object({
-  plugin: exports_external.array(exports_external.union([exports_external.string(), OpencodePluginTupleSchema])).optional()
-});
-var PackageJsonSchema = exports_external.object({
-  name: exports_external.string().optional(),
-  version: exports_external.string().optional(),
-  dependencies: exports_external.record(exports_external.string(), exports_external.string()).optional()
-}).passthrough();
-
-// src/hooks/auto-update-checker/checker.ts
-function warn(message) {
-  log(`WARN: ${message}`);
-}
-function isString(value) {
-  return typeof value === "string";
-}
-function pluginSpecifier(entry) {
-  return typeof entry === "string" ? entry : entry[0];
-}
-function getPluginEntries(config2) {
-  const parsed = OpencodeConfigSchema.safeParse(config2);
-  if (!parsed.success)
-    return [];
-  return (parsed.data.plugin ?? []).map(pluginSpecifier).filter(isString);
-}
-function parseJsonConfig(content) {
-  try {
-    return import_comment_json.parse(content);
-  } catch (err) {
-    warn(`[auto-update-checker] Failed to parse OpenCode config: ${String(err)}`);
-    return null;
-  }
-}
-function isPrereleaseVersion(version2) {
-  return version2.includes("-");
-}
-function isDistTag(version2) {
-  return !/^\d/.test(version2);
-}
-function extractChannel(version2) {
-  if (!version2)
-    return "latest";
-  if (isDistTag(version2))
-    return version2;
-  if (isPrereleaseVersion(version2)) {
-    const prereleasePart = version2.split("-")[1];
-    const channelMatch = prereleasePart?.match(/^(alpha|beta|rc|canary|next)/);
-    if (channelMatch?.[1])
-      return channelMatch[1];
-  }
-  return "latest";
-}
-function getConfigPaths(directory) {
-  return [
-    join9(directory, ".opencode", "opencode.json"),
-    join9(directory, ".opencode", "opencode.jsonc"),
-    USER_OPENCODE_CONFIG,
-    USER_OPENCODE_CONFIG_JSONC
-  ];
-}
-function resolvePathPluginSpec(spec, configPath) {
-  if (spec.startsWith("file://")) {
-    try {
-      return fileURLToPath(spec);
-    } catch {
-      return spec.replace(/^file:\/\//, "");
-    }
-  }
-  if (isAbsolute2(spec) || /^[A-Za-z]:[\\/]/.test(spec))
-    return spec;
-  return resolve3(dirname4(configPath), spec);
-}
-function findPackageJsonUp(startPath) {
-  try {
-    const stat = statSync(startPath);
-    let dir = stat.isDirectory() ? startPath : dirname4(startPath);
-    for (let i = 0;i < 10; i++) {
-      const pkgPath = join9(dir, "package.json");
-      if (existsSync8(pkgPath)) {
-        try {
-          const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync5(pkgPath, "utf-8")));
-          if (pkg.success && pkg.data.name === PACKAGE_NAME)
-            return pkgPath;
-        } catch {}
-      }
-      const parent = dirname4(dir);
-      if (parent === dir)
-        break;
-      dir = parent;
-    }
-  } catch {}
-  return null;
-}
-function getLocalDevPath(directory) {
-  for (const configPath of getConfigPaths(directory)) {
-    try {
-      if (!existsSync8(configPath))
-        continue;
-      const rawConfig = parseJsonConfig(readFileSync5(configPath, "utf-8"));
-      const plugins = getPluginEntries(rawConfig);
-      for (const entry of plugins) {
-        if (entry === PACKAGE_NAME || entry.startsWith(`${PACKAGE_NAME}@`))
-          continue;
-        if (entry.startsWith("file://") || entry.startsWith(".") || isAbsolute2(entry)) {
-          const localPath = resolvePathPluginSpec(entry, configPath);
-          const pkgPath = findPackageJsonUp(localPath);
-          if (!pkgPath)
-            continue;
-          const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync5(pkgPath, "utf-8")));
-          if (pkg.success && pkg.data.name === PACKAGE_NAME)
-            return localPath;
-        }
-      }
-    } catch {}
-  }
-  return null;
-}
-function getLocalDevVersion(directory) {
-  const localPath = getLocalDevPath(directory);
-  if (!localPath)
-    return null;
-  try {
-    const pkgPath = findPackageJsonUp(localPath);
-    if (!pkgPath)
-      return null;
-    const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync5(pkgPath, "utf-8")));
-    return pkg.success ? pkg.data.version ?? null : null;
-  } catch {
-    return null;
-  }
-}
-function getCurrentRuntimePackageJsonPath(currentModuleUrl = import.meta.url) {
-  try {
-    return findPackageJsonUp(dirname4(fileURLToPath(currentModuleUrl)));
-  } catch (err) {
-    warn(`[auto-update-checker] Failed to resolve runtime package path: ${String(err)}`);
-    return null;
-  }
-}
-function findPluginEntry(directory) {
-  for (const configPath of getConfigPaths(directory)) {
-    try {
-      if (!existsSync8(configPath))
-        continue;
-      const rawConfig = parseJsonConfig(readFileSync5(configPath, "utf-8"));
-      const plugins = getPluginEntries(rawConfig);
-      for (const entry of plugins) {
-        if (entry === PACKAGE_NAME) {
-          return { entry, isPinned: false, pinnedVersion: null, configPath };
-        }
-        if (entry.startsWith(`${PACKAGE_NAME}@`)) {
-          const pinnedVersion = entry.slice(PACKAGE_NAME.length + 1);
-          const isPinned = pinnedVersion !== "latest";
-          return {
-            entry,
-            isPinned,
-            pinnedVersion: isPinned ? pinnedVersion : null,
-            configPath
-          };
-        }
-      }
-    } catch {}
-  }
-  return null;
-}
-var cachedPackageVersion = null;
-function getSpecCachePackageJsonPath(spec) {
-  return join9(CACHE_DIR, spec, "node_modules", PACKAGE_NAME, "package.json");
-}
-function getCachedVersion(spec) {
-  if (!spec && cachedPackageVersion)
-    return cachedPackageVersion;
-  const candidates = [
-    getCurrentRuntimePackageJsonPath(),
-    spec ? getSpecCachePackageJsonPath(spec) : null,
-    getSpecCachePackageJsonPath(`${PACKAGE_NAME}@latest`),
-    join9(homedir5(), ".cache", "opencode", "node_modules", PACKAGE_NAME, "package.json")
-  ].filter(isString);
-  for (const packageJsonPath of candidates) {
-    try {
-      if (!existsSync8(packageJsonPath))
-        continue;
-      const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync5(packageJsonPath, "utf-8")));
-      if (pkg.success && pkg.data.version) {
-        if (!spec)
-          cachedPackageVersion = pkg.data.version;
-        return pkg.data.version;
-      }
-    } catch {}
-  }
-  return null;
-}
-function buildRegistryUrl(registryUrl) {
-  return `${registryUrl.replace(/\/+$/, "")}/${encodeURIComponent(PACKAGE_NAME).replace("%2F", "/")}`;
-}
-async function getLatestVersion(channel = "latest", options = {}) {
-  const controller = new AbortController;
-  const timeoutId = setTimeout(() => controller.abort(), options.timeoutMs ?? NPM_FETCH_TIMEOUT);
-  const abortHandler = () => controller.abort();
-  options.signal?.addEventListener("abort", abortHandler, { once: true });
-  try {
-    if (options.signal?.aborted)
-      return null;
-    const response = await fetch(buildRegistryUrl(options.registryUrl ?? NPM_REGISTRY_URL), {
-      signal: controller.signal,
-      headers: { Accept: "application/json" }
-    });
-    if (!response.ok)
-      return null;
-    const data = NpmPackageEnvelopeSchema.safeParse(await response.json());
-    if (!data.success)
-      return null;
-    return data.data["dist-tags"][channel] ?? data.data["dist-tags"].latest ?? null;
-  } catch {
-    return null;
-  } finally {
-    options.signal?.removeEventListener("abort", abortHandler);
-    clearTimeout(timeoutId);
-  }
-}
-
-// src/hooks/auto-update-checker/cache.ts
-function warn2(message) {
-  log(`WARN: ${message}`);
-}
-function stripPackageNameFromPath(pathValue, packageName) {
-  let current = pathValue;
-  for (const segment of [...packageName.split("/")].reverse()) {
-    if (basename(current) !== segment)
-      return null;
-    current = dirname5(current);
-  }
-  return current;
-}
-function removeFromPackageLock(installDir, packageName) {
-  const lockPath = join10(installDir, "package-lock.json");
-  if (!existsSync9(lockPath))
-    return false;
-  try {
-    const lock = import_comment_json2.parse(readFileSync6(lockPath, "utf-8"));
-    let modified = false;
-    if (lock.packages) {
-      const key = `node_modules/${packageName}`;
-      if (lock.packages[key] !== undefined) {
-        delete lock.packages[key];
-        modified = true;
-      }
-    }
-    if (lock.dependencies?.[packageName]) {
-      delete lock.dependencies[packageName];
-      modified = true;
-    }
-    if (modified) {
-      writeFileSync3(lockPath, JSON.stringify(lock, null, 2));
-      log(`[auto-update-checker] Removed from package-lock.json: ${packageName}`);
-    }
-    return modified;
-  } catch {
-    return false;
-  }
-}
-function ensureDependencyVersion(packageJsonPath, packageName, version2) {
-  if (!existsSync9(packageJsonPath))
-    return false;
-  try {
-    const raw = import_comment_json2.parse(readFileSync6(packageJsonPath, "utf-8"));
-    const pkgJson = PackageJsonSchema.safeParse(raw);
-    if (!pkgJson.success)
-      return false;
-    const nextPackageJson = { ...pkgJson.data };
-    const dependencies = { ...nextPackageJson.dependencies ?? {} };
-    if (dependencies[packageName] === version2)
-      return true;
-    dependencies[packageName] = version2;
-    nextPackageJson.dependencies = dependencies;
-    writeFileSync3(packageJsonPath, JSON.stringify(nextPackageJson, null, 2));
-    log(`[auto-update-checker] Updated dependency in package.json: ${packageName} → ${version2}`);
-    return true;
-  } catch (err) {
-    warn2(`[auto-update-checker] Failed to update package.json dependency: ${String(err)}`);
-    return false;
-  }
-}
-function removeInstalledPackage(installDir, packageName) {
-  const packageDir = join10(installDir, "node_modules", packageName);
-  if (!existsSync9(packageDir))
-    return false;
-  rmSync(packageDir, { recursive: true, force: true });
-  log(`[auto-update-checker] Package removed: ${packageDir}`);
-  return true;
-}
-function resolveInstallContext(runtimePackageJsonPath = getCurrentRuntimePackageJsonPath()) {
-  if (runtimePackageJsonPath) {
-    const packageDir = dirname5(runtimePackageJsonPath);
-    const nodeModulesDir = stripPackageNameFromPath(packageDir, PACKAGE_NAME);
-    if (nodeModulesDir && basename(nodeModulesDir) === "node_modules") {
-      const installDir = dirname5(nodeModulesDir);
-      const packageJsonPath = join10(installDir, "package.json");
-      if (!existsSync9(packageJsonPath)) {
-        try {
-          writeFileSync3(packageJsonPath, `${JSON.stringify({ private: true, dependencies: {} }, null, 2)}
-`);
-          log(`[auto-update-checker] Seeded missing package.json at ${packageJsonPath} (issue #73)`);
-        } catch (err) {
-          warn2(`[auto-update-checker] Could not seed package.json at ${packageJsonPath}: ${String(err)}`);
-          return null;
-        }
-      }
-      return { installDir, packageJsonPath };
-    }
-    return null;
-  }
-  const legacyPackageJsonPath = join10(dirname5(CACHE_DIR), "package.json");
-  if (existsSync9(legacyPackageJsonPath)) {
-    return { installDir: dirname5(CACHE_DIR), packageJsonPath: legacyPackageJsonPath };
-  }
-  return null;
-}
-function preparePackageUpdate(version2, packageName = PACKAGE_NAME, runtimePackageJsonPath = getCurrentRuntimePackageJsonPath()) {
-  try {
-    const installContext = resolveInstallContext(runtimePackageJsonPath);
-    if (!installContext) {
-      warn2("[auto-update-checker] No install context found for auto-update");
-      return null;
-    }
-    if (!ensureDependencyVersion(installContext.packageJsonPath, packageName, version2))
-      return null;
-    const packageRemoved = removeInstalledPackage(installContext.installDir, packageName);
-    const lockRemoved = removeFromPackageLock(installContext.installDir, packageName);
-    if (!packageRemoved && !lockRemoved) {
-      log(`[auto-update-checker] No cached package artifacts removed for ${packageName}; continuing with updated dependency spec`);
-    }
-    return installContext.installDir;
-  } catch (err) {
-    warn2(`[auto-update-checker] Failed to prepare package update: ${String(err)}`);
-    return null;
-  }
-}
-async function runNpmInstallSafe(installDir, options = {}) {
-  let timeout = null;
-  try {
-    if (options.signal?.aborted)
-      return false;
-    const proc = spawn("npm", ["install", "--no-audit", "--no-fund", "--no-progress"], {
-      cwd: installDir,
-      stdio: "pipe"
-    });
-    const abortProcess = () => {
-      try {
-        proc.kill();
-      } catch {}
-    };
-    options.signal?.addEventListener("abort", abortProcess, { once: true });
-    const exitPromise = new Promise((resolveExit) => {
-      proc.on("error", () => resolveExit(false));
-      proc.on("exit", (code) => resolveExit(code === 0));
-    });
-    const timeoutPromise = new Promise((resolveTimeout) => {
-      timeout = setTimeout(() => resolveTimeout("timeout"), options.timeoutMs ?? 60000);
-    });
-    const result = await Promise.race([exitPromise, timeoutPromise]);
-    options.signal?.removeEventListener("abort", abortProcess);
-    if (result === "timeout" || options.signal?.aborted) {
-      abortProcess();
-      return false;
-    }
-    return result;
-  } catch (err) {
-    warn2(`[auto-update-checker] npm install error: ${String(err)}`);
-    return false;
-  } finally {
-    if (timeout)
-      clearTimeout(timeout);
-  }
-}
-
-// src/hooks/auto-update-checker/index.ts
-var DEFAULT_CHECK_INTERVAL_MS = 60 * 60 * 1000;
-var DEFAULT_INIT_DELAY_MS = 5000;
-var TIMESTAMP_FILENAME = "last-update-check.json";
-function warn3(message) {
-  log(`WARN: ${message}`);
-}
-function createAutoUpdateCheckerHook(ctx, options = {}) {
-  const {
-    enabled = true,
-    showStartupToast = true,
-    autoUpdate = true,
-    npmRegistryUrl = NPM_REGISTRY_URL,
-    fetchTimeoutMs = NPM_FETCH_TIMEOUT,
-    signal = new AbortController().signal,
-    storageDir = null,
-    checkIntervalMs = DEFAULT_CHECK_INTERVAL_MS,
-    initDelayMs = DEFAULT_INIT_DELAY_MS
-  } = options;
-  if (!enabled) {
-    return async (_input) => {};
-  }
-  const initTimer = setTimeout(() => {
-    maybeRunCheck(ctx, {
-      showStartupToast,
-      autoUpdate,
-      npmRegistryUrl,
-      fetchTimeoutMs,
-      signal,
-      storageDir,
-      checkIntervalMs,
-      initDelayMs
-    }).catch((err) => {
-      warn3(`[auto-update-checker] Background update check failed: ${String(err)}`);
-    });
-  }, initDelayMs);
-  if (typeof initTimer === "object" && initTimer !== null && "unref" in initTimer) {
-    initTimer.unref();
-  }
-  signal.addEventListener("abort", () => {
-    clearTimeout(initTimer);
-  }, { once: true });
-  return async (_input) => {};
-}
-async function maybeRunCheck(ctx, options) {
-  if (options.signal.aborted)
-    return;
-  if (!claimCheckSlot(options.storageDir, options.checkIntervalMs)) {
-    log("[auto-update-checker] Skipping check (another instance ran one recently)");
-    return;
-  }
-  await runStartupCheck(ctx, options);
-}
-function claimCheckSlot(storageDir, intervalMs) {
-  if (!storageDir)
-    return true;
-  try {
-    const file2 = join11(storageDir, TIMESTAMP_FILENAME);
-    if (existsSync10(file2)) {
-      try {
-        const raw = JSON.parse(readFileSync7(file2, "utf-8"));
-        const last = typeof raw.lastCheckedMs === "number" ? raw.lastCheckedMs : 0;
-        if (Number.isFinite(last) && Date.now() - last < intervalMs) {
-          return false;
-        }
-      } catch {}
-    }
-    mkdirSync4(dirname6(file2), { recursive: true });
-    const tmp = `${file2}.tmp.${process.pid}`;
-    writeFileSync4(tmp, JSON.stringify({ lastCheckedMs: Date.now() }), "utf-8");
-    renameSync(tmp, file2);
-    return true;
-  } catch (err) {
-    warn3(`[auto-update-checker] Could not coordinate via timestamp file: ${String(err)}`);
-    return true;
-  }
-}
-async function runStartupCheck(ctx, options) {
-  if (options.signal.aborted)
-    return;
-  const cachedVersion = getCachedVersion();
-  const localDevVersion = getLocalDevVersion(ctx.directory);
-  const displayVersion = localDevVersion ?? cachedVersion;
-  if (localDevVersion) {
-    if (options.showStartupToast) {
-      showToast(ctx, `Magic Context ${displayVersion} (dev)`, "Running in local development mode.", "info");
-    }
-    log("[auto-update-checker] Local development mode");
-    return;
-  }
-  if (options.showStartupToast) {
-    showToast(ctx, `Magic Context ${displayVersion ?? "unknown"}`, "@wolfx/opencode-magic-context is active.", "info");
-  }
-  await runBackgroundUpdateCheck(ctx, options);
-}
-async function runBackgroundUpdateCheck(ctx, options) {
-  if (options.signal.aborted)
-    return;
-  const pluginInfo = findPluginEntry(ctx.directory);
-  if (!pluginInfo) {
-    log("[auto-update-checker] Plugin not found in config");
-    return;
-  }
-  const cachedVersion = getCachedVersion(pluginInfo.entry);
-  const currentVersion = cachedVersion ?? pluginInfo.pinnedVersion;
-  if (!currentVersion) {
-    log("[auto-update-checker] No version found (cached or pinned)");
-    return;
-  }
-  const channel = extractChannel(pluginInfo.pinnedVersion ?? currentVersion);
-  const latestVersion = await getLatestVersion(channel, {
-    registryUrl: options.npmRegistryUrl,
-    timeoutMs: options.fetchTimeoutMs,
-    signal: options.signal
-  });
-  if (!latestVersion) {
-    warn3(`[auto-update-checker] Failed to fetch latest version for channel: ${channel}`);
-    showToast(ctx, "Magic Context update check failed", "Could not check npm for @wolfx/opencode-magic-context updates. Continuing with the cached version.", "warning", 8000);
-    return;
-  }
-  if (currentVersion === latestVersion) {
-    log(`[auto-update-checker] Already on latest version for channel: ${channel}`);
-    return;
-  }
-  log(`[auto-update-checker] Update available (${channel}): ${currentVersion} → ${latestVersion}`);
-  if (pluginInfo.isPinned) {
-    showToast(ctx, `Magic Context ${latestVersion}`, `v${latestVersion} available. Version is pinned; update your OpenCode plugin config to upgrade.`, "info", 8000);
-    log("[auto-update-checker] Version is pinned; skipping auto-update");
-    return;
-  }
-  if (!options.autoUpdate) {
-    showToast(ctx, `Magic Context ${latestVersion}`, `v${latestVersion} available. Auto-update is disabled.`, "info", 8000);
-    log("[auto-update-checker] Auto-update disabled, notification only");
-    return;
-  }
-  const installDir = preparePackageUpdate(latestVersion, PACKAGE_NAME);
-  if (!installDir) {
-    showToast(ctx, `Magic Context ${latestVersion}`, `v${latestVersion} available. Auto-update could not prepare the active install.`, "warning", 8000);
-    warn3("[auto-update-checker] Failed to prepare install root for auto-update");
-    return;
-  }
-  const installSuccess = await runNpmInstallSafe(installDir, { signal: options.signal });
-  if (installSuccess) {
-    showToast(ctx, "Magic Context Updated!", `v${currentVersion} → v${latestVersion}
-Restart OpenCode to apply.`, "success", 8000);
-    log(`[auto-update-checker] Update installed: ${currentVersion} → ${latestVersion}`);
-    return;
-  }
-  showToast(ctx, `Magic Context ${latestVersion}`, `v${latestVersion} available, but auto-update failed to install it. Check logs or retry manually.`, "error", 8000);
-  warn3("[auto-update-checker] npm install failed; update not installed");
-}
-function showToast(ctx, title, message, variant = "info", duration3 = 3000) {
-  ctx.client.tui.showToast({ body: { title, message, variant, duration: duration3 } }).catch(() => {});
-}
-
-// src/index.ts
 init_compartment_prompt();
 
 // src/hooks/magic-context/live-session-state.ts
@@ -168739,27 +168142,27 @@ init_assistant_message_extractor();
 init_data_path();
 init_logger();
 await init_sqlite();
-import { existsSync as existsSync13 } from "node:fs";
-import { join as join17 } from "node:path";
+import { existsSync as existsSync10 } from "node:fs";
+import { join as join13 } from "node:path";
 
 // src/features/magic-context/key-files/identify-key-files.ts
 init_read_session_formatting();
 init_shared();
 init_assistant_message_extractor();
 init_logger();
-import { readFileSync as readFileSync10 } from "node:fs";
-import { join as join16 } from "node:path";
+import { readFileSync as readFileSync7 } from "node:fs";
+import { join as join12 } from "node:path";
 
 // src/features/magic-context/key-files/aft-availability.ts
-var import_comment_json3 = __toESM(require_src2(), 1);
-import { existsSync as existsSync12, readFileSync as readFileSync9 } from "node:fs";
-import { homedir as homedir8 } from "node:os";
-import { join as join15 } from "node:path";
+var import_comment_json = __toESM(require_src2(), 1);
+import { existsSync as existsSync9, readFileSync as readFileSync6 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { join as join11 } from "node:path";
 var overrideAvailability = null;
 function parseConfig(path5) {
-  if (!existsSync12(path5))
+  if (!existsSync9(path5))
     return null;
-  return import_comment_json3.parse(readFileSync9(path5, "utf-8"));
+  return import_comment_json.parse(readFileSync6(path5, "utf-8"));
 }
 function entryMatchesAft(entry) {
   const value = Array.isArray(entry) ? entry[0] : entry;
@@ -168779,12 +168182,12 @@ function hasAftAtKeys(value, keys) {
   return false;
 }
 function getAftAvailability() {
-  const home = process.env.HOME || homedir8();
+  const home = process.env.HOME || homedir6();
   const opencodePaths = [
-    join15(home, ".config", "opencode", "opencode.jsonc"),
-    join15(home, ".config", "opencode", "opencode.json")
+    join11(home, ".config", "opencode", "opencode.jsonc"),
+    join11(home, ".config", "opencode", "opencode.json")
   ];
-  const piPaths = [join15(home, ".pi", "agent", "settings.json")];
+  const piPaths = [join11(home, ".pi", "agent", "settings.json")];
   const checkedPaths = [...opencodePaths, ...piPaths];
   let opencode = false;
   for (const path5 of opencodePaths) {
@@ -168828,7 +168231,7 @@ init_project_key_files();
 
 // src/features/magic-context/key-files/read-history.ts
 import { realpathSync as realpathSync2 } from "node:fs";
-import { relative, resolve as resolve5 } from "node:path";
+import { relative, resolve as resolve4 } from "node:path";
 function toMs(value) {
   if (typeof value === "number" && Number.isFinite(value))
     return value;
@@ -168865,7 +168268,7 @@ function coalesceRanges(ranges) {
 }
 function normalizeProjectRelativePath(projectPath, filePath) {
   const root = realpathSync2(projectPath);
-  const abs = filePath.startsWith("/") ? resolve5(filePath) : resolve5(root, filePath);
+  const abs = filePath.startsWith("/") ? resolve4(filePath) : resolve4(root, filePath);
   let real = abs;
   try {
     real = realpathSync2(abs);
@@ -169251,7 +168654,7 @@ async function runKeyFilesTask(args) {
     if (row.staleReason !== null || row.generationConfigHash !== configHash)
       return false;
     try {
-      return sha256(readFileSync10(join16(projectPath, row.path))) === row.contentHash;
+      return sha256(readFileSync7(join12(projectPath, row.path))) === row.contentHash;
     } catch {
       return false;
     }
@@ -169558,11 +168961,11 @@ function logWithStackHead(message, stackHead) {
   log(message, stackHead ? { stackHead } : undefined);
 }
 function getOpenCodeDbPath2() {
-  return join17(getDataDir(), "opencode", "opencode.db");
+  return join13(getDataDir(), "opencode", "opencode.db");
 }
 function openOpenCodeDb() {
   const dbPath = getOpenCodeDbPath2();
-  if (!existsSync13(dbPath)) {
+  if (!existsSync10(dbPath)) {
     log(`[key-files] OpenCode DB not found at ${dbPath} — skipping`);
     return null;
   }
@@ -169711,8 +169114,8 @@ async function runDream(args) {
       try {
         const docsDir = args.sessionDirectory ?? args.projectIdentity;
         const existingDocs = taskName === "maintain-docs" ? {
-          architecture: existsSync13(join17(docsDir, "ARCHITECTURE.md")),
-          structure: existsSync13(join17(docsDir, "STRUCTURE.md"))
+          architecture: existsSync10(join13(docsDir, "ARCHITECTURE.md")),
+          structure: existsSync10(join13(docsDir, "STRUCTURE.md"))
         } : undefined;
         const userMemories = taskName === "archive-stale" ? getActiveUserMemories(args.db).map((um) => ({
           id: um.id,
@@ -170968,7 +170371,6 @@ async function ensureProjectRegisteredFromOpenCodeDirectory(directory, db) {
 // src/plugin/event.ts
 function createEventHandler(args) {
   return async (input) => {
-    await args.autoUpdateChecker?.(input);
     await args.magicContext?.event?.(input);
   };
 }
@@ -173181,7 +172583,7 @@ async function runCompartmentPhase(args) {
   async function awaitCompartmentRun(activeRun, reason) {
     sessionLog(args.sessionId, reason);
     const timeoutMs = args.historianTimeoutMs ?? 120000;
-    const timeout = new Promise((resolve6) => setTimeout(() => resolve6("timeout"), timeoutMs));
+    const timeout = new Promise((resolve5) => setTimeout(() => resolve5("timeout"), timeoutMs));
     const result = await Promise.race([activeRun.promise.then(() => "done"), timeout]);
     if (result === "timeout") {
       sessionLog(args.sessionId, `transform: compartment await timed out after ${timeoutMs}ms — proceeding without waiting`);
@@ -174632,10 +174034,10 @@ var AUTO_SEARCH_TIMEOUT_MS = 3000;
 async function unifiedSearchWithTimeout(db, sessionId, projectPath, prompt, options, timeoutMs) {
   const controller = new AbortController;
   let timer;
-  const timeoutPromise = new Promise((resolve6) => {
+  const timeoutPromise = new Promise((resolve5) => {
     timer = setTimeout(() => {
       controller.abort();
-      resolve6(null);
+      resolve5(null);
     }, timeoutMs);
   });
   try {
@@ -176697,11 +176099,24 @@ function estimateProjectedPercentage(db, sessionId, contextUsage, preloadedTags)
 await init_read_session_db();
 
 // src/hooks/magic-context/text-complete.ts
-var LEADING_TAG_PREFIX_REGEX = /^(\u00a7\d+\u00a7\s*)+/;
-var SECTION_CHAR_REGEX = /\u00a7/g;
-function createTextCompleteHandler() {
+var DEFAULT_PATTERNS = [
+  /^(\u00a7\d+\u00a7\s*)+/,
+  /\u00a7/g
+];
+function createTextCompleteHandler(stripConfig) {
+  const isEnabled = stripConfig?.enabled ?? true;
+  let patterns;
+  if (!isEnabled) {
+    patterns = [];
+  } else if (stripConfig?.patterns && stripConfig.patterns.length > 0) {
+    patterns = stripConfig.patterns.map((src) => new RegExp(src));
+  } else {
+    patterns = DEFAULT_PATTERNS;
+  }
   return async (_input, output) => {
-    output.text = output.text.replace(LEADING_TAG_PREFIX_REGEX, "").replace(SECTION_CHAR_REGEX, "");
+    for (const regex of patterns) {
+      output.text = output.text.replace(regex, "");
+    }
   };
 }
 
@@ -176924,8 +176339,8 @@ init_send_session_notification();
 
 // src/hooks/magic-context/system-prompt-hash.ts
 import { createHash as createHash9 } from "node:crypto";
-import { existsSync as existsSync15, readFileSync as readFileSync13 } from "node:fs";
-import { join as join25 } from "node:path";
+import { existsSync as existsSync12, readFileSync as readFileSync10 } from "node:fs";
+import { join as join21 } from "node:path";
 
 // src/agents/magic-context-prompt.ts
 function getToolHistoryGuidance(dropToolStructure) {
@@ -177021,8 +176436,8 @@ await init_storage();
 
 // src/hooks/magic-context/key-files-block.ts
 init_compartment_storage();
-import { readFileSync as readFileSync12, realpathSync as realpathSync3 } from "node:fs";
-import { join as join24, sep as sep2 } from "node:path";
+import { readFileSync as readFileSync9, realpathSync as realpathSync3 } from "node:fs";
+import { join as join20, sep as sep2 } from "node:path";
 init_project_key_files();
 init_logger();
 var cachedKeyFilesBySession = new Map;
@@ -177076,13 +176491,13 @@ function buildKeyFilesBlock(db, projectPath, config2 = { enabled: true, tokenBud
     let nextStale = null;
     let observed = false;
     try {
-      const absPath = join24(projectPath, row.path);
+      const absPath = join20(projectPath, row.path);
       const real = realpathSync3(absPath);
       if (!isUnderProject(projectPath, real)) {
         nextStale = "missing";
         observed = true;
       } else {
-        const diskHash = sha256(readFileSync12(real));
+        const diskHash = sha256(readFileSync9(real));
         if (diskHash !== row.contentHash)
           nextStale = "content_drift";
         observed = true;
@@ -177166,10 +176581,10 @@ var DOC_FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
 function readProjectDocs(directory) {
   const sections = [];
   for (const filename of DOC_FILES) {
-    const filePath = join25(directory, filename);
+    const filePath = join21(directory, filename);
     try {
-      if (existsSync15(filePath)) {
-        const content = readFileSync13(filePath, "utf-8").trim();
+      if (existsSync12(filePath)) {
+        const content = readFileSync10(filePath, "utf-8").trim();
         if (content.length > 0) {
           sections.push(`<${filename}>
 ${escapeXmlContent(content)}
@@ -177676,7 +177091,7 @@ function createMagicContextHook(deps) {
   return {
     "experimental.chat.messages.transform": transform2,
     "experimental.chat.system.transform": systemPromptHashHandler,
-    "experimental.text.complete": createTextCompleteHandler(),
+    "experimental.text.complete": createTextCompleteHandler(deps.config.experimental?.text_complete_strip),
     "chat.message": createChatMessageHook({
       db,
       toolUsageSinceUserTurn,
@@ -179392,28 +178807,28 @@ init_models_dev_cache();
 // src/shared/rpc-server.ts
 init_logger();
 import {
-  mkdirSync as mkdirSync9,
+  mkdirSync as mkdirSync8,
   readdirSync,
-  readFileSync as readFileSync15,
-  renameSync as renameSync2,
+  readFileSync as readFileSync12,
+  renameSync,
   unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync8
+  writeFileSync as writeFileSync5
 } from "node:fs";
 import { createServer } from "node:http";
-import { dirname as dirname8 } from "node:path";
+import { dirname as dirname5 } from "node:path";
 
 // src/shared/rpc-utils.ts
 import { createHash as createHash10 } from "node:crypto";
-import { join as join27 } from "node:path";
+import { join as join23 } from "node:path";
 function projectHash(directory) {
   const normalized = directory.replace(/\/+$/, "");
   return createHash10("sha256").update(normalized).digest("hex").slice(0, 16);
 }
 function rpcPortDir(storageDir, directory) {
-  return join27(storageDir, "rpc", projectHash(directory));
+  return join23(storageDir, "rpc", projectHash(directory));
 }
 function rpcPortFilePath(storageDir, directory, pid = process.pid) {
-  return join27(rpcPortDir(storageDir, directory), `port-${pid}.json`);
+  return join23(rpcPortDir(storageDir, directory), `port-${pid}.json`);
 }
 function isPidAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0)
@@ -179471,7 +178886,7 @@ class MagicContextRpcServer {
     this.handlers.set(method, handler);
   }
   async start() {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve5, reject) => {
       const server = createServer((req, res) => this.dispatch(req, res));
       server.on("error", (err) => {
         log(`[rpc] server error: ${err.message}`);
@@ -179487,20 +178902,20 @@ class MagicContextRpcServer {
         this.server = server;
         try {
           this.warnIfOtherLiveInstance();
-          const dir = dirname8(this.portFilePath);
-          mkdirSync9(dir, { recursive: true });
+          const dir = dirname5(this.portFilePath);
+          mkdirSync8(dir, { recursive: true });
           const tmpPath = `${this.portFilePath}.tmp`;
-          writeFileSync8(tmpPath, JSON.stringify({
+          writeFileSync5(tmpPath, JSON.stringify({
             port: this.port,
             pid: process.pid,
             started_at: this.startedAt
           }), "utf-8");
-          renameSync2(tmpPath, this.portFilePath);
+          renameSync(tmpPath, this.portFilePath);
           log(`[rpc] server listening on 127.0.0.1:${this.port}`);
         } catch (err) {
           log(`[rpc] failed to write port file: ${err}`);
         }
-        resolve6(this.port);
+        resolve5(this.port);
       });
       server.unref();
     });
@@ -179510,7 +178925,7 @@ class MagicContextRpcServer {
       for (const entry of readdirSync(this.portDir)) {
         if (!entry.startsWith("port-") || !entry.endsWith(".json"))
           continue;
-        const record2 = parseRpcPortFile(readFileSync15(`${this.portDir}/${entry}`, "utf-8"));
+        const record2 = parseRpcPortFile(readFileSync12(`${this.portDir}/${entry}`, "utf-8"));
         if (!record2 || record2.pid === process.pid || !isPidAlive(record2.pid))
           continue;
         log(`[rpc] another Magic Context RPC server is active for this project (pid ${record2.pid}, port ${record2.port}); starting separate instance on a new port`);
@@ -179582,10 +178997,6 @@ class MagicContextRpcServer {
 // src/index.ts
 var plugin = async (ctx) => {
   const pluginConfig = loadPluginConfig(ctx.directory);
-  const autoUpdateAbort = new AbortController;
-  process.once("exit", () => {
-    autoUpdateAbort.abort();
-  });
   if (pluginConfig.configWarnings?.length) {
     for (const w of pluginConfig.configWarnings) {
       log(`[magic-context] config warning: ${w}`);
@@ -179699,12 +179110,7 @@ var plugin = async (ctx) => {
   return {
     tool: tools5,
     event: createEventHandler({
-      magicContext: hooks.magicContext,
-      autoUpdateChecker: createAutoUpdateCheckerHook(ctx, {
-        autoUpdate: pluginConfig.auto_update !== false,
-        signal: autoUpdateAbort.signal,
-        storageDir
-      })
+      magicContext: hooks.magicContext
     }),
     "experimental.chat.messages.transform": createMessagesTransformHandler({
       magicContext: hooks.magicContext