oh-my-opencode-slim 1.0.2 → 1.0.4

package/dist/index.js

@@ -6246,33 +6246,33 @@ var require_URL = __commonJS((exports, module) => {
         else
           return basepath.substring(0, lastslash + 1) + refpath;
       }
-      function remove_dot_segments(path13) {
-        if (!path13)
-          return path13;
+      function remove_dot_segments(path14) {
+        if (!path14)
+          return path14;
         var output = "";
-        while (path13.length > 0) {
-          if (path13 === "." || path13 === "..") {
-            path13 = "";
+        while (path14.length > 0) {
+          if (path14 === "." || path14 === "..") {
+            path14 = "";
             break;
           }
-          var twochars = path13.substring(0, 2);
-          var threechars = path13.substring(0, 3);
-          var fourchars = path13.substring(0, 4);
+          var twochars = path14.substring(0, 2);
+          var threechars = path14.substring(0, 3);
+          var fourchars = path14.substring(0, 4);
           if (threechars === "../") {
-            path13 = path13.substring(3);
+            path14 = path14.substring(3);
           } else if (twochars === "./") {
-            path13 = path13.substring(2);
+            path14 = path14.substring(2);
           } else if (threechars === "/./") {
-            path13 = "/" + path13.substring(3);
-          } else if (twochars === "/." && path13.length === 2) {
-            path13 = "/";
-          } else if (fourchars === "/../" || threechars === "/.." && path13.length === 3) {
-            path13 = "/" + path13.substring(4);
+            path14 = "/" + path14.substring(3);
+          } else if (twochars === "/." && path14.length === 2) {
+            path14 = "/";
+          } else if (fourchars === "/../" || threechars === "/.." && path14.length === 3) {
+            path14 = "/" + path14.substring(4);
             output = output.replace(/\/?[^\/]*$/, "");
           } else {
-            var segment = path13.match(/(\/?([^\/]*))/)[0];
+            var segment = path14.match(/(\/?([^\/]*))/)[0];
             output += segment;
-            path13 = path13.substring(segment.length);
+            path14 = path14.substring(segment.length);
           }
         }
         return output;
@@ -18316,7 +18316,7 @@ var DEFAULT_TIMEOUT_MS = 2 * 60 * 1000;
 var MAX_POLL_TIME_MS = 5 * 60 * 1000;
 var DEFAULT_MAX_SUBAGENT_DEPTH = 3;
 var PHASE_REMINDER_TEXT = `!IMPORTANT! Recall the workflow rules:
-Understand → choose the best parallelized path based on your capabilities and agents delegation rules → execute → verify.
+Understand → choose the best parallelized path based on your capabilities and agents delegation rules → recall session reuse rules → execute → verify.
 If delegating, launch the specialist in the same turn you mention it !END!`;
 var TMUX_SPAWN_DELAY_MS = 500;
 var COUNCILLOR_STAGGER_MS = 250;
@@ -18526,7 +18526,9 @@ var InterviewConfigSchema = z2.object({
   dashboard: z2.boolean().default(false)
 });
 var SessionManagerConfigSchema = z2.object({
-  maxSessionsPerAgent: z2.number().int().min(1).max(10).default(2)
+  maxSessionsPerAgent: z2.number().int().min(1).max(10).default(2),
+  readContextMinLines: z2.number().int().min(0).max(1000).default(10),
+  readContextMaxFiles: z2.number().int().min(0).max(50).default(8)
 });
 var TodoContinuationConfigSchema = z2.object({
   maxContinuations: z2.number().int().min(1).max(50).default(5).describe("Maximum consecutive auto-continuations before stopping to ask user"),
@@ -18852,14 +18854,15 @@ var AGENT_DESCRIPTIONS = {
 - **Don't delegate when:** Needs discovery/research/decisions • Single small change (<20 lines, one file) • Unclear requirements needing iteration • Explaining to fixer > doing • Tight integration with your current work • Sequential dependencies
 - **Rule of thumb:** Explaining > doing? → yourself. Test file modifications and bounded implementation work usually go to @fixer. Bigger or lots of edits, splitting makes sense, parallelized by spawning @fixers per certain scope.`,
   council: `@council
-- Role: Multi-LLM consensus engine for high-confidence answers
+- Role: Multi-LLM consensus engine that runs several councillors, synthesizes their views, and returns a structured council report.
 - Permissions: Read files
 - Stats: 3x slower than orchestrator, 3x or more cost of orchestrator
-- Capabilities: Runs multiple models in parallel, synthesizes their responses into a consensus answer
-- **Delegate when:** Critical decisions needing diverse model perspectives • High-stakes architectural choices where consensus reduces risk • Ambiguous problems where multi-model disagreement is informative • Security-sensitive design reviews
-- **Don't delegate when:** Straightforward tasks you're confident about • Speed matters more than confidence • Single-model answer is sufficient • Routine implementation work
-- **Result handling:** Present the council's synthesized response verbatim. Do not re-summarize or condense.
-- **Rule of thumb:** Need second/third opinions from different models? → @council. One good answer enough? → yourself.`,
+- Capabilities: Runs multiple models in parallel, compares their answers, resolves disagreements, and produces a final synthesized answer plus councillor details and consensus summary.
+- **Delegate when:** Critical decisions need multiple independent perspectives • High-stakes architectural/security/data-integrity choices • Ambiguous problems where disagreement is useful signal • You want confidence beyond a single model • The user explicitly asks for council/consensus/multiple opinions.
+- **Don't delegate when:** Straightforward tasks you're confident about • Speed matters more than confidence • Routine implementation/debugging • A single specialist is clearly the right tool • You only need current docs/search/code review rather than multi-model consensus.
+- **How to call:** Send the full question/task and relevant context. Be explicit about what decision, trade-off, or answer the council should resolve. Do not ask council to do routine code edits.
+- **Result handling:** Council returns a structured response that may include: synthesized Council Response, individual Councillor Details, and Council Summary/confidence. Preserve that structure when the user asked for council output. Do not pretend the council only returned a final answer. If you need to act on the council result, first briefly state the council's recommendation, then proceed.
+- **Rule of thumb:** Need second/third opinions from different models? → @council. Need one expert agent or direct execution? → use the specialist or yourself.`,
   observer: `@observer
 - Role: Visual analysis specialist for images, PDFs, and diagrams
 - Permissions: Read files
@@ -18951,10 +18954,10 @@ Balance: respect dependencies, avoid parallelizing what must be sequential.
 5. Adjust if needed
 
 ### Session Reuse
-- Reuse an available specialist session only for clear follow-up work on the same thread.
-- Prefer a fresh session for unrelated work, even with the same specialist.
+- Smartly reuse an available specialist session - constext reuse saves time and tokens
+- When too much unrelated, and really needed, start a fresh session with the specialist
 - If multiple remembered sessions fit, prefer the most recently used matching session.
-- If reuse is unclear, start a fresh session.
+- Prefer re-uses over creating new sessions all the time
 
 ### Auto-Continue
 When working through multi-step tasks, consider enabling auto-continue to avoid stopping between batches:
@@ -19042,27 +19045,47 @@ var COUNCIL_AGENT_PROMPT = `You are the Council agent — a multi-LLM orchestrat
 1. Call the \`council_session\` tool with the user's prompt
 2. Optionally specify a preset (default: "default")
 3. Receive the councillor responses formatted for synthesis
-4. Synthesize the optimal final answer from the councillor responses
-5. Present the synthesized result to the user
-
-**Synthesis Guidelines**:
-When you receive councillor responses, synthesize them into the optimal final answer:
-- Review all councillor responses thoroughly and create the best possible answer
-- Credit specific insights from individual councillors by name (e.g., "alpha noted that...", "beta suggested...")
-- Clearly explain your reasoning for the chosen approach
-- Be transparent about trade-offs when different approaches have valid pros/cons
-- Note any remaining uncertainties or areas where further investigation is needed
-- If councillors disagree, explain the resolution and your reasoning
-- Acknowledge if consensus was impossible and explain why
-- Don't just average responses — choose the best approach and improve upon it
-- Present the synthesized solution with relevant code examples, concrete details, and clear explanations
+4. Follow the Synthesis Process below
+5. Present the result to the user
+
+**Synthesis Process** (MANDATORY — follow in order):
+1. Read the original user prompt
+2. Review each councillor's response individually — note each councillor's key insight and unique contribution by name
+3. Identify agreements and contradictions between councillors
+4. Resolve contradictions with explicit reasoning
+5. Synthesize the optimal final answer
+6. Format output per the Required Output Format below
 
 **Behavior**:
 - Delegate requests directly to council_session
 - Don't pre-analyze or filter the prompt before calling council_session
-- Synthesize the councillor results into a comprehensive, coherent answer
-- Include attribution for valuable insights from specific councillors
-- If councillors disagree, explain why you chose one approach over another`;
+- Credit specific insights from individual councillors using their names
+- If councillors disagree, explain why you chose one approach over another
+- Do not omit per-councillor details from the final response
+- Do not collapse the output into only a final summary
+- Be transparent about trade-offs when different approaches have valid pros/cons
+- Don't just average responses — choose the best approach and improve upon it
+
+**Required Output Format**:
+Always include these sections in your final response:
+
+## Council Response
+Provide the best synthesized answer. Integrate the strongest points from the councillors, resolve disagreements, and give the user a clear final recommendation or answer. Include relevant code examples and concrete details.
+
+## Councillor Details
+Include each councillor's response separately.
+
+Use each councillor name exactly as provided in the tool result.
+
+Format each councillor like:
+
+### <councillor name>
+<that councillor's response>
+
+If a councillor failed or timed out, include that status briefly.
+
+## Council Summary
+Summarize where councillors agreed, where they disagreed, why you chose the final answer, and any remaining uncertainty. Include a consensus confidence rating: unanimous, majority, or split.`;
 function createCouncilAgent(model, customPrompt, customAppendPrompt) {
   const prompt = resolvePrompt(COUNCIL_AGENT_PROMPT, customPrompt, customAppendPrompt);
   const definition = {
@@ -19135,7 +19158,7 @@ ${failedSection}`;
 
 ---
 
-Synthesize the optimal response based on the above.`;
+You MUST follow the Synthesis Process steps before producing output: review each councillor response individually, then produce the required output with a synthesized Council Response, per-councillor details using their exact names, and a Council Summary with consensus confidence rating (unanimous, majority, or split).`;
   return prompt;
 }
 
@@ -19767,14 +19790,37 @@ function getDisabledAgents(config) {
   return disabled;
 }
 
+// src/config/runtime-preset.ts
+var activeRuntimePreset = null;
+function setActiveRuntimePreset(name) {
+  activeRuntimePreset = name;
+}
+function getActiveRuntimePreset() {
+  return activeRuntimePreset;
+}
+var previousRuntimePreset = null;
+function getPreviousRuntimePreset() {
+  return previousRuntimePreset;
+}
+function setActiveRuntimePresetWithPrevious(name) {
+  previousRuntimePreset = activeRuntimePreset;
+  activeRuntimePreset = name;
+}
+function rollbackRuntimePreset(previous) {
+  activeRuntimePreset = previous;
+  previousRuntimePreset = null;
+}
+
 // src/utils/logger.ts
 import * as fs2 from "node:fs";
+import { appendFile } from "node:fs/promises";
 import * as os from "node:os";
 import * as path2 from "node:path";
 var LOG_PREFIX = "oh-my-opencode-slim.";
 var LOG_SUFFIX = ".log";
 var RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
 var logFile = null;
+var writeChain = Promise.resolve();
 function getLogDir() {
   return process.env.OPENCODE_LOG_DIR ?? path2.join(os.homedir(), ".local/share/opencode");
 }
@@ -19817,10 +19863,14 @@ function initLogger(sessionId) {
     fs2.mkdirSync(dir, { recursive: true });
   } catch {}
   logFile = path2.join(dir, `${LOG_PREFIX}${sessionId}${LOG_SUFFIX}`);
+  try {
+    fs2.closeSync(fs2.openSync(logFile, "a"));
+  } catch {}
   cleanupOldLogs(dir);
 }
 function log(message, data) {
-  if (!logFile)
+  const target = logFile;
+  if (!target)
     return;
   try {
     const timestamp = new Date().toISOString();
@@ -19834,7 +19884,7 @@ function log(message, data) {
     }
     const logEntry = `[${timestamp}] ${message} ${dataStr}
 `;
-    fs2.appendFileSync(logFile, logEntry);
+    writeChain = writeChain.then(() => appendFile(target, logEntry)).catch(() => {});
   } catch {}
 }
 
@@ -20020,7 +20070,7 @@ class CouncilManager {
       }
     } else {
       const promises = entries.map(([name, config], index) => (async () => {
-        if (index > 0) {
+        if (this.tmuxEnabled && index > 0) {
           await new Promise((r) => setTimeout(r, index * COUNCILLOR_STAGGER_MS));
         }
         return this.runCouncillorWithRetry(name, config, prompt, parentSessionId, timeout, maxRetries);
@@ -20206,6 +20256,16 @@ function unexpectedPatchLine(context, line) {
   const rendered = line.length === 0 ? "<empty>" : line;
   throw new Error(`Invalid patch format: unexpected line ${context}: ${rendered}`);
 }
+function parseChangeContext(line) {
+  const context = line.slice(2);
+  if (context.length === 0) {
+    return;
+  }
+  return context.startsWith(" ") ? context.slice(1) || undefined : context;
+}
+function isPatchBoundary(line, marker) {
+  return line.trimEnd() === marker;
+}
 function parseChunks(lines, index, mode) {
   const chunks = [];
   let at = index;
@@ -20217,7 +20277,7 @@ function parseChunks(lines, index, mode) {
       at += 1;
       continue;
     }
-    const context = lines[at].slice(2).trim() || undefined;
+    const context = parseChangeContext(lines[at]);
     at += 1;
     const old_lines = [];
     const new_lines = [];
@@ -20260,12 +20320,11 @@ function parseChunks(lines, index, mode) {
   return { chunks, next: at };
 }
 function parseAdd(lines, index, mode) {
-  let contents = "";
+  const contents = [];
   let at = index;
   while (at < lines.length && !lines[at].startsWith("***")) {
     if (lines[at].startsWith("+")) {
-      contents += `${lines[at].slice(1)}
-`;
+      contents.push(lines[at].slice(1));
       at += 1;
       continue;
     }
@@ -20274,18 +20333,15 @@ function parseAdd(lines, index, mode) {
     }
     at += 1;
   }
-  if (contents.endsWith(`
-`)) {
-    contents = contents.slice(0, -1);
-  }
-  return { content: contents, next: at };
+  return { content: contents.join(`
+`), next: at };
 }
 function parsePatchInternal(patchText, mode) {
   const clean = normalizePatchText(patchText);
   const lines = clean.split(`
 `);
-  const begin = lines.findIndex((line) => line.trim() === "*** Begin Patch");
-  const end = lines.findIndex((line) => line.trim() === "*** End Patch");
+  const begin = lines.findIndex((line) => isPatchBoundary(line, "*** Begin Patch"));
+  const end = lines.findIndex((line, index2) => index2 > begin && isPatchBoundary(line, "*** End Patch"));
   if (begin === -1 || end === -1 || begin >= end) {
     throw new Error("Invalid patch format: missing Begin/End markers");
   }
@@ -20417,12 +20473,6 @@ function formatPatch(patch) {
 }
 
 // src/hooks/apply-patch/matching.ts
-var AUTO_RESCUE_COMPARATOR_NAMES = new Set([
-  "exact",
-  "unicode",
-  "trim-end",
-  "unicode-trim-end"
-]);
 function equalExact(a, b) {
   return a === b;
 }
@@ -20441,7 +20491,7 @@ function equalTrim(a, b) {
 function equalUnicodeTrim(a, b) {
   return normalizeUnicode(a.trim()) === normalizeUnicode(b.trim());
 }
-var comparatorEntries = [
+var autoRescueComparatorEntries = [
   { name: "exact", exact: true, same: equalExact },
   { name: "unicode", exact: false, same: equalUnicodeExact },
   { name: "trim-end", exact: false, same: equalTrimEnd },
@@ -20449,14 +20499,44 @@ var comparatorEntries = [
     name: "unicode-trim-end",
     exact: false,
     same: equalUnicodeTrimEnd
-  },
+  }
+];
+var comparatorEntries = [
+  ...autoRescueComparatorEntries,
   { name: "trim", exact: false, same: equalTrim },
   { name: "unicode-trim", exact: false, same: equalUnicodeTrim }
 ];
-var autoRescueComparatorEntries = comparatorEntries.filter((entry) => AUTO_RESCUE_COMPARATOR_NAMES.has(entry.name));
 var MAX_LCS_CHUNK_LINES = 48;
 var MAX_LCS_CANDIDATES = 64;
 var autoRescueComparators = autoRescueComparatorEntries.map((entry) => entry.same);
+function prepareAutoRescueTarget(target) {
+  const trimEnd = target.trimEnd();
+  const unicode = normalizeUnicode(target);
+  return {
+    exact: target,
+    unicode,
+    trimEnd,
+    unicodeTrimEnd: trimEnd === target ? unicode : normalizeUnicode(trimEnd)
+  };
+}
+function matchPreparedAutoRescueComparator(candidate, target) {
+  if (candidate === target.exact) {
+    return "exact";
+  }
+  const unicode = normalizeUnicode(candidate);
+  if (unicode === target.unicode) {
+    return "unicode";
+  }
+  const trimEnd = candidate.trimEnd();
+  if (trimEnd === target.trimEnd) {
+    return "trim-end";
+  }
+  const unicodeTrimEnd = trimEnd === candidate ? unicode : normalizeUnicode(trimEnd);
+  if (unicodeTrimEnd === target.unicodeTrimEnd) {
+    return "unicode-trim-end";
+  }
+  return;
+}
 var permissiveComparators = comparatorEntries.map((entry) => entry.same);
 function tryMatch(lines, pattern, start, comparator, eof) {
   if (eof) {
@@ -20530,6 +20610,19 @@ function list(lines, pattern, start, same) {
   }
   return out;
 }
+function lowerBound(values, target) {
+  let low = 0;
+  let high = values.length;
+  while (low < high) {
+    const middle = Math.floor((low + high) / 2);
+    if (values[middle] < target) {
+      low = middle + 1;
+      continue;
+    }
+    high = middle;
+  }
+  return low;
+}
 function sameRescueLine(a, b) {
   return equalExact(a, b) || equalUnicodeExact(a, b);
 }
@@ -20556,36 +20649,102 @@ function rescueByPrefixSuffix(lines, old_lines, new_lines, start) {
   const left = old_lines.slice(0, prefixLength);
   const right = old_lines.slice(old_lines.length - suffixLength);
   const middle = new_lines.slice(prefixLength, new_lines.length - suffixLength);
-  const hits = new Map;
+  if (left.length === 1 && right.length === 1) {
+    const { leftHits, rightHits } = collectOneLinePrefixSuffixHits(lines, left[0], right[0], start);
+    return resolvePrefixSuffixHits(leftHits, rightHits, left.length, middle);
+  }
+  const hits = new Set;
+  let hit;
   for (const same of autoRescueComparators) {
-    for (const leftIndex of list(lines, left, start, same)) {
+    const leftHits = list(lines, left, start, same);
+    if (leftHits.length === 0) {
+      continue;
+    }
+    const rightHits = list(lines, right, leftHits[0] + left.length, same);
+    if (rightHits.length === 0) {
+      continue;
+    }
+    for (const leftIndex of leftHits) {
       const from = leftIndex + left.length;
-      for (const rightIndex of list(lines, right, from, same)) {
+      for (let index = lowerBound(rightHits, from);index < rightHits.length; index += 1) {
+        const rightIndex = rightHits[index];
         const key = `${from}:${rightIndex}`;
-        hits.set(key, {
+        if (!hits.has(key)) {
+          hits.add(key);
+          hit = {
+            start: from,
+            del: rightIndex - from,
+            add: [...middle]
+          };
+        }
+        if (hits.size > 1) {
+          return { kind: "ambiguous", phase: "prefix_suffix" };
+        }
+      }
+    }
+  }
+  if (!hit) {
+    return { kind: "miss" };
+  }
+  return { kind: "match", hit };
+}
+function collectOneLinePrefixSuffixHits(lines, left, right, start) {
+  const leftTarget = prepareAutoRescueTarget(left);
+  const rightTarget = prepareAutoRescueTarget(right);
+  const leftHits = [];
+  const rightHits = [];
+  for (let index = start;index < lines.length; index += 1) {
+    const line = prepareAutoRescueTarget(lines[index]);
+    if (line.unicodeTrimEnd === leftTarget.unicodeTrimEnd) {
+      leftHits.push(index);
+    }
+    if (index > start && line.unicodeTrimEnd === rightTarget.unicodeTrimEnd) {
+      rightHits.push(index);
+    }
+  }
+  return { leftHits, rightHits };
+}
+function resolvePrefixSuffixHits(leftHits, rightHits, leftLength, middle) {
+  if (leftHits.length === 0 || rightHits.length === 0) {
+    return { kind: "miss" };
+  }
+  const hits = new Set;
+  let hit;
+  for (const leftIndex of leftHits) {
+    const from = leftIndex + leftLength;
+    for (let index = lowerBound(rightHits, from);index < rightHits.length; index += 1) {
+      const rightIndex = rightHits[index];
+      const key = `${from}:${rightIndex}`;
+      if (!hits.has(key)) {
+        hits.add(key);
+        hit = {
           start: from,
           del: rightIndex - from,
           add: [...middle]
-        });
+        };
+      }
+      if (hits.size > 1) {
+        return { kind: "ambiguous", phase: "prefix_suffix" };
       }
     }
   }
-  if (hits.size === 0) {
+  if (!hit) {
     return { kind: "miss" };
   }
-  if (hits.size > 1) {
-    return { kind: "ambiguous", phase: "prefix_suffix" };
-  }
-  return { kind: "match", hit: [...hits.values()][0] };
+  return { kind: "match", hit };
 }
 function score(a, b) {
-  const dp = Array.from({ length: a.length + 1 }, () => Array(b.length + 1).fill(0));
+  const normalizedA = a.map(normalizeLcsLine);
+  const normalizedB = b.map(normalizeLcsLine);
+  let previous = Array(b.length + 1).fill(0);
   for (let i = 1;i <= a.length; i += 1) {
+    const current = Array(b.length + 1).fill(0);
     for (let j = 1;j <= b.length; j += 1) {
-      dp[i][j] = normalizeUnicode(a[i - 1].trim()) === normalizeUnicode(b[j - 1].trim()) ? dp[i - 1][j - 1] + 1 : Math.max(dp[i - 1][j], dp[i][j - 1]);
+      current[j] = normalizedA[i - 1] === normalizedB[j - 1] ? previous[j - 1] + 1 : Math.max(previous[j], current[j - 1]);
     }
+    previous = current;
   }
-  return dp[a.length][b.length];
+  return previous[b.length];
 }
 function normalizeLcsLine(line) {
   return normalizeUnicode(line).trim();
@@ -20612,45 +20771,23 @@ function countLcsUpperBound(a, b) {
   }
   return shared;
 }
-function hasStableBorders(oldLines, candidate) {
-  if (oldLines.length === 0 || candidate.length !== oldLines.length) {
-    return false;
-  }
-  const same = autoRescueComparators.some((compare) => compare(oldLines[0], candidate[0]));
-  if (!same) {
-    return false;
-  }
-  if (oldLines.length === 1) {
-    return true;
-  }
-  return autoRescueComparators.some((compare) => compare(oldLines[oldLines.length - 1], candidate[candidate.length - 1]));
-}
 function collectBorderAnchoredStarts(lines, oldLines, start) {
   if (oldLines.length === 0) {
     return [];
   }
-  const firstHits = new Set;
-  const lastHits = new Set;
-  const lastLine = oldLines[oldLines.length - 1];
-  for (const same of autoRescueComparators) {
-    for (const index of list(lines, [oldLines[0]], start, same)) {
-      firstHits.add(index);
-    }
-    for (const index of list(lines, [lastLine], start, same)) {
-      lastHits.add(index);
-    }
-  }
   const candidates = [];
-  for (const index of [...firstHits].sort((a, b) => a - b)) {
-    const end = index + oldLines.length - 1;
-    if (end >= lines.length || !lastHits.has(end)) {
+  const firstLine = prepareAutoRescueTarget(oldLines[0]);
+  const lastLine = prepareAutoRescueTarget(oldLines[oldLines.length - 1]);
+  const lastOffset = oldLines.length - 1;
+  const maxStart = lines.length - oldLines.length;
+  for (let index = start;index <= maxStart; index += 1) {
+    const end = index + lastOffset;
+    if (matchPreparedAutoRescueComparator(lines[index], firstLine) === undefined) {
       continue;
     }
-    const candidate = lines.slice(index, index + oldLines.length);
-    if (!hasStableBorders(oldLines, candidate)) {
-      continue;
+    if (oldLines.length === 1 || matchPreparedAutoRescueComparator(lines[end], lastLine) !== undefined) {
+      candidates.push(index);
     }
-    candidates.push(index);
   }
   return candidates;
 }
@@ -20658,11 +20795,6 @@ function rescueByLcs(lines, old_lines, new_lines, start) {
   if (old_lines.length === 0 || lines.length === 0) {
     return { kind: "miss" };
   }
-  const from = start;
-  const to = lines.length - old_lines.length;
-  if (to < from) {
-    return { kind: "miss" };
-  }
   if (old_lines.length > MAX_LCS_CHUNK_LINES) {
     return { kind: "miss" };
   }
@@ -20675,9 +20807,6 @@ function rescueByLcs(lines, old_lines, new_lines, start) {
   let bestScore = 0;
   let ties = 0;
   for (const index of candidates) {
-    if (index < from || index > to) {
-      continue;
-    }
     const window2 = lines.slice(index, index + old_lines.length);
     if (countLcsUpperBound(old_lines, window2) < needed) {
       continue;
@@ -20732,26 +20861,29 @@ function resolveChunkStart(lines, chunk, start) {
   return at === -1 ? start : at + 1;
 }
 function resolveUniqueAnchor(lines, changeContext, start) {
-  const hits = new Set;
-  for (const same of autoRescueComparators) {
-    for (const index2 of list(lines, [changeContext], start, same)) {
-      hits.add(index2);
+  let matchedIndex;
+  let matchedComparator;
+  const anchorTarget = prepareAutoRescueTarget(changeContext);
+  for (let index = start;index < lines.length; index += 1) {
+    const comparator = matchPreparedAutoRescueComparator(lines[index], anchorTarget);
+    if (!comparator) {
+      continue;
+    }
+    if (matchedIndex !== undefined) {
+      return { kind: "ambiguous" };
     }
+    matchedIndex = index;
+    matchedComparator = comparator;
   }
-  if (hits.size === 0) {
+  if (matchedIndex === undefined) {
     return { kind: "missing" };
   }
-  if (hits.size > 1) {
-    return { kind: "ambiguous" };
-  }
-  const index = [...hits][0];
-  const canonicalLine = lines[index];
-  const comparator = seekMatch(lines, [changeContext], index)?.comparator;
+  const canonicalLine = lines[matchedIndex];
   return {
     kind: "match",
-    index,
+    index: matchedIndex,
     exact: canonicalLine === changeContext,
-    comparator: comparator ?? "exact",
+    comparator: matchedComparator ?? "exact",
     canonicalLine
   };
 }
@@ -20902,10 +21034,11 @@ ${chunk.change_context}`);
         old_lines: [],
         canonical_old_lines: [anchor],
         canonical_new_lines: [...chunk.new_lines, anchor],
+        canonical_change_context: anchorMatch.exact ? undefined : anchorMatch.canonicalLine,
         resolved_is_end_of_file: insertAt + 1 === lines.length,
         rewritten: true,
         strategy,
-        matchComparator: "exact"
+        matchComparator: anchorMatch.comparator
       });
       start = insertAt;
       continue;
@@ -21279,15 +21412,6 @@ function renderRewriteDependencyGroup(group, cfg) {
   }
   return group.group.chunks ? createUpdateHunk(group.group.sourcePath, group.group.chunks, group.group.outputPath !== group.group.sourcePath ? group.group.outputPath : undefined) : createCollapsedUpdateHunk(group.group.sourcePath, group.group.sourceFilePath, group.group.baseText, group.group.finalText, cfg, group.group.outputPath !== group.group.sourcePath ? group.group.outputPath : undefined);
 }
-function rewriteModeForDependentUpdate(group) {
-  if (group.kind === "add") {
-    return "collapse:add-followed-by-update";
-  }
-  if (group.group.outputPath !== group.group.sourcePath) {
-    return "collapse:move-followed-by-update";
-  }
-  return "merge:same-file-updates";
-}
 function combineDependentUpdateGroup(filePath, group, nextChunks, finalText, nextOutputPath, nextOutputFilePath, cfg) {
   if (group.kind === "add") {
     return {
@@ -21327,12 +21451,6 @@ async function rewritePatch(root, patchText, cfg, worktree) {
     const normalizedPatchText = normalizePatchText(patchText);
     const rewritten = [];
     let changed = false;
-    let rewrittenChunks = 0;
-    const rewriteModes = new Set;
-    const totalChunks = hunks.reduce((count, hunk) => count + (hunk.type === "update" ? hunk.chunks.length : 0), 0);
-    if (pathsNormalized) {
-      rewriteModes.add("normalize:patch-paths");
-    }
     const dependencyGroups = new Map;
     for (const hunk of hunks) {
       if (hunk.type === "add") {
@@ -21387,14 +21505,6 @@ async function rewritePatch(root, patchText, cfg, worktree) {
           continue;
         }
         changed = true;
-        rewrittenChunks += 1;
-        if (chunk.strategy) {
-          rewriteModes.add(chunk.strategy);
-          continue;
-        }
-        if (chunk.matchComparator && chunk.matchComparator !== "exact") {
-          rewriteModes.add(`match:${chunk.matchComparator}`);
-        }
       }
       const nextOutputPath = hunk.move_path ?? hunk.path;
       const nextOutputFilePath = movePath ?? filePath;
@@ -21402,7 +21512,6 @@ async function rewritePatch(root, patchText, cfg, worktree) {
         const nextGroup = combineDependentUpdateGroup(filePath, currentDependency, next, nextText, nextOutputPath, nextOutputFilePath, cfg);
         rewritten[currentDependency.group.index] = renderRewriteDependencyGroup(nextGroup, cfg);
         changed = true;
-        rewriteModes.add(rewriteModeForDependentUpdate(currentDependency));
         clearDependencyGroup(filePath);
         if (movePath && movePath !== filePath) {
           clearDependencyGroup(movePath);
@@ -21449,35 +21558,23 @@ async function rewritePatch(root, patchText, cfg, worktree) {
       if (pathsNormalized) {
         return {
           patchText: formatPatch({ hunks }),
-          changed: true,
-          rewrittenChunks: 0,
-          totalChunks,
-          rewriteModes: [...rewriteModes].sort()
+          changed: true
         };
       }
       if (normalizedPatchText !== patchText) {
         return {
           patchText: normalizedPatchText,
-          changed: true,
-          rewrittenChunks: 0,
-          totalChunks,
-          rewriteModes: ["normalize:patch-text"]
+          changed: true
         };
       }
       return {
         patchText,
-        changed: false,
-        rewrittenChunks: 0,
-        totalChunks,
-        rewriteModes: []
+        changed: false
       };
     }
     return {
       patchText: formatPatch({ hunks: rewritten }),
-      changed: true,
-      rewrittenChunks,
-      totalChunks,
-      rewriteModes: [...rewriteModes].sort()
+      changed: true
     };
   } catch (error) {
     throw ensureApplyPatchError(error, "Unexpected rewrite failure");
@@ -21497,30 +21594,36 @@ function createApplyPatchHook(ctx) {
       if (input.tool !== "apply_patch") {
         return;
       }
-      if (typeof output.args?.patchText !== "string") {
+      const args = output.args;
+      if (!args || typeof args.patchText !== "string") {
         return;
       }
+      const patchText = args.patchText;
       const root = input.directory || ctx.directory || process.cwd();
       const worktree = ctx.worktree || root;
       try {
-        const result = await rewritePatch(root, output.args.patchText, APPLY_PATCH_RESCUE_OPTIONS, worktree);
+        const result = await rewritePatch(root, patchText, APPLY_PATCH_RESCUE_OPTIONS, worktree);
         if (result.changed) {
-          output.args.patchText = result.patchText;
-          logHookStatus("rewrite", {
-            rewrittenChunks: result.rewrittenChunks,
-            totalChunks: result.totalChunks,
-            strategies: result.rewriteModes
-          });
+          args.patchText = result.patchText;
+          logHookStatus("rewrite");
           return;
         }
-        logHookStatus("unchanged", {
-          rewrittenChunks: 0,
-          totalChunks: result.totalChunks
-        });
+        logHookStatus("unchanged");
         return;
       } catch (error) {
         const normalizedError = isApplyPatchError(error) ? error : createApplyPatchInternalError(`Unexpected hook failure before native apply: ${error instanceof Error ? error.message : String(error)}`, error);
         const details = getApplyPatchErrorDetails(normalizedError);
+        if (normalizedError.kind === "blocked" && details?.code === "outside_workspace") {
+          logHookStatus("skipped", {
+            kind: details.kind,
+            code: details.code,
+            reason: normalizedError.message,
+            failOpen: true,
+            rescueOptions: APPLY_PATCH_RESCUE_OPTIONS,
+            rewriteStage: "before-native"
+          });
+          return;
+        }
         logHookStatus(isApplyPatchVerificationError(normalizedError) ? "verification" : normalizedError.kind === "validation" ? "validation" : normalizedError.kind === "internal" ? "internal" : "blocked", {
           kind: details?.kind ?? "internal",
           code: details?.code ?? "internal_unexpected",
@@ -22036,11 +22139,8 @@ function resolveRuntimeAgentName(config, agentName) {
 function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function rewriteDisplayNameMentions(config, text) {
-  if (!text.includes("@")) {
-    return text;
-  }
-  let rewritten = text;
+function createDisplayNameMentionRewriter(config) {
+  const replacements = [];
   for (const internalName of getRuntimeAgentNames(config)) {
     const displayName = getAgentOverride(config, internalName)?.displayName;
     if (!displayName) {
@@ -22050,9 +22150,24 @@ function rewriteDisplayNameMentions(config, text) {
     if (!normalizedDisplayName || normalizedDisplayName === internalName) {
       continue;
     }
-    rewritten = rewritten.replace(new RegExp(`(^|[^\\w.])@${escapeRegExp2(normalizedDisplayName)}\\b`, "g"), `$1@${internalName}`);
+    replacements.push({
+      regex: new RegExp(`(^|[^\\w.])@${escapeRegExp2(normalizedDisplayName)}\\b`, "g"),
+      internalName
+    });
   }
-  return rewritten;
+  if (replacements.length === 0) {
+    return (text) => text;
+  }
+  return (text) => {
+    if (!text.includes("@")) {
+      return text;
+    }
+    let rewritten = text;
+    for (const replacement of replacements) {
+      rewritten = rewritten.replace(replacement.regex, `$1@${replacement.internalName}`);
+    }
+    return rewritten;
+  };
 }
 // src/utils/internal-initiator.ts
 var SLIM_INTERNAL_INITIATOR_MARKER = "<!-- SLIM_INTERNAL_INITIATOR -->";
@@ -22076,6 +22191,8 @@ function hasInternalInitiatorMarker(part) {
   return part.text.includes(SLIM_INTERNAL_INITIATOR_MARKER);
 }
 // src/utils/session-manager.ts
+var MIN_CONTEXT_FILE_LINES = 10;
+var MAX_CONTEXT_FILES_PER_SESSION = 8;
 function aliasPrefix(agentType) {
   switch (agentType) {
     case "explorer":
@@ -22115,11 +22232,15 @@ function deriveTaskSessionLabel(input) {
 
 class SessionManager {
   maxSessionsPerAgent;
+  readContextMinLines;
+  readContextMaxFiles;
   sessionsByParent = new Map;
   nextAliasIndexByParent = new Map;
   orderCounter = 0;
-  constructor(maxSessionsPerAgent) {
+  constructor(maxSessionsPerAgent, options = {}) {
     this.maxSessionsPerAgent = maxSessionsPerAgent;
+    this.readContextMinLines = options.readContextMinLines ?? MIN_CONTEXT_FILE_LINES;
+    this.readContextMaxFiles = options.readContextMaxFiles ?? MAX_CONTEXT_FILES_PER_SESSION;
   }
   remember(input) {
     const now = this.nextOrder();
@@ -22138,6 +22259,7 @@ class SessionManager {
       taskId: input.taskId,
       agentType: input.agentType,
       label: input.label,
+      contextFiles: [],
       createdAt: now,
       lastUsedAt: now
     };
@@ -22171,6 +22293,39 @@ class SessionManager {
       }
     }
   }
+  taskIds() {
+    const ids = new Set;
+    for (const groups of this.sessionsByParent.values()) {
+      for (const group of groups.values()) {
+        for (const entry of group) {
+          ids.add(entry.taskId);
+        }
+      }
+    }
+    return ids;
+  }
+  addContext(taskId, files) {
+    if (files.length === 0)
+      return;
+    for (const groups of this.sessionsByParent.values()) {
+      for (const group of groups.values()) {
+        const match = group.find((entry) => entry.taskId === taskId);
+        if (!match)
+          continue;
+        const existing = new Map(match.contextFiles.map((file) => [file.path, file]));
+        for (const file of files) {
+          const previous = existing.get(file.path);
+          if (previous) {
+            previous.lineCount = Math.max(previous.lineCount, file.lineCount);
+            previous.lastReadAt = Math.max(previous.lastReadAt, file.lastReadAt);
+            continue;
+          }
+          match.contextFiles.push({ ...file });
+        }
+        this.trimContextFiles(match);
+      }
+    }
+  }
   clearParent(parentSessionId) {
     this.sessionsByParent.delete(parentSessionId);
     this.nextAliasIndexByParent.delete(parentSessionId);
@@ -22182,7 +22337,17 @@ class SessionManager {
     const lines = [...groups.entries()].map(([agentType, entries]) => [
       agentType,
       [...entries].sort((a, b) => b.lastUsedAt - a.lastUsedAt)
-    ]).filter(([, entries]) => entries.length > 0).sort((a, b) => b[1][0].lastUsedAt - a[1][0].lastUsedAt).map(([agentType, entries]) => `- ${agentType}: ${entries.map((entry) => `${entry.alias} ${entry.label}`).join("; ")}`);
+    ]).filter(([, entries]) => entries.length > 0).sort((a, b) => b[1][0].lastUsedAt - a[1][0].lastUsedAt).map(([agentType, entries]) => [
+      `- ${agentType}: ${entries.map((entry) => `${entry.alias} ${entry.label}`).join("; ")}`,
+      ...entries.map((entry) => [
+        entry,
+        formatContextFiles(entry.contextFiles, {
+          minLines: this.readContextMinLines,
+          maxFiles: this.readContextMaxFiles
+        })
+      ]).filter(([, context]) => context.length > 0).map(([entry, context]) => `  Context read by ${entry.alias}: ${context}`)
+    ].join(`
+`));
     if (lines.length === 0)
       return;
     return [
@@ -22236,11 +22401,25 @@ class SessionManager {
       group.length = this.maxSessionsPerAgent;
     }
   }
+  trimContextFiles(entry) {
+    if (this.readContextMaxFiles === 0) {
+      entry.contextFiles = [];
+      return;
+    }
+    entry.contextFiles = entry.contextFiles.filter((file) => file.lineCount >= this.readContextMinLines).sort((a, b) => b.lastReadAt - a.lastReadAt).slice(0, this.readContextMaxFiles + 1);
+  }
   nextOrder() {
     this.orderCounter += 1;
     return this.orderCounter;
   }
 }
+function formatContextFiles(files, options) {
+  const eligible = files.filter((file) => file.lineCount >= options.minLines).sort((a, b) => b.lastReadAt - a.lastReadAt);
+  const shown = eligible.slice(0, options.maxFiles);
+  const rest = eligible.length - shown.length;
+  const rendered = shown.map((file) => `${file.path} (${file.lineCount} lines)`);
+  return `${rendered.join(", ")}${rest > 0 ? ` (+${rest} more)` : ""}`;
+}
 // src/utils/task.ts
 function parseTaskIdFromTaskOutput(output) {
   const lines = output.split(/\r?\n/);
@@ -22542,6 +22721,17 @@ ${allowedEntries.map((entry) => entry.block).join(`
   });
 }
 function createFilterAvailableSkillsHook(_ctx, config) {
+  const permissionRulesByAgent = new Map;
+  const getPermissionRules = (agentName) => {
+    const cached = permissionRulesByAgent.get(agentName);
+    if (cached) {
+      return cached;
+    }
+    const configuredSkills = getAgentOverride(config, agentName)?.skills;
+    const permissionRules = getSkillPermissionsForAgent(agentName, configuredSkills);
+    permissionRulesByAgent.set(agentName, permissionRules);
+    return permissionRules;
+  };
   return {
     "experimental.chat.messages.transform": async (_input, output) => {
       const { messages } = output;
@@ -22549,8 +22739,7 @@ function createFilterAvailableSkillsHook(_ctx, config) {
         return;
       }
       const agentName = getCurrentAgent(messages);
-      const configuredSkills = getAgentOverride(config, agentName)?.skills;
-      const permissionRules = getSkillPermissionsForAgent(agentName, configuredSkills);
+      const permissionRules = getPermissionRules(agentName);
       for (const message of messages) {
         for (const part of message.parts) {
           if (part.type !== "text" || !part.text || !part.text.includes("<available_skills>")) {
@@ -22903,7 +23092,21 @@ function processImageAttachments(args) {
   const observerEnabled = !disabledAgents.has("observer");
   if (!observerEnabled)
     return;
+  const messagesWithImages = [];
+  for (const msg of messages) {
+    if (msg.info.role !== "user")
+      continue;
+    const imageParts = msg.parts.filter(isImagePart);
+    if (imageParts.length > 0) {
+      messagesWithImages.push({ msg, imageParts });
+    }
+  }
   const saveDir = join7(workDir, ".opencode", "images");
+  if (messagesWithImages.length === 0) {
+    if (existsSync4(saveDir))
+      cleanupAllSessions(saveDir);
+    return;
+  }
   const gitignorePath = join7(workDir, ".opencode", ".gitignore");
   try {
     mkdirSync2(saveDir, { recursive: true });
@@ -22914,12 +23117,7 @@ function processImageAttachments(args) {
     log2(`[image-hook] failed to create image directory: ${e}`);
   }
   cleanupAllSessions(saveDir);
-  for (const msg of messages) {
-    if (msg.info.role !== "user")
-      continue;
-    const imageParts = msg.parts.filter(isImagePart);
-    if (imageParts.length === 0)
-      continue;
+  for (const { msg, imageParts } of messagesWithImages) {
     const sessionSubdir = msg.info.sessionID ? sanitizeFilename(msg.info.sessionID) : undefined;
     const targetDir = sessionSubdir ? join7(saveDir, sessionSubdir) : saveDir;
     try {
@@ -23007,7 +23205,7 @@ ${JSON_ERROR_REMINDER}`;
   };
 }
 // src/hooks/phase-reminder/index.ts
-var PHASE_REMINDER = `<reminder>${PHASE_REMINDER_TEXT}</reminder>`;
+var PHASE_REMINDER = `<internal_reminder>${PHASE_REMINDER_TEXT}</internal_reminder>`;
 function createPhaseReminderHook() {
   return {
     "experimental.chat.messages.transform": async (_input, output) => {
@@ -23038,11 +23236,14 @@ function createPhaseReminderHook() {
       if (originalText.includes(SLIM_INTERNAL_INITIATOR_MARKER)) {
         return;
       }
-      lastUserMessage.parts[textPartIndex].text = `${PHASE_REMINDER}
+      if (originalText.includes(PHASE_REMINDER)) {
+        return;
+      }
+      lastUserMessage.parts[textPartIndex].text = `${originalText}
 
 ---
 
-${originalText}`;
+${PHASE_REMINDER}`;
     }
   };
 }
@@ -23050,36 +23251,36 @@ ${originalText}`;
 var POST_FILE_TOOL_NUDGE = PHASE_REMINDER_TEXT;
 var FILE_TOOLS = new Set(["Read", "read", "Write", "write"]);
 function createPostFileToolNudgeHook(options = {}) {
-  const pendingSessionIds = new Set;
+  function appendReminder(output) {
+    if (typeof output.output !== "string") {
+      return;
+    }
+    if (output.output.includes(POST_FILE_TOOL_NUDGE)) {
+      return;
+    }
+    output.output = [
+      output.output,
+      "",
+      "<internal_reminder>",
+      POST_FILE_TOOL_NUDGE,
+      "</internal_reminder>"
+    ].join(`
+`);
+  }
   return {
-    "tool.execute.after": async (input, _output) => {
+    "tool.execute.after": async (input, output) => {
       if (!FILE_TOOLS.has(input.tool) || !input.sessionID) {
         return;
       }
-      pendingSessionIds.add(input.sessionID);
-    },
-    "experimental.chat.system.transform": async (input, output) => {
-      if (!input.sessionID || !pendingSessionIds.delete(input.sessionID)) {
-        return;
-      }
       if (options.shouldInject && !options.shouldInject(input.sessionID)) {
         return;
       }
-      output.system.push(POST_FILE_TOOL_NUDGE);
-    },
-    event: async (input) => {
-      if (input.event.type !== "session.deleted") {
-        return;
-      }
-      const sessionID = input.event.properties?.sessionID ?? input.event.properties?.info?.id;
-      if (!sessionID) {
-        return;
-      }
-      pendingSessionIds.delete(sessionID);
+      appendReminder(output);
     }
   };
 }
 // src/hooks/task-session-manager/index.ts
+import path8 from "node:path";
 var AGENT_NAME_SET = new Set([
   "orchestrator",
   "oracle",
@@ -23092,16 +23293,97 @@ var AGENT_NAME_SET = new Set([
   "councillor"
 ]);
 var MAX_PENDING_TASK_CALLS = 100;
+var RESUMABLE_SESSIONS_START = "<resumable_sessions>";
+var RESUMABLE_SESSIONS_END = "</resumable_sessions>";
 function isAgentName(value) {
   return typeof value === "string" && AGENT_NAME_SET.has(value);
 }
 function isObjectRecord(value) {
   return typeof value === "object" && value !== null;
 }
+function extractPath(output) {
+  return /<path>([^<]+)<\/path>/.exec(output)?.[1];
+}
+function normalizePath(root, file) {
+  const relative = path8.relative(root, file);
+  if (!relative || relative.startsWith("..") || path8.isAbsolute(relative)) {
+    return file;
+  }
+  return relative;
+}
+function extractReadFiles(root, output) {
+  if (typeof output.output !== "string")
+    return [];
+  const file = extractPath(output.output);
+  if (!file)
+    return [];
+  return [
+    {
+      path: normalizePath(root, file),
+      lineCount: countReadLines(output.output).length,
+      lineNumbers: countReadLines(output.output),
+      lastReadAt: Date.now()
+    }
+  ];
+}
+function countReadLines(output) {
+  const lines = new Set;
+  for (const match of output.matchAll(/^([0-9]+):/gm)) {
+    lines.add(Number(match[1]));
+  }
+  return [...lines];
+}
 function createTaskSessionManagerHook(_ctx, options) {
-  const sessionManager = new SessionManager(options.maxSessionsPerAgent);
+  const sessionManager = new SessionManager(options.maxSessionsPerAgent, {
+    readContextMinLines: options.readContextMinLines,
+    readContextMaxFiles: options.readContextMaxFiles
+  });
   const pendingCalls = new Map;
   const pendingCallOrder = [];
+  const contextByTask = new Map;
+  const pendingManagedTaskIds = new Set;
+  function addTaskContext(taskId, files) {
+    if (files.length === 0)
+      return;
+    let context = contextByTask.get(taskId);
+    if (!context) {
+      context = new Map;
+      contextByTask.set(taskId, context);
+    }
+    for (const file of files) {
+      const pending = context.get(file.path) ?? {
+        path: file.path,
+        lines: new Set,
+        lastReadAt: file.lastReadAt
+      };
+      for (const line of file.lineNumbers ?? []) {
+        pending.lines.add(line);
+      }
+      pending.lastReadAt = Math.max(pending.lastReadAt, file.lastReadAt);
+      context.set(file.path, pending);
+    }
+    sessionManager.addContext(taskId, contextFilesForPrompt(context));
+  }
+  function contextFilesForPrompt(context) {
+    if (!context)
+      return [];
+    return [...context.values()].map((file) => ({
+      path: file.path,
+      lineCount: file.lines.size,
+      lastReadAt: file.lastReadAt
+    }));
+  }
+  function canTrackTaskContext(taskId) {
+    return pendingManagedTaskIds.has(taskId) || sessionManager.taskIds().has(taskId);
+  }
+  function pruneContext() {
+    const remembered = sessionManager.taskIds();
+    for (const taskId of contextByTask.keys()) {
+      if (!pendingManagedTaskIds.has(taskId) && !remembered.has(taskId)) {
+        contextByTask.delete(taskId);
+      }
+    }
+  }
   function isMissingRememberedSessionError(output) {
     const firstLine = output.split(/\r?\n/, 1)[0]?.trim().toLowerCase() ?? "";
     return firstLine.startsWith("[error]") && firstLine.includes("session") && (firstLine.includes("not found") || firstLine.includes("no session"));
@@ -23167,6 +23449,7 @@ function createTaskSessionManagerHook(_ctx, options) {
         return;
       }
       args.task_id = remembered.taskId;
+      pendingManagedTaskIds.add(remembered.taskId);
       sessionManager.markUsed(input.sessionID, args.subagent_type, remembered.taskId);
       if (input.callID) {
         rememberPendingCall({
@@ -23179,6 +23462,12 @@ function createTaskSessionManagerHook(_ctx, options) {
       }
     },
     "tool.execute.after": async (input, output) => {
+      if (input.tool.toLowerCase() === "read") {
+        if (input.sessionID && canTrackTaskContext(input.sessionID)) {
+          addTaskContext(input.sessionID, extractReadFiles(_ctx.directory, output));
+        }
+        return;
+      }
       if (input.tool.toLowerCase() !== "task")
         return;
       const pending = takePendingCall(input.callID);
@@ -23200,17 +23489,50 @@ function createTaskSessionManagerHook(_ctx, options) {
         agentType: pending.agentType,
         label: pending.label
       });
+      pendingManagedTaskIds.delete(taskId);
+      const contextFiles = contextFilesForPrompt(contextByTask.get(taskId));
+      sessionManager.addContext(taskId, contextFiles);
+      pruneContext();
     },
-    "experimental.chat.system.transform": async (input, output) => {
-      if (!input.sessionID || !options.shouldManageSession(input.sessionID)) {
+    "experimental.chat.messages.transform": async (_input, output) => {
+      for (let i = output.messages.length - 1;i >= 0; i -= 1) {
+        const message = output.messages[i];
+        if (message.info.role !== "user")
+          continue;
+        if (message.info.agent && message.info.agent !== "orchestrator")
+          return;
+        if (!message.info.sessionID || !options.shouldManageSession(message.info.sessionID)) {
+          return;
+        }
+        const reminder = sessionManager.formatForPrompt(message.info.sessionID);
+        if (!reminder)
+          return;
+        const textPart = message.parts.find((part) => part.type === "text" && typeof part.text === "string");
+        if (!textPart)
+          return;
+        if (textPart.text?.includes(SLIM_INTERNAL_INITIATOR_MARKER))
+          return;
+        if (textPart.text?.includes(RESUMABLE_SESSIONS_START))
+          return;
+        textPart.text = [
+          textPart.text ?? "",
+          "",
+          RESUMABLE_SESSIONS_START,
+          reminder,
+          RESUMABLE_SESSIONS_END
+        ].join(`
+`);
         return;
       }
-      const reminder = sessionManager.formatForPrompt(input.sessionID);
-      if (!reminder)
-        return;
-      output.system.push(reminder);
     },
     event: async (input) => {
+      if (input.event.type === "session.created") {
+        const info = input.event.properties?.info;
+        if (info?.id && info.parentID && options.shouldManageSession(info.parentID)) {
+          pendingManagedTaskIds.add(info.id);
+        }
+        return;
+      }
       if (input.event.type !== "session.deleted")
         return;
       const sessionId = input.event.properties?.info?.id ?? input.event.properties?.sessionID;
@@ -23218,6 +23540,9 @@ function createTaskSessionManagerHook(_ctx, options) {
         return;
       sessionManager.clearParent(sessionId);
       sessionManager.dropTask(sessionId);
+      contextByTask.delete(sessionId);
+      pendingManagedTaskIds.delete(sessionId);
+      pruneContext();
       for (const [callId, pending] of pendingCalls.entries()) {
         if (pending.parentSessionId !== sessionId) {
           continue;
@@ -23263,7 +23588,7 @@ function createTodoHygiene(options) {
     handleRequestStart(input) {
       clear(input.sessionID);
     },
-    async handleToolExecuteAfter(input) {
+    async handleToolExecuteAfter(input, _output) {
       if (!input.sessionID) {
         return;
       }
@@ -23273,6 +23598,10 @@ function createTodoHygiene(options) {
       }
       try {
         if (RESET.has(tool)) {
+          if (options.shouldInject && !options.shouldInject(input.sessionID)) {
+            clear(input.sessionID);
+            return;
+          }
           active.add(input.sessionID);
           clearCycle(input.sessionID);
           const state2 = await options.getTodoState(input.sessionID);
@@ -23331,39 +23660,22 @@ function createTodoHygiene(options) {
         });
       }
     },
-    async handleChatSystemTransform(input, output) {
-      if (!input.sessionID) {
-        return;
-      }
-      const reasons = pending.get(input.sessionID);
+    getPendingReminder(sessionID) {
+      const reasons = pending.get(sessionID);
       if (!reasons || reasons.size === 0) {
-        return;
-      }
-      const reminder = pick(reasons);
-      if (options.shouldInject && !options.shouldInject(input.sessionID)) {
-        clear(input.sessionID);
-        return;
+        return null;
       }
-      try {
-        const state = await options.getTodoState(input.sessionID);
-        if (!state.hasOpenTodos) {
-          clear(input.sessionID);
-          return;
-        }
-        pending.delete(input.sessionID);
-        output.system.push(reminder);
-        options.log?.("Injected todo hygiene reminder", {
-          sessionID: input.sessionID,
-          reminder,
-          reasons: Array.from(reasons)
-        });
-      } catch (error) {
-        pending.delete(input.sessionID);
-        options.log?.("Skipped todo hygiene reminder: failed to inspect todos", {
-          sessionID: input.sessionID,
-          error: error instanceof Error ? error.message : String(error)
-        });
+      if (options.shouldInject && !options.shouldInject(sessionID)) {
+        clear(sessionID);
+        return null;
       }
+      const reminder = pick(reasons);
+      options.log?.("Read todo hygiene reminder", {
+        sessionID,
+        reminder,
+        reasons: Array.from(reasons)
+      });
+      return reminder;
     },
     handleEvent(event) {
       if (event.type !== "session.deleted") {
@@ -23382,6 +23694,8 @@ function createTodoHygiene(options) {
 var HOOK_NAME = "todo-continuation";
 var COMMAND_NAME = "auto-continue";
 var CONTINUATION_PROMPT = "[Auto-continue: enabled - there are incomplete todos remaining. Continue with the next uncompleted item. Press Esc to cancel. If you need user input or review for the next item, ask instead of proceeding.]";
+var TODO_HYGIENE_INSTRUCTION_OPEN = '<instruction name="todo_hygiene">';
+var TODO_HYGIENE_INSTRUCTION_CLOSE = "</instruction>";
 var SUPPRESS_AFTER_ABORT_MS = 5000;
 var NOTIFICATION_BUSY_GRACE_MS = 250;
 var QUESTION_PHRASES = [
@@ -23419,6 +23733,35 @@ function resetState(state) {
   state.notifyingSessionIds.clear();
   state.notificationBusyUntilBySession.clear();
 }
+function stripTodoHygieneInstruction(text) {
+  const trimmed = text.trimEnd();
+  if (!trimmed.endsWith(TODO_HYGIENE_INSTRUCTION_CLOSE)) {
+    return trimmed;
+  }
+  const start = trimmed.lastIndexOf(TODO_HYGIENE_INSTRUCTION_OPEN);
+  if (start === -1) {
+    return trimmed;
+  }
+  return trimmed.slice(0, start).trimEnd();
+}
+function appendTodoHygieneInstruction(message, reminder) {
+  const textPart = [...message.parts].reverse().find((part) => part.type === "text" && typeof part.text === "string");
+  if (!textPart)
+    return;
+  const baseText = stripTodoHygieneInstruction(textPart.text ?? "");
+  const instruction = `${TODO_HYGIENE_INSTRUCTION_OPEN}
+${reminder}
+${TODO_HYGIENE_INSTRUCTION_CLOSE}`;
+  textPart.text = baseText ? `${baseText}
+
+${instruction}` : instruction;
+}
+function stripTodoHygieneInstructionFromMessage(message) {
+  const textPart = [...message.parts].reverse().find((part) => part.type === "text" && typeof part.text === "string");
+  if (!textPart)
+    return;
+  textPart.text = stripTodoHygieneInstruction(textPart.text ?? "");
+}
 function createTodoContinuationHook(ctx, config) {
   const maxContinuations = config?.maxContinuations ?? 5;
   const cooldownMs = config?.cooldownMs ?? 3000;
@@ -23494,7 +23837,8 @@ function createTodoContinuationHook(ctx, config) {
       const sessionID = inferSessionID(messages, i);
       const partSignature = message.parts.map((part) => {
         if (part.type === "text" && typeof part.text === "string") {
-          return `${part.type}:${part.text.includes(SLIM_INTERNAL_INITIATOR_MARKER) ? "<internal>" : part.text.trim()}`;
+          const text = stripTodoHygieneInstruction(part.text);
+          return `${part.type}:${text.includes(SLIM_INTERNAL_INITIATOR_MARKER) ? "<internal>" : text.trim()}`;
         }
         return part.type ?? "unknown";
       }).join("|");
@@ -23502,6 +23846,7 @@ function createTodoContinuationHook(ctx, config) {
       return {
         sessionID,
         agent: message.info.agent,
+        message,
         signature: message.info.id ? `${message.info.id}:${partSignature}` : `${ordinal}:${partSignature}`
       };
     }
@@ -23529,9 +23874,16 @@ function createTodoContinuationHook(ctx, config) {
       return;
     }
     if (requestSignatureBySession.get(lastUserMessage.sessionID) === lastUserMessage.signature) {
+      const reminder = hygiene.getPendingReminder(lastUserMessage.sessionID);
+      if (reminder) {
+        appendTodoHygieneInstruction(lastUserMessage.message, reminder);
+      } else {
+        stripTodoHygieneInstructionFromMessage(lastUserMessage.message);
+      }
       return;
     }
     requestSignatureBySession.set(lastUserMessage.sessionID, lastUserMessage.signature);
+    stripTodoHygieneInstructionFromMessage(lastUserMessage.message);
     hygiene.handleRequestStart({ sessionID: lastUserMessage.sessionID });
   }
   function markNotificationStarted(sessionID) {
@@ -23881,7 +24233,6 @@ function createTodoContinuationHook(ctx, config) {
   return {
     tool: { auto_continue: autoContinue },
     handleToolExecuteAfter: hygiene.handleToolExecuteAfter,
-    handleChatSystemTransform: hygiene.handleChatSystemTransform,
     handleMessagesTransform,
     handleEvent,
     handleChatMessage,
@@ -23889,7 +24240,7 @@ function createTodoContinuationHook(ctx, config) {
   };
 }
 // src/interview/manager.ts
-import path11 from "node:path";
+import path12 from "node:path";
 
 // src/interview/dashboard.ts
 import crypto from "node:crypto";
@@ -23899,27 +24250,27 @@ import {
   createServer
 } from "node:http";
 import os3 from "node:os";
-import path9 from "node:path";
+import path10 from "node:path";
 import { URL as URL2 } from "node:url";
 
 // src/interview/document.ts
 import * as fsSync from "node:fs";
 import * as fs6 from "node:fs/promises";
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 var DEFAULT_OUTPUT_FOLDER = "interview";
 function normalizeOutputFolder(outputFolder) {
   const normalized = outputFolder.trim().replace(/^\/+|\/+$/g, "");
   return normalized || DEFAULT_OUTPUT_FOLDER;
 }
 function createInterviewDirectoryPath(directory, outputFolder) {
-  return path8.join(directory, normalizeOutputFolder(outputFolder));
+  return path9.join(directory, normalizeOutputFolder(outputFolder));
 }
 function createInterviewFilePath(directory, outputFolder, idea) {
   const fileName = `${slugify(idea) || "interview"}.md`;
-  return path8.join(createInterviewDirectoryPath(directory, outputFolder), fileName);
+  return path9.join(createInterviewDirectoryPath(directory, outputFolder), fileName);
 }
 function relativeInterviewPath(directory, filePath) {
-  return path8.relative(directory, filePath) || path8.basename(filePath);
+  return path9.relative(directory, filePath) || path9.basename(filePath);
 }
 function resolveExistingInterviewPath(directory, outputFolder, value) {
   const trimmed = value.trim();
@@ -23928,22 +24279,22 @@ function resolveExistingInterviewPath(directory, outputFolder, value) {
   }
   const outputDir = createInterviewDirectoryPath(directory, outputFolder);
   const candidates = new Set;
-  const resolvedRoot = path8.resolve(directory);
-  if (path8.isAbsolute(trimmed)) {
+  const resolvedRoot = path9.resolve(directory);
+  if (path9.isAbsolute(trimmed)) {
     candidates.add(trimmed);
   } else {
-    candidates.add(path8.resolve(directory, trimmed));
-    candidates.add(path8.join(outputDir, trimmed));
+    candidates.add(path9.resolve(directory, trimmed));
+    candidates.add(path9.join(outputDir, trimmed));
     if (!trimmed.endsWith(".md")) {
-      candidates.add(path8.join(outputDir, `${trimmed}.md`));
+      candidates.add(path9.join(outputDir, `${trimmed}.md`));
     }
   }
   for (const candidate of candidates) {
-    if (path8.extname(candidate) !== ".md") {
+    if (path9.extname(candidate) !== ".md") {
       continue;
     }
-    const resolved = path8.resolve(candidate);
-    if (!resolved.startsWith(resolvedRoot + path8.sep) && resolved !== resolvedRoot) {
+    const resolved = path9.resolve(candidate);
+    if (!resolved.startsWith(resolvedRoot + path9.sep) && resolved !== resolvedRoot) {
       continue;
     }
     if (fsSync.existsSync(candidate)) {
@@ -24023,7 +24374,7 @@ function parseFrontmatter(content) {
   return result;
 }
 async function ensureInterviewFile(record) {
-  await fs6.mkdir(path8.dirname(record.markdownPath), { recursive: true });
+  await fs6.mkdir(path9.dirname(record.markdownPath), { recursive: true });
   try {
     await fs6.access(record.markdownPath);
   } catch {
@@ -25693,12 +26044,12 @@ function renderInterviewPage(interviewId, resumeSlug) {
 
 // src/interview/dashboard.ts
 function getAuthFilePath(port) {
-  const dataHome = process.env.XDG_DATA_HOME || path9.join(os3.homedir(), ".local", "share");
-  return path9.join(dataHome, "opencode", `.dashboard-${port}.json`);
+  const dataHome = process.env.XDG_DATA_HOME || path10.join(os3.homedir(), ".local", "share");
+  return path10.join(dataHome, "opencode", `.dashboard-${port}.json`);
 }
 function writeAuthFile(port, token) {
   const filePath = getAuthFilePath(port);
-  const dir = path9.dirname(filePath);
+  const dir = path10.dirname(filePath);
   try {
     fsSync2.mkdirSync(dir, { recursive: true });
   } catch {}
@@ -25835,7 +26186,7 @@ function createDashboardServer(config) {
     const directories = getKnownDirectories();
     const items = [];
     for (const dir of directories) {
-      const interviewDir = path9.join(dir, config.outputFolder);
+      const interviewDir = path10.join(dir, config.outputFolder);
       let entries;
       try {
         entries = await fs7.readdir(interviewDir);
@@ -25847,7 +26198,7 @@ function createDashboardServer(config) {
           continue;
         let content;
         try {
-          content = await fs7.readFile(path9.join(interviewDir, entry), "utf8");
+          content = await fs7.readFile(path10.join(interviewDir, entry), "utf8");
         } catch {
           continue;
         }
@@ -25873,7 +26224,7 @@ function createDashboardServer(config) {
     const directories = getKnownDirectories();
     let rebuilt = 0;
     for (const dir of directories) {
-      const interviewDir = path9.join(dir, config.outputFolder);
+      const interviewDir = path10.join(dir, config.outputFolder);
       let entries;
       try {
         entries = await fs7.readdir(interviewDir);
@@ -25885,7 +26236,7 @@ function createDashboardServer(config) {
           continue;
         let content;
         try {
-          content = await fs7.readFile(path9.join(interviewDir, entry), "utf8");
+          content = await fs7.readFile(path10.join(interviewDir, entry), "utf8");
         } catch {
           continue;
         }
@@ -25911,7 +26262,7 @@ function createDashboardServer(config) {
           questions: [],
           pendingAnswers: null,
           lastUpdatedAt: fm.updatedAt ? new Date(fm.updatedAt).getTime() : Date.now(),
-          filePath: path9.join(interviewDir, entry),
+          filePath: path10.join(interviewDir, entry),
           nudgeAction: null
         });
         if (!sessions.has(fm.sessionID)) {
@@ -26175,7 +26526,7 @@ function createDashboardServer(config) {
         const dirs = getKnownDirectories();
         for (const dir of dirs) {
           const slug = extractResumeSlug(interviewId);
-          const candidate = path9.join(dir, config.outputFolder, `${slug}.md`);
+          const candidate = path10.join(dir, config.outputFolder, `${slug}.md`);
           try {
             document = await fs7.readFile(candidate, "utf8");
             markdownPath = candidate;
@@ -26703,7 +27054,7 @@ function createInterviewServer(deps) {
 // src/interview/service.ts
 import { spawn } from "node:child_process";
 import * as fs8 from "node:fs/promises";
-import * as path10 from "node:path";
+import * as path11 from "node:path";
 
 // src/interview/types.ts
 import { z as z3 } from "zod";
@@ -26970,12 +27321,12 @@ function createInterviewService(ctx, config, deps) {
     if (!newSlug) {
       return;
     }
-    const currentFileName = path10.basename(interview.markdownPath, ".md");
+    const currentFileName = path11.basename(interview.markdownPath, ".md");
     if (currentFileName === newSlug) {
       return;
     }
-    const dir = path10.dirname(interview.markdownPath);
-    const newPath = path10.join(dir, `${newSlug}.md`);
+    const dir = path11.dirname(interview.markdownPath);
+    const newPath = path11.join(dir, `${newSlug}.md`);
     try {
       await fs8.access(newPath);
       return;
@@ -27051,9 +27402,9 @@ function createInterviewService(ctx, config, deps) {
     const messages = await loadMessages(sessionID);
     const title = extractTitle(document);
     const record = {
-      id: `${Date.now()}-${++idCounter}-${slugify(path10.basename(markdownPath, ".md")) || "interview"}`,
+      id: `${Date.now()}-${++idCounter}-${slugify(path11.basename(markdownPath, ".md")) || "interview"}`,
       sessionID,
-      idea: title || path10.basename(markdownPath, ".md"),
+      idea: title || path11.basename(markdownPath, ".md"),
       markdownPath,
       createdAt: nowIso(),
       status: "active",
@@ -27280,7 +27631,7 @@ function createInterviewService(ctx, config, deps) {
       return fileCache.items;
     }
     const outputDir = createInterviewDirectoryPath(ctx.directory, outputFolder);
-    const activePaths = new Set([...interviewsById.values()].filter((i) => i.status === "active").map((i) => path10.resolve(i.markdownPath)));
+    const activePaths = new Set([...interviewsById.values()].filter((i) => i.status === "active").map((i) => path11.resolve(i.markdownPath)));
     let entries;
     try {
       entries = await fs8.readdir(outputDir);
@@ -27291,8 +27642,8 @@ function createInterviewService(ctx, config, deps) {
     for (const entry of entries) {
       if (!entry.endsWith(".md"))
         continue;
-      const fullPath = path10.join(outputDir, entry);
-      if (activePaths.has(path10.resolve(fullPath)))
+      const fullPath = path11.join(outputDir, entry);
+      if (activePaths.has(path11.resolve(fullPath)))
         continue;
       let content;
       try {
@@ -27391,7 +27742,7 @@ function createInterviewManager(ctx, config) {
   const outputFolder = interviewConfig?.outputFolder ?? "interview";
   if (!dashboardEnabled) {
     const service2 = createInterviewService(ctx, interviewConfig);
-    const resolvedOutputPath = path11.join(ctx.directory, outputFolder);
+    const resolvedOutputPath = path12.join(ctx.directory, outputFolder);
     const server = createInterviewServer({
       getState: async (interviewId) => service2.getInterviewState(interviewId),
       listInterviewFiles: async () => service2.listInterviewFiles(),
@@ -27496,7 +27847,7 @@ function createInterviewManager(ctx, config) {
               listInterviews: () => service.listInterviews(),
               submitAnswers: async (interviewId, answers) => service.submitAnswers(interviewId, answers),
               handleNudgeAction: async (interviewId, action) => service.handleNudgeAction(interviewId, action),
-              outputFolder: path11.join(ctx.directory, outputFolder),
+              outputFolder: path12.join(ctx.directory, outputFolder),
               port: 0
             });
             service.setBaseUrlResolver(() => perSessionServer.ensureStarted());
@@ -27936,23 +28287,23 @@ class TmuxMultiplexer {
         return null;
       }
       const stdout = await proc.stdout();
-      const path12 = stdout.trim().split(`
+      const path13 = stdout.trim().split(`
 `)[0];
-      if (!path12) {
+      if (!path13) {
         log("[tmux] findBinary: no path in output");
         return null;
       }
-      const verifyProc = crossSpawn([path12, "-V"], {
+      const verifyProc = crossSpawn([path13, "-V"], {
         stdout: "pipe",
         stderr: "pipe"
       });
       const verifyExit = await verifyProc.exited;
       if (verifyExit !== 0) {
-        log("[tmux] findBinary: tmux -V failed", { path: path12, verifyExit });
+        log("[tmux] findBinary: tmux -V failed", { path: path13, verifyExit });
         return null;
       }
-      log("[tmux] findBinary: found", { path: path12 });
-      return path12;
+      log("[tmux] findBinary: found", { path: path13 });
+      return path13;
     } catch (err) {
       log("[tmux] findBinary: exception", { error: String(err) });
       return null;
@@ -28333,6 +28684,7 @@ class MultiplexerSessionManager {
   sessions = new Map;
   knownSessions = new Map;
   spawningSessions = new Set;
+  closingSessions = new Map;
   pollInterval;
   enabled = false;
   constructor(ctx, config) {
@@ -28361,17 +28713,22 @@ class MultiplexerSessionManager {
     const parentId = info.parentID;
     const title = info.title ?? "Subagent";
     const directory = info.directory ?? this.directory;
-    this.knownSessions.set(sessionId, {
-      parentId,
-      title,
-      directory
-    });
     if (this.isTrackedOrSpawning(sessionId)) {
       log("[multiplexer-session-manager] session already tracked or spawning", {
         sessionId
       });
       return;
     }
+    const closing = this.closingSessions.get(sessionId);
+    if (closing)
+      await closing;
+    if (this.isTrackedOrSpawning(sessionId))
+      return;
+    this.knownSessions.set(sessionId, {
+      parentId,
+      title,
+      directory
+    });
     this.spawningSessions.add(sessionId);
     try {
       const serverRunning = await isServerRunning(this.serverUrl);
@@ -28381,7 +28738,7 @@ class MultiplexerSessionManager {
         });
         return;
       }
-      if (this.sessions.has(sessionId)) {
+      if (this.closingSessions.has(sessionId) || this.sessions.has(sessionId)) {
         return;
       }
       log("[multiplexer-session-manager] child session created, spawning pane", {
@@ -28395,23 +28752,31 @@ class MultiplexerSessionManager {
         });
         return { success: false, paneId: undefined };
       });
-      if (paneResult.success && paneResult.paneId) {
-        const now = Date.now();
-        this.sessions.set(sessionId, {
+      if (!paneResult.success || !paneResult.paneId)
+        return;
+      if (!this.knownSessions.has(sessionId) || this.closingSessions.has(sessionId)) {
+        await this.multiplexer.closePane(paneResult.paneId).catch((err) => log("[multiplexer-session-manager] closing stale spawned pane failed", {
           sessionId,
           paneId: paneResult.paneId,
-          parentId,
-          title,
-          directory,
-          createdAt: now,
-          lastSeenAt: now
-        });
-        log("[multiplexer-session-manager] pane spawned", {
-          sessionId,
-          paneId: paneResult.paneId
-        });
-        this.startPolling();
+          error: String(err)
+        }));
+        return;
       }
+      const now = Date.now();
+      this.sessions.set(sessionId, {
+        sessionId,
+        paneId: paneResult.paneId,
+        parentId,
+        title,
+        directory,
+        createdAt: now,
+        lastSeenAt: now
+      });
+      log("[multiplexer-session-manager] pane spawned", {
+        sessionId,
+        paneId: paneResult.paneId
+      });
+      this.startPolling();
     } finally {
       this.spawningSessions.delete(sessionId);
     }
@@ -28425,7 +28790,7 @@ class MultiplexerSessionManager {
     if (!sessionId)
       return;
     if (event.properties?.status?.type === "idle") {
-      await this.closeSession(sessionId);
+      await this.closeSession(sessionId, "idle");
       return;
     }
     if (event.properties?.status?.type === "busy") {
@@ -28437,14 +28802,13 @@ class MultiplexerSessionManager {
       return;
     if (event.type !== "session.deleted")
       return;
-    const sessionId = event.properties?.sessionID;
+    const sessionId = this.getSessionId(event);
     if (!sessionId)
       return;
     log("[multiplexer-session-manager] session deleted, closing pane", {
       sessionId
     });
-    await this.closeSession(sessionId);
-    this.knownSessions.delete(sessionId);
+    await this.closeSession(sessionId, "deleted");
   }
   startPolling() {
     if (this.pollInterval)
@@ -28481,35 +28845,58 @@ class MultiplexerSessionManager {
         const missingTooLong = !!tracked.missingSince && now - tracked.missingSince >= SESSION_MISSING_GRACE_MS;
         const isTimedOut = now - tracked.createdAt > SESSION_TIMEOUT_MS;
         if (isIdle || missingTooLong || isTimedOut) {
-          sessionsToClose.push(sessionId);
+          sessionsToClose.push({
+            sessionId,
+            reason: isIdle ? "idle" : isTimedOut ? "timeout" : "missing"
+          });
         }
       }
-      for (const sessionId of sessionsToClose) {
-        await this.closeSession(sessionId);
+      for (const { sessionId, reason } of sessionsToClose) {
+        await this.closeSession(sessionId, reason);
       }
     } catch (err) {
       log("[multiplexer-session-manager] poll error", { error: String(err) });
     }
   }
-  async closeSession(sessionId) {
+  async closeSession(sessionId, reason) {
+    if (reason === "deleted") {
+      this.knownSessions.delete(sessionId);
+    }
+    const existingClose = this.closingSessions.get(sessionId);
+    if (existingClose)
+      return existingClose;
     const tracked = this.sessions.get(sessionId);
     if (!tracked || !this.multiplexer)
       return;
+    this.sessions.delete(sessionId);
     log("[multiplexer-session-manager] closing session pane", {
       sessionId,
-      paneId: tracked.paneId
+      paneId: tracked.paneId,
+      reason
     });
-    await this.multiplexer.closePane(tracked.paneId);
-    this.sessions.delete(sessionId);
-    if (this.sessions.size === 0) {
-      this.stopPolling();
-    }
+    const closePromise = this.multiplexer.closePane(tracked.paneId).then(() => {
+      return;
+    }).catch((err) => log("[multiplexer-session-manager] failed to close session pane", {
+      sessionId,
+      paneId: tracked.paneId,
+      reason,
+      error: String(err)
+    })).finally(() => {
+      this.closingSessions.delete(sessionId);
+      this.updatePolling();
+    });
+    this.closingSessions.set(sessionId, closePromise);
+    await closePromise;
   }
   async respawnIfKnown(sessionId) {
     if (!this.enabled || !this.multiplexer)
       return;
-    if (this.isTrackedOrSpawning(sessionId))
+    const closing = this.closingSessions.get(sessionId);
+    if (closing)
+      await closing;
+    if (this.isTrackedOrSpawning(sessionId)) {
       return;
+    }
     const known = this.knownSessions.get(sessionId);
     if (!known)
       return;
@@ -28523,8 +28910,9 @@ class MultiplexerSessionManager {
         });
         return;
       }
-      if (this.sessions.has(sessionId))
+      if (this.sessions.has(sessionId) || this.closingSessions.has(sessionId)) {
         return;
+      }
       log("[multiplexer-session-manager] child session busy again, respawning pane", {
         sessionId,
         parentId: known.parentId,
@@ -28538,6 +28926,14 @@ class MultiplexerSessionManager {
       });
       if (!paneResult.success || !paneResult.paneId)
         return;
+      if (!this.knownSessions.has(sessionId) || this.closingSessions.has(sessionId)) {
+        await this.multiplexer.closePane(paneResult.paneId).catch((err) => log("[multiplexer-session-manager] closing stale respawned pane failed", {
+          sessionId,
+          paneId: paneResult.paneId,
+          error: String(err)
+        }));
+        return;
+      }
       const now = Date.now();
       this.sessions.set(sessionId, {
         sessionId,
@@ -28560,8 +28956,21 @@ class MultiplexerSessionManager {
   isTrackedOrSpawning(sessionId) {
     return this.sessions.has(sessionId) || this.spawningSessions.has(sessionId);
   }
+  updatePolling() {
+    if (this.sessions.size > 0 || this.closingSessions.size > 0) {
+      this.startPolling();
+    } else {
+      this.stopPolling();
+    }
+  }
+  getSessionId(event) {
+    return event.properties?.info?.id ?? event.properties?.sessionID;
+  }
   async cleanup() {
     this.stopPolling();
+    if (this.closingSessions.size > 0) {
+      await Promise.all(this.closingSessions.values());
+    }
     if (this.sessions.size > 0 && this.multiplexer) {
       log("[multiplexer-session-manager] closing all panes", {
         count: this.sessions.size
@@ -28576,6 +28985,7 @@ class MultiplexerSessionManager {
     }
     this.knownSessions.clear();
     this.spawningSessions.clear();
+    this.closingSessions.clear();
     log("[multiplexer-session-manager] cleanup complete");
   }
 }
@@ -28787,9 +29197,9 @@ function findSgCliPathSync() {
   }
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
-    for (const path12 of homebrewPaths) {
-      if (existsSync7(path12) && isValidBinary(path12)) {
-        return path12;
+    for (const path13 of homebrewPaths) {
+      if (existsSync7(path13) && isValidBinary(path13)) {
+        return path13;
       }
     }
   }
@@ -28806,8 +29216,8 @@ function getSgCliPath() {
   }
   return "sg";
 }
-function setSgCliPath(path12) {
-  resolvedCliPath = path12;
+function setSgCliPath(path13) {
+  resolvedCliPath = path13;
 }
 var DEFAULT_TIMEOUT_MS2 = 300000;
 var DEFAULT_MAX_OUTPUT_BYTES = 1 * 1024 * 1024;
@@ -29215,7 +29625,7 @@ Returns the councillor responses with a summary footer.`,
 // src/tools/preset-manager.ts
 var COMMAND_NAME3 = "preset";
 function createPresetManager(ctx, config) {
-  let activePreset = config.preset ?? null;
+  let activePreset = getActiveRuntimePreset() ?? config.preset ?? null;
   async function handleCommandExecuteBefore(input, output) {
     if (input.command !== COMMAND_NAME3) {
       return;
@@ -29256,21 +29666,41 @@ function createPresetManager(ctx, config) {
     }
     const agentUpdates = {};
     for (const [agentName, override] of Object.entries(preset)) {
+      const resolvedName = AGENT_ALIASES[agentName] ?? agentName;
       const agentConfig = mapOverrideToAgentConfig(override);
       if (Object.keys(agentConfig).length > 0) {
-        agentUpdates[agentName] = agentConfig;
+        agentUpdates[resolvedName] = agentConfig;
       }
     }
-    if (Object.keys(agentUpdates).length === 0) {
+    const currentRuntimePreset = getActiveRuntimePreset();
+    const resetUpdates = {};
+    if (currentRuntimePreset && config.presets?.[currentRuntimePreset]) {
+      const oldPreset = config.presets[currentRuntimePreset];
+      for (const rawName of Object.keys(oldPreset)) {
+        const resolvedOld = AGENT_ALIASES[rawName] ?? rawName;
+        if (resolvedOld in agentUpdates)
+          continue;
+        const baseline = config.agents?.[resolvedOld];
+        if (baseline) {
+          resetUpdates[resolvedOld] = mapOverrideToAgentConfig(baseline);
+        }
+      }
+    }
+    const hasAgentUpdates = Object.keys(agentUpdates).length > 0;
+    const allUpdates = { ...resetUpdates, ...agentUpdates };
+    if (!hasAgentUpdates) {
       output.parts.push(createInternalAgentTextPart(`Preset "${presetName}" is empty (no agent overrides defined).`));
       return;
     }
+    const previousPreset = activePreset;
+    setActiveRuntimePresetWithPrevious(presetName);
     try {
       await ctx.client.config.update({
-        body: { agent: agentUpdates }
+        body: { agent: allUpdates }
       });
       activePreset = presetName;
-      const summary = Object.entries(agentUpdates).map(([name, cfg]) => {
+      const summaryParts = [];
+      for (const [name, cfg] of Object.entries(agentUpdates)) {
         const parts = [name];
         if (cfg.model)
           parts.push(`model: ${cfg.model}`);
@@ -29280,12 +29710,16 @@ function createPresetManager(ctx, config) {
           parts.push(`temp: ${cfg.temperature}`);
         if (cfg.options)
           parts.push("options: yes");
-        return parts.join(" → ");
-      }).join(`
-`);
+        summaryParts.push(parts.join(" → "));
+      }
+      if (Object.keys(resetUpdates).length > 0) {
+        summaryParts.push(`Reset to baseline: ${Object.keys(resetUpdates).join(", ")}`);
+      }
       output.parts.push(createInternalAgentTextPart(`Switched to preset "${presetName}":
-${summary}`));
+${summaryParts.join(`
+`)}`));
     } catch (err) {
+      rollbackRuntimePreset(previousPreset);
       output.parts.push(createInternalAgentTextPart(`Failed to switch preset "${presetName}": ${String(err)}`));
     }
   }
@@ -29375,14 +29809,14 @@ var BINARY_PREFIXES = [
 var WEBFETCH_DESCRIPTION = "Fetch a URL with better extraction for static/docs pages. Supports llms.txt probing, content-focused HTML extraction, metadata, redirects, and an optional prompt processed by a cheap secondary model.";
 // src/tools/smartfetch/tool.ts
 import os4 from "node:os";
-import path15 from "node:path";
+import path16 from "node:path";
 import {
   tool as tool4
 } from "@opencode-ai/plugin";
 
 // src/tools/smartfetch/binary.ts
 import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
-import path12 from "node:path";
+import path13 from "node:path";
 function extensionForMime(contentType) {
   const mime = contentType.split(";")[0]?.trim().toLowerCase();
   const map = {
@@ -29403,10 +29837,10 @@ function buildBinaryResultMessage(fetchResult, savedPath) {
 async function saveBinary(binaryDir, data, contentType, filename) {
   await mkdir2(binaryDir, { recursive: true });
   const initialName = filename || `webfetch-${Date.now()}.${extensionForMime(contentType)}`;
-  const parsed = path12.parse(initialName);
+  const parsed = path13.parse(initialName);
   for (let attempt = 0;attempt < 1000; attempt++) {
     const candidateName = attempt === 0 ? initialName : `${parsed.name}-${attempt}${parsed.ext || `.${extensionForMime(contentType)}`}`;
-    const file = path12.join(binaryDir, candidateName);
+    const file = path13.join(binaryDir, candidateName);
     try {
       await writeFile2(file, data, { flag: "wx" });
       return file;
@@ -30060,7 +30494,7 @@ var L = class u2 {
 };
 
 // src/tools/smartfetch/network.ts
-import path13 from "node:path";
+import path14 from "node:path";
 
 // src/tools/smartfetch/utils.ts
 var import_readability = __toESM(require_readability(), 1);
@@ -30785,7 +31219,7 @@ function inferFilenameFromUrl(url) {
 function truncateFilename(name, maxLength = 180) {
   if (name.length <= maxLength)
     return name;
-  const parsed = path13.parse(name);
+  const parsed = path14.parse(name);
   const ext = parsed.ext || "";
   const baseLimit = Math.max(1, maxLength - ext.length);
   return `${parsed.name.slice(0, baseLimit)}${ext}`;
@@ -30957,7 +31391,7 @@ function isInvalidLlmsResult(fetchResult) {
 // src/tools/smartfetch/secondary-model.ts
 import { existsSync as existsSync9 } from "node:fs";
 import { readFile as readFile4 } from "node:fs/promises";
-import path14 from "node:path";
+import path15 from "node:path";
 function parseModelRef(value) {
   if (!value)
     return;
@@ -30983,7 +31417,7 @@ function pickAgentModelRef(value) {
 }
 function findPreferredOpenCodeConfigPath(baseDir) {
   for (const file of ["opencode.jsonc", "opencode.json"]) {
-    const fullPath = path14.join(baseDir, file);
+    const fullPath = path15.join(baseDir, file);
     if (existsSync9(fullPath))
       return fullPath;
   }
@@ -31000,7 +31434,7 @@ async function readOpenCodeConfigFile(configPath) {
   }
 }
 async function readEffectiveOpenCodeConfig(directory) {
-  const projectDir = path14.join(directory, ".opencode");
+  const projectDir = path15.join(directory, ".opencode");
   const userDirs = getConfigSearchDirs();
   const projectPath = findPreferredOpenCodeConfigPath(projectDir);
   const userPath = userDirs.map((configDir) => findPreferredOpenCodeConfigPath(configDir)).find(Boolean);
@@ -31161,7 +31595,7 @@ async function runSecondaryModelWithFallback(client, directory, models, prompt,
 // src/tools/smartfetch/tool.ts
 var z5 = tool4.schema;
 function createWebfetchTool(pluginCtx, options = {}) {
-  const binaryDir = options.binaryDir || path15.join(os4.tmpdir(), "opencode-smartfetch");
+  const binaryDir = options.binaryDir || path16.join(os4.tmpdir(), "opencode-smartfetch");
   return tool4({
     description: WEBFETCH_DESCRIPTION,
     args: {
@@ -31685,6 +32119,16 @@ class SubagentDepthTracker {
 
 // src/utils/system-collapse.ts
 function collapseSystemInPlace(system2) {
+  if (system2.length === 0) {
+    return;
+  }
+  if (system2.length === 1) {
+    if (system2[0]) {
+      return;
+    }
+    system2.length = 0;
+    return;
+  }
   const joined = system2.join(`
 
 `);
@@ -31723,6 +32167,7 @@ var OhMyOpenCodeLite = async (ctx) => {
   const sessionId = new Date().toISOString().replace(/[-:]/g, "").slice(0, 15);
   initLogger(sessionId);
   let config;
+  let disabledAgents;
   let agentDefs;
   let agents;
   let mcps;
@@ -31748,9 +32193,20 @@ var OhMyOpenCodeLite = async (ctx) => {
   let presetManager;
   let councilTools;
   let webfetch;
+  let rewriteDisplayNameMentions;
   let toolCount = 0;
   try {
     config = loadPluginConfig(ctx.directory);
+    const runtimePreset = getActiveRuntimePreset();
+    if (runtimePreset && config.presets?.[runtimePreset]) {
+      config.preset = runtimePreset;
+      const presetAgents = config.presets[runtimePreset];
+      config.agents = deepMerge(config.agents, presetAgents);
+    } else if (runtimePreset) {
+      setActiveRuntimePreset(null);
+    }
+    disabledAgents = getDisabledAgents(config);
+    rewriteDisplayNameMentions = createDisplayNameMentionRewriter(config);
     agentDefs = createAgents(config);
     agents = getAgentConfigs(config);
     modelArrayMap = {};
@@ -31787,7 +32243,7 @@ var OhMyOpenCodeLite = async (ctx) => {
       main_pane_size: config.multiplexer?.main_pane_size ?? 60
     };
     const multiplexer = getMultiplexer(multiplexerConfig);
-    multiplexerEnabled = multiplexerConfig.type !== "none" && multiplexer !== null;
+    multiplexerEnabled = multiplexerConfig.type !== "none" && multiplexer !== null && multiplexer.isInsideSession();
     log("[plugin] initialized with multiplexer config", {
       multiplexerConfig,
       enabled: multiplexerEnabled,
@@ -31824,6 +32280,8 @@ var OhMyOpenCodeLite = async (ctx) => {
     });
     taskSessionManagerHook = createTaskSessionManagerHook(ctx, {
       maxSessionsPerAgent: config.sessionManager?.maxSessionsPerAgent ?? 2,
+      readContextMinLines: config.sessionManager?.readContextMinLines ?? 10,
+      readContextMaxFiles: config.sessionManager?.readContextMaxFiles ?? 8,
       shouldManageSession: (sessionID) => sessionAgentMap.get(sessionID) === "orchestrator"
     });
     interviewManager = createInterviewManager(ctx, config);
@@ -31943,6 +32401,83 @@ var OhMyOpenCodeLite = async (ctx) => {
           });
         }
       }
+      const runtimePresetName = getActiveRuntimePreset();
+      if (runtimePresetName && config.presets?.[runtimePresetName]) {
+        const runtimePreset = config.presets[runtimePresetName];
+        for (const [agentName, override] of Object.entries(runtimePreset)) {
+          const resolvedName = AGENT_ALIASES[agentName] ?? agentName;
+          const entry = configAgent[resolvedName];
+          if (!entry)
+            continue;
+          if (typeof override.model === "string") {
+            entry.model = override.model;
+          } else if (Array.isArray(override.model) && override.model.length > 0) {
+            const first = override.model[0];
+            entry.model = typeof first === "string" ? first : first.id;
+            if (typeof first !== "string" && first.variant) {
+              entry.variant = first.variant;
+            }
+          }
+          if (typeof override.variant === "string") {
+            entry.variant = override.variant;
+          } else if ("variant" in override) {
+            delete entry.variant;
+          }
+          if (typeof override.temperature === "number") {
+            entry.temperature = override.temperature;
+          } else if ("temperature" in override) {
+            delete entry.temperature;
+          }
+          if (override.options && typeof override.options === "object" && !Array.isArray(override.options)) {
+            entry.options = override.options;
+          } else if ("options" in override) {
+            delete entry.options;
+          }
+          log("[plugin] runtime preset override", {
+            preset: runtimePresetName,
+            agent: agentName,
+            model: entry.model
+          });
+        }
+        const prevPresetName = getPreviousRuntimePreset();
+        if (prevPresetName && config.presets?.[prevPresetName]) {
+          const prevPreset = config.presets[prevPresetName];
+          const newPresetResolved = new Set(Object.keys(runtimePreset).map((k) => AGENT_ALIASES[k] ?? k));
+          for (const agentName of Object.keys(prevPreset)) {
+            const resolvedName = AGENT_ALIASES[agentName] ?? agentName;
+            if (newPresetResolved.has(resolvedName))
+              continue;
+            const entry = configAgent[resolvedName];
+            if (!entry)
+              continue;
+            const baseline = config.agents?.[resolvedName];
+            const prevOverride = prevPreset[agentName];
+            if (typeof baseline?.model === "string") {
+              entry.model = baseline.model;
+            }
+            if (typeof baseline?.variant === "string") {
+              entry.variant = baseline.variant;
+            } else if (prevOverride && "variant" in prevOverride) {
+              delete entry.variant;
+            }
+            if (typeof baseline?.temperature === "number") {
+              entry.temperature = baseline.temperature;
+            } else if (prevOverride && "temperature" in prevOverride) {
+              delete entry.temperature;
+            }
+            if (baseline?.options && typeof baseline.options === "object" && !Array.isArray(baseline.options)) {
+              entry.options = baseline.options;
+            } else if (prevOverride && "options" in prevOverride) {
+              delete entry.options;
+            }
+            log("[plugin] runtime preset reset from previous", {
+              previousPreset: prevPresetName,
+              agent: resolvedName,
+              model: entry.model
+            });
+          }
+        }
+      }
       const configMcp = opencodeConfig.mcp;
       if (!configMcp) {
         opencodeConfig.mcp = { ...mcps };
@@ -32000,7 +32535,6 @@ var OhMyOpenCodeLite = async (ctx) => {
       await multiplexerSessionManager.onSessionStatus(event);
       await multiplexerSessionManager.onSessionDeleted(event);
       await interviewManager.handleEvent(input);
-      await postFileToolNudgeHook.event(input);
       await taskSessionManagerHook.event(input);
       if (input.event.type === "session.deleted") {
         const props = input.event.properties;
@@ -32043,15 +32577,12 @@ var OhMyOpenCodeLite = async (ctx) => {
         const alreadyInjected = output.system.some((s) => typeof s === "string" && s.includes("<Role>") && s.includes("orchestrator"));
         if (!alreadyInjected) {
           const orchestratorDef = agentDefs.find((a) => a.name === "orchestrator");
-          const orchestratorPrompt = typeof orchestratorDef?.config?.prompt === "string" ? orchestratorDef.config.prompt : buildOrchestratorPrompt(getDisabledAgents(config));
+          const orchestratorPrompt = typeof orchestratorDef?.config?.prompt === "string" ? orchestratorDef.config.prompt : buildOrchestratorPrompt(disabledAgents);
           output.system[0] = orchestratorPrompt + (output.system[0] ? `
 
 ${output.system[0]}` : "");
         }
       }
-      await todoContinuationHook.handleChatSystemTransform(input, output);
-      await postFileToolNudgeHook["experimental.chat.system.transform"](input, output);
-      await taskSessionManagerHook["experimental.chat.system.transform"](input, output);
       collapseSystemInPlace(output.system);
     },
     "experimental.chat.messages.transform": async (input, output) => {
@@ -32064,25 +32595,26 @@ ${output.system[0]}` : "");
           if (part.type !== "text" || typeof part.text !== "string") {
             continue;
           }
-          part.text = rewriteDisplayNameMentions(config, part.text);
+          part.text = rewriteDisplayNameMentions(part.text);
         }
       }
       processImageAttachments({
         messages: typedOutput.messages,
         workDir: ctx.directory,
-        disabledAgents: getDisabledAgents(config),
+        disabledAgents,
         log
       });
       await todoContinuationHook.handleMessagesTransform({
         messages: typedOutput.messages
       });
+      await taskSessionManagerHook["experimental.chat.messages.transform"](input, typedOutput);
       await phaseReminderHook["experimental.chat.messages.transform"](input, typedOutput);
       await filterAvailableSkillsHook["experimental.chat.messages.transform"](input, typedOutput);
     },
     "tool.execute.after": async (input, output) => {
       await delegateTaskRetryHook["tool.execute.after"](input, output);
       await jsonErrorRecoveryHook["tool.execute.after"](input, output);
-      await todoContinuationHook.handleToolExecuteAfter(input);
+      await todoContinuationHook.handleToolExecuteAfter(input, output);
       await postFileToolNudgeHook["tool.execute.after"](input, output);
       await taskSessionManagerHook["tool.execute.after"](input, output);
     }