oh-my-opencode-slim 0.9.8 → 0.9.10

package/dist/index.js

@@ -2956,34 +2956,1439 @@ ${bestResult.result}` : undefined,
     };
   }
 }
+// src/hooks/apply-patch/errors.ts
+var APPLY_PATCH_ERROR_PREFIX = {
+  blocked: "apply_patch blocked",
+  validation: "apply_patch validation failed",
+  verification: "apply_patch verification failed",
+  internal: "apply_patch internal error"
+};
+
+class ApplyPatchError extends Error {
+  kind;
+  code;
+  cause;
+  constructor(kind, code, message, options) {
+    super(`${APPLY_PATCH_ERROR_PREFIX[kind]}: ${message}`);
+    this.kind = kind;
+    this.code = code;
+    this.name = "ApplyPatchError";
+    this.cause = options?.cause;
+  }
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function createApplyPatchBlockedError(message, cause) {
+  return new ApplyPatchError("blocked", "outside_workspace", message, {
+    cause
+  });
+}
+function createApplyPatchValidationError(message, cause) {
+  return new ApplyPatchError("validation", "malformed_patch", message, {
+    cause
+  });
+}
+function createApplyPatchVerificationError(message, cause) {
+  return new ApplyPatchError("verification", "verification_failed", message, {
+    cause
+  });
+}
+function createApplyPatchInternalError(message, cause) {
+  return new ApplyPatchError("internal", "internal_unexpected", message, {
+    cause
+  });
+}
+function isApplyPatchError(error) {
+  return error instanceof ApplyPatchError;
+}
+function isApplyPatchVerificationError(error) {
+  return isApplyPatchError(error) && error.kind === "verification";
+}
+function getApplyPatchErrorDetails(error) {
+  if (!isApplyPatchError(error)) {
+    return;
+  }
+  return {
+    kind: error.kind,
+    code: error.code,
+    message: error.message
+  };
+}
+function ensureApplyPatchError(error, context) {
+  if (isApplyPatchError(error)) {
+    return error;
+  }
+  return createApplyPatchInternalError(`${context}: ${getErrorMessage(error)}`, error);
+}
+
+// src/hooks/apply-patch/execution-context.ts
+import * as fs3 from "fs/promises";
+import path3 from "path";
+
+// src/hooks/apply-patch/codec.ts
+function normalizeLineEndings(text) {
+  return text.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+}
+function normalizeUnicode(text) {
+  return text.replace(/[\u2018\u2019\u201A\u201B]/g, "'").replace(/[\u201C\u201D\u201E\u201F]/g, '"').replace(/[\u2010\u2011\u2012\u2013\u2014\u2015]/g, "-").replace(/\u2026/g, "...").replace(/\u00A0/g, " ");
+}
+function stripHeredoc(input) {
+  const normalized = normalizeLineEndings(input);
+  const match = normalized.match(/^(?:cat\s+)?<<['"]?(\w+)['"]?\s*\n([\s\S]*?)\n\1\s*$/);
+  return match ? match[2] : normalized;
+}
+function normalizePatchText(patchText) {
+  return stripHeredoc(normalizeLineEndings(patchText).trim());
+}
+function parseHeader(lines, index) {
+  const line = lines[index];
+  if (line.startsWith("*** Add File:")) {
+    const file = line.slice("*** Add File:".length).trim();
+    return file ? { file, next: index + 1 } : null;
+  }
+  if (line.startsWith("*** Delete File:")) {
+    const file = line.slice("*** Delete File:".length).trim();
+    return file ? { file, next: index + 1 } : null;
+  }
+  if (line.startsWith("*** Update File:")) {
+    const file = line.slice("*** Update File:".length).trim();
+    let move;
+    let next = index + 1;
+    if (next < lines.length && lines[next].startsWith("*** Move to:")) {
+      const moveTarget = lines[next].slice("*** Move to:".length).trim();
+      if (!moveTarget) {
+        return null;
+      }
+      move = moveTarget;
+      next += 1;
+    }
+    return file ? { file, move, next } : null;
+  }
+  return null;
+}
+function unexpectedPatchLine(context, line) {
+  const rendered = line.length === 0 ? "<empty>" : line;
+  throw new Error(`Invalid patch format: unexpected line ${context}: ${rendered}`);
+}
+function parseChunks(lines, index, mode) {
+  const chunks = [];
+  let at = index;
+  while (at < lines.length && !lines[at].startsWith("***")) {
+    if (!lines[at].startsWith("@@")) {
+      if (mode === "strict") {
+        unexpectedPatchLine("in update body", lines[at]);
+      }
+      at += 1;
+      continue;
+    }
+    const context = lines[at].slice(2).trim() || undefined;
+    at += 1;
+    const old_lines = [];
+    const new_lines = [];
+    let eof = false;
+    while (at < lines.length && !lines[at].startsWith("@@") && (!lines[at].startsWith("***") || lines[at] === "*** End of File")) {
+      const line = lines[at];
+      if (line === "*** End of File") {
+        eof = true;
+        at += 1;
+        break;
+      }
+      if (line.startsWith(" ")) {
+        old_lines.push(line.slice(1));
+        new_lines.push(line.slice(1));
+        at += 1;
+        continue;
+      }
+      if (line.startsWith("-")) {
+        old_lines.push(line.slice(1));
+        at += 1;
+        continue;
+      }
+      if (line.startsWith("+")) {
+        new_lines.push(line.slice(1));
+        at += 1;
+        continue;
+      }
+      if (mode === "strict") {
+        unexpectedPatchLine("in patch chunk", line);
+      }
+      at += 1;
+    }
+    chunks.push({
+      old_lines,
+      new_lines,
+      change_context: context,
+      is_end_of_file: eof || undefined
+    });
+  }
+  return { chunks, next: at };
+}
+function parseAdd(lines, index, mode) {
+  let contents = "";
+  let at = index;
+  while (at < lines.length && !lines[at].startsWith("***")) {
+    if (lines[at].startsWith("+")) {
+      contents += `${lines[at].slice(1)}
+`;
+      at += 1;
+      continue;
+    }
+    if (mode === "strict") {
+      unexpectedPatchLine("in Add File body", lines[at]);
+    }
+    at += 1;
+  }
+  if (contents.endsWith(`
+`)) {
+    contents = contents.slice(0, -1);
+  }
+  return { content: contents, 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");
+  if (begin === -1 || end === -1 || begin >= end) {
+    throw new Error("Invalid patch format: missing Begin/End markers");
+  }
+  if (mode === "strict") {
+    for (const line of lines.slice(0, begin)) {
+      unexpectedPatchLine("before Begin Patch", line);
+    }
+    for (const line of lines.slice(end + 1)) {
+      unexpectedPatchLine("after End Patch", line);
+    }
+  }
+  const hunks = [];
+  let index = begin + 1;
+  while (index < end) {
+    const header = parseHeader(lines, index);
+    if (!header) {
+      if (mode === "strict") {
+        unexpectedPatchLine("between hunks", lines[index]);
+      }
+      index += 1;
+      continue;
+    }
+    if (lines[index].startsWith("*** Add File:")) {
+      const next2 = parseAdd(lines, header.next, mode);
+      hunks.push({
+        type: "add",
+        path: header.file,
+        contents: next2.content
+      });
+      index = next2.next;
+      continue;
+    }
+    if (lines[index].startsWith("*** Delete File:")) {
+      hunks.push({ type: "delete", path: header.file });
+      index = header.next;
+      continue;
+    }
+    const next = parseChunks(lines, header.next, mode);
+    if (mode === "strict" && next.chunks.length === 0) {
+      throw new Error(`Invalid patch format: Update File is missing @@ chunk body: ${header.file}`);
+    }
+    hunks.push({
+      type: "update",
+      path: header.file,
+      move_path: header.move,
+      chunks: next.chunks
+    });
+    index = next.next;
+  }
+  return { hunks };
+}
+function parsePatchStrict(patchText) {
+  return parsePatchInternal(patchText, "strict");
+}
+function diffMatrix(old_lines, new_lines) {
+  const dp = Array.from({ length: old_lines.length + 1 }, () => Array(new_lines.length + 1).fill(0));
+  for (let oldIndex = 1;oldIndex <= old_lines.length; oldIndex += 1) {
+    for (let newIndex = 1;newIndex <= new_lines.length; newIndex += 1) {
+      dp[oldIndex][newIndex] = old_lines[oldIndex - 1] === new_lines[newIndex - 1] ? dp[oldIndex - 1][newIndex - 1] + 1 : Math.max(dp[oldIndex - 1][newIndex], dp[oldIndex][newIndex - 1]);
+    }
+  }
+  return dp;
+}
+function renderChunk(chunk) {
+  const lines = [chunk.change_context ? `@@ ${chunk.change_context}` : "@@"];
+  const dp = diffMatrix(chunk.old_lines, chunk.new_lines);
+  const body = [];
+  let oldIndex = chunk.old_lines.length;
+  let newIndex = chunk.new_lines.length;
+  while (oldIndex > 0 && newIndex > 0) {
+    if (chunk.old_lines[oldIndex - 1] === chunk.new_lines[newIndex - 1]) {
+      body.push(` ${chunk.old_lines[oldIndex - 1]}`);
+      oldIndex -= 1;
+      newIndex -= 1;
+      continue;
+    }
+    if (dp[oldIndex - 1][newIndex] >= dp[oldIndex][newIndex - 1]) {
+      body.push(`-${chunk.old_lines[oldIndex - 1]}`);
+      oldIndex -= 1;
+      continue;
+    }
+    body.push(`+${chunk.new_lines[newIndex - 1]}`);
+    newIndex -= 1;
+  }
+  while (oldIndex > 0) {
+    body.push(`-${chunk.old_lines[oldIndex - 1]}`);
+    oldIndex -= 1;
+  }
+  while (newIndex > 0) {
+    body.push(`+${chunk.new_lines[newIndex - 1]}`);
+    newIndex -= 1;
+  }
+  lines.push(...body.reverse());
+  if (chunk.is_end_of_file) {
+    lines.push("*** End of File");
+  }
+  return lines;
+}
+function renderAddContents(contents) {
+  if (contents.length === 0) {
+    return [];
+  }
+  return contents.split(`
+`).map((line) => `+${line}`);
+}
+function formatPatch(patch) {
+  const lines = ["*** Begin Patch"];
+  for (const hunk of patch.hunks) {
+    if (hunk.type === "add") {
+      lines.push(`*** Add File: ${hunk.path}`);
+      lines.push(...renderAddContents(hunk.contents));
+      continue;
+    }
+    if (hunk.type === "delete") {
+      lines.push(`*** Delete File: ${hunk.path}`);
+      continue;
+    }
+    lines.push(`*** Update File: ${hunk.path}`);
+    if (hunk.move_path) {
+      lines.push(`*** Move to: ${hunk.move_path}`);
+    }
+    for (const chunk of hunk.chunks) {
+      lines.push(...renderChunk(chunk));
+    }
+  }
+  lines.push("*** End Patch");
+  return lines.join(`
+`);
+}
+
+// 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;
+}
+function equalUnicodeExact(a, b) {
+  return normalizeUnicode(a) === normalizeUnicode(b);
+}
+function equalTrimEnd(a, b) {
+  return a.trimEnd() === b.trimEnd();
+}
+function equalUnicodeTrimEnd(a, b) {
+  return normalizeUnicode(a.trimEnd()) === normalizeUnicode(b.trimEnd());
+}
+function equalTrim(a, b) {
+  return a.trim() === b.trim();
+}
+function equalUnicodeTrim(a, b) {
+  return normalizeUnicode(a.trim()) === normalizeUnicode(b.trim());
+}
+var comparatorEntries = [
+  { name: "exact", exact: true, same: equalExact },
+  { name: "unicode", exact: false, same: equalUnicodeExact },
+  { name: "trim-end", exact: false, same: equalTrimEnd },
+  {
+    name: "unicode-trim-end",
+    exact: false,
+    same: equalUnicodeTrimEnd
+  },
+  { 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);
+var permissiveComparators = comparatorEntries.map((entry) => entry.same);
+function tryMatch(lines, pattern, start, comparator, eof) {
+  if (eof) {
+    const at = lines.length - pattern.length;
+    if (at >= start) {
+      let ok = true;
+      for (let index = 0;index < pattern.length; index += 1) {
+        if (!comparator.same(lines[at + index], pattern[index])) {
+          ok = false;
+          break;
+        }
+      }
+      if (ok) {
+        return {
+          index: at,
+          comparator: comparator.name,
+          exact: comparator.exact
+        };
+      }
+    }
+  }
+  for (let index = start;index <= lines.length - pattern.length; index += 1) {
+    let ok = true;
+    for (let inner = 0;inner < pattern.length; inner += 1) {
+      if (!comparator.same(lines[index + inner], pattern[inner])) {
+        ok = false;
+        break;
+      }
+    }
+    if (ok) {
+      return {
+        index,
+        comparator: comparator.name,
+        exact: comparator.exact
+      };
+    }
+  }
+  return;
+}
+function seekMatch(lines, pattern, start, eof = false) {
+  if (pattern.length === 0) {
+    return;
+  }
+  for (const comparator of autoRescueComparatorEntries) {
+    const hit = tryMatch(lines, pattern, start, comparator, eof);
+    if (hit) {
+      return hit;
+    }
+  }
+  return;
+}
+function seek(lines, pattern, start, eof = false) {
+  return seekMatch(lines, pattern, start, eof)?.index ?? -1;
+}
+function list(lines, pattern, start, same) {
+  if (pattern.length === 0) {
+    return [];
+  }
+  const out = [];
+  for (let index = start;index <= lines.length - pattern.length; index += 1) {
+    let ok = true;
+    for (let inner = 0;inner < pattern.length; inner += 1) {
+      if (!same(lines[index + inner], pattern[inner])) {
+        ok = false;
+        break;
+      }
+    }
+    if (ok) {
+      out.push(index);
+    }
+  }
+  return out;
+}
+function sameRescueLine(a, b) {
+  return equalExact(a, b) || equalUnicodeExact(a, b);
+}
+function prefix(old_lines, new_lines) {
+  let index = 0;
+  while (index < old_lines.length && index < new_lines.length && sameRescueLine(old_lines[index], new_lines[index])) {
+    index += 1;
+  }
+  return index;
+}
+function suffix(old_lines, new_lines, prefixLength) {
+  let index = 0;
+  while (old_lines.length - index - 1 >= prefixLength && new_lines.length - index - 1 >= prefixLength && sameRescueLine(old_lines[old_lines.length - index - 1], new_lines[new_lines.length - index - 1])) {
+    index += 1;
+  }
+  return index;
+}
+function rescueByPrefixSuffix(lines, old_lines, new_lines, start) {
+  const prefixLength = prefix(old_lines, new_lines);
+  const suffixLength = suffix(old_lines, new_lines, prefixLength);
+  if (prefixLength === 0 || suffixLength === 0) {
+    return { kind: "miss" };
+  }
+  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;
+  for (const same of autoRescueComparators) {
+    for (const leftIndex of list(lines, left, start, same)) {
+      const from = leftIndex + left.length;
+      for (const rightIndex of list(lines, right, from, same)) {
+        const key = `${from}:${rightIndex}`;
+        hits.set(key, {
+          start: from,
+          del: rightIndex - from,
+          add: [...middle]
+        });
+      }
+    }
+  }
+  if (hits.size === 0) {
+    return { kind: "miss" };
+  }
+  if (hits.size > 1) {
+    return { kind: "ambiguous", phase: "prefix_suffix" };
+  }
+  return { kind: "match", hit: [...hits.values()][0] };
+}
+function score(a, b) {
+  const dp = Array.from({ length: a.length + 1 }, () => Array(b.length + 1).fill(0));
+  for (let i = 1;i <= a.length; i += 1) {
+    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]);
+    }
+  }
+  return dp[a.length][b.length];
+}
+function normalizeLcsLine(line) {
+  return normalizeUnicode(line).trim();
+}
+function countLcsUpperBound(a, b) {
+  const counts = new Map;
+  for (const line of a) {
+    const key = normalizeLcsLine(line);
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  let shared = 0;
+  for (const line of b) {
+    const key = normalizeLcsLine(line);
+    const available = counts.get(key) ?? 0;
+    if (available === 0) {
+      continue;
+    }
+    shared += 1;
+    if (available === 1) {
+      counts.delete(key);
+      continue;
+    }
+    counts.set(key, available - 1);
+  }
+  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)) {
+      continue;
+    }
+    const candidate = lines.slice(index, index + oldLines.length);
+    if (!hasStableBorders(oldLines, candidate)) {
+      continue;
+    }
+    candidates.push(index);
+  }
+  return candidates;
+}
+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" };
+  }
+  const needed = old_lines.length <= 2 ? old_lines.length : Math.max(2, Math.ceil(old_lines.length * 0.7));
+  const candidates = collectBorderAnchoredStarts(lines, old_lines, start);
+  if (candidates.length === 0 || candidates.length > MAX_LCS_CANDIDATES) {
+    return { kind: "miss" };
+  }
+  let best;
+  let bestScore = 0;
+  let ties = 0;
+  for (const index of candidates) {
+    if (index < from || index > to) {
+      continue;
+    }
+    const window = lines.slice(index, index + old_lines.length);
+    if (countLcsUpperBound(old_lines, window) < needed) {
+      continue;
+    }
+    const current = score(old_lines, window);
+    if (current > bestScore) {
+      bestScore = current;
+      ties = 1;
+      best = {
+        start: index,
+        del: old_lines.length,
+        add: [...new_lines]
+      };
+      continue;
+    }
+    if (current === bestScore && current > 0) {
+      ties += 1;
+    }
+  }
+  if (!best || bestScore < needed) {
+    return { kind: "miss" };
+  }
+  if (ties > 1) {
+    return { kind: "ambiguous", phase: "lcs" };
+  }
+  return { kind: "match", hit: best };
+}
+
+// src/hooks/apply-patch/resolution.ts
+function splitFileLines(text) {
+  const eol = text.match(/\r\n|\n|\r/)?.[0] === `\r
+` ? `\r
+` : `
+`;
+  const normalized = text.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+  const hasFinalNewline = normalized.endsWith(`
+`);
+  const lines = normalized.split(`
+`);
+  if (hasFinalNewline) {
+    lines.pop();
+  }
+  return { lines, eol, hasFinalNewline };
+}
+function resolveChunkStart(lines, chunk, start) {
+  if (!chunk.change_context) {
+    return start;
+  }
+  const at = seek(lines, [chunk.change_context], 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);
+    }
+  }
+  if (hits.size === 0) {
+    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;
+  return {
+    kind: "match",
+    index,
+    exact: canonicalLine === changeContext,
+    comparator: comparator ?? "exact",
+    canonicalLine
+  };
+}
+function locateChunk(lines, file, chunk, start, cfg) {
+  const old_lines = chunk.old_lines;
+  const new_lines = chunk.new_lines;
+  const match = seekMatch(lines, old_lines, start, chunk.is_end_of_file ?? false);
+  if (match) {
+    const canonical_old_lines = lines.slice(match.index, match.index + old_lines.length);
+    const rewritten = !match.exact;
+    return {
+      hit: { start: match.index, del: old_lines.length, add: [...new_lines] },
+      old_lines,
+      canonical_old_lines,
+      canonical_new_lines: [...chunk.new_lines],
+      resolved_is_end_of_file: match.index + canonical_old_lines.length === lines.length,
+      rewritten,
+      strategy: undefined,
+      matchComparator: match.comparator
+    };
+  }
+  if (cfg.prefixSuffix) {
+    const rescued = rescueByPrefixSuffix(lines, old_lines, new_lines, start);
+    if (rescued.kind === "ambiguous") {
+      throw new Error(`Prefix/suffix rescue was ambiguous in ${file}:
+${chunk.old_lines.join(`
+`)}`);
+    }
+    if (rescued.kind === "match") {
+      const prefixLength = prefix(old_lines, new_lines);
+      const suffixLength = suffix(old_lines, new_lines, prefixLength);
+      const canonicalStart = rescued.hit.start - prefixLength;
+      const canonicalEnd = rescued.hit.start + rescued.hit.del + suffixLength;
+      return {
+        hit: rescued.hit,
+        old_lines,
+        canonical_old_lines: lines.slice(canonicalStart, canonicalEnd),
+        canonical_new_lines: [...chunk.new_lines],
+        resolved_is_end_of_file: canonicalEnd === lines.length,
+        rewritten: true,
+        strategy: "prefix/suffix",
+        matchComparator: "exact"
+      };
+    }
+  }
+  if (cfg.lcsRescue) {
+    const rescued = rescueByLcs(lines, old_lines, new_lines, start);
+    if (rescued.kind === "ambiguous") {
+      throw new Error(`LCS rescue was ambiguous in ${file}:
+${chunk.old_lines.join(`
+`)}`);
+    }
+    if (rescued.kind === "match") {
+      return {
+        hit: rescued.hit,
+        old_lines,
+        canonical_old_lines: lines.slice(rescued.hit.start, rescued.hit.start + rescued.hit.del),
+        canonical_new_lines: [...chunk.new_lines],
+        resolved_is_end_of_file: rescued.hit.start + rescued.hit.del === lines.length,
+        rewritten: true,
+        strategy: "lcs",
+        matchComparator: "exact"
+      };
+    }
+  }
+  throw new Error(`Failed to find expected lines in ${file}:
+${chunk.old_lines.join(`
+`)}`);
+}
+function applyHits(lines, hits, eol = `
+`, hasFinalNewline = true) {
+  const out = [...lines];
+  for (let index = hits.length - 1;index >= 0; index -= 1) {
+    out.splice(hits[index].start, hits[index].del, ...hits[index].add);
+  }
+  if (out.length === 0) {
+    return "";
+  }
+  const rendered = out.join(eol);
+  return hasFinalNewline ? `${rendered}${eol}` : rendered;
+}
+function resolveUpdateChunksFromFileLines(file, state, chunks, cfg) {
+  const lines = [...state.lines];
+  const resolved = [];
+  let start = 0;
+  for (const chunk of chunks) {
+    const chunkStart = resolveChunkStart(lines, chunk, start);
+    let strategy;
+    if (chunk.old_lines.length === 0) {
+      if (chunk.is_end_of_file) {
+        resolved.push({
+          hit: {
+            start: lines.length,
+            del: 0,
+            add: [...chunk.new_lines]
+          },
+          old_lines: [],
+          canonical_old_lines: [],
+          canonical_new_lines: [...chunk.new_lines],
+          resolved_is_end_of_file: true,
+          rewritten: false,
+          strategy,
+          matchComparator: "exact"
+        });
+        start = lines.length;
+        continue;
+      }
+      if (!chunk.change_context) {
+        throw new Error(`Missing insertion anchor in ${file}`);
+      }
+      const anchorMatch = resolveUniqueAnchor(lines, chunk.change_context, start);
+      if (anchorMatch.kind === "missing") {
+        throw new Error(`Failed to find insertion anchor in ${file}:
+${chunk.change_context}`);
+      }
+      if (anchorMatch.kind === "ambiguous") {
+        throw new Error(`Insertion anchor was ambiguous in ${file}:
+${chunk.change_context}`);
+      }
+      const insertAt = anchorMatch.index + 1;
+      if (insertAt === lines.length) {
+        resolved.push({
+          hit: {
+            start: insertAt,
+            del: 0,
+            add: [...chunk.new_lines]
+          },
+          old_lines: [],
+          canonical_old_lines: [],
+          canonical_new_lines: [...chunk.new_lines],
+          canonical_change_context: anchorMatch.exact ? undefined : anchorMatch.canonicalLine,
+          resolved_is_end_of_file: insertAt === lines.length,
+          rewritten: !anchorMatch.exact,
+          strategy: anchorMatch.exact ? strategy : "anchor",
+          matchComparator: anchorMatch.comparator
+        });
+        start = insertAt;
+        continue;
+      }
+      const anchor = lines[insertAt];
+      strategy = "anchor";
+      resolved.push({
+        hit: {
+          start: insertAt,
+          del: 0,
+          add: [...chunk.new_lines]
+        },
+        old_lines: [],
+        canonical_old_lines: [anchor],
+        canonical_new_lines: [...chunk.new_lines, anchor],
+        resolved_is_end_of_file: insertAt + 1 === lines.length,
+        rewritten: true,
+        strategy,
+        matchComparator: "exact"
+      });
+      start = insertAt;
+      continue;
+    }
+    const found = locateChunk(lines, file, chunk, chunkStart, cfg);
+    resolved.push(found);
+    start = found.hit.start + found.hit.del;
+  }
+  resolved.sort((a, b) => a.hit.start - b.hit.start);
+  for (let index = 1;index < resolved.length; index += 1) {
+    const previous = resolved[index - 1].hit;
+    const current = resolved[index].hit;
+    if (previous.start + previous.del > current.start) {
+      throw new Error(`Overlapping patch chunks in ${file}`);
+    }
+  }
+  return {
+    lines,
+    resolved,
+    eol: state.eol,
+    hasFinalNewline: state.hasFinalNewline
+  };
+}
+function deriveNewContentFromText(file, text, chunks, cfg) {
+  const { lines, resolved, eol, hasFinalNewline } = resolveUpdateChunksFromFileLines(file, splitFileLines(text), chunks, cfg);
+  return applyHits(lines, resolved.map((chunk) => chunk.hit), eol, hasFinalNewline);
+}
+function resolveUpdateChunksFromText(file, text, chunks, cfg) {
+  return resolveUpdateChunksFromFileLines(file, splitFileLines(text), chunks, cfg);
+}
+
+// src/hooks/apply-patch/execution-context.ts
+function isMissingPathError(error) {
+  return !!error && typeof error === "object" && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
+}
+async function real(target) {
+  const parts = [];
+  let current = path3.resolve(target);
+  while (true) {
+    const exact = await fs3.realpath(current).catch((error) => {
+      if (isMissingPathError(error)) {
+        return null;
+      }
+      throw createApplyPatchInternalError(`Failed to resolve real path: ${current}`, error);
+    });
+    if (exact) {
+      return parts.length === 0 ? exact : path3.join(exact, ...parts.reverse());
+    }
+    const parent = path3.dirname(current);
+    if (parent === current) {
+      return parts.length === 0 ? current : path3.join(current, ...parts.reverse());
+    }
+    parts.push(path3.basename(current));
+    current = parent;
+  }
+}
+function inside(root, target) {
+  const rel = path3.relative(root, target);
+  return rel === "" || !rel.startsWith("..") && !path3.isAbsolute(rel);
+}
+function createPathGuardContext(root, worktree) {
+  return {
+    rootReal: real(root),
+    worktreeReal: worktree && worktree !== "/" ? real(worktree) : undefined,
+    realCache: new Map
+  };
+}
+async function realCached(ctx, target) {
+  const resolvedTarget = path3.resolve(target);
+  let pending = ctx.realCache.get(resolvedTarget);
+  if (!pending) {
+    pending = real(resolvedTarget);
+    ctx.realCache.set(resolvedTarget, pending);
+  }
+  return await pending;
+}
+async function guard(ctx, target) {
+  const [targetReal, rootReal] = await Promise.all([
+    realCached(ctx, target),
+    ctx.rootReal
+  ]);
+  if (inside(rootReal, targetReal)) {
+    return;
+  }
+  if (!ctx.worktreeReal) {
+    throw createApplyPatchBlockedError(`patch contains path outside workspace root: ${target}`);
+  }
+  const treeReal = await ctx.worktreeReal;
+  if (inside(treeReal, targetReal)) {
+    return;
+  }
+  throw createApplyPatchBlockedError(`patch contains path outside workspace root: ${target}`);
+}
+function createFileCacheContext() {
+  return { stats: new Map };
+}
+async function statCached(ctx, filePath) {
+  let pending = ctx.stats.get(filePath);
+  if (!pending) {
+    const nextPending = fs3.stat(filePath).catch((error) => {
+      if (isMissingPathError(error)) {
+        return null;
+      }
+      throw createApplyPatchInternalError(`Failed to stat file for patch verification: ${filePath}`, error);
+    });
+    ctx.stats.set(filePath, nextPending);
+    pending = nextPending;
+  }
+  return await pending;
+}
+async function assertRegularFile(ctx, filePath, verb) {
+  const stat2 = await statCached(ctx, filePath);
+  if (!stat2 || stat2.isDirectory()) {
+    throw createApplyPatchVerificationError(`Failed to read file to ${verb}: ${filePath}`);
+  }
+}
+function collectPatchTargets(root, hunks) {
+  const targets = new Set;
+  for (const hunk of hunks) {
+    targets.add(path3.resolve(root, hunk.path));
+    if (hunk.type === "update" && hunk.move_path) {
+      targets.add(path3.resolve(root, hunk.move_path));
+    }
+  }
+  return [...targets];
+}
+function validatePatchPaths(hunks) {
+  for (const hunk of hunks) {
+    if (path3.isAbsolute(hunk.path)) {
+      throw createApplyPatchValidationError(`absolute patch paths are not allowed: ${hunk.path}`);
+    }
+    if (hunk.type === "update" && hunk.move_path && path3.isAbsolute(hunk.move_path)) {
+      throw createApplyPatchValidationError(`absolute patch paths are not allowed: ${hunk.move_path}`);
+    }
+  }
+}
+async function guardPatchTargets(root, worktree, targets) {
+  const guardContext = createPathGuardContext(root, worktree);
+  for (const target of targets) {
+    await guard(guardContext, target);
+  }
+  return targets.length;
+}
+function parseValidatedPatch(patchText) {
+  let hunks;
+  try {
+    hunks = parsePatchStrict(patchText).hunks;
+  } catch (error) {
+    throw createApplyPatchValidationError(getErrorMessage(error));
+  }
+  if (hunks.length === 0) {
+    const clean = patchText.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`).trim();
+    if (clean === `*** Begin Patch
+*** End Patch`) {
+      throw createApplyPatchValidationError("empty patch");
+    }
+    throw createApplyPatchValidationError("no hunks found");
+  }
+  validatePatchPaths(hunks);
+  return hunks;
+}
+async function readPreparedFileText(filePath, verb) {
+  try {
+    return await fs3.readFile(filePath, "utf-8");
+  } catch (error) {
+    if (isMissingPathError(error)) {
+      throw createApplyPatchVerificationError(`Failed to read file to ${verb}: ${filePath}`);
+    }
+    throw createApplyPatchInternalError(`Failed to read file for patch verification: ${filePath}`, error);
+  }
+}
+async function createPatchExecutionContext(root, patchText, worktree) {
+  const hunks = parseValidatedPatch(patchText);
+  await guardPatchTargets(root, worktree, collectPatchTargets(root, hunks));
+  const files = createFileCacheContext();
+  const staged = new Map;
+  async function assertPreparedPathMissing(filePath, verb) {
+    const existing = staged.get(filePath);
+    if (existing) {
+      if (!existing.exists) {
+        return;
+      }
+      throw createApplyPatchVerificationError(verb === "add" ? `Add File target already exists: ${filePath}` : `Move destination already exists: ${filePath}`);
+    }
+    const stat2 = await statCached(files, filePath);
+    if (!stat2) {
+      return;
+    }
+    throw createApplyPatchVerificationError(verb === "add" ? `Add File target already exists: ${filePath}` : `Move destination already exists: ${filePath}`);
+  }
+  async function getPreparedFileState(filePath, verb) {
+    const existing = staged.get(filePath);
+    if (existing) {
+      if (!existing.exists) {
+        throw createApplyPatchVerificationError(`Failed to read file to ${verb}: ${filePath}`);
+      }
+      return existing;
+    }
+    await assertRegularFile(files, filePath, verb);
+    const stat2 = await statCached(files, filePath);
+    const text = await readPreparedFileText(filePath, verb);
+    const state = {
+      exists: true,
+      text,
+      mode: stat2 ? stat2.mode & 4095 : undefined,
+      derived: false
+    };
+    staged.set(filePath, state);
+    return state;
+  }
+  return {
+    hunks,
+    staged,
+    getPreparedFileState,
+    assertPreparedPathMissing
+  };
+}
+function resolvePreparedUpdate(filePath, currentText, hunk, cfg) {
+  try {
+    const { lines, resolved, eol, hasFinalNewline } = resolveUpdateChunksFromText(filePath, currentText, hunk.chunks, cfg);
+    return {
+      resolved,
+      nextText: applyHits(lines, resolved.map((chunk) => chunk.hit), eol, hasFinalNewline)
+    };
+  } catch (error) {
+    throw createApplyPatchVerificationError(getErrorMessage(error), error);
+  }
+}
+function stageAddedText(contents) {
+  return contents.length === 0 || contents.endsWith(`
+`) ? contents : `${contents}
+`;
+}
+// src/hooks/apply-patch/rewrite.ts
+import path4 from "path";
+function normalizeTextLineEndings(text) {
+  return text.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+}
+function splitPatchTextLines(text) {
+  const normalized = normalizeTextLineEndings(text);
+  const lines = normalized.split(`
+`);
+  if (normalized.endsWith(`
+`)) {
+    lines.pop();
+  }
+  return lines;
+}
+function createCollapsedUpdateHunk(pathValue, filePath, baseText, finalText, cfg, movePath) {
+  const collapsedChunk = {
+    old_lines: splitPatchTextLines(baseText),
+    new_lines: splitPatchTextLines(finalText),
+    change_context: undefined,
+    is_end_of_file: true
+  };
+  const minimizedChunk = minimizeMergedChunk(collapsedChunk);
+  const chunk = minimizedChunk.old_lines.length === collapsedChunk.old_lines.length && minimizedChunk.new_lines.length === collapsedChunk.new_lines.length && minimizedChunk.change_context === collapsedChunk.change_context && minimizedChunk.is_end_of_file === collapsedChunk.is_end_of_file ? collapsedChunk : (() => {
+    try {
+      return deriveNewContentFromText(filePath, baseText, [minimizedChunk], cfg) === finalText ? minimizedChunk : collapsedChunk;
+    } catch {
+      return collapsedChunk;
+    }
+  })();
+  return {
+    type: "update",
+    path: pathValue,
+    move_path: movePath,
+    chunks: [chunk]
+  };
+}
+function clonePatchChunks(chunks) {
+  return chunks.map((chunk) => ({
+    old_lines: [...chunk.old_lines],
+    new_lines: [...chunk.new_lines],
+    change_context: chunk.change_context,
+    is_end_of_file: chunk.is_end_of_file
+  }));
+}
+function minimizeMergedChunk(chunk) {
+  if (chunk.old_lines.length === 0 && chunk.new_lines.length === 0) {
+    return {
+      old_lines: [],
+      new_lines: [],
+      change_context: chunk.change_context,
+      is_end_of_file: chunk.is_end_of_file
+    };
+  }
+  let prefixLength = 0;
+  while (prefixLength < chunk.old_lines.length && prefixLength < chunk.new_lines.length && chunk.old_lines[prefixLength] === chunk.new_lines[prefixLength]) {
+    prefixLength += 1;
+  }
+  let suffixLength = 0;
+  while (chunk.old_lines.length - suffixLength - 1 >= prefixLength && chunk.new_lines.length - suffixLength - 1 >= prefixLength && chunk.old_lines[chunk.old_lines.length - suffixLength - 1] === chunk.new_lines[chunk.new_lines.length - suffixLength - 1]) {
+    suffixLength += 1;
+  }
+  if (prefixLength === 0 && suffixLength === 0) {
+    return {
+      old_lines: [...chunk.old_lines],
+      new_lines: [...chunk.new_lines],
+      change_context: chunk.change_context,
+      is_end_of_file: chunk.is_end_of_file
+    };
+  }
+  return {
+    old_lines: chunk.old_lines.slice(prefixLength, chunk.old_lines.length - suffixLength),
+    new_lines: chunk.new_lines.slice(prefixLength, chunk.new_lines.length - suffixLength),
+    change_context: prefixLength > 0 ? chunk.old_lines[prefixLength - 1] : chunk.change_context,
+    is_end_of_file: chunk.is_end_of_file && suffixLength === 0 ? true : undefined
+  };
+}
+function createUpdateHunk(pathValue, chunks, movePath) {
+  return {
+    type: "update",
+    path: pathValue,
+    move_path: movePath,
+    chunks: clonePatchChunks(chunks)
+  };
+}
+function mergeSameFileUpdateGroupChunks(filePath, group, nextChunks, finalText, cfg) {
+  if (!group.chunks) {
+    return;
+  }
+  const mergedChunks = [
+    ...clonePatchChunks(group.chunks).map(minimizeMergedChunk),
+    ...clonePatchChunks(nextChunks).map(minimizeMergedChunk)
+  ];
+  try {
+    const mergedText = deriveNewContentFromText(filePath, group.baseText, mergedChunks, cfg);
+    return mergedText === finalText ? mergedChunks : undefined;
+  } catch {
+    return;
+  }
+}
+function addContentsFromFinalText(text) {
+  return text.endsWith(`
+`) ? text.slice(0, -1) : text;
+}
+function renderRewriteDependencyGroup(group, cfg) {
+  if (group.kind === "add") {
+    return {
+      type: "add",
+      path: group.group.outputPath,
+      contents: addContentsFromFinalText(group.group.finalText)
+    };
+  }
+  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 {
+      kind: "add",
+      group: {
+        ...group.group,
+        outputPath: nextOutputPath,
+        outputFilePath: nextOutputFilePath,
+        finalText
+      }
+    };
+  }
+  const mergedChunks = group.group.outputFilePath === filePath && group.group.sourceFilePath === filePath && nextOutputFilePath === filePath ? mergeSameFileUpdateGroupChunks(filePath, group.group, nextChunks, finalText, cfg) : undefined;
+  return {
+    kind: "update",
+    group: {
+      ...group.group,
+      outputPath: nextOutputPath,
+      outputFilePath: nextOutputFilePath,
+      finalText,
+      chunks: mergedChunks
+    }
+  };
+}
+async function rewritePatch(root, patchText, cfg, worktree) {
+  try {
+    let clearDependencyGroup = function(filePath) {
+      dependencyGroups.delete(filePath);
+    };
+    const { hunks, staged, getPreparedFileState, assertPreparedPathMissing } = await createPatchExecutionContext(root, patchText, 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);
+    const dependencyGroups = new Map;
+    for (const hunk of hunks) {
+      if (hunk.type === "add") {
+        const filePath2 = path4.resolve(root, hunk.path);
+        await assertPreparedPathMissing(filePath2, "add");
+        rewritten.push(hunk);
+        clearDependencyGroup(filePath2);
+        const finalText = stageAddedText(hunk.contents);
+        staged.set(filePath2, {
+          exists: true,
+          text: finalText,
+          derived: true
+        });
+        dependencyGroups.set(filePath2, {
+          kind: "add",
+          group: {
+            index: rewritten.length - 1,
+            outputPath: hunk.path,
+            outputFilePath: filePath2,
+            finalText
+          }
+        });
+        continue;
+      }
+      if (hunk.type === "delete") {
+        const filePath2 = path4.resolve(root, hunk.path);
+        await getPreparedFileState(filePath2, "delete");
+        clearDependencyGroup(filePath2);
+        rewritten.push(hunk);
+        staged.set(filePath2, { exists: false, derived: true });
+        continue;
+      }
+      const filePath = path4.resolve(root, hunk.path);
+      const currentDependency = dependencyGroups.get(filePath);
+      const current = await getPreparedFileState(filePath, "update");
+      if (!current.exists) {
+        throw createApplyPatchVerificationError(`Failed to read file to update: ${filePath}`);
+      }
+      const movePath = hunk.move_path ? path4.resolve(root, hunk.move_path) : undefined;
+      if (movePath && movePath !== filePath) {
+        await assertPreparedPathMissing(movePath, "move");
+      }
+      const { resolved, nextText } = resolvePreparedUpdate(filePath, current.text, hunk, cfg);
+      const next = resolved.map((chunk, index) => ({
+        old_lines: [...chunk.canonical_old_lines],
+        new_lines: [...chunk.canonical_new_lines],
+        change_context: chunk.canonical_change_context ?? hunk.chunks[index].change_context,
+        is_end_of_file: hunk.chunks[index].is_end_of_file && chunk.resolved_is_end_of_file ? true : undefined
+      }));
+      for (const chunk of resolved) {
+        if (!chunk.rewritten) {
+          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;
+      if (current.derived && currentDependency) {
+        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);
+        }
+        dependencyGroups.set(nextOutputFilePath, nextGroup);
+      } else {
+        rewritten.push(createUpdateHunk(hunk.path, next, hunk.move_path));
+        clearDependencyGroup(filePath);
+        if (movePath && movePath !== filePath) {
+          clearDependencyGroup(movePath);
+        }
+        dependencyGroups.set(nextOutputFilePath, {
+          kind: "update",
+          group: {
+            index: rewritten.length - 1,
+            sourcePath: hunk.path,
+            outputPath: nextOutputPath,
+            sourceFilePath: filePath,
+            outputFilePath: nextOutputFilePath,
+            baseText: current.text,
+            finalText: nextText,
+            chunks: clonePatchChunks(next)
+          }
+        });
+      }
+      if (movePath && movePath !== filePath) {
+        staged.set(filePath, { exists: false, derived: true });
+        staged.set(movePath, {
+          exists: true,
+          text: nextText,
+          mode: current.mode,
+          derived: true
+        });
+      } else {
+        staged.set(filePath, {
+          exists: true,
+          text: nextText,
+          mode: current.mode,
+          derived: true
+        });
+      }
+    }
+    if (!changed) {
+      if (normalizedPatchText !== patchText) {
+        return {
+          patchText: normalizedPatchText,
+          changed: true,
+          rewrittenChunks: 0,
+          totalChunks,
+          rewriteModes: ["normalize:patch-text"]
+        };
+      }
+      return {
+        patchText,
+        changed: false,
+        rewrittenChunks: 0,
+        totalChunks,
+        rewriteModes: []
+      };
+    }
+    return {
+      patchText: formatPatch({ hunks: rewritten }),
+      changed: true,
+      rewrittenChunks,
+      totalChunks,
+      rewriteModes: [...rewriteModes].sort()
+    };
+  } catch (error) {
+    throw ensureApplyPatchError(error, "Unexpected rewrite failure");
+  }
+}
+// src/hooks/apply-patch/index.ts
+var APPLY_PATCH_RESCUE_OPTIONS = {
+  prefixSuffix: true,
+  lcsRescue: true
+};
+function createApplyPatchHook(ctx) {
+  function logHookStatus(state, data) {
+    log(`apply-patch hook ${state}`, data);
+  }
+  return {
+    "tool.execute.before": async (input, output) => {
+      if (input.tool !== "apply_patch") {
+        return;
+      }
+      if (typeof output.args?.patchText !== "string") {
+        return;
+      }
+      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);
+        if (result.changed) {
+          output.args.patchText = result.patchText;
+          logHookStatus("rewrite", {
+            rewrittenChunks: result.rewrittenChunks,
+            totalChunks: result.totalChunks,
+            strategies: result.rewriteModes
+          });
+          return;
+        }
+        logHookStatus("unchanged", {
+          rewrittenChunks: 0,
+          totalChunks: result.totalChunks
+        });
+        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);
+        logHookStatus(isApplyPatchVerificationError(normalizedError) ? "verification" : normalizedError.kind === "validation" ? "validation" : normalizedError.kind === "internal" ? "internal" : "blocked", {
+          kind: details?.kind ?? "internal",
+          code: details?.code ?? "internal_unexpected",
+          reason: normalizedError.message,
+          failOpen: false,
+          rescueOptions: APPLY_PATCH_RESCUE_OPTIONS,
+          rewriteStage: "before-native"
+        });
+        throw normalizedError;
+      }
+    }
+  };
+}
 // src/hooks/auto-update-checker/cache.ts
