oh-my-opencode-slim 1.0.3 → 1.0.4

package/dist/index.js

@@ -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;
@@ -18854,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
@@ -18953,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:
@@ -19044,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 = {
@@ -19137,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;
 }
 
@@ -19769,6 +19790,27 @@ 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";
@@ -20214,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;
@@ -20225,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 = [];
@@ -20268,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;
     }
@@ -20282,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");
   }
@@ -20425,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;
 }
@@ -20449,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 },
@@ -20457,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) {
@@ -20538,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);
 }
@@ -20564,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();
@@ -20620,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;
 }
@@ -20666,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" };
   }
@@ -20683,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;
@@ -20740,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
   };
 }
@@ -20910,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;
@@ -21287,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 {
@@ -21335,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") {
@@ -21395,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;
@@ -21410,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);
@@ -21457,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");
@@ -21505,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",
@@ -23110,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) => {
@@ -23141,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}`;
     }
   };
 }
@@ -23153,32 +23251,31 @@ ${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);
     }
   };
 }
@@ -23196,6 +23293,8 @@ 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);
 }
@@ -23395,14 +23494,36 @@ function createTaskSessionManagerHook(_ctx, options) {
       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") {
@@ -23467,7 +23588,7 @@ function createTodoHygiene(options) {
     handleRequestStart(input) {
       clear(input.sessionID);
     },
-    async handleToolExecuteAfter(input) {
+    async handleToolExecuteAfter(input, _output) {
       if (!input.sessionID) {
         return;
       }
@@ -23477,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);
@@ -23535,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") {
@@ -23586,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 = [
@@ -23623,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;
@@ -23698,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("|");
@@ -23706,6 +23846,7 @@ function createTodoContinuationHook(ctx, config) {
       return {
         sessionID,
         agent: message.info.agent,
+        message,
         signature: message.info.id ? `${message.info.id}:${partSignature}` : `${ordinal}:${partSignature}`
       };
     }
@@ -23733,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) {
@@ -24085,7 +24233,6 @@ function createTodoContinuationHook(ctx, config) {
   return {
     tool: { auto_continue: autoContinue },
     handleToolExecuteAfter: hygiene.handleToolExecuteAfter,
-    handleChatSystemTransform: hygiene.handleChatSystemTransform,
     handleMessagesTransform,
     handleEvent,
     handleChatMessage,
@@ -28537,6 +28684,7 @@ class MultiplexerSessionManager {
   sessions = new Map;
   knownSessions = new Map;
   spawningSessions = new Set;
+  closingSessions = new Map;
   pollInterval;
   enabled = false;
   constructor(ctx, config) {
@@ -28565,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);
@@ -28585,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", {
@@ -28599,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);
     }
@@ -28629,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") {
@@ -28641,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)
@@ -28685,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;
@@ -28727,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,
@@ -28742,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,
@@ -28764,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
@@ -28780,6 +28985,7 @@ class MultiplexerSessionManager {
     }
     this.knownSessions.clear();
     this.spawningSessions.clear();
+    this.closingSessions.clear();
     log("[multiplexer-session-manager] cleanup complete");
   }
 }
@@ -29419,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;
@@ -29460,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}`);
@@ -29484,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)}`));
     }
   }
@@ -31967,6 +32197,14 @@ var OhMyOpenCodeLite = async (ctx) => {
   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);
@@ -32163,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 };
@@ -32220,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;
@@ -32269,9 +32583,6 @@ var OhMyOpenCodeLite = async (ctx) => {
 ${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) => {
@@ -32296,13 +32607,14 @@ ${output.system[0]}` : "");
       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);
     }