-import * as fs3 from "fs";
-import * as path4 from "path";
+import * as fs4 from "fs";
+import * as path6 from "path";
 // src/hooks/auto-update-checker/constants.ts
 import * as os2 from "os";
-import * as path3 from "path";
+import * as path5 from "path";
 var PACKAGE_NAME = "oh-my-opencode-slim";
 var NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/dist-tags`;
 var NPM_FETCH_TIMEOUT = 5000;
 function getCacheDir() {
   if (process.platform === "win32") {
-    return path3.join(process.env.LOCALAPPDATA ?? os2.homedir(), "opencode");
+    return path5.join(process.env.LOCALAPPDATA ?? os2.homedir(), "opencode");
   }
-  return path3.join(os2.homedir(), ".cache", "opencode");
+  return path5.join(os2.homedir(), ".cache", "opencode");
 }
 var CACHE_DIR = getCacheDir();
-var INSTALLED_PACKAGE_JSON = path3.join(CACHE_DIR, "node_modules", PACKAGE_NAME, "package.json");
+var INSTALLED_PACKAGE_JSON = path5.join(CACHE_DIR, "node_modules", PACKAGE_NAME, "package.json");
 var configPaths = getOpenCodeConfigPaths();
 var USER_OPENCODE_CONFIG = configPaths[0];
 var USER_OPENCODE_CONFIG_JSONC = configPaths[1];
 
 // src/hooks/auto-update-checker/cache.ts
 function removeFromBunLock(packageName) {
-  const lockPath = path4.join(CACHE_DIR, "bun.lock");
-  if (!fs3.existsSync(lockPath))
+  const lockPath = path6.join(CACHE_DIR, "bun.lock");
+  if (!fs4.existsSync(lockPath))
     return false;
   try {
-    const content = fs3.readFileSync(lockPath, "utf-8");
+    const content = fs4.readFileSync(lockPath, "utf-8");
     let lock;
     try {
       lock = JSON.parse(stripJsonComments(content));
@@ -3000,7 +4405,7 @@ function removeFromBunLock(packageName) {
       modified = true;
     }
     if (modified) {
-      fs3.writeFileSync(lockPath, JSON.stringify(lock, null, 2));
+      fs4.writeFileSync(lockPath, JSON.stringify(lock, null, 2));
       log(`[auto-update-checker] Removed from bun.lock: ${packageName}`);
     }
     return modified;
@@ -3011,23 +4416,23 @@ function removeFromBunLock(packageName) {
 }
 function invalidatePackage(packageName = PACKAGE_NAME) {
   try {
-    const pkgDir = path4.join(CACHE_DIR, "node_modules", packageName);
-    const pkgJsonPath = path4.join(CACHE_DIR, "package.json");
+    const pkgDir = path6.join(CACHE_DIR, "node_modules", packageName);
+    const pkgJsonPath = path6.join(CACHE_DIR, "package.json");
     let packageRemoved = false;
     let dependencyRemoved = false;
     let lockRemoved = false;
-    if (fs3.existsSync(pkgDir)) {
-      fs3.rmSync(pkgDir, { recursive: true, force: true });
+    if (fs4.existsSync(pkgDir)) {
+      fs4.rmSync(pkgDir, { recursive: true, force: true });
       log(`[auto-update-checker] Package removed: ${pkgDir}`);
       packageRemoved = true;
     }
-    if (fs3.existsSync(pkgJsonPath)) {
+    if (fs4.existsSync(pkgJsonPath)) {
       try {
-        const content = fs3.readFileSync(pkgJsonPath, "utf-8");
+        const content = fs4.readFileSync(pkgJsonPath, "utf-8");
         const pkgJson = JSON.parse(stripJsonComments(content));
         if (pkgJson.dependencies?.[packageName]) {
           delete pkgJson.dependencies[packageName];
-          fs3.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+          fs4.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
           log(`[auto-update-checker] Dependency removed from package.json: ${packageName}`);
           dependencyRemoved = true;
         }
@@ -3048,8 +4453,8 @@ function invalidatePackage(packageName = PACKAGE_NAME) {
 }
 
 // src/hooks/auto-update-checker/checker.ts
-import * as fs4 from "fs";
-import * as path5 from "path";
+import * as fs5 from "fs";
+import * as path7 from "path";
 import { fileURLToPath } from "url";
 function isPrereleaseVersion(version) {
   return version.includes("-");
@@ -3074,8 +4479,8 @@ function extractChannel(version) {
 }
 function getConfigPaths(directory) {
   return [
-    path5.join(directory, ".opencode", "opencode.json"),
-    path5.join(directory, ".opencode", "opencode.jsonc"),
+    path7.join(directory, ".opencode", "opencode.json"),
+    path7.join(directory, ".opencode", "opencode.jsonc"),
     USER_OPENCODE_CONFIG,
     USER_OPENCODE_CONFIG_JSONC
   ];
@@ -3083,9 +4488,9 @@ function getConfigPaths(directory) {
 function getLocalDevPath(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!fs4.existsSync(configPath))
+      if (!fs5.existsSync(configPath))
         continue;
-      const content = fs4.readFileSync(configPath, "utf-8");
+      const content = fs5.readFileSync(configPath, "utf-8");
       const config = JSON.parse(stripJsonComments(content));
       const plugins = config.plugin ?? [];
       for (const entry of plugins) {
@@ -3103,19 +4508,19 @@ function getLocalDevPath(directory) {
 }
 function findPackageJsonUp(startPath) {
   try {
-    const stat = fs4.statSync(startPath);
-    let dir = stat.isDirectory() ? startPath : path5.dirname(startPath);
+    const stat2 = fs5.statSync(startPath);
+    let dir = stat2.isDirectory() ? startPath : path7.dirname(startPath);
     for (let i = 0;i < 10; i++) {
-      const pkgPath = path5.join(dir, "package.json");
-      if (fs4.existsSync(pkgPath)) {
+      const pkgPath = path7.join(dir, "package.json");
+      if (fs5.existsSync(pkgPath)) {
         try {
-          const content = fs4.readFileSync(pkgPath, "utf-8");
+          const content = fs5.readFileSync(pkgPath, "utf-8");
           const pkg = JSON.parse(content);
           if (pkg.name === PACKAGE_NAME)
             return pkgPath;
         } catch {}
       }
-      const parent = path5.dirname(dir);
+      const parent = path7.dirname(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -3131,7 +4536,7 @@ function getLocalDevVersion(directory) {
     const pkgPath = findPackageJsonUp(localPath);
     if (!pkgPath)
       return null;
-    const content = fs4.readFileSync(pkgPath, "utf-8");
+    const content = fs5.readFileSync(pkgPath, "utf-8");
     const pkg = JSON.parse(content);
     return pkg.version ?? null;
   } catch {
@@ -3141,9 +4546,9 @@ function getLocalDevVersion(directory) {
 function findPluginEntry(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!fs4.existsSync(configPath))
+      if (!fs5.existsSync(configPath))
         continue;
-      const content = fs4.readFileSync(configPath, "utf-8");
+      const content = fs5.readFileSync(configPath, "utf-8");
       const config = JSON.parse(stripJsonComments(content));
       const plugins = config.plugin ?? [];
       for (const entry of plugins) {
@@ -3170,8 +4575,8 @@ function getCachedVersion() {
   if (cachedPackageVersion)
     return cachedPackageVersion;
   try {
-    if (fs4.existsSync(INSTALLED_PACKAGE_JSON)) {
-      const content = fs4.readFileSync(INSTALLED_PACKAGE_JSON, "utf-8");
+    if (fs5.existsSync(INSTALLED_PACKAGE_JSON)) {
+      const content = fs5.readFileSync(INSTALLED_PACKAGE_JSON, "utf-8");
       const pkg = JSON.parse(content);
       if (pkg.version) {
         cachedPackageVersion = pkg.version;
@@ -3180,10 +4585,10 @@ function getCachedVersion() {
     }
   } catch {}
   try {
-    const currentDir = path5.dirname(fileURLToPath(import.meta.url));
+    const currentDir = path7.dirname(fileURLToPath(import.meta.url));
     const pkgPath = findPackageJsonUp(currentDir);
     if (pkgPath) {
-      const content = fs4.readFileSync(pkgPath, "utf-8");
+      const content = fs5.readFileSync(pkgPath, "utf-8");
       const pkg = JSON.parse(content);
       if (pkg.version) {
         cachedPackageVersion = pkg.version;
@@ -3858,17 +5263,35 @@ ${originalText}`;
   };
 }
 // src/hooks/post-file-tool-nudge/index.ts
-var NUDGE = `
-
----
-${PHASE_REMINDER_TEXT}`;
-function createPostFileToolNudgeHook() {
+var POST_FILE_TOOL_NUDGE = PHASE_REMINDER_TEXT;
+var FILE_TOOLS = new Set(["Read", "read", "Write", "write"]);
+function createPostFileToolNudgeHook(options = {}) {
+  const pendingSessionIds = new Set;
   return {
-    "tool.execute.after": async (input, output) => {
-      if (input.tool !== "Read" && input.tool !== "read" && input.tool !== "Write" && input.tool !== "write") {
+    "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;
       }
-      output.output = output.output + NUDGE;
+      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);
     }
   };
 }
@@ -3878,6 +5301,7 @@ 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 SUPPRESS_AFTER_ABORT_MS = 5000;
+var NOTIFICATION_BUSY_GRACE_MS = 250;
 var QUESTION_PHRASES = [
   "would you like",
   "should i",
@@ -3903,12 +5327,15 @@ function cancelPendingTimer(state) {
     clearTimeout(state.pendingTimer);
     state.pendingTimer = null;
   }
+  state.pendingTimerSessionId = null;
 }
 function resetState(state) {
   cancelPendingTimer(state);
   state.consecutiveContinuations = 0;
   state.suppressUntil = 0;
   state.isAutoInjecting = false;
+  state.notifyingSessionIds.clear();
+  state.notificationBusyUntilBySession.clear();
 }
 function createTodoContinuationHook(ctx, config) {
   const maxContinuations = config?.maxContinuations ?? 5;
@@ -3919,10 +5346,51 @@ function createTodoContinuationHook(ctx, config) {
     enabled: false,
     consecutiveContinuations: 0,
     pendingTimer: null,
+    pendingTimerSessionId: null,
     suppressUntil: 0,
-    orchestratorSessionId: null,
-    isAutoInjecting: false
+    orchestratorSessionIds: new Set,
+    sawChatMessage: false,
+    isAutoInjecting: false,
+    notifyingSessionIds: new Set,
+    notificationBusyUntilBySession: new Map
   };
+  function markNotificationStarted(sessionID) {
+    state.notifyingSessionIds.add(sessionID);
+  }
+  function markNotificationFinished(sessionID) {
+    state.notifyingSessionIds.delete(sessionID);
+    state.notificationBusyUntilBySession.set(sessionID, Date.now() + NOTIFICATION_BUSY_GRACE_MS);
+  }
+  function clearNotificationState(sessionID) {
+    state.notifyingSessionIds.delete(sessionID);
+    state.notificationBusyUntilBySession.delete(sessionID);
+  }
+  function isNotificationBusy(sessionID) {
+    if (state.notifyingSessionIds.has(sessionID)) {
+      return true;
+    }
+    const until = state.notificationBusyUntilBySession.get(sessionID) ?? 0;
+    if (until <= Date.now()) {
+      state.notificationBusyUntilBySession.delete(sessionID);
+      return false;
+    }
+    return true;
+  }
+  function isOrchestratorSession(sessionID) {
+    return state.orchestratorSessionIds.has(sessionID);
+  }
+  function registerOrchestratorSession(sessionID) {
+    state.orchestratorSessionIds.add(sessionID);
+  }
+  function handleChatMessage(input) {
+    if (!input.agent) {
+      return;
+    }
+    state.sawChatMessage = true;
+    if (input.agent === "orchestrator") {
+      registerOrchestratorSession(input.sessionID);
+    }
+  }
   const autoContinue = tool({
     description: "Toggle auto-continuation for incomplete todos. When enabled, the orchestrator will automatically continue working through its todo list when it stops with incomplete items.",
     args: { enabled: tool.schema.boolean() },
@@ -3943,19 +5411,19 @@ function createTodoContinuationHook(ctx, config) {
   async function handleEvent(input) {
     const { event } = input;
     const properties = event.properties ?? {};
-    if (event.type === "session.idle") {
+    if (event.type === "session.idle" || event.type === "session.status" && properties.status?.type === "idle") {
       const sessionID = properties.sessionID;
       if (!sessionID) {
         return;
       }
       log(`[${HOOK_NAME}] Session idle`, { sessionID });
-      if (!state.orchestratorSessionId) {
-        state.orchestratorSessionId = sessionID;
+      if (!state.sawChatMessage && state.orchestratorSessionIds.size === 0) {
+        registerOrchestratorSession(sessionID);
         log(`[${HOOK_NAME}] Tracked orchestrator session`, {
           sessionID
         });
       }
-      if (state.orchestratorSessionId !== sessionID) {
+      if (!isOrchestratorSession(sessionID)) {
         log(`[${HOOK_NAME}] Skipped: not orchestrator session`, {
           sessionID
         });
@@ -4068,6 +5536,7 @@ function createTodoContinuationHook(ctx, config) {
         sessionID,
         delayMs: cooldownMs
       });
+      markNotificationStarted(sessionID);
       ctx.client.session.prompt({
         path: { id: sessionID },
         body: {
@@ -4084,9 +5553,14 @@ function createTodoContinuationHook(ctx, config) {
             }
           ]
         }
-      }).catch(() => {});
+      }).catch(() => {}).finally(() => {
+        markNotificationFinished(sessionID);
+      });
+      state.pendingTimerSessionId = sessionID;
       state.pendingTimer = setTimeout(async () => {
         state.pendingTimer = null;
+        state.pendingTimerSessionId = null;
+        clearNotificationState(sessionID);
         if (!state.enabled) {
           log(`[${HOOK_NAME}] Cancelled: disabled during cooldown`, {
             sessionID
@@ -4119,11 +5593,12 @@ function createTodoContinuationHook(ctx, config) {
       const status = properties.status;
       const sessionID = properties.sessionID;
       if (status?.type === "busy") {
-        const isOrchestrator = sessionID === state.orchestratorSessionId;
-        if (isOrchestrator) {
+        const isOrchestrator = isOrchestratorSession(sessionID);
+        const isNotification = isNotificationBusy(sessionID);
+        if (isOrchestrator && !isNotification && state.pendingTimerSessionId === sessionID) {
           cancelPendingTimer(state);
         }
-        if (!state.isAutoInjecting && isOrchestrator && state.consecutiveContinuations > 0) {
+        if (!state.isAutoInjecting && !isNotification && isOrchestrator && state.consecutiveContinuations > 0) {
           state.consecutiveContinuations = 0;
           log(`[${HOOK_NAME}] Reset consecutive count on user activity`, {
             sessionID
@@ -4134,7 +5609,7 @@ function createTodoContinuationHook(ctx, config) {
       const error = properties.error;
       const sessionID = properties.sessionID;
       const errorName = error?.name;
-      const isOrchestrator = sessionID === state.orchestratorSessionId;
+      const isOrchestrator = isOrchestratorSession(sessionID);
       if (isOrchestrator && (errorName === "MessageAbortedError" || errorName === "AbortError")) {
         state.suppressUntil = Date.now() + SUPPRESS_AFTER_ABORT_MS;
         log(`[${HOOK_NAME}] Suppressed continuation after abort`, {
@@ -4150,13 +5625,19 @@ function createTodoContinuationHook(ctx, config) {
       }
     } else if (event.type === "session.deleted") {
       const deletedSessionId = properties.info?.id ?? properties.sessionID;
-      if (state.orchestratorSessionId === deletedSessionId) {
-        cancelPendingTimer(state);
-        log(`[${HOOK_NAME}] Cancelled pending timer on orchestrator delete`, {
-          sessionID: deletedSessionId
-        });
-        resetState(state);
-        state.orchestratorSessionId = null;
+      if (deletedSessionId && isOrchestratorSession(deletedSessionId)) {
+        if (state.pendingTimerSessionId === deletedSessionId) {
+          cancelPendingTimer(state);
+          log(`[${HOOK_NAME}] Cancelled pending timer on orchestrator delete`, {
+            sessionID: deletedSessionId
+          });
+        }
+        state.orchestratorSessionIds.delete(deletedSessionId);
+        clearNotificationState(deletedSessionId);
+        if (state.orchestratorSessionIds.size === 0) {
+          resetState(state);
+          state.sawChatMessage = false;
+        }
         log(`[${HOOK_NAME}] Reset orchestrator session on delete`, {
           sessionID: deletedSessionId
         });
@@ -4167,9 +5648,7 @@ function createTodoContinuationHook(ctx, config) {
     if (input.command !== COMMAND_NAME) {
       return;
     }
-    if (!state.orchestratorSessionId) {
-      state.orchestratorSessionId = input.sessionID;
-    }
+    registerOrchestratorSession(input.sessionID);
     output.parts.length = 0;
     const arg = input.arguments.trim().toLowerCase();
     let newEnabled;
@@ -4214,6 +5693,7 @@ function createTodoContinuationHook(ctx, config) {
   return {
     tool: { auto_continue: autoContinue },
     handleEvent,
+    handleChatMessage,
     handleCommandExecuteBefore
   };
 }
@@ -5077,8 +6557,8 @@ function createInterviewServer(deps) {
 // src/interview/service.ts
 import { spawn as spawn4 } from "child_process";
 import * as fsSync from "fs";
-import * as fs5 from "fs/promises";
-import * as path6 from "path";
+import * as fs6 from "fs/promises";
+import * as path8 from "path";
 
 // src/interview/parser.ts
 var INTERVIEW_BLOCK_REGEX = /<interview_state>\s*([\s\S]*?)\s*<\/interview_state>/i;
@@ -5271,14 +6751,14 @@ function normalizeOutputFolder(outputFolder) {
   return normalized || DEFAULT_OUTPUT_FOLDER;
 }
 function createInterviewDirectoryPath(directory, outputFolder) {
-  return path6.join(directory, normalizeOutputFolder(outputFolder));
+  return path8.join(directory, normalizeOutputFolder(outputFolder));
 }
 function createInterviewFilePath(directory, outputFolder, idea) {
   const fileName = `${slugify(idea) || "interview"}.md`;
-  return path6.join(createInterviewDirectoryPath(directory, outputFolder), fileName);
+  return path8.join(createInterviewDirectoryPath(directory, outputFolder), fileName);
 }
 function relativeInterviewPath(directory, filePath) {
-  return path6.relative(directory, filePath) || path6.basename(filePath);
+  return path8.relative(directory, filePath) || path8.basename(filePath);
 }
 function extractHistorySection(document) {
   const marker = `## Q&A history
@@ -5324,31 +6804,31 @@ function buildInterviewDocument(idea, summary, history) {
 `);
 }
 async function ensureInterviewFile(record) {
-  await fs5.mkdir(path6.dirname(record.markdownPath), { recursive: true });
+  await fs6.mkdir(path8.dirname(record.markdownPath), { recursive: true });
   try {
-    await fs5.access(record.markdownPath);
+    await fs6.access(record.markdownPath);
   } catch {
-    await fs5.writeFile(record.markdownPath, buildInterviewDocument(record.idea, "", ""), "utf8");
+    await fs6.writeFile(record.markdownPath, buildInterviewDocument(record.idea, "", ""), "utf8");
   }
 }
 async function readInterviewDocument(record) {
   try {
-    return await fs5.readFile(record.markdownPath, "utf8");
+    return await fs6.readFile(record.markdownPath, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       try {
-        return await fs5.readFile(record.markdownPath, "utf8");
+        return await fs6.readFile(record.markdownPath, "utf8");
       } catch {}
     }
   }
   await ensureInterviewFile(record);
-  return fs5.readFile(record.markdownPath, "utf8");
+  return fs6.readFile(record.markdownPath, "utf8");
 }
 async function rewriteInterviewDocument(record, summary) {
   const existing = await readInterviewDocument(record);
   const history = extractHistorySection(existing);
   const next = buildInterviewDocument(record.idea, summary, history);
-  await fs5.writeFile(record.markdownPath, next, "utf8");
+  await fs6.writeFile(record.markdownPath, next, "utf8");
   return next;
 }
 async function appendInterviewAnswers(record, questions, answers) {
@@ -5366,7 +6846,7 @@ A: ${answer.answer.trim()}` : null;
   const nextHistory = [history === "No answers yet." ? "" : history, appended].filter(Boolean).join(`
 
 `);
-  await fs5.writeFile(record.markdownPath, buildInterviewDocument(record.idea, summary, nextHistory), "utf8");
+  await fs6.writeFile(record.markdownPath, buildInterviewDocument(record.idea, summary, nextHistory), "utf8");
 }
 function resolveExistingInterviewPath(directory, outputFolder, value) {
   const trimmed = value.trim();
@@ -5375,22 +6855,22 @@ function resolveExistingInterviewPath(directory, outputFolder, value) {
   }
   const outputDir = createInterviewDirectoryPath(directory, outputFolder);
   const candidates = new Set;
-  const resolvedRoot = path6.resolve(directory);
-  if (path6.isAbsolute(trimmed)) {
+  const resolvedRoot = path8.resolve(directory);
+  if (path8.isAbsolute(trimmed)) {
     candidates.add(trimmed);
   } else {
-    candidates.add(path6.resolve(directory, trimmed));
-    candidates.add(path6.join(outputDir, trimmed));
+    candidates.add(path8.resolve(directory, trimmed));
+    candidates.add(path8.join(outputDir, trimmed));
     if (!trimmed.endsWith(".md")) {
-      candidates.add(path6.join(outputDir, `${trimmed}.md`));
+      candidates.add(path8.join(outputDir, `${trimmed}.md`));
     }
   }
   for (const candidate of candidates) {
-    if (path6.extname(candidate) !== ".md") {
+    if (path8.extname(candidate) !== ".md") {
       continue;
     }
-    const resolved = path6.resolve(candidate);
-    if (!resolved.startsWith(resolvedRoot + path6.sep) && resolved !== resolvedRoot) {
+    const resolved = path8.resolve(candidate);
+    if (!resolved.startsWith(resolvedRoot + path8.sep) && resolved !== resolvedRoot) {
       continue;
     }
     if (fsSync.existsSync(candidate)) {
@@ -5437,18 +6917,18 @@ function createInterviewService(ctx, config, deps) {
     if (!newSlug) {
       return;
     }
-    const currentFileName = path6.basename(interview.markdownPath, ".md");
+    const currentFileName = path8.basename(interview.markdownPath, ".md");
     if (currentFileName === newSlug) {
       return;
     }
-    const dir = path6.dirname(interview.markdownPath);
-    const newPath = path6.join(dir, `${newSlug}.md`);
+    const dir = path8.dirname(interview.markdownPath);
+    const newPath = path8.join(dir, `${newSlug}.md`);
     try {
-      await fs5.access(newPath);
+      await fs6.access(newPath);
       return;
     } catch {}
     try {
-      await fs5.rename(interview.markdownPath, newPath);
+      await fs6.rename(interview.markdownPath, newPath);
       interview.markdownPath = newPath;
       log("[interview] renamed file with assistant title:", {
         from: currentFileName,
@@ -5510,13 +6990,13 @@ function createInterviewService(ctx, config, deps) {
         active.status = "abandoned";
       }
     }
-    const document = await fs5.readFile(markdownPath, "utf8");
+    const document = await fs6.readFile(markdownPath, "utf8");
     const messages = await loadMessages(sessionID);
     const title = extractTitle(document);
     const record = {
-      id: `${Date.now()}-${++idCounter}-${slugify(path6.basename(markdownPath, ".md")) || "interview"}`,
+      id: `${Date.now()}-${++idCounter}-${slugify(path8.basename(markdownPath, ".md")) || "interview"}`,
       sessionID,
-      idea: title || path6.basename(markdownPath, ".md"),
+      idea: title || path8.basename(markdownPath, ".md"),
       markdownPath,
       createdAt: nowIso(),
       status: "active",
@@ -5658,7 +7138,7 @@ function createInterviewService(ctx, config, deps) {
     const resumePath = resolveExistingInterviewPath(ctx.directory, outputFolder, idea);
     if (resumePath) {
       const interview2 = await resumeInterview(input.sessionID, resumePath);
-      const document = await fs5.readFile(interview2.markdownPath, "utf8");
+      const document = await fs6.readFile(interview2.markdownPath, "utf8");
       await notifyInterviewUrl(input.sessionID, interview2);
       output.parts.push(createInternalAgentTextPart(buildResumePrompt(document, maxQuestions)));
       return;
@@ -5969,9 +7449,9 @@ function findSgCliPathSync() {
   }
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
-    for (const path7 of homebrewPaths) {
-      if (existsSync6(path7) && isValidBinary(path7)) {
-        return path7;
+    for (const path9 of homebrewPaths) {
+      if (existsSync6(path9) && isValidBinary(path9)) {
+        return path9;
       }
     }
   }
@@ -5988,8 +7468,8 @@ function getSgCliPath() {
   }
   return "sg";
 }
-function setSgCliPath(path7) {
-  resolvedCliPath = path7;
+function setSgCliPath(path9) {
+  resolvedCliPath = path9;
 }
 var DEFAULT_TIMEOUT_MS2 = 300000;
 var DEFAULT_MAX_OUTPUT_BYTES = 1 * 1024 * 1024;
@@ -8232,14 +9712,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 os3 from "os";
-import path10 from "path";
+import path12 from "path";
 import {
   tool as tool6
 } from "@opencode-ai/plugin";
 
 // src/tools/smartfetch/binary.ts
 import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
-import path7 from "path";
+import path9 from "path";
 function extensionForMime(contentType) {
   const mime = contentType.split(";")[0]?.trim().toLowerCase();
   const map = {
@@ -8260,10 +9740,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 = path7.parse(initialName);
+  const parsed = path9.parse(initialName);
   for (let attempt = 0;attempt < 1000; attempt++) {
     const candidateName = attempt === 0 ? initialName : `${parsed.name}-${attempt}${parsed.ext || `.${extensionForMime(contentType)}`}`;
-    const file = path7.join(binaryDir, candidateName);
+    const file = path9.join(binaryDir, candidateName);
     try {
       await writeFile2(file, data, { flag: "wx" });
       return file;
@@ -8281,7 +9761,7 @@ async function saveBinary(binaryDir, data, contentType, filename) {
 import { LRUCache } from "lru-cache";
 
 // src/tools/smartfetch/network.ts
-import path8 from "path";
+import path10 from "path";
 
 // src/tools/smartfetch/utils.ts
 import { Readability } from "@mozilla/readability";
@@ -8665,7 +10145,7 @@ function normalizeUrl(input) {
 }
 function isDocsLikeUrl(url) {
   const host = url.hostname.toLowerCase();
-  return DOCS_HOST_SUFFIXES.some((suffix) => host.endsWith(suffix)) || DOCS_HOST_PREFIXES.some((prefix) => host.startsWith(prefix));
+  return DOCS_HOST_SUFFIXES.some((suffix2) => host.endsWith(suffix2)) || DOCS_HOST_PREFIXES.some((prefix2) => host.startsWith(prefix2));
 }
 function buildPermissionPatterns(normalized, shouldProbeLlmsTxt) {
   const patterns = new Set([normalized.url]);
@@ -8721,7 +10201,7 @@ function isPermittedRedirect(from, to, allowedOrigins) {
 }
 function isBinaryContentType(contentType) {
   const mime = contentType.split(";")[0]?.trim().toLowerCase() || "";
-  return BINARY_PREFIXES.some((prefix) => mime.startsWith(prefix));
+  return BINARY_PREFIXES.some((prefix2) => mime.startsWith(prefix2));
 }
 function getBinaryKind(contentType) {
   const mime = contentType.split(";")[0]?.trim().toLowerCase() || "";
@@ -9000,7 +10480,7 @@ function inferFilenameFromUrl(url) {
 function truncateFilename(name, maxLength = 180) {
   if (name.length <= maxLength)
     return name;
-  const parsed = path8.parse(name);
+  const parsed = path10.parse(name);
   const ext = parsed.ext || "";
   const baseLimit = Math.max(1, maxLength - ext.length);
   return `${parsed.name.slice(0, baseLimit)}${ext}`;
@@ -9171,8 +10651,8 @@ function isInvalidLlmsResult(fetchResult) {
 
 // src/tools/smartfetch/secondary-model.ts
 import { existsSync as existsSync11 } from "fs";
-import { readFile as readFile2 } from "fs/promises";
-import path9 from "path";
+import { readFile as readFile3 } from "fs/promises";
+import path11 from "path";
 function parseModelRef(value) {
   if (!value)
     return;
@@ -9198,7 +10678,7 @@ function pickAgentModelRef(value) {
 }
 function findPreferredOpenCodeConfigPath(baseDir) {
   for (const file of ["opencode.jsonc", "opencode.json"]) {
-    const fullPath = path9.join(baseDir, file);
+    const fullPath = path11.join(baseDir, file);
     if (existsSync11(fullPath))
       return fullPath;
   }
@@ -9208,14 +10688,14 @@ async function readOpenCodeConfigFile(configPath) {
   if (!configPath)
     return;
   try {
-    const content = await readFile2(configPath, "utf8");
+    const content = await readFile3(configPath, "utf8");
     return JSON.parse(stripJsonComments(content));
   } catch {
     return;
   }
 }
 async function readEffectiveOpenCodeConfig(directory) {
-  const projectDir = path9.join(directory, ".opencode");
+  const projectDir = path11.join(directory, ".opencode");
   const userDirs = getConfigSearchDirs();
   const projectPath = findPreferredOpenCodeConfigPath(projectDir);
   const userPath = userDirs.map((configDir) => findPreferredOpenCodeConfigPath(configDir)).find(Boolean);
@@ -9376,7 +10856,7 @@ async function runSecondaryModelWithFallback(client, directory, models, prompt,
 // src/tools/smartfetch/tool.ts
 var z5 = tool6.schema;
 function createWebfetchTool(pluginCtx, options = {}) {
-  const binaryDir = options.binaryDir || path10.join(os3.tmpdir(), "opencode-smartfetch");
+  const binaryDir = options.binaryDir || path12.join(os3.tmpdir(), "opencode-smartfetch");
   return tool6({
     description: WEBFETCH_DESCRIPTION,
     args: {
@@ -9917,12 +11397,15 @@ var OhMyOpenCodeLite = async (ctx) => {
   });
   const phaseReminderHook = createPhaseReminderHook();
   const filterAvailableSkillsHook = createFilterAvailableSkillsHook(ctx, config);
-  const postFileToolNudgeHook = createPostFileToolNudgeHook();
+  const sessionAgentMap = new Map;
+  const postFileToolNudgeHook = createPostFileToolNudgeHook({
+    shouldInject: (sessionID) => sessionAgentMap.get(sessionID) === "orchestrator"
+  });
   const chatHeadersHook = createChatHeadersHook(ctx);
   const delegateTaskRetryHook = createDelegateTaskRetryHook(ctx);
+  const applyPatchHook = createApplyPatchHook(ctx);
   const jsonErrorRecoveryHook = createJsonErrorRecoveryHook(ctx);
   const foregroundFallback = new ForegroundFallbackManager(ctx.client, runtimeChains, config.fallback?.enabled !== false && Object.keys(runtimeChains).length > 0);
-  const sessionAgentMap = new Map;
   const todoContinuationHook = createTodoContinuationHook(ctx, {
     maxContinuations: config.todoContinuation?.maxContinuations ?? 5,
     cooldownMs: config.todoContinuation?.cooldownMs ?? 3000,
@@ -10061,16 +11544,25 @@ var OhMyOpenCodeLite = async (ctx) => {
       await backgroundManager.handleSessionDeleted(input.event);
       await multiplexerSessionManager.onSessionDeleted(input.event);
       await interviewManager.handleEvent(input);
+      await postFileToolNudgeHook.event(input);
+    },
+    "tool.execute.before": async (input, output) => {
+      await applyPatchHook["tool.execute.before"](input, output);
     },
     "command.execute.before": async (input, output) => {
       await todoContinuationHook.handleCommandExecuteBefore(input, output);
       await interviewManager.handleCommandExecuteBefore(input, output);
     },
     "chat.headers": chatHeadersHook["chat.headers"],
-    "chat.message": async (input) => {
-      if (input.agent) {
-        sessionAgentMap.set(input.sessionID, input.agent);
+    "chat.message": async (input, output) => {
+      const agent = input.agent ?? output?.message?.agent;
+      if (agent) {
+        sessionAgentMap.set(input.sessionID, agent);
       }
+      todoContinuationHook.handleChatMessage({
+        sessionID: input.sessionID,
+        agent
+      });
     },
     "experimental.chat.system.transform": async (input, output) => {
       const agentName = input.sessionID ? sessionAgentMap.get(input.sessionID) : undefined;
@@ -10080,9 +11572,10 @@ var OhMyOpenCodeLite = async (ctx) => {
           const { ORCHESTRATOR_PROMPT: ORCHESTRATOR_PROMPT2 } = await Promise.resolve().then(() => exports_orchestrator);
           output.system[0] = ORCHESTRATOR_PROMPT2 + (output.system[0] ? `
 
-` + output.system[0] : "");
+${output.system[0]}` : "");
         }
       }
+      await postFileToolNudgeHook["experimental.chat.system.transform"](input, output);
     },
     "experimental.chat.messages.transform": async (input, output) => {
       const typedOutput = output;