@yanlinglabs/winter-agent-runtime 0.0.40 → 0.0.43

package/dist/{index-a8j104mg.js → index-kqc3tdph.js}

@@ -732,43 +732,59 @@ function isExactWebFetchDomainRule(rule, hostname) {
 }
 var SKILL_RULE_TOOL = "Skill";
 var FIELD_VALUE = /^([A-Za-z_][A-Za-z0-9_]*):(.*)$/s;
-function isEscapedAt(s, t) {
-  let backslashes = 0;
-  let i = t - 1;
-  while (i >= 0 && s[i] === "\\") {
-    backslashes++;
-    i--;
-  }
-  return backslashes % 2 !== 0;
-}
-function firstUnescaped(s, ch) {
-  for (let t = 0;t < s.length; t++)
-    if (s[t] === ch && !isEscapedAt(s, t))
-      return t;
-  return -1;
+function splitRuleText(text) {
+  const { opens, closes } = unescapedParens(text);
+  const open = opens[0];
+  if (open === undefined || open === 0)
+    return;
+  const close = closes[closes.length - 1];
+  if (close === undefined || close !== text.length - 1 || close <= open)
+    return;
+  return { toolName: text.slice(0, open), rawContent: text.slice(open + 1, close) };
 }
-function lastUnescaped(s, ch) {
-  for (let t = s.length - 1;t >= 0; t--)
-    if (s[t] === ch && !isEscapedAt(s, t))
-      return t;
-  return -1;
+function unescapedParens(text) {
+  const opens = [];
+  const closes = [];
+  let backslashRun = 0;
+  for (let i = 0;i < text.length; i++) {
+    const ch = text[i];
+    if (ch === "\\") {
+      backslashRun++;
+      continue;
+    }
+    if (backslashRun % 2 === 0) {
+      if (ch === "(")
+        opens.push(i);
+      else if (ch === ")")
+        closes.push(i);
+    }
+    backslashRun = 0;
+  }
+  return { opens, closes };
 }
 function unescapeRuleContent(raw) {
-  return raw.replaceAll("\\(", "(").replaceAll("\\)", ")").replaceAll("\\\\", "\\");
+  let out = "";
+  for (let i = 0;i < raw.length; i++) {
+    const ch = raw[i];
+    const next = raw[i + 1];
+    if (ch === "\\" && (next === "(" || next === ")" || next === "\\")) {
+      out += next;
+      i++;
+    } else {
+      out += ch;
+    }
+  }
+  return out;
 }
 function parseRule(raw) {
   const trimmed = raw.trim();
   const bareFallback = () => ({ toolName: trimmed, isBareEquivalent: true });
-  const openIdx = firstUnescaped(trimmed, "(");
-  if (openIdx === -1)
-    return bareFallback();
-  const toolName = trimmed.slice(0, openIdx);
-  if (toolName === "" || /\s/.test(toolName))
+  const parts = splitRuleText(trimmed);
+  if (parts === undefined)
     return bareFallback();
-  const closeIdx = lastUnescaped(trimmed, ")");
-  if (closeIdx === -1 || closeIdx <= openIdx || closeIdx !== trimmed.length - 1)
+  const { toolName, rawContent } = parts;
+  if (/\s/.test(toolName))
     return bareFallback();
-  const rawContent = trimmed.slice(openIdx + 1, closeIdx);
   if (rawContent === "" || rawContent === "*") {
     return { toolName, specifier: { kind: "wildcardAll" }, isBareEquivalent: true };
   }
@@ -870,139 +886,67 @@ function matchesRule(rule, call, opts) {
     }
   }
 }
-var SUE_FILE_PATTERN_TOOLS = new Set(["Read", "Write", "Edit", "Glob", "NotebookRead", "NotebookEdit", "Cd"]);
-var SUE_BASH_PREFIX_TOOLS = new Set(["Bash"]);
-function sueCustomValidator(toolName) {
-  if (toolName === "WebSearch") {
-    return (content) => content.includes("*") || content.includes("?") ? { valid: false, error: "WebSearch does not support wildcards", suggestion: "Use exact search terms without * or ?" } : { valid: true };
-  }
-  if (toolName === "WebFetch") {
-    return (content) => {
-      if (content.includes("://") || content.startsWith("http")) {
-        return { valid: false, error: "WebFetch permissions use domain format, not URLs", suggestion: 'Use "domain:hostname" format' };
-      }
-      if (!content.startsWith("domain:")) {
-        return { valid: false, error: 'WebFetch permissions must use "domain:" prefix', suggestion: 'Use "domain:hostname" format' };
-      }
-      return { valid: true };
-    };
-  }
-  return;
-}
-function sueCountUnescaped(s, ch) {
-  let count = 0;
-  for (let i = 0;i < s.length; i++)
-    if (s[i] === ch && !isEscapedAt(s, i))
-      count++;
-  return count;
-}
-function sueHasUnescapedEmptyParens(s) {
-  for (let i = 0;i < s.length - 1; i++) {
-    if (s[i] === "(" && s[i + 1] === ")" && !isEscapedAt(s, i))
-      return true;
-  }
-  return false;
-}
-function sueParseMcpName(toolName) {
-  const parts = toolName.split("__");
-  const first = parts[0];
-  const serverName = parts[1];
-  if (first !== "mcp" || !serverName)
-    return null;
-  const rest = parts.slice(2);
-  return { serverName, ...rest.length > 0 ? { toolName: rest.join("__") } : {} };
-}
-function sueAllowWildcardScopeError(toolName) {
-  if (!toolName.includes("*"))
-    return null;
-  const mcp = sueParseMcpName(toolName);
-  if (mcp !== null && !mcp.serverName.includes("*"))
-    return null;
-  return {
-    valid: false,
-    error: `Wildcard tool name "${toolName}" is not supported in allow rules`,
-    suggestion: "An allow pattern must name the scope it widens — globs are permitted only in the tool position after a literal mcp__<server>__ prefix. Deny and ask rules accept wildcards anywhere"
-  };
-}
-function sueExtractToolAndContent(raw) {
-  const trimmed = raw.trim();
-  const openIdx = firstUnescaped(trimmed, "(");
-  if (openIdx === -1)
-    return { toolName: trimmed };
-  const toolName = trimmed.slice(0, openIdx);
-  if (toolName === "")
-    return { toolName: trimmed };
-  const closeIdx = lastUnescaped(trimmed, ")");
-  if (closeIdx === -1 || closeIdx <= openIdx || closeIdx !== trimmed.length - 1)
-    return { toolName: trimmed };
-  const rawContent = trimmed.slice(openIdx + 1, closeIdx);
-  if (rawContent === "" || rawContent === "*")
-    return { toolName };
-  return { toolName, ruleContent: unescapeRuleContent(rawContent) };
-}
 function validatePermissionRuleString(raw, direction) {
-  if (!raw || raw.trim() === "")
-    return { valid: false, error: "Permission rule cannot be empty" };
-  const openCount = sueCountUnescaped(raw, "(");
-  const closeCount = sueCountUnescaped(raw, ")");
-  if (openCount !== closeCount) {
-    return { valid: false, error: "Mismatched parentheses", suggestion: "Ensure all opening parentheses have matching closing parentheses" };
-  }
-  if (sueHasUnescapedEmptyParens(raw)) {
-    const parenIdx = raw.indexOf("(");
-    const prefix = parenIdx === -1 ? "" : raw.substring(0, parenIdx);
-    if (!prefix)
-      return { valid: false, error: "Empty parentheses with no tool name", suggestion: "Specify a tool name before the parentheses" };
-    return { valid: false, error: "Empty parentheses", suggestion: `Either specify a pattern or use just "${prefix}" without parentheses` };
-  }
-  const { toolName, ruleContent } = sueExtractToolAndContent(raw);
-  const mcp = sueParseMcpName(toolName);
-  if (mcp !== null) {
-    if (ruleContent !== undefined || sueCountUnescaped(raw, "(") > 0) {
-      return {
-        valid: false,
-        error: "MCP rules do not support patterns in parentheses",
-        suggestion: `Use "${toolName}" without parentheses, or use "mcp__${mcp.serverName}__*" for all tools`
-      };
-    }
-    if (direction === "allow") {
-      const wildcardError = sueAllowWildcardScopeError(toolName);
-      if (wildcardError !== null)
-        return wildcardError;
-    }
+  const invalid = (error, suggestion) => suggestion === undefined ? { valid: false, error } : { valid: false, error, suggestion };
+  const trimmed = raw.trim();
+  if (trimmed === "")
+    return invalid("Permission rule cannot be empty");
+  const { opens, closes } = unescapedParens(raw);
+  if (opens.length !== closes.length)
+    return invalid("Mismatched parentheses", "Ensure all opening parentheses have matching closing parentheses");
+  if (opens.some((i) => raw[i + 1] === ")")) {
+    const prefix = raw.slice(0, raw.indexOf("("));
+    return prefix === "" ? invalid("Empty parentheses with no tool name", "Specify a tool name before the parentheses") : invalid("Empty parentheses", `Either specify a pattern or use just "${prefix}" without parentheses`);
+  }
+  const parts = splitRuleText(trimmed);
+  const toolName = parts === undefined ? trimmed : parts.toolName;
+  const content = parts === undefined || parts.rawContent === "" || parts.rawContent === "*" ? undefined : unescapeRuleContent(parts.rawContent);
+  const wildcardRefusal = () => invalid(`Wildcard tool name "${toolName}" is not supported in allow rules`, ALLOW_WILDCARD_SUGGESTION);
+  const nameParts = toolName.split("__");
+  if (nameParts[0] === "mcp" && nameParts[1]) {
+    const server = nameParts[1];
+    if (content !== undefined || opens.length > 0) {
+      return invalid("MCP rules do not support patterns in parentheses", `Use "${toolName}" without parentheses, or use "mcp__${server}__*" for all tools`);
+    }
+    if (direction === "allow" && server.includes("*"))
+      return wildcardRefusal();
     return { valid: true };
   }
-  if (!toolName || toolName.length === 0)
-    return { valid: false, error: "Tool name cannot be empty" };
-  if (direction === "allow") {
-    const wildcardError = sueAllowWildcardScopeError(toolName);
-    if (wildcardError !== null)
-      return wildcardError;
-  }
-  if (!toolName.includes("_") && toolName[0] !== toolName[0]?.toUpperCase()) {
-    return { valid: false, error: "Tool names must start with uppercase", suggestion: `Use "${toolName.charAt(0).toUpperCase()}${toolName.slice(1)}"` };
-  }
-  const customValidator = sueCustomValidator(toolName);
-  if (customValidator !== undefined && ruleContent !== undefined) {
-    const result = customValidator(ruleContent);
-    if (!result.valid)
-      return result;
+  if (toolName === "")
+    return invalid("Tool name cannot be empty");
+  if (direction === "allow" && toolName.includes("*"))
+    return wildcardRefusal();
+  if (!toolName.includes("_")) {
+    const first = toolName[0];
+    const upper = first.toUpperCase();
+    if (first !== upper)
+      return invalid("Tool names must start with uppercase", `Use "${upper}${toolName.slice(1)}"`);
   }
-  if (SUE_BASH_PREFIX_TOOLS.has(toolName) && ruleContent !== undefined) {
-    if (ruleContent.includes(":*") && !ruleContent.endsWith(":*")) {
-      return { valid: false, error: "The :* pattern must be at the end", suggestion: "Move :* to the end for prefix matching, or use * for wildcard matching" };
+  if (content !== undefined) {
+    if (toolName === "WebSearch" && (content.includes("*") || content.includes("?"))) {
+      return invalid("WebSearch does not support wildcards", "Use exact search terms without * or ?");
     }
-    if (ruleContent === ":*") {
-      return { valid: false, error: "Prefix cannot be empty before :*", suggestion: "Specify a command prefix before :*" };
+    if (toolName === "WebFetch") {
+      if (content.includes("://") || content.startsWith("http"))
+        return invalid("WebFetch permissions use domain format, not URLs", 'Use "domain:hostname" format');
+      if (!content.startsWith("domain:"))
+        return invalid('WebFetch permissions must use "domain:" prefix', 'Use "domain:hostname" format');
     }
-  }
-  if (SUE_FILE_PATTERN_TOOLS.has(toolName) && ruleContent !== undefined) {
-    if (ruleContent.includes(":*")) {
-      return { valid: false, error: 'The ":*" syntax is only for Bash prefix rules', suggestion: 'Use glob patterns like "*" or "**" for file matching' };
+    if (toolName === "Bash") {
+      if (content.includes(":*") && !content.endsWith(":*")) {
+        return invalid("The :* pattern must be at the end", "Move :* to the end for prefix matching, or use * for wildcard matching");
+      }
+      if (content === ":*")
+        return invalid("Prefix cannot be empty before :*", "Specify a command prefix before :*");
+    }
+    if (LOAD_TIME_FILE_PATTERN_TOOLS.has(toolName) && content.includes(":*")) {
+      return invalid('The ":*" syntax is only for Bash prefix rules', 'Use glob patterns like "*" or "**" for file matching');
     }
   }
   return { valid: true };
 }
+var ALLOW_WILDCARD_SUGGESTION = "An allow pattern must name the scope it widens — globs are permitted only in the tool position after a literal mcp__<server>__ prefix. Deny and ask rules accept wildcards anywhere";
+var LOAD_TIME_FILE_PATTERN_TOOLS = new Set(["Read", "Write", "Edit", "Glob", "NotebookRead", "NotebookEdit", "Cd"]);
 
 // src/tools/registry.ts
 var DEFERRED_BUILTINS_CAPABILITY = "winter.deferred-builtins";
@@ -1187,6 +1131,11 @@ var CONCURRENCY_LANE = /^[A-Za-z0-9_.:-]{1,64}$/;
 function isValidConcurrencyLane(lane) {
   return typeof lane === "string" && CONCURRENCY_LANE.test(lane);
 }
+function concurrentToolSet(raw) {
+  if (!Array.isArray(raw))
+    return new Set;
+  return new Set(raw.filter((name) => typeof name === "string"));
+}
 function registerMcpServerTools(server, incomingTools, opts) {
   if (RESERVED_MCP_SERVER_NAMES.has(server)) {
     throw new Error(`registerMcpServerTools: "${server}" is a RESERVED server name -- the standing Winter server ` + `(its name is defined in mcp/winter-server.ts) owns this identity and is registry-native; it is never installed through ` + `this live-mutation function, and nothing else may register live tools under it either.`);
@@ -1238,12 +1187,13 @@ function registerMcpServerTools(server, incomingTools, opts) {
     }
   }
   const nowOwned = new Set;
+  const concurrent = concurrentToolSet(opts.concurrentTools);
   for (const tool of tools) {
     const canonicalName = registeredName(tool);
     const existingEntry = registry.get(canonicalName);
     const built = buildMcpToolDescriptor(server, tool, opts, plainNameFor(tool));
     const lane = opts.toolLanes !== undefined && Object.hasOwn(opts.toolLanes, tool.name) ? opts.toolLanes[tool.name] : undefined;
-    const descriptor = isValidConcurrencyLane(lane) ? { ...built, concurrencyLane: lane } : built;
+    const descriptor = isValidConcurrencyLane(lane) ? { ...built, concurrencyLane: lane } : concurrent.has(tool.name) ? { ...built, concurrencySafe: true } : built;
     registry.set(canonicalName, existingEntry ? { ...existingEntry, descriptor } : { descriptor });
     mcpToolOwner.set(canonicalName, server);
     nowOwned.add(canonicalName);
@@ -1699,37 +1649,53 @@ function resolveRealTarget(path) {
     return join(resolveRealTarget(dir), basename(path));
   }
 }
-var MAX_SYMLINK_CHAIN_HOPS = 40;
 function resolveSymlinkTargetChain(path) {
-  let current = path;
-  for (let hop = 0;hop < MAX_SYMLINK_CHAIN_HOPS; hop++) {
-    try {
-      return realpathSync(current);
-    } catch {}
-    let probe = current;
-    const remainder = [];
-    let deepestReal = null;
-    while (deepestReal === null) {
-      const parent = dirname(probe);
-      if (parent === probe)
-        return;
-      remainder.unshift(basename(probe));
-      probe = parent;
-      try {
-        deepestReal = realpathSync(probe);
-      } catch {}
-    }
-    const firstUnresolved = join(deepestReal, remainder[0]);
-    let linkValue = null;
-    try {
-      linkValue = readlinkSync(firstUnresolved);
-    } catch {}
-    if (linkValue === null)
-      return join(deepestReal, ...remainder);
-    current = join(resolve(dirname(firstUnresolved), linkValue), ...remainder.slice(1));
+  return followChainFrom(path, MAX_HAND_FOLLOWED_LINKS);
+}
+var MAX_HAND_FOLLOWED_LINKS = 40;
+function followChainFrom(current, followsLeft) {
+  const real = realpathOrUndefined(current);
+  if (real !== undefined)
+    return real;
+  const split = splitAtDeepestResolvableAncestor(current);
+  if (split === undefined)
+    return;
+  const { realAncestor, nextName, remainingNames } = split;
+  const linkTarget = readlinkOrUndefined(join(realAncestor, nextName));
+  if (linkTarget === undefined)
+    return join(realAncestor, nextName, ...remainingNames);
+  if (followsLeft <= 1)
+    return;
+  return followChainFrom(join(resolve(realAncestor, linkTarget), ...remainingNames), followsLeft - 1);
+}
+function splitAtDeepestResolvableAncestor(path) {
+  const lineage = [path];
+  for (let parent = dirname(path);parent !== lineage[lineage.length - 1]; parent = dirname(parent)) {
+    lineage.push(parent);
+  }
+  for (let depth = 1;depth < lineage.length; depth++) {
+    const realAncestor = realpathOrUndefined(lineage[depth]);
+    if (realAncestor === undefined)
+      continue;
+    const leafward = lineage.slice(0, depth).map((member) => basename(member));
+    return { realAncestor, nextName: leafward[depth - 1], remainingNames: leafward.slice(0, depth - 1).reverse() };
   }
   return;
 }
+function realpathOrUndefined(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return;
+  }
+}
+function readlinkOrUndefined(path) {
+  try {
+    return readlinkSync(path);
+  } catch {
+    return;
+  }
+}
 function resolveSymlinkEnds(path) {
   return { target: resolveRealTarget(path), chainTarget: resolveSymlinkTargetChain(path) };
 }
@@ -1746,7 +1712,7 @@ function checkSymlinkBothEnds(path, matcher) {
 
 // src/permissions/file-rules.ts
 import { realpathSync as realpathSync2 } from "node:fs";
-import { dirname as dirname2, isAbsolute as isAbsolute2, join as join2, normalize as normalize2, relative, sep } from "node:path";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join2, normalize as normalize2, relative } from "node:path";
 import ignoreFactory from "ignore";
 function fileRuleKindFor(toolName) {
   switch (toolName) {
@@ -1767,20 +1733,14 @@ function canonicalFileRuleAuthoringToolName(kind) {
 }
 var INERT_ANCHOR = Symbol("file-rule-inert-anchor");
 function resolveFileRuleAnchor(pattern, opts) {
-  if (pattern.startsWith("//")) {
+  if (pattern.startsWith("//"))
     return { relativePattern: pattern.slice(1), root: "/" };
-  }
-  if (pattern.startsWith("~/")) {
+  if (pattern.startsWith("~/"))
     return { relativePattern: pattern.slice(1), root: opts.home };
-  }
-  if (pattern.startsWith("/")) {
-    if (opts.sourceDir === undefined)
-      return { relativePattern: pattern, root: INERT_ANCHOR };
-    return { relativePattern: pattern, root: opts.sourceDir };
-  }
-  if (pattern.startsWith("./")) {
+  if (pattern.startsWith("/"))
+    return { relativePattern: pattern, root: opts.sourceDir ?? INERT_ANCHOR };
+  if (pattern.startsWith("./"))
     return { relativePattern: pattern.slice(2), root: null };
-  }
   return { relativePattern: pattern, root: null };
 }
 var RULE_PATH_GLOB_CHARS = /[*?[\]]/;
@@ -1847,36 +1807,19 @@ function escapeRegexLiteralPath(path) {
   return path.replace(/[.^$+{}()|\\[\]*?]/g, "\\$&");
 }
 function isSuspiciousRealpathResolution(original, resolved) {
-  const r = normalize2(original);
-  const o = normalize2(resolved);
-  if (o === r)
-    return false;
-  if (r.startsWith("/tmp/") && o === "/private" + r)
-    return false;
-  if (r.startsWith("/var/") && o === "/private" + r)
+  const written = normalize2(original);
+  const landed = normalize2(resolved);
+  const spellings = acceptableSpellingsOf(written);
+  if (spellings.includes(landed))
     return false;
-  if (r.startsWith("/private/tmp/") && o === r)
-    return false;
-  if (r.startsWith("/private/var/") && o === r)
-    return false;
-  if (o === "/")
-    return true;
-  if (o.split("/").filter(Boolean).length <= 1)
-    return true;
-  if (r.startsWith(o + "/"))
-    return true;
-  let p = r;
-  if (r.startsWith("/tmp/"))
-    p = "/private" + r;
-  else if (r.startsWith("/var/"))
-    p = "/private" + r;
-  if (p !== r && p.startsWith(o + "/"))
-    return true;
-  const linkUnderOriginal = o.startsWith(r + "/");
-  const linkUnderPrivateAlias = p !== r && o.startsWith(p + "/");
-  if (o !== r && !(p !== r && o === p) && !linkUnderOriginal && !linkUnderPrivateAlias)
-    return true;
-  return false;
+  const shallow = landed.split("/").filter((segment) => segment !== "").length <= 1;
+  const climbedAbove = spellings.some((spelling) => spelling.startsWith(landed + "/"));
+  const wentBelow = spellings.some((spelling) => landed.startsWith(spelling + "/"));
+  return shallow || climbedAbove || !wentBelow;
+}
+function acceptableSpellingsOf(path) {
+  const aliased = path.startsWith("/tmp/") || path.startsWith("/var/");
+  return aliased ? [path, "/private" + path] : [path];
 }
 function guardedCanonicalize(path) {
   try {
@@ -1895,19 +1838,81 @@ function canonicalizedGlobFixedPrefix(absoluteGlob) {
   return guardedCanonicalize(scan.literal.slice(0, scan.lastSepLiteralLength));
 }
 function ancestorDirectoriesOf(path) {
-  const out = [];
-  let current = dirname2(path);
-  while (current !== "/" && current !== ".") {
-    out.push(current);
+  const ancestors = [];
+  let current = path;
+  for (;; ) {
     const parent = dirname2(current);
-    if (parent === current)
-      break;
+    if (parent === current || parent === "/" || parent === ".")
+      return ancestors;
+    ancestors.push(parent);
     current = parent;
   }
-  return out;
 }
-function poVerbatim(glob) {
-  return "^" + glob.replace(/[.^$+{}()|\\]/g, "\\$&").replace(/\[([^\]]*?)$/g, "\\[$1").replace(/\*\*\//g, "__GLOBSTAR_SLASH__").replace(/\*\*/g, "__GLOBSTAR__").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/__GLOBSTAR_SLASH__/g, "(.*/)?").replace(/__GLOBSTAR__/g, ".*") + "$";
+function globToAnchoredRegex(glob) {
+  const literalBracketAt = glob.indexOf("[", glob.lastIndexOf("]") + 1);
+  let body = "";
+  let wordRun = "";
+  const emit = (rendered) => {
+    if (wordRun !== "") {
+      body += renderWordRun(wordRun);
+      wordRun = "";
+    }
+    body += rendered;
+  };
+  let i = 0;
+  while (i < glob.length) {
+    const ch = glob.charAt(i);
+    if (ch === "*") {
+      let runEnd = i;
+      while (glob.charAt(runEnd) === "*")
+        runEnd++;
+      let stars = runEnd - i;
+      const intoDirectory = stars >= 2 && glob.charAt(runEnd) === "/";
+      if (intoDirectory)
+        stars -= 2;
+      for (let pair = 0;pair < Math.floor(stars / 2); pair++)
+        wordRun += GLOBSTAR_SPELLING;
+      if (stars % 2 === 1)
+        emit(SINGLE_SEGMENT_REGEX);
+      if (intoDirectory)
+        wordRun += GLOBSTAR_SLASH_SPELLING;
+      i = intoDirectory ? runEnd + 1 : runEnd;
+      continue;
+    }
+    if (WORD_RUN_CHARACTERS.has(ch))
+      wordRun += ch;
+    else
+      emit(renderGlobCharacter(ch, i === literalBracketAt));
+    i++;
+  }
+  emit("");
+  return "^" + body + "$";
+}
+var SINGLE_SEGMENT_REGEX = "[^/]*";
+var GLOBSTAR_SPELLING = "__GLOBSTAR__";
+var GLOBSTAR_SLASH_SPELLING = "__GLOBSTAR_SLASH__";
+var WORD_RUN_CHARACTERS = new Set(GLOBSTAR_SPELLING + GLOBSTAR_SLASH_SPELLING);
+var ESCAPED_REGEX_CHARACTERS = new Set(".^$+{}()|\\");
+function renderGlobCharacter(ch, isLiteralBracket) {
+  if (ESCAPED_REGEX_CHARACTERS.has(ch))
+    return "\\" + ch;
+  if (ch === "?")
+    return "[^/]";
+  if (ch === "[" && isLiteralBracket)
+    return "\\[";
+  return ch;
+}
+function renderWordRun(spelling) {
+  return expandOccurrences(spelling, GLOBSTAR_SLASH_SPELLING, "(.*/)?", (stretch) => expandOccurrences(stretch, GLOBSTAR_SPELLING, ".*", (plain) => plain));
+}
+function expandOccurrences(text, needle, expansion, between) {
+  let out = "";
+  let from = 0;
+  for (let hit = text.indexOf(needle);hit !== -1; hit = text.indexOf(needle, from)) {
+    out += between(text.slice(from, hit)) + expansion;
+    from = hit + needle.length;
+  }
+  return out + between(text.slice(from));
 }
 function globToSbplRegexSource(absoluteGlob) {
   const scan = scanDenyPathGlob(absoluteGlob);
@@ -1915,12 +1920,11 @@ function globToSbplRegexSource(absoluteGlob) {
     return "^" + escapeRegexLiteralPath(guardedCanonicalize(scan.literal)) + "$";
   const canonicalPrefix = canonicalizedGlobFixedPrefix(absoluteGlob);
   if (canonicalPrefix === undefined)
-    return poVerbatim(absoluteGlob);
-  return "^" + escapeRegexLiteralPath(canonicalPrefix) + poVerbatim(absoluteGlob.slice(scan.lastSepRaw)).slice(1);
+    return globToAnchoredRegex(absoluteGlob);
+  return "^" + escapeRegexLiteralPath(canonicalPrefix) + globToAnchoredRegex(absoluteGlob.slice(scan.lastSepRaw)).slice(1);
 }
 function recursiveGlobToSbplRegexSource(absoluteGlob) {
-  const base = globToSbplRegexSource(absoluteGlob);
-  return base.slice(0, -1) + "(/.*)?$";
+  return globToSbplRegexSource(absoluteGlob).replace(/\$$/, "(/.*)?$");
 }
 function splitDenyPathsByGlobShape(paths) {
   const plain = [];
@@ -1950,18 +1954,37 @@ function globDenyEntriesOf(paths) {
 }
 function normalizeFileRulePattern(relativePattern) {
   const collapsed = relativePattern.replace(/\/{2,}/g, "/");
-  if (/^\s*(?:\/\*\*)?$/.test(collapsed))
-    return collapsed;
-  return collapsed.replace(/^([!#]?)/, (_m, directive) => directive ? "\\" + directive : "").replace(/^/, "[\uFEFF]");
+  switch (leadingBomTreatment(collapsed)) {
+    case "keep":
+      return collapsed;
+    case "escape-directive":
+      return "\\" + collapsed.slice(1);
+    case "bracket-second-bom":
+      return `[${BYTE_ORDER_MARK}]` + collapsed.slice(2);
+    case "drop":
+      return collapsed.slice(1);
+  }
+}
+var BYTE_ORDER_MARK = "\uFEFF";
+function leadingBomTreatment(pattern) {
+  if (/^\s*(?:\/\*\*)?$/.test(pattern) || !pattern.startsWith(BYTE_ORDER_MARK))
+    return "keep";
+  const next = pattern.charAt(1);
+  if (next === "!" || next === "#")
+    return "escape-directive";
+  return next === BYTE_ORDER_MARK ? "bracket-second-bom" : "drop";
 }
 function unanchorTrailingDoubleStar(pattern, isAllow) {
   if (!pattern.endsWith("/**"))
     return pattern;
-  const stripped = pattern.slice(0, -3);
-  if (/[^/]/.test(stripped)) {
-    return stripped.includes("/") || !isAllow || /^[!#]/.test(stripped) ? stripped : "/" + stripped;
-  }
-  return "/**";
+  const rest = pattern.slice(0, -3);
+  if (/^\/*$/.test(rest))
+    return "/**";
+  if (!isAllow)
+    return rest;
+  const singleSegment = !rest.includes("/");
+  const directive = rest.startsWith("!") || rest.startsWith("#");
+  return singleSegment && !directive ? "/" + rest : rest;
 }
 
 class FileRuleCompileError extends Error {
@@ -1970,90 +1993,94 @@ class FileRuleCompileError extends Error {
     this.name = "FileRuleCompileError";
   }
 }
-var INVALID_RELATIVE_PATH = /^\.{0,2}\/|^\.{1,2}$/;
-function isPathValidRelative(rel) {
-  return rel !== "" && !INVALID_RELATIVE_PATH.test(rel);
-}
 function matchFileRulesGrouped(candidates, path, opts, behavior) {
-  if (candidates.length === 0)
-    return null;
+  const isAllow = behavior === "allow";
   const groups = new Map;
-  const groupOrder = [];
   for (const candidate of candidates) {
     const anchor = resolveFileRuleAnchor(candidate.pattern, { home: opts.home, sourceDir: candidate.sourceDir });
     if (anchor.root === INERT_ANCHOR)
       continue;
-    const rootKey = anchor.root ?? opts.cwd;
-    const normalized = normalizeFileRulePattern(anchor.relativePattern);
-    const compiled = unanchorTrailingDoubleStar(normalized, behavior === "allow");
-    let group = groups.get(rootKey);
+    const root = anchor.root ?? opts.cwd;
+    const compiled = unanchorTrailingDoubleStar(normalizeFileRulePattern(anchor.relativePattern), isAllow);
+    let group = groups.get(root);
     if (group === undefined) {
-      group = { byCompiledPattern: new Map, ig: ignoreFactory({ ignorecase: true }) };
-      groups.set(rootKey, group);
-      groupOrder.push(rootKey);
+      group = { matcher: ignoreFactory({ ignorecase: true }), entryByPattern: new Map };
+      groups.set(root, group);
     }
-    group.byCompiledPattern.set(compiled, candidate.entry);
-    group.ig.add(compiled);
+    group.matcher.add(compiled);
+    group.entryByPattern.set(compiled, candidate.entry);
   }
-  for (const rootKey of groupOrder) {
-    const group = groups.get(rootKey);
-    const rel = relative(rootKey, path);
-    if (!isPathValidRelative(rel))
+  for (const [root, group] of groups) {
+    const rel = relative(root, path);
+    if (isOutsideIgnoreRoot(rel))
       continue;
     let result;
     try {
-      result = group.ig.test(rel);
-    } catch (cause) {
-      throw new FileRuleCompileError(`a file-rule pattern under ${JSON.stringify(rootKey)} failed to compile`, { cause });
-    }
-    if (result.ignored && result.rule) {
-      const winner = group.byCompiledPattern.get(result.rule.pattern);
-      if (winner !== undefined)
-        return winner;
+      result = group.matcher.test(rel);
+    } catch (err) {
+      throw new FileRuleCompileError(`a file-rule pattern under ${JSON.stringify(root)} failed to compile`, { cause: err });
     }
+    if (!result.ignored)
+      continue;
+    const matchedPattern = result.rule?.pattern;
+    if (matchedPattern !== undefined && group.entryByPattern.has(matchedPattern))
+      return group.entryByPattern.get(matchedPattern);
   }
   return null;
 }
-var TRUSTED_SYMLINK_CANDIDATES = [
-  ["/private/tmp", "/tmp"],
-  ["/private/var", "/var"],
-  ["/private/etc", "/etc"],
-  ["/usr/bin", "/bin"],
-  ["/usr/lib", "/lib"],
-  ["/usr/sbin", "/sbin"]
-];
-var cachedTrustedSymlinkEquivalences;
-function trustedSymlinkEquivalences() {
-  if (cachedTrustedSymlinkEquivalences !== undefined)
-    return cachedTrustedSymlinkEquivalences;
-  const result = new Map;
-  for (const [real, alias] of TRUSTED_SYMLINK_CANDIDATES) {
-    try {
-      if (realpathSync2(alias) === real)
-        result.set(real, alias);
-    } catch {}
-  }
-  cachedTrustedSymlinkEquivalences = result;
-  return result;
+function isOutsideIgnoreRoot(rel) {
+  return rel === "" || rel === "." || rel === ".." || rel.startsWith("/") || rel.startsWith("./") || rel.startsWith("../");
 }
 function canonicalizeTrustedSymlinkPath(path) {
-  for (const [real, alias] of trustedSymlinkEquivalences()) {
-    if (path === real || path.startsWith(real + sep))
+  for (const { real, alias } of verifiedTrustedSymlinkPairs()) {
+    if (path === real)
+      return alias;
+    if (path.startsWith(real + "/"))
       return alias + path.slice(real.length);
   }
   return path;
 }
+var TRUSTED_SYMLINK_PAIRS = [
+  { real: "/private/tmp", alias: "/tmp" },
+  { real: "/private/var", alias: "/var" },
+  { real: "/private/etc", alias: "/etc" },
+  { real: "/usr/bin", alias: "/bin" },
+  { real: "/usr/lib", alias: "/lib" },
+  { real: "/usr/sbin", alias: "/sbin" }
+];
+var trustedSymlinkPairsCache;
+function verifiedTrustedSymlinkPairs() {
+  if (trustedSymlinkPairsCache === undefined) {
+    trustedSymlinkPairsCache = TRUSTED_SYMLINK_PAIRS.filter(({ real, alias }) => {
+      try {
+        return realpathSync2(alias) === real;
+      } catch {
+        return false;
+      }
+    });
+  }
+  return trustedSymlinkPairsCache;
+}
 function isPathWithinRoot(childPath, rootPath, opts = {}) {
   const caseFold = opts.caseFold ?? true;
-  const alias = (p) => p.replace(/^\/private\/var\//, "/var/").replace(/^\/private\/tmp(\/|$)/, "/tmp$1");
-  const fold = (p) => caseFold ? p.toLowerCase() : p;
-  const rel = relative(fold(alias(rootPath)), fold(alias(childPath)));
+  const prepare = (p) => {
+    const short = shortSystemAlias(p);
+    return caseFold ? short.toLowerCase() : short;
+  };
+  const rel = relative(prepare(rootPath), prepare(childPath));
   if (rel === "")
     return true;
-  if (rel === ".." || rel.startsWith(`..${sep}`))
+  if (rel === ".." || rel.startsWith("../"))
     return false;
   return !isAbsolute2(rel);
 }
+function shortSystemAlias(p) {
+  if (p.startsWith("/private/var/"))
+    return "/var/" + p.slice("/private/var/".length);
+  if (p === "/private/tmp" || p.startsWith("/private/tmp/"))
+    return "/tmp" + p.slice("/private/tmp".length);
+  return p;
+}
 function resolvesWithinPluginRoot(candidatePath, pluginRoot) {
   if (candidatePath.includes("\\"))
     return false;
@@ -2073,8 +2100,16 @@ function resolvesWithinPluginRoot(candidatePath, pluginRoot) {
   return !isAbsolute2(rel);
 }
 function escapeFileRulePathSegment(path) {
-  const bracketsAndStar = path.replace(/[[\]*\\]/g, (ch) => "\\" + ch);
-  return bracketsAndStar.replace(/\s+$/, (run) => Array.from(run, (ch) => "\\" + ch).join(""));
+  const escaped = path.replace(/[[\]*\\]/g, "\\$&");
+  let start = escaped.length;
+  while (start > 0 && /\s/.test(escaped[start - 1]))
+    start--;
+  if (start === escaped.length)
+    return escaped;
+  let tail = "";
+  for (const ch of escaped.slice(start))
+    tail += "\\" + ch;
+  return escaped.slice(0, start) + tail;
 }
 function matchesSingleFileRulePattern(pattern, path, opts, behavior) {
   return matchFileRulesGrouped([{ entry: true, pattern }], path, opts, behavior) !== null;
@@ -2114,113 +2149,120 @@ function canonicalizePath(p) {
   }
 }
 var canon = canonicalizePath;
+var subpathClause = (p) => `(subpath "${sbplString(p)}")`;
+var literalClause = (p) => `(literal "${sbplString(p)}")`;
+var regexClause = (source) => `(regex #"${escapeSbplRegexDelimiter(source)}")`;
+
+class ClauseBlock {
+  seen = new Set;
+  clauses = [];
+  add(clause) {
+    if (this.seen.has(clause))
+      return;
+    this.seen.add(clause);
+    this.clauses.push(clause);
+  }
+  render(header) {
+    if (this.clauses.length === 0)
+      return "";
+    const lines = this.clauses.map((c) => `  ${c}`);
+    lines[lines.length - 1] += ")";
+    return [header, ...lines].join(`
+`);
+  }
+}
 function buildAncestorRenameBypassBlock(plainDenyPaths, globFixedPrefixes) {
-  const clauses = new Set;
-  for (const path of plainDenyPaths) {
-    const canonical = canon(path);
-    clauses.add(`(subpath "${sbplString(canonical)}")`);
-    for (const ancestor of ancestorDirectoriesOf(canonical))
-      clauses.add(`(literal "${sbplString(ancestor)}")`);
+  const block = new ClauseBlock;
+  for (const entry of plainDenyPaths) {
+    const path = canon(entry);
+    block.add(subpathClause(path));
+    for (const dir of ancestorDirectoriesOf(path))
+      block.add(literalClause(dir));
   }
   for (const prefix of globFixedPrefixes) {
-    clauses.add(`(literal "${sbplString(prefix)}")`);
-    for (const ancestor of ancestorDirectoriesOf(prefix))
-      clauses.add(`(literal "${sbplString(ancestor)}")`);
+    block.add(literalClause(prefix));
+    for (const dir of ancestorDirectoriesOf(prefix))
+      block.add(literalClause(dir));
   }
-  if (clauses.size === 0)
-    return "";
-  return [`(deny file-write-unlink file-write-create`, ...[...clauses].map((c) => `  ${c}`)].join(`
-`) + ")";
+  return block.render("(deny file-write-unlink file-write-create");
 }
 function buildReadDenyWritePermitBlock(writableRoots) {
-  if (writableRoots.length === 0)
-    return "";
-  const clauses = new Set(writableRoots.map((r) => `(subpath "${sbplString(r)}")`));
-  return [`(allow file-write-unlink file-write-create`, ...[...clauses].map((c) => `  ${c}`)].join(`
-`) + ")";
+  const block = new ClauseBlock;
+  for (const root of writableRoots)
+    block.add(subpathClause(root));
+  return block.render("(allow file-write-unlink file-write-create");
 }
 var IMAGE_PREP_DIRNAME = "image-prep";
 var WRITE_OPS_SURVIVING_READ_DENY_REPERMIT = "file-write* file-write-unlink file-write-create";
 var DEFAULT_PROTECTED_FILES = [".gitconfig", ".gitmodules", ".bashrc", ".bash_profile", ".zshrc", ".zprofile", ".profile", ".ripgreprc", ".mcp.json"];
 var DEFAULT_PROTECTED_DIRS = [".vscode", ".idea", ".claude/commands", ".claude/agents"];
 var PROJECT_DIR_PROTECTED_KINDS = ["commands", "agents", "skills", "rules", "output-styles"];
-function cwdAnchoredEntryRegex(cwd, entry, recursive) {
-  const absoluteGlob = join3(cwd, "**", entry) + (recursive ? "/**" : "");
-  return recursiveGlobToSbplRegexSource(absoluteGlob);
-}
-function buildDefaultWriteProtectionEntries(cwd, brand, allowGitConfigWrites) {
-  const plainPaths = [];
-  const regexes = [];
-  for (const f of DEFAULT_PROTECTED_FILES) {
-    plainPaths.push(join3(cwd, f));
-    regexes.push(cwdAnchoredEntryRegex(cwd, f, false));
-  }
-  const winterMcpJson = join3(brand.projectDirName, "mcp.json");
-  plainPaths.push(join3(cwd, winterMcpJson));
-  regexes.push(cwdAnchoredEntryRegex(cwd, winterMcpJson, false));
-  for (const d of DEFAULT_PROTECTED_DIRS) {
-    plainPaths.push(join3(cwd, d));
-    regexes.push(cwdAnchoredEntryRegex(cwd, d, true));
-  }
-  for (const kind of PROJECT_DIR_PROTECTED_KINDS) {
-    const d = join3(brand.projectDirName, kind);
-    plainPaths.push(join3(cwd, d));
-    regexes.push(cwdAnchoredEntryRegex(cwd, d, true));
-  }
-  plainPaths.push(join3(cwd, ".git", "hooks"));
-  regexes.push(cwdAnchoredEntryRegex(cwd, ".git/hooks", true));
-  if (!allowGitConfigWrites) {
-    plainPaths.push(join3(cwd, ".git", "config"));
-    regexes.push(cwdAnchoredEntryRegex(cwd, ".git/config", false));
-  }
-  return { plainPaths, regexes };
-}
 function buildDefaultWriteProtectionBlock(cwd, brand, allowGitConfigWrites) {
-  const { plainPaths, regexes } = buildDefaultWriteProtectionEntries(cwd, brand, allowGitConfigWrites);
-  const plainDenyClauses = plainPaths.map((p) => `(deny ${WRITE_OPS_SURVIVING_READ_DENY_REPERMIT} (subpath "${sbplString(canon(p))}"))`).join(`
-`);
-  const regexDenyClauses = regexes.map((r) => `(deny ${WRITE_OPS_SURVIVING_READ_DENY_REPERMIT} (regex #"${escapeSbplRegexDelimiter(r)}"))`).join(`
-`);
-  const ancestorFence = buildAncestorRenameBypassBlock(plainPaths, []);
-  return [plainDenyClauses, regexDenyClauses, ancestorFence].filter((s) => s.length > 0).join(`
+  const proj = brand.projectDirName;
+  const entries = [
+    ...DEFAULT_PROTECTED_FILES.map((rel) => ({ rel, isDir: false })),
+    { rel: `${proj}/mcp.json`, isDir: false },
+    ...DEFAULT_PROTECTED_DIRS.map((rel) => ({ rel, isDir: true })),
+    ...PROJECT_DIR_PROTECTED_KINDS.map((kind) => ({ rel: `${proj}/${kind}`, isDir: true })),
+    { rel: ".git/hooks", isDir: true },
+    ...allowGitConfigWrites ? [] : [{ rel: ".git/config", isDir: false }]
+  ];
+  const plainPaths = entries.map((e) => join3(cwd, e.rel));
+  const regexSources = entries.map((e) => {
+    const anyDepth = join3(cwd, "**", e.rel);
+    return recursiveGlobToSbplRegexSource(e.isDir ? `${anyDepth}/**` : anyDepth);
+  });
+  const lines = [
+    ...plainPaths.map((p) => `(deny ${WRITE_OPS_SURVIVING_READ_DENY_REPERMIT} ${subpathClause(canon(p))})`),
+    ...regexSources.map((r) => `(deny ${WRITE_OPS_SURVIVING_READ_DENY_REPERMIT} ${regexClause(r)})`),
+    buildAncestorRenameBypassBlock(plainPaths, [])
+  ];
+  return lines.join(`
 `);
 }
 function isProperDescendantOf(candidate, root) {
-  return root === "/" ? candidate !== "/" && candidate.startsWith("/") : candidate !== root && candidate.startsWith(root + "/");
+  if (root === "/")
+    return candidate !== "/" && candidate.startsWith("/");
+  return candidate !== root && candidate.startsWith(`${root}/`);
+}
+function withCarveOuts(base, carveOuts) {
+  if (carveOuts.length === 0)
+    return base;
+  const exclusions = carveOuts.map((x) => `(require-not ${subpathClause(x)})`).join(" ");
+  return `(require-all ${base} ${exclusions})`;
 }
 function buildReadDenyKeepInPlaceBlock(plainDenyReadPaths, globDenyReadEntries, writableRoots) {
   if (writableRoots.length === 0)
     return "";
-  const isUnderAnyWriteRoot = (path) => writableRoots.some((root) => isProperDescendantOf(path, root));
-  const nestedWriteRootCarveOuts = (deniedPath) => writableRoots.filter((root) => isProperDescendantOf(root, deniedPath)).map((root) => `(subpath "${sbplString(root)}")`);
-  const withCarveOuts = (base, carveOuts) => carveOuts.length === 0 ? base : `(require-all ${base} ${carveOuts.map((c) => `(require-not ${c})`).join(" ")})`;
-  const addAncestorLiterals = (clauses, ancestors) => {
-    for (const ancestor of ancestors)
-      if (isUnderAnyWriteRoot(ancestor))
-        clauses.add(`(literal "${sbplString(ancestor)}")`);
-  };
-  const clauses = new Set;
-  for (const rawPath of plainDenyReadPaths) {
-    const path = canon(rawPath);
-    if (!isUnderAnyWriteRoot(path))
+  const insideSomeRoot = (p) => writableRoots.some((root) => isProperDescendantOf(p, root));
+  const block = new ClauseBlock;
+  for (const entry of plainDenyReadPaths) {
+    const path = canon(entry);
+    if (!insideSomeRoot(path))
       continue;
-    clauses.add(withCarveOuts(`(subpath "${sbplString(path)}")`, nestedWriteRootCarveOuts(path)));
-    addAncestorLiterals(clauses, ancestorDirectoriesOf(path));
+    const nestedRoots = writableRoots.filter((root) => isProperDescendantOf(root, path));
+    block.add(withCarveOuts(subpathClause(path), nestedRoots));
+    for (const dir of ancestorDirectoriesOf(path)) {
+      if (insideSomeRoot(dir))
+        block.add(literalClause(dir));
+    }
   }
-  for (const entry of globDenyReadEntries) {
-    const relatesToAWriteRoot = writableRoots.some((root) => entry.fixedPrefix === root || isProperDescendantOf(entry.fixedPrefix, root) || isProperDescendantOf(root, entry.fixedPrefix));
-    if (!relatesToAWriteRoot)
+  for (const { regex, fixedPrefix } of globDenyReadEntries) {
+    const prefix = fixedPrefix;
+    const relates = writableRoots.some((root) => prefix === root || isProperDescendantOf(prefix, root) || isProperDescendantOf(root, prefix));
+    if (!relates)
       continue;
-    const regex = new RegExp(entry.regex);
-    const carveOuts = writableRoots.filter((root) => regex.test(root)).map((root) => `(subpath "${sbplString(root)}")`);
-    clauses.add(withCarveOuts(`(regex #"${escapeSbplRegexDelimiter(entry.regex)}")`, carveOuts));
-    if (entry.fixedPrefix !== "/")
-      addAncestorLiterals(clauses, [entry.fixedPrefix, ...ancestorDirectoriesOf(entry.fixedPrefix)]);
+    const compiled = new RegExp(regex);
+    const matchedRoots = writableRoots.filter((root) => compiled.test(root));
+    block.add(withCarveOuts(regexClause(regex), matchedRoots));
+    if (prefix !== "/") {
+      for (const dir of [prefix, ...ancestorDirectoriesOf(prefix)]) {
+        if (insideSomeRoot(dir))
+          block.add(literalClause(dir));
+      }
+    }
   }
-  if (clauses.size === 0)
-    return "";
-  return [`(deny file-write-unlink`, ...[...clauses].map((c) => `  ${c}`)].join(`
-`) + ")";
+  return block.render("(deny file-write-unlink");
 }
 var CONTROL_PLANE_FILES = ["permissions.local.json", "settings.json", "settings.local.json"];
 function caseFoldSegment(segment) {
@@ -2628,23 +2670,22 @@ registerAttachmentRenderer("agent_listing_delta", (a) => {
   const addedLines = stringArray(a["addedLines"]);
   const addedTypes = stringArray(a["addedTypes"]);
   const removedTypes = stringArray(a["removedTypes"]);
+  const initial = a["isInitial"] === true;
   const sections = [];
   const hasAdded = addedLines.length > 0 && addedTypes.length > 0;
   if (hasAdded)
-    sections.push(`${a["isInitial"] === true ? AGENT_LISTING_INITIAL_HEADER : AGENT_LISTING_ADDED_HEADER}
+    sections.push(`${initial ? AGENT_LISTING_INITIAL_HEADER : AGENT_LISTING_ADDED_HEADER}
 ${addedLines.join(`
 `)}`);
   if (removedTypes.length > 0) {
     sections.push(`${AGENT_LISTING_REMOVED_HEADER}
-${removedTypes.map((t) => `- ${t}`).join(`
+${removedTypes.map((name) => `- ${name}`).join(`
 `)}`);
     sections.push(AMBIENT_CONTEXT_SENTENCE);
   }
-  if (hasAdded && a["isInitial"] === true && a["showConcurrencyNote"] === true)
+  if (hasAdded && initial && a["showConcurrencyNote"] === true)
     sections.push(AGENT_CONCURRENCY_SENTENCE);
-  if (sections.length === 0)
-    return;
-  return neutralizeReminderTags(sections.join(`
+  return sections.length === 0 ? undefined : neutralizeReminderTags(sections.join(`
 
 `));
 });
@@ -2740,10 +2781,10 @@ function announcedAgentTypes(messages) {
     if (a.type !== "agent_listing_delta")
       continue;
     if (Array.isArray(a["addedLines"]))
-      for (const t of stringArray(a["addedTypes"]))
-        announced.add(t);
-    for (const t of stringArray(a["removedTypes"]))
-      announced.delete(t);
+      for (const type of stringArray(a["addedTypes"]))
+        announced.add(type);
+    for (const type of stringArray(a["removedTypes"]))
+      announced.delete(type);
   }
   return announced;
 }
@@ -2779,26 +2820,26 @@ function localDateString(now = new Date) {
 function xmlEscape(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }
-var TAG_ROOT = "task-notification";
-var TAG_ORDER = [
-  ["task-id", "taskId"],
-  ["tool-use-id", "toolUseId"],
-  ["task-type", "taskType"],
-  ["output-file", "outputFile"],
-  ["status", "status"],
-  ["summary", "summary"]
-];
 function renderTaskNotification(fields) {
-  let out = `<${TAG_ROOT}>`;
-  for (const [tag, key] of TAG_ORDER) {
-    const value = fields[key];
-    if (typeof value !== "string" || value.length === 0)
-      continue;
-    out += `
+  const tagged = [
+    ["task-id", fields.taskId],
+    ["tool-use-id", fields.toolUseId],
+    ["task-type", fields.taskType],
+    ["output-file", fields.outputFile],
+    ["status", fields.status],
+    ["summary", fields.summary]
+  ];
+  let out = "<task-notification>";
+  for (const [tag, value] of tagged) {
+    if (typeof value === "string" && value.length > 0)
+      out += `
 <${tag}>${value}</${tag}>`;
   }
-  return `${out}${fields.body ?? ""}
-</${TAG_ROOT}>${fields.trailing ?? ""}`;
+  out += fields.body ?? "";
+  out += `
+</task-notification>`;
+  out += fields.trailing ?? "";
+  return out;
 }
 var SYSTEM_NOTIFICATION_MARKER = "[SYSTEM NOTIFICATION - NOT USER INPUT]";
 var NOTIFICATION_PREAMBLE = `${SYSTEM_NOTIFICATION_MARKER}
@@ -2818,34 +2859,60 @@ function withNotificationPreamble(value, opts) {
     return value;
   return `${opts?.inHumanTurn === true ? NOTIFICATION_PREAMBLE_IN_HUMAN_TURN : NOTIFICATION_PREAMBLE}${neutralizeReminderTags(value)}`;
 }
-function xmlStatus(status) {
+function nonEmpty(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function statusWord(status) {
   return status === "stopped" ? "killed" : status;
 }
+function optionalEscaped(toolUseId, outputFile) {
+  return {
+    ...toolUseId !== undefined ? { toolUseId: xmlEscape(toolUseId) } : {},
+    ...outputFile !== undefined ? { outputFile: xmlEscape(outputFile) } : {}
+  };
+}
+function usageCounters(usage) {
+  return `<subagent_tokens>${String(usage.totalTokens)}</subagent_tokens><tool_uses>${String(usage.toolUses)}</tool_uses><duration_ms>${String(usage.durationMs)}</duration_ms>`;
+}
+function usageBlock(usage) {
+  return `<usage>${usageCounters(usage)}</usage>`;
+}
+var AGENT_RESUME_NOTE = "<note>This notification fires each time the agent stops with no background work of its own still running, so the same task-id can notify more than once. Send it another message with SendMessage to resume it.</note>";
 function renderAgentNotification(input) {
-  const finished = input.maxTurnsReached !== undefined ? `stopped at its ${input.maxTurnsReached}-turn limit (partial result; SendMessage to task-id to continue)` : "finished";
-  const outcome = input.status === "completed" ? finished : input.status === "failed" ? `failed: ${input.error !== undefined && input.error.length > 0 ? input.error : "Unknown error"}` : input.stoppedBy === "parent" ? "was stopped by the assistant" : input.stoppedBy === "user" ? "was stopped by user" : "was stopped";
-  const result = input.finalMessage !== undefined && input.finalMessage.length > 0 ? `
-<result>${xmlEscape(input.finalMessage)}</result>` : "";
-  const usage = input.usage !== undefined ? `
-<usage><subagent_tokens>${input.usage.totalTokens}</subagent_tokens><tool_uses>${input.usage.toolUses}</tool_uses><duration_ms>${input.usage.durationMs}</duration_ms></usage>` : "";
-  const worktree = input.worktree !== undefined ? `
-<worktree><worktreePath>${xmlEscape(input.worktree.path)}</worktreePath>${input.worktree.branch !== undefined ? `<worktreeBranch>${xmlEscape(input.worktree.branch)}</worktreeBranch>` : ""}</worktree>` : "";
+  let outcome;
+  if (input.status === "completed") {
+    outcome = input.maxTurnsReached !== undefined ? `stopped at its ${input.maxTurnsReached}-turn limit (partial result; SendMessage to task-id to continue)` : "finished";
+  } else if (input.status === "failed") {
+    outcome = `failed: ${nonEmpty(input.error) ? input.error : "Unknown error"}`;
+  } else {
+    outcome = input.stoppedBy === "parent" ? "was stopped by the assistant" : input.stoppedBy === "user" ? "was stopped by user" : "was stopped";
+  }
+  let body = `
+${AGENT_RESUME_NOTE}`;
+  if (nonEmpty(input.finalMessage))
+    body += `
+<result>${xmlEscape(input.finalMessage)}</result>`;
+  if (input.usage !== undefined)
+    body += `
+${usageBlock(input.usage)}`;
+  if (input.worktree !== undefined) {
+    const branch = input.worktree.branch !== undefined ? `<worktreeBranch>${xmlEscape(input.worktree.branch)}</worktreeBranch>` : "";
+    body += `
+<worktree><worktreePath>${xmlEscape(input.worktree.path)}</worktreePath>${branch}</worktree>`;
+  }
   return renderTaskNotification({
     taskId: xmlEscape(input.taskId),
-    ...input.toolUseId !== undefined ? { toolUseId: xmlEscape(input.toolUseId) } : {},
-    ...input.outputFile !== undefined ? { outputFile: xmlEscape(input.outputFile) } : {},
-    status: xmlStatus(input.status),
+    ...optionalEscaped(input.toolUseId, input.outputFile),
+    status: statusWord(input.status),
     summary: xmlEscape(`Agent "${input.description}" ${outcome}`),
-    body: `
-<note>This notification fires each time the agent stops with no background work of its own still running, so the same task-id can notify more than once. Send it another message with SendMessage to resume it.</note>${result}${usage}${worktree}`
+    body
   });
 }
 function renderShellNotification(input) {
   return renderTaskNotification({
     taskId: xmlEscape(input.taskId),
-    ...input.toolUseId !== undefined ? { toolUseId: xmlEscape(input.toolUseId) } : {},
-    ...input.outputFile !== undefined ? { outputFile: xmlEscape(input.outputFile) } : {},
-    status: xmlStatus(input.status),
+    ...optionalEscaped(input.toolUseId, input.outputFile),
+    status: statusWord(input.status),
     summary: xmlEscape(input.summary)
   });
 }
@@ -2861,28 +2928,40 @@ function renderTaskStopNotification(input) {
   const who = input.stoppedBy === "parent" ? "the assistant" : "user";
   return renderTaskNotification({
     taskId: xmlEscape(input.taskId),
-    ...input.toolUseId !== undefined ? { toolUseId: xmlEscape(input.toolUseId) } : {},
+    ...optionalEscaped(input.toolUseId, undefined),
     status: "stopped",
     summary: xmlEscape(`Task "${input.description}" was stopped by ${who}`)
   });
 }
 function renderWorkflowNotification(input) {
-  const name = xmlEscape(input.name !== undefined && input.name.length > 0 ? input.name : "Dynamic workflow");
-  const summary = input.status === "completed" ? `Dynamic workflow "${name}" completed` : input.status === "failed" ? `Dynamic workflow "${name}" failed: ${input.error !== undefined && input.error.length > 0 ? xmlEscape(input.error) : "Unknown error"}` : `Dynamic workflow "${name}" was stopped`;
-  const result = input.result !== undefined && input.result.length > 0 ? `
-<result>${xmlEscape(input.result)}</result>` : "";
-  const failures = input.failures !== undefined && input.failures.length > 0 ? `
+  const name = xmlEscape(nonEmpty(input.name) ? input.name : "Dynamic workflow");
+  let summary;
+  if (input.status === "completed")
+    summary = `Dynamic workflow "${name}" completed`;
+  else if (input.status === "failed")
+    summary = `Dynamic workflow "${name}" failed: ${nonEmpty(input.error) ? xmlEscape(input.error) : "Unknown error"}`;
+  else
+    summary = `Dynamic workflow "${name}" was stopped`;
+  let body = "";
+  if (nonEmpty(input.result))
+    body += `
+<result>${xmlEscape(input.result)}</result>`;
+  if (input.failures !== undefined && input.failures.length > 0)
+    body += `
 <failures>${xmlEscape(input.failures.join(`
-`))}</failures>` : "";
-  const usage = input.usage !== undefined || input.agentCount !== undefined ? `
-<usage><agent_count>${input.agentCount ?? 0}</agent_count><subagent_tokens>${input.usage?.totalTokens ?? 0}</subagent_tokens><tool_uses>${input.usage?.toolUses ?? 0}</tool_uses><duration_ms>${input.usage?.durationMs ?? 0}</duration_ms></usage>` : "";
+`))}</failures>`;
+  if (input.usage !== undefined || input.agentCount !== undefined) {
+    const given = input.usage ?? {};
+    const usage = { totalTokens: given.totalTokens ?? 0, toolUses: given.toolUses ?? 0, durationMs: given.durationMs ?? 0 };
+    body += `
+<usage><agent_count>${String(input.agentCount ?? 0)}</agent_count>${usageCounters(usage)}</usage>`;
+  }
   return renderTaskNotification({
     taskId: xmlEscape(input.taskId),
-    ...input.toolUseId !== undefined ? { toolUseId: xmlEscape(input.toolUseId) } : {},
-    ...input.outputFile !== undefined ? { outputFile: xmlEscape(input.outputFile) } : {},
-    status: xmlStatus(input.status),
+    ...optionalEscaped(input.toolUseId, input.outputFile),
+    status: statusWord(input.status),
     summary,
-    body: `${result}${failures}${usage}`
+    body
   });
 }
 var PRIORITY_RANK = { next: 0, later: 1 };
@@ -7002,8 +7081,17 @@ function isCacheableTransport(config) {
 }
 var FIRST_TURN_MCP_WAIT_DEFAULT_MS = 2000;
 function firstTurnMcpWaitDeadlineMs(opts) {
-  const explicitAsksForWait = opts.strictMcpConfig === true || Object.values(opts.explicitServers ?? {}).some((server) => server?.type !== "sdk");
-  return explicitAsksForWait ? opts.envConfig.timeoutMs : FIRST_TURN_MCP_WAIT_DEFAULT_MS;
+  if (opts.strictMcpConfig === true)
+    return opts.envConfig.timeoutMs;
+  const servers = opts.explicitServers;
+  if (servers !== undefined && servers !== null) {
+    for (const config of Object.values(servers)) {
+      const inProcess = typeof config === "object" && config !== null && config.type === "sdk";
+      if (!inProcess)
+        return opts.envConfig.timeoutMs;
+    }
+  }
+  return FIRST_TURN_MCP_WAIT_DEFAULT_MS;
 }
 var sessionLifecycles = new Map;
 function registerSessionMcpLifecycle(sessionId, lifecycle) {
@@ -9119,66 +9207,80 @@ function resolveBuiltinAgents(opts) {
 }
 
 // src/subagents/definitions.ts
-var FRONTMATTER_REGEX = /^---\s*\n([\s\S]*?)---\s*\n?/;
-function stripLeadingBom(raw) {
-  return raw.charCodeAt(0) === 65279 ? raw.slice(1) : raw;
+function parseFrontmatter(raw) {
+  const text = raw.charCodeAt(0) === 65279 ? raw.slice(1) : raw;
+  const split = splitFrontmatter(text);
+  if (split === undefined)
+    return { attrs: {}, body: raw };
+  return { attrs: readFrontmatterBlock(split.block), body: text.slice(split.bodyStart) };
 }
-var YAML_SPECIAL_CHARS = /[{}[\]*&#!|>%@`]|: /;
-function quoteProblematicValues(frontmatterText) {
-  const lines = frontmatterText.split(`
-`);
-  const result = [];
-  for (const line of lines) {
-    const match = /^([a-zA-Z_-]+):\s+(.+)$/.exec(line);
-    if (match) {
-      const key = match[1];
-      const value = match[2];
-      if (value.startsWith("[") && value.endsWith("]")) {
-        try {
-          if (Array.isArray(Bun.YAML.parse(value))) {
-            result.push(line);
-            continue;
-          }
-        } catch {}
-      }
-      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-        result.push(line);
-        continue;
-      }
-      if (YAML_SPECIAL_CHARS.test(value)) {
-        const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
-        result.push(`${key}: "${escaped}"`);
-        continue;
-      }
-    }
-    result.push(line);
-  }
-  return result.join(`
-`);
+var WHITESPACE_CHAR = /\s/;
+function skipWhitespace(text, from) {
+  let i = from;
+  while (i < text.length && WHITESPACE_CHAR.test(text[i]))
+    i++;
+  return i;
 }
-function quoteAndDetab(frontmatterText) {
-  return quoteProblematicValues(frontmatterText).replace(/^\t+/gm, (m) => "  ".repeat(m.length));
+function splitFrontmatter(text) {
+  if (!text.startsWith("---"))
+    return;
+  const runEnd = skipWhitespace(text, 3);
+  const lastLf = text.lastIndexOf(`
+`, runEnd - 1);
+  if (lastLf < 3)
+    return;
+  const blockStart = lastLf + 1;
+  const close = text.indexOf("---", blockStart);
+  if (close === -1)
+    return;
+  return { block: text.slice(blockStart, close), bodyStart: skipWhitespace(text, close + 3) };
 }
-function parseFrontmatter(raw) {
-  const stripped = stripLeadingBom(raw);
-  const match = FRONTMATTER_REGEX.exec(stripped);
-  if (!match)
-    return { attrs: {}, body: raw };
-  const frontmatterText = match[1] ?? "";
-  const body = stripped.slice(match[0].length);
-  let attrs = {};
+function isPlainObject2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readFrontmatterBlock(block) {
+  let parsed;
   try {
-    const parsed = Bun.YAML.parse(frontmatterText);
-    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed))
-      attrs = parsed;
+    parsed = Bun.YAML.parse(block);
   } catch {
     try {
-      const parsed = Bun.YAML.parse(quoteAndDetab(frontmatterText));
-      if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed))
-        attrs = parsed;
-    } catch {}
+      parsed = Bun.YAML.parse(detabLineStarts(quoteLooseValues(block)));
+    } catch {
+      return {};
+    }
   }
-  return { attrs, body };
+  return isPlainObject2(parsed) ? parsed : {};
+}
+var KEY_LINE_HEAD = /^([A-Za-z_-]+):(\s+)/;
+var LINE_TERMINATOR = /[\r\u2028\u2029]/;
+var YAML_SPECIAL_CHAR = /[{}[\]*&#!|>%@`]/;
+function quoteLooseValues(block) {
+  return block.split(`
+`).map((line) => {
+    const head = KEY_LINE_HEAD.exec(line);
+    if (head === null)
+      return line;
+    const key = head[1];
+    const value = line.slice(head[0].length);
+    if (value.length === 0 || LINE_TERMINATOR.test(value))
+      return line;
+    if (value.startsWith("[") && value.endsWith("]")) {
+      try {
+        if (Array.isArray(Bun.YAML.parse(value)))
+          return line;
+      } catch {}
+    }
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))
+      return line;
+    if (YAML_SPECIAL_CHAR.test(value) || value.includes(": ")) {
+      return `${key}: "${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+    }
+    return line;
+  }).join(`
+`);
+}
+function detabLineStarts(text) {
+  return text.replace(/^\t+/gm, (tabs) => "  ".repeat(tabs.length));
 }
 function asString(v) {
   return typeof v === "string" ? v : undefined;
@@ -9489,67 +9591,70 @@ var PREAPPROVED_HOST_ENTRIES = [
   "nginx.org",
   "httpd.apache.org"
 ];
+function isPreapprovedHost(hostname, pathname) {
+  if (HOSTNAME_ONLY.has(hostname))
+    return true;
+  const prefixes = PATH_PREFIXES.get(hostname);
+  if (prefixes === undefined)
+    return false;
+  if (isTraversalEncoded(pathname))
+    return false;
+  return prefixes.some((prefix) => underPrefix(pathname, prefix));
+}
 var HOSTNAME_ONLY = new Set;
 var PATH_PREFIXES = new Map;
 for (const entry of PREAPPROVED_HOST_ENTRIES) {
   const slash = entry.indexOf("/");
   if (slash === -1) {
     HOSTNAME_ONLY.add(entry);
-  } else {
-    const host = entry.slice(0, slash);
-    const prefix = entry.slice(slash);
-    const existing = PATH_PREFIXES.get(host);
-    if (existing)
-      existing.push(prefix);
-    else
-      PATH_PREFIXES.set(host, [prefix]);
+    continue;
   }
+  const host = entry.slice(0, slash);
+  const prefix = entry.slice(slash);
+  const list = PATH_PREFIXES.get(host);
+  if (list === undefined)
+    PATH_PREFIXES.set(host, [prefix]);
+  else if (!list.includes(prefix))
+    list.push(prefix);
 }
-var ENCODED_TRAVERSAL = /%(25)*(2f|5c|2e)/i;
-function isPreapprovedHost(hostname, pathname) {
-  if (HOSTNAME_ONLY.has(hostname))
-    return true;
-  const prefixes = PATH_PREFIXES.get(hostname);
-  if (prefixes === undefined)
-    return false;
-  if (ENCODED_TRAVERSAL.test(pathname))
-    return false;
-  return prefixes.some((prefix) => pathname === prefix || pathname.startsWith(`${prefix}/`));
+var ENCODED_TRAVERSAL = /%(?:25)*(?:2f|5c|2e)/i;
+function isTraversalEncoded(pathname) {
+  return ENCODED_TRAVERSAL.test(pathname);
+}
+function underPrefix(pathname, prefix) {
+  return pathname === prefix || pathname.startsWith(`${prefix}/`);
+}
+function wwwVariants(host) {
+  const bare = host.startsWith("www.") ? host.slice(4) : host;
+  return [...new Set([host, bare, `www.${bare}`])];
 }
 function isPreapprovedUrl(url) {
   return isPreapprovedHost(url.hostname, url.pathname);
 }
-function candidateHosts(hostname) {
-  const stripped = hostname.startsWith("www.") ? hostname.slice(4) : hostname;
-  return [...new Set([hostname, stripped, `www.${stripped}`])];
-}
 function preapprovedScopeOf(url) {
-  const { pathname } = url;
-  for (const host of candidateHosts(url.hostname)) {
-    if (HOSTNAME_ONLY.has(host))
-      return { host };
-    const prefixes = PATH_PREFIXES.get(host);
+  const pathname = url.pathname;
+  for (const candidate of wwwVariants(url.hostname)) {
+    if (HOSTNAME_ONLY.has(candidate))
+      return { host: candidate };
+    const prefixes = PATH_PREFIXES.get(candidate);
     if (prefixes === undefined)
       continue;
-    if (ENCODED_TRAVERSAL.test(pathname))
+    if (isTraversalEncoded(pathname))
       return;
-    const prefix = prefixes.find((p) => pathname === p || pathname.startsWith(`${p}/`));
+    const prefix = prefixes.find((p) => underPrefix(pathname, p));
     if (prefix !== undefined)
-      return { host, pathPrefix: prefix };
+      return { host: candidate, pathPrefix: prefix };
   }
   return;
 }
 function staysWithinScope(from, url) {
-  const stripped = from.host.startsWith("www.") ? from.host.slice(4) : from.host;
-  const acceptableHosts = new Set([from.host, stripped, `www.${stripped}`]);
-  if (!acceptableHosts.has(url.hostname))
+  if (!wwwVariants(from.host).includes(url.hostname))
     return false;
   if (from.pathPrefix === undefined)
     return true;
-  const { pathname } = url;
-  if (ENCODED_TRAVERSAL.test(pathname))
+  if (isTraversalEncoded(url.pathname))
     return false;
-  return pathname === from.pathPrefix || pathname.startsWith(`${from.pathPrefix}/`);
+  return underPrefix(url.pathname, from.pathPrefix);
 }
 
 // src/web/private-address.ts
@@ -9647,29 +9752,22 @@ function extractCandidateWritePaths(call, ctx) {
   const recognized = recognizeEditOperation(call, { sessionRoot: ctx.sessionRoot, home: ctx.home, ...ctx.brand !== undefined ? { brand: ctx.brand } : {} });
   return recognized ? recognized.paths : [];
 }
-var TRAILING_DOT_OR_WHITESPACE_COMPONENT = /[.\s]+$/;
-var DEVICE_NAME_SUFFIX = /\.(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])$/i;
-var TRIPLE_DOT_COMPONENT = /(^|\/|\\)\.{3,}(\/|\\|$)/;
-var SHORT_FILENAME_TILDE = /~\d/;
 function isSuspiciousPath(path) {
-  if (/^[\\/]\?\?[\\/]/.test(path))
+  if (/^[/\\]\?\?[/\\]/.test(path))
     return true;
-  if (SHORT_FILENAME_TILDE.test(path))
+  if (/~[0-9]/.test(path))
     return true;
-  if (path.startsWith("\\\\?\\") || path.startsWith("\\\\.\\") || path.startsWith("//?/") || path.startsWith("//./"))
+  if (SUSPICIOUS_PATH_PREFIXES.some((prefix) => path.startsWith(prefix)))
     return true;
   for (const component of path.split(/[/\\]/)) {
     if (component === "" || component === "." || component === "..")
       continue;
-    if (TRAILING_DOT_OR_WHITESPACE_COMPONENT.test(component))
+    if (/[.\s]$/.test(component))
       return true;
   }
-  if (DEVICE_NAME_SUFFIX.test(path))
-    return true;
-  if (TRIPLE_DOT_COMPONENT.test(path))
-    return true;
-  return false;
+  return /\.(?:CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])$/i.test(path);
 }
+var SUSPICIOUS_PATH_PREFIXES = ["\\\\?\\", "\\\\.\\", "//?/", "//./"];
 function suspiciousSymlinkTarget(rawCandidate, ctx) {
   try {
     const absPath = resolveTargetPath(rawCandidate, ctx.cwd);
@@ -11909,66 +12007,46 @@ ${DIRECTIVE_PREFIX}${input.prompt}`;
 
 ${worktreeNote(input.worktree.parentRoot, input.worktree.worktreeRoot)}` : directive;
 }
-function isToolUseBlock(block) {
-  return block.type === "tool_use";
-}
-function isToolResultBlock(block) {
-  return block.type === "tool_result";
-}
-function answeredToolUseIds(messages) {
+function buildForkInitialMessages(inherit, forkToolUseId) {
+  const messages = inherit.messages;
+  if (messages === undefined)
+    return [];
   const answered = new Set;
-  for (const m of messages) {
-    if (typeof m.content === "string")
+  for (const message of messages) {
+    if (!Array.isArray(message.content))
       continue;
-    for (const block of m.content)
-      if (isToolResultBlock(block))
+    for (const block of message.content) {
+      if (block.type === "tool_result")
         answered.add(block.tool_use_id);
+    }
   }
-  return answered;
-}
-function dropUnansweredAssistantMessages(messages) {
-  const answered = answeredToolUseIds(messages);
-  const filtered = [];
+  const kept = [];
   const dropped = [];
-  for (const m of messages) {
-    if (m.role !== "assistant" || typeof m.content === "string") {
-      filtered.push(m);
-      continue;
-    }
-    const toolUses = m.content.filter(isToolUseBlock);
-    const hasUnanswered = toolUses.some((call) => !answered.has(call.id));
-    (hasUnanswered ? dropped : filtered).push(m);
+  for (const message of messages) {
+    const hasUnanswered = message.role === "assistant" && Array.isArray(message.content) && message.content.some((block) => block.type === "tool_use" && !answered.has(block.id));
+    (hasUnanswered ? dropped : kept).push(message);
   }
-  return { filtered, dropped };
-}
-function cloneWithOwnToolUse(original, ownToolUse) {
-  return {
-    role: "assistant",
-    content: [ownToolUse],
-    ...original.origin !== undefined ? { origin: original.origin } : {}
-  };
-}
-function buildForkInitialMessages(inherit, forkToolUseId) {
-  if (inherit.messages === undefined)
-    return [];
-  const { filtered, dropped } = dropUnansweredAssistantMessages(inherit.messages);
-  let ownToolUse;
-  let sourceMessage;
-  for (const m of dropped) {
-    if (typeof m.content === "string")
-      continue;
-    const match = m.content.filter(isToolUseBlock).find((call) => call.id === forkToolUseId);
+  let source;
+  let call;
+  for (const message of dropped) {
+    const blocks = message.content;
+    const match = blocks.find((block) => block.type === "tool_use" && block.id === forkToolUseId);
     if (match !== undefined) {
-      ownToolUse = match;
-      sourceMessage = m;
+      source = message;
+      call = match;
       break;
     }
   }
-  if (ownToolUse === undefined || sourceMessage === undefined)
-    return filtered;
-  const clone = cloneWithOwnToolUse(sourceMessage, ownToolUse);
-  const toolResult = { role: "tool", content: [{ type: "tool_result", tool_use_id: forkToolUseId, content: FORK_PLACEHOLDER_TOOL_RESULT }] };
-  return [...filtered, clone, toolResult];
+  if (source === undefined || call === undefined)
+    return kept;
+  const clone = { role: "assistant", content: [call] };
+  if (source.origin !== undefined)
+    clone.origin = source.origin;
+  const placeholder = {
+    role: "tool",
+    content: [{ type: "tool_result", tool_use_id: forkToolUseId, content: FORK_PLACEHOLDER_TOOL_RESULT }]
+  };
+  return [...kept, clone, placeholder];
 }
 class ForkRequestLayoutUnavailableError extends Error {
   constructor() {
@@ -12132,9 +12210,8 @@ function renderAgentToolSpec(entry) {
   const tools = entry.tools ?? [];
   const disallowed = entry.disallowedTools ?? [];
   if (tools.length > 0 && disallowed.length > 0) {
-    const denied = new Set(disallowed);
-    const effective = tools.filter((t) => !denied.has(t));
-    return effective.length === 0 ? "None" : effective.join(", ");
+    const kept = tools.filter((name) => !disallowed.includes(name));
+    return kept.length === 0 ? "None" : kept.join(", ");
   }
   if (tools.length > 0)
     return tools.join(", ");
@@ -12143,26 +12220,25 @@ function renderAgentToolSpec(entry) {
   return "All tools";
 }
 function renderAgentListingLine(entry, leanModel = false) {
-  const whenToUse = leanModel && entry.whenToUseLean || entry.whenToUse;
-  return neutralizeReminderTags(`- ${entry.agentType}: ${whenToUse} (Tools: ${renderAgentToolSpec(entry)})`);
+  const lean = entry.whenToUseLean;
+  const description = leanModel && typeof lean === "string" && lean.length > 0 ? lean : entry.whenToUse;
+  return neutralizeReminderTags(`- ${entry.agentType}: ${description} (Tools: ${renderAgentToolSpec(entry)})`);
 }
 function computeAgentListingDelta(available, history, opts = {}) {
   const announced = announcedAgentTypes(history);
-  const availableTypes = new Set(available.map((e) => e.agentType));
-  const added = available.filter((e) => !announced.has(e.agentType));
-  const removed = [];
-  for (const type of announced)
-    if (!availableTypes.has(type))
-      removed.push(type);
+  const availableTypes = new Set(available.map((entry) => entry.agentType));
+  const added = available.filter((entry) => !announced.has(entry.agentType));
+  const removed = [...announced].filter((type) => !availableTypes.has(type));
   if (added.length === 0 && removed.length === 0)
     return;
-  added.sort((a, b) => a.agentType.localeCompare(b.agentType));
-  removed.sort();
+  const sortedAdded = [...added].sort((a, b) => a.agentType.localeCompare(b.agentType));
+  const sortedRemoved = [...removed].sort();
+  const lean = opts.leanModel === true;
   return {
     type: "agent_listing_delta",
-    addedTypes: added.map((e) => e.agentType),
-    addedLines: added.map((e) => renderAgentListingLine(e, opts.leanModel === true)),
-    removedTypes: removed,
+    addedTypes: sortedAdded.map((entry) => entry.agentType),
+    addedLines: sortedAdded.map((entry) => renderAgentListingLine(entry, lean)),
+    removedTypes: sortedRemoved,
     isInitial: announced.size === 0,
     showConcurrencyNote: opts.showConcurrencyNote ?? true
   };
@@ -12427,53 +12503,55 @@ function isUserRole(message) {
 function isReorderStop(message) {
   if (message.role === "assistant")
     return true;
-  return Array.isArray(message.content) && message.content[0]?.type === "tool_result";
+  if (typeof message.content === "string")
+    return false;
+  const first = message.content[0];
+  return first !== undefined && first.type === "tool_result";
 }
 function reorderAttachments(messages, stays = () => false) {
   if (!messages.some((m) => m.meta !== undefined))
     return [...messages];
-  const reversed = [];
-  const pending = [];
-  for (let i = messages.length - 1;i >= 0; i--) {
-    const m = messages[i];
-    if (m.meta !== undefined && !stays(m)) {
-      pending.push(m);
+  const top = [];
+  const groups = [];
+  let landing = top;
+  for (const message of messages) {
+    const moving = message.meta !== undefined && !stays(message);
+    if (moving) {
+      landing.push(message);
       continue;
     }
-    if (isReorderStop(m) && pending.length > 0) {
-      for (const a of pending)
-        reversed.push(a);
-      reversed.push(m);
-      pending.length = 0;
-    } else {
-      reversed.push(m);
-    }
+    const group = { fixed: message, moved: [] };
+    groups.push(group);
+    if (isReorderStop(message))
+      landing = group.moved;
   }
-  for (const a of pending)
-    reversed.push(a);
-  return reversed.reverse();
+  const out = [...top];
+  for (const group of groups)
+    out.push(group.fixed, ...group.moved);
+  return out;
 }
 function hoistToolResults(blocks) {
-  const results = [];
-  const rest = [];
-  for (const b of blocks)
-    (b.type === "tool_result" ? results : rest).push(b);
+  const results = blocks.filter((b) => b.type === "tool_result");
+  const rest = blocks.filter((b) => b.type !== "tool_result");
   return [...results, ...rest];
 }
 function joinUserBlocks(prev, next) {
   const last = prev[prev.length - 1];
   const first = next[0];
-  if (last?.type === "text" && first?.type === "text")
+  if (last !== undefined && last.type === "text" && first !== undefined && first.type === "text") {
     return [...prev.slice(0, -1), { ...last, text: `${last.text}
 ` }, ...next];
+  }
   return [...prev, ...next];
 }
+var SMOOSH_EXEMPT_TAG = `<system-reminder>
+`;
+var SMOOSH_EXEMPT_BODIES = ["<system>authentic event nonces for this delivery: ", "<event "];
 function isSmooshExempt(text) {
-  if (!text.startsWith(`<system-reminder>
-`))
+  if (!text.startsWith(SMOOSH_EXEMPT_TAG))
     return false;
-  const inner = text.slice(18);
-  return inner.startsWith("<system>authentic event nonces for this delivery: ") || inner.startsWith("<event ");
+  const rest = text.slice(SMOOSH_EXEMPT_TAG.length);
+  return SMOOSH_EXEMPT_BODIES.some((prefix) => rest.startsWith(prefix));
 }
 function foldTextIntoToolResult(result, texts) {
   if (texts.length === 0)
@@ -12481,44 +12559,44 @@ function foldTextIntoToolResult(result, texts) {
   const content = result.content;
   if (Array.isArray(content) && content.some((b) => b.type === "tool_reference"))
     return null;
-  if ((result.loadedTools?.length ?? 0) > 0)
+  if (Array.isArray(result.loadedTools) && result.loadedTools.length > 0)
     return null;
   if (typeof content === "string") {
-    const joined = [content.trim(), ...texts.map((t) => t.text.trim())].filter((s) => s.length > 0).join(`
+    const pieces = [content.trim(), ...texts.map((t) => t.text.trim())].filter((piece) => piece.length > 0);
+    return { ...result, content: pieces.join(`
 
-`);
-    return { ...result, content: joined };
+`) };
   }
-  const merged = [];
+  const folded = [];
   for (const block of [...content, ...texts]) {
     if (block.type !== "text") {
-      merged.push(block);
+      folded.push(block);
       continue;
     }
     const trimmed = block.text.trim();
     if (trimmed.length === 0)
       continue;
-    const tail = merged[merged.length - 1];
-    if (tail?.type === "text")
-      merged[merged.length - 1] = { ...tail, text: `${tail.text}
+    const tail = folded[folded.length - 1];
+    if (tail !== undefined && tail.type === "text")
+      folded[folded.length - 1] = { type: "text", text: `${tail.text}
 
 ${trimmed}` };
     else
-      merged.push({ type: "text", text: trimmed });
+      folded.push({ type: "text", text: trimmed });
   }
-  return { ...result, content: merged };
+  return { ...result, content: folded };
 }
 function joinAttachmentBlocks(prev, next) {
   const last = prev[prev.length - 1];
-  if (last?.type !== "tool_result")
+  if (last === undefined || last.type !== "tool_result")
     return [...prev, ...next];
-  if ((last.loadedTools?.length ?? 0) > 0)
+  if (Array.isArray(last.loadedTools) && last.loadedTools.length > 0)
     return [...prev, ...next];
   if (next.some((b) => b.type === "text" && isSmooshExempt(b.text)))
     return [...prev, ...next];
   if (typeof last.content === "string" && next.every((b) => b.type === "text")) {
-    const folded = foldTextIntoToolResult(last, next) ?? last;
-    return [...prev.slice(0, -1), folded];
+    const folded = foldTextIntoToolResult(last, next);
+    return [...prev.slice(0, -1), folded ?? last];
   }
   return [...prev, ...next];
 }
@@ -12666,7 +12744,6 @@ import { execFile as execFile2 } from "node:child_process";
 var GIT_STATUS_CAVEAT = "This git status was captured when the session began; it is a snapshot and does not change as the conversation goes on.";
 var BASH_TOOL_NAME = "Bash";
 var GIT_STATUS_MAX_CHARS = 2000;
-var MAIN_BRANCH_CANDIDATES = ["main", "master"];
 var GIT_TIMEOUT_MS = 1e4;
 function runGit2(cwd, args, env) {
   return new Promise((resolve) => {
@@ -12678,17 +12755,25 @@ function runGit2(cwd, args, env) {
 }
 async function currentBranch(cwd, env) {
   const { code, stdout } = await runGit2(cwd, ["rev-parse", "--abbrev-ref", "HEAD"], env);
-  return code === 0 ? stdout.trim() || "HEAD" : "HEAD";
+  const name = stdout.trim();
+  return code === 0 && name.length > 0 ? name : "HEAD";
 }
+async function originRefExists(cwd, name, env) {
+  const { code } = await runGit2(cwd, ["show-ref", "--verify", "--quiet", `refs/remotes/origin/${name}`], env);
+  return code === 0;
+}
+var FALLBACK_MAIN_BRANCHES = ["main", "master"];
 async function mainBranch(cwd, env) {
-  const head = await runGit2(cwd, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], env);
+  const head = await runGit2(cwd, ["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"], env);
   if (head.code === 0) {
-    const name = head.stdout.trim().replace(/^origin\//, "");
-    if (name.length > 0 && (await runGit2(cwd, ["show-ref", "--verify", "--quiet", `refs/remotes/origin/${name}`], env)).code === 0)
+    let name = head.stdout.trim();
+    if (name.startsWith("origin/"))
+      name = name.slice("origin/".length);
+    if (name.length > 0 && await originRefExists(cwd, name, env))
       return name;
   }
-  for (const candidate of MAIN_BRANCH_CANDIDATES) {
-    if ((await runGit2(cwd, ["show-ref", "--verify", "--quiet", `refs/remotes/origin/${candidate}`], env)).code === 0)
+  for (const candidate of FALLBACK_MAIN_BRANCHES) {
+    if (await originRefExists(cwd, candidate, env))
       return candidate;
   }
   return "main";
@@ -12763,11 +12848,17 @@ function isUserInvocable(overrides, skill) {
 var DEFAULT_SKILL_LISTING_CONTEXT_WINDOW_TOKENS = 200000;
 function skillListingBudgetChars(opts) {
   if (opts.budgetChars !== undefined)
-    return Number.isFinite(opts.budgetChars) && opts.budgetChars > 0 ? opts.budgetChars : 0;
-  const window = opts.contextWindowTokens !== undefined && Number.isFinite(opts.contextWindowTokens) && opts.contextWindowTokens > 0 ? opts.contextWindowTokens : DEFAULT_SKILL_LISTING_CONTEXT_WINDOW_TOKENS;
-  const fraction = opts.budgetFraction !== undefined && Number.isFinite(opts.budgetFraction) && opts.budgetFraction > 0 ? opts.budgetFraction : DEFAULT_SKILL_LISTING_BUDGET_FRACTION;
+    return isPositiveFinite(opts.budgetChars) ? opts.budgetChars : 0;
+  const window = isPositiveFinite(opts.contextWindowTokens) ? opts.contextWindowTokens : DEFAULT_SKILL_LISTING_CONTEXT_WINDOW_TOKENS;
+  const fraction = isPositiveFinite(opts.budgetFraction) ? opts.budgetFraction : DEFAULT_SKILL_LISTING_BUDGET_FRACTION;
   return Math.max(1, Math.floor(window * SKILL_LISTING_CHARS_PER_TOKEN * fraction));
 }
+function isPositiveFinite(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function lineLength(name, description) {
+  return description.length > 0 ? 4 + name.length + description.length : 2 + name.length;
+}
 function truncateSkillDescription(description, maxDescChars) {
   if (!Number.isFinite(maxDescChars) || maxDescChars <= 0 || description.length <= maxDescChars)
     return description;
@@ -12781,42 +12872,53 @@ function renderSkillListingContent(entries) {
 `);
 }
 function buildSkillListing(skills, opts) {
-  const maxDescChars = opts?.maxDescChars ?? DEFAULT_SKILL_LISTING_MAX_DESC_CHARS;
+  const cap = opts?.maxDescChars ?? DEFAULT_SKILL_LISTING_MAX_DESC_CHARS;
   const budget = skillListingBudgetChars({
-    ...opts?.contextWindowTokens !== undefined ? { contextWindowTokens: opts.contextWindowTokens } : {},
-    ...opts?.budgetFraction !== undefined ? { budgetFraction: opts.budgetFraction } : {},
-    ...opts?.budgetChars !== undefined ? { budgetChars: opts.budgetChars } : {}
+    contextWindowTokens: opts?.contextWindowTokens,
+    budgetFraction: opts?.budgetFraction,
+    budgetChars: opts?.budgetChars
   });
   const entries = [];
-  const alwaysFull = new Set;
+  const fixed = [];
   for (const skill of skills) {
     if (!isModelVisible(opts?.skillOverrides, skill))
       continue;
     const nameOnly = overrideFor(opts?.skillOverrides, skill) === "name-only";
-    if (nameOnly || skill.source === "builtin")
-      alwaysFull.add(entries.length);
-    entries.push({ name: skill.name, description: nameOnly ? "" : truncateSkillDescription(skill.description, maxDescChars), source: skill.source });
+    const description = nameOnly ? "" : truncateSkillDescription(skill.description, cap);
+    entries.push({ name: skill.name, description, source: skill.source });
+    fixed.push(nameOnly || skill.source === "builtin");
   }
-  if (budget <= 0 || entries.length === 0)
+  if (!(budget > 0) || entries.length === 0)
     return entries;
-  const fullLength = (i) => renderSkillListingLine(entries[i]).length;
-  const nameLength = (i) => entries[i].name.length + 2;
-  const total = entries.reduce((sum, _e, i) => sum + fullLength(i), 0) + (entries.length - 1);
-  if (total <= budget)
+  const separators = entries.length - 1;
+  let fullSize = separators;
+  for (const e of entries)
+    fullSize += lineLength(e.name, e.description);
+  if (fullSize <= budget)
     return entries;
-  const candidates = entries.map((_e, i) => i).filter((i) => !alwaysFull.has(i));
-  if (candidates.length === 0)
+  if (fixed.every(Boolean))
     return entries;
-  let remaining = budget - (entries.reduce((sum, _e, i) => sum + (alwaysFull.has(i) ? fullLength(i) : nameLength(i)), 0) + (entries.length - 1));
-  const keep = new Set;
-  for (const i of candidates) {
-    const cost = fullLength(i) - nameLength(i);
+  let remaining = budget - separators;
+  for (let i = 0;i < entries.length; i++) {
+    const e = entries[i];
+    remaining -= fixed[i] ? lineLength(e.name, e.description) : lineLength(e.name, "");
+  }
+  const out = [];
+  for (let i = 0;i < entries.length; i++) {
+    const e = entries[i];
+    if (fixed[i]) {
+      out.push(e);
+      continue;
+    }
+    const cost = lineLength(e.name, e.description) - lineLength(e.name, "");
     if (cost <= remaining) {
-      keep.add(i);
       remaining -= cost;
+      out.push(e);
+    } else {
+      out.push({ name: e.name, description: "", source: e.source });
     }
   }
-  return entries.map((e, i) => alwaysFull.has(i) || keep.has(i) ? e : { ...e, description: "" });
+  return out;
 }
 
 // src/subagents/plugin-agents.ts
@@ -12881,7 +12983,7 @@ var HOOK_SOURCE_BY_SETTING_SOURCE = {
   project: "project",
   local: "local"
 };
-function isPlainObject2(v) {
+function isPlainObject3(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function buildHookEntriesFromSettings(perSource) {
@@ -12895,7 +12997,7 @@ function buildHookEntriesFromSettings(perSource) {
     if (hooks === undefined)
       continue;
     const where = { source: tier.source, ...tier.path !== undefined ? { path: tier.path } : {} };
-    if (!isPlainObject2(hooks)) {
+    if (!isPlainObject3(hooks)) {
       rejected.push({ ...where, reason: `expected an object for "hooks", got ${Array.isArray(hooks) ? "an array" : typeof hooks}` });
       continue;
     }
@@ -12908,7 +13010,7 @@ function buildHookEntriesFromSettings(perSource) {
         continue;
       }
       groups.forEach((group, groupIndex) => {
-        if (!isPlainObject2(group)) {
+        if (!isPlainObject3(group)) {
           rejected.push({ ...where, event, reason: `matcher group ${groupIndex} is not an object` });
           return;
         }
@@ -12919,7 +13021,7 @@ function buildHookEntriesFromSettings(perSource) {
         }
         const matcher = typeof group["matcher"] === "string" ? group["matcher"] : undefined;
         groupHooks.forEach((handler, hookIndex) => {
-          if (!isPlainObject2(handler)) {
+          if (!isPlainObject3(handler)) {
             rejected.push({ ...where, event, reason: `hook ${groupIndex}:${hookIndex} is not an object` });
             return;
           }
@@ -15887,7 +15989,7 @@ replaceExecutor(ASK_USER_QUESTION_TOOL_NAME2, askUserQuestionExecutor);
 // src/tools/impl/bash.ts
 import { randomUUID as randomUUID9 } from "node:crypto";
 import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, mkdirSync as mkdirSync10, unlinkSync, createWriteStream } from "node:fs";
-import { join as join17, sep as sep2 } from "node:path";
+import { join as join17, sep } from "node:path";
 
 // src/tools/sandbox-run-inputs.ts
 function computeWritableRoots(ctx) {
@@ -15979,7 +16081,7 @@ function buildRunCommandOptions(input, ctx) {
 function isWithinAllowedDirs(candidate, cwd, writableRoots) {
   const canonicalCandidate = canonicalizePath(candidate);
   const allowed = [canonicalizePath(cwd), ...writableRoots.map(canonicalizePath)];
-  return allowed.some((root) => canonicalCandidate === root || canonicalCandidate.startsWith(root + sep2));
+  return allowed.some((root) => canonicalCandidate === root || canonicalCandidate.startsWith(root + sep));
 }
 function computeCwdCarryAllowedRoots(ctx) {
   return [ctx.session.getSessionRoot(), ...ctx.session.getBoundedRoots()];
@@ -16479,11 +16581,11 @@ function writeDurableJobsAtomic(projectDir, jobs, brand) {
   }
   renameSync2(tmpPath, path);
 }
-function isPlainObject3(v) {
+function isPlainObject4(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function parseCreateInput(raw) {
-  if (!isPlainObject3(raw))
+  if (!isPlainObject4(raw))
     throw new Error("input must be an object");
   const cron = raw["cron"];
   if (typeof cron !== "string" || cron.length === 0)
@@ -16501,7 +16603,7 @@ function parseCreateInput(raw) {
   return { cron, prompt, recurring: recurring ?? true, durable: durable ?? false };
 }
 function parseIdInput(raw) {
-  if (!isPlainObject3(raw))
+  if (!isPlainObject4(raw))
     throw new Error("input must be an object");
   const id = raw["id"];
   if (typeof id !== "string" || id.length === 0)
@@ -17020,13 +17122,13 @@ var exitPlanModeExecutor = {
 replaceExecutor(EXIT_PLAN_MODE_TOOL_NAME, exitPlanModeExecutor);
 
 // src/tools/impl/exit-worktree.ts
-import { sep as sep3 } from "node:path";
+import { sep as sep2 } from "node:path";
 var EXIT_WORKTREE_TOOL_NAME = "ExitWorktree";
 function hasUncommittedChanges(statusPorcelainOutput) {
   return statusPorcelainOutput.trim().length > 0;
 }
 function findWorktreeContainingCwd(worktrees, cwdRealPath) {
-  const candidates = worktrees.filter((w) => cwdRealPath === w.realPath || cwdRealPath.startsWith(w.realPath + sep3));
+  const candidates = worktrees.filter((w) => cwdRealPath === w.realPath || cwdRealPath.startsWith(w.realPath + sep2));
   if (candidates.length === 0)
     return;
   return candidates.reduce((longest, w) => w.realPath.length > longest.realPath.length ? w : longest);
@@ -17191,7 +17293,7 @@ replaceExecutor("Glob", globExecutor, extractGlobPaths);
 
 // src/tools/impl/grep.ts
 import { readFileSync as readFileSync13, statSync as statSync7 } from "node:fs";
-import { dirname as dirname8, isAbsolute as isAbsolute4, relative as relative2, resolve as resolve9, sep as sep4 } from "node:path";
+import { dirname as dirname8, isAbsolute as isAbsolute4, relative as relative2, resolve as resolve9, sep as sep3 } from "node:path";
 var OUTPUT_MODES = ["content", "files_with_matches", "count"];
 var MAX_PATTERN_LENGTH = 1000;
 function parseInput4(raw) {
@@ -17296,7 +17398,7 @@ var TYPE_EXTENSIONS = {
 };
 function extOf(path) {
   const i = path.lastIndexOf(".");
-  const slashIdx = Math.max(path.lastIndexOf("/"), path.lastIndexOf(sep4));
+  const slashIdx = Math.max(path.lastIndexOf("/"), path.lastIndexOf(sep3));
   if (i <= slashIdx)
     return "";
   return path.slice(i).toLowerCase();
@@ -17340,7 +17442,7 @@ async function loadGitignoreRules(searchRoot) {
   const found = [];
   try {
     for await (const rel of discovery.scan({ cwd: searchRoot, dot: true, onlyFiles: true, followSymlinks: false })) {
-      const relPosix = rel.split(sep4).join("/");
+      const relPosix = rel.split(sep3).join("/");
       const dir = dirname8(relPosix);
       const relDir = dir === "." ? "" : dir;
       try {
@@ -17378,7 +17480,7 @@ async function discoverCandidateFiles(searchRoot, globPattern) {
   const out = [];
   for await (const p of glob.scan({ cwd: searchRoot, onlyFiles: true, dot: false, followSymlinks: false })) {
     const abs = isAbsolute4(p) ? resolve9(p) : resolve9(searchRoot, p);
-    const relPosix = relative2(searchRoot, abs).split(sep4).join("/");
+    const relPosix = relative2(searchRoot, abs).split(sep3).join("/");
     if (isIgnored(relPosix, rules))
       continue;
     out.push(abs);
@@ -18113,11 +18215,11 @@ replaceExecutor("NotebookEdit", notebookEditExecutor);
 var MAX_MESSAGE_LENGTH = 199;
 var DISABLED_REASON = "push transport unconfigured";
 var activeNotifier = () => {};
-function isPlainObject4(v) {
+function isPlainObject5(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function parseInput6(raw) {
-  if (!isPlainObject4(raw))
+  if (!isPlainObject5(raw))
     throw new Error("input must be an object");
   const message = raw["message"];
   if (typeof message !== "string" || message.length === 0)
@@ -18426,11 +18528,11 @@ var MAX_FINDINGS = 32;
 var LEVELS = ["low", "medium", "high", "xhigh", "max"];
 var VERDICTS = ["CONFIRMED", "PLAUSIBLE"];
 var OUTCOMES = ["fixed", "skipped", "no_change_needed"];
-function isPlainObject5(v) {
+function isPlainObject6(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function parseFinding(raw, index) {
-  if (!isPlainObject5(raw))
+  if (!isPlainObject6(raw))
     throw new Error(`findings[${index}] must be an object`);
   const file = raw["file"];
   if (typeof file !== "string" || file.length === 0)
@@ -18471,7 +18573,7 @@ function parseFinding(raw, index) {
   };
 }
 function parseInput8(raw) {
-  if (!isPlainObject5(raw))
+  if (!isPlainObject6(raw))
     throw new Error("input must be an object");
   const level = raw["level"];
   if (level !== undefined && (typeof level !== "string" || !LEVELS.includes(level))) {
@@ -18517,11 +18619,11 @@ function sessionList(sessionId) {
   }
   return list;
 }
-function isPlainObject6(v) {
+function isPlainObject7(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function parseInput9(raw) {
-  if (!isPlainObject6(raw))
+  if (!isPlainObject7(raw))
     throw new Error("input must be an object");
   const stop = raw["stop"];
   if (stop !== undefined && typeof stop !== "boolean")
@@ -18666,7 +18768,7 @@ function updateTask2(sessionId, input) {
 }
 
 // src/tools/impl/task-graph.ts
-function isPlainObject7(v) {
+function isPlainObject8(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function isNonEmptyString(v) {
@@ -18680,7 +18782,7 @@ function errorResult5(message) {
   return { output: `Error: ${message}`, isError: true };
 }
 function parseCreateInput2(raw) {
-  if (!isPlainObject7(raw))
+  if (!isPlainObject8(raw))
     throw new Error("input must be an object");
   const subject = raw["subject"];
   const description = raw["description"];
@@ -18692,7 +18794,7 @@ function parseCreateInput2(raw) {
   if (activeForm !== undefined && typeof activeForm !== "string")
     throw new Error("activeForm must be a string");
   const metadata = raw["metadata"];
-  if (metadata !== undefined && !isPlainObject7(metadata))
+  if (metadata !== undefined && !isPlainObject8(metadata))
     throw new Error("metadata must be an object");
   return {
     subject,
@@ -18712,7 +18814,7 @@ async function executeCreate2(rawInput, ctx) {
   return { output: JSON.stringify({ task: { id: row.id, subject: row.subject } }) };
 }
 function parseTaskIdInput(raw) {
-  if (!isPlainObject7(raw))
+  if (!isPlainObject8(raw))
     throw new Error("input must be an object");
   const taskId = raw["taskId"];
   if (!isNonEmptyString(taskId))
@@ -18747,7 +18849,7 @@ async function executeList2(_rawInput, ctx) {
   return { output: JSON.stringify({ tasks: rows }) };
 }
 function parseUpdateInput(raw) {
-  if (!isPlainObject7(raw))
+  if (!isPlainObject8(raw))
     throw new Error("input must be an object");
   const taskId = raw["taskId"];
   if (!isNonEmptyString(taskId))
@@ -18775,7 +18877,7 @@ function parseUpdateInput(raw) {
   if (addBlockedBy !== undefined && !isStringArray(addBlockedBy))
     throw new Error("addBlockedBy must be an array of non-empty strings");
   const metadata = raw["metadata"];
-  if (metadata !== undefined && !isPlainObject7(metadata))
+  if (metadata !== undefined && !isPlainObject8(metadata))
     throw new Error("metadata must be an object");
   return {
     taskId,
@@ -18850,7 +18952,7 @@ replaceExecutor("TaskUpdate", { execute: executeUpdate });
 
 // src/tools/impl/task-output.ts
 import { existsSync as existsSync7, readFileSync as readFileSync16 } from "node:fs";
-import { join as join20, sep as sep5 } from "node:path";
+import { join as join20, sep as sep4 } from "node:path";
 function parseTaskOutputInput(input) {
   if (typeof input !== "object" || input === null)
     return { error: "TaskOutput: input must be an object" };
@@ -18880,7 +18982,7 @@ function resolveOutputPath(taskId, ctx) {
     return;
   const realFallback = resolveRealTarget(fallback);
   const realTasksDir = resolveRealTarget(tasksDir);
-  return realFallback.startsWith(realTasksDir + sep5) ? fallback : undefined;
+  return realFallback.startsWith(realTasksDir + sep4) ? fallback : undefined;
 }
 async function waitForTerminal(taskId, timeoutMs) {
   const deadline = Date.now() + timeoutMs;
@@ -19008,12 +19110,12 @@ replaceExecutor("TaskStop", taskStopExecutor);
 
 // src/tools/impl/todo-write.ts
 var sessions3 = new Map;
-function isPlainObject8(v) {
+function isPlainObject9(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 var TODO_STATUSES = ["pending", "in_progress", "completed"];
 function parseTodo(raw, index) {
-  if (!isPlainObject8(raw))
+  if (!isPlainObject9(raw))
     throw new Error(`todos[${index}] must be an object`);
   const content = raw["content"];
   if (typeof content !== "string" || content.length === 0)
@@ -19028,7 +19130,7 @@ function parseTodo(raw, index) {
   return { content, status, activeForm };
 }
 function parseInput10(raw) {
-  if (!isPlainObject8(raw))
+  if (!isPlainObject9(raw))
     throw new Error("input must be an object");
   const todos = raw["todos"];
   if (!Array.isArray(todos))
@@ -22139,17 +22241,24 @@ function flushWebSearchStream(events) {
   let buffer = "";
   const flush = () => {
     const text = buffer.trim();
-    if (text.length > 0)
+    if (text !== "")
       items.push(text);
     buffer = "";
   };
   for (const event of events) {
-    if (event.type === "text") {
-      buffer += event.text;
-      continue;
+    switch (event.type) {
+      case "text":
+        buffer += event.text;
+        break;
+      case "search_result":
+        flush();
+        items.push({ content: event.hits.map((hit) => ({ title: hit.title, url: hit.url })) });
+        break;
+      default:
+        flush();
+        items.push(`Web search error: ${String(event.code)}`);
+        break;
     }
-    flush();
-    items.push(event.type === "search_result" ? { content: event.hits.map((h) => ({ title: h.title, url: h.url })) } : `Web search error: ${event.code}`);
   }
   flush();
   return items;
@@ -22162,14 +22271,20 @@ function headerQuery(query) {
   return `${query.slice(0, HEADER_QUERY_CAP)}[query truncated at ${HEADER_QUERY_CAP.toLocaleString("en-US")} characters]`;
 }
 function renderWebSearchToolResult(query, items) {
-  const header = `Web search results for query: "${headerQuery(query)}"`;
-  const body = items.map((item) => typeof item === "string" ? item : item.content.length > 0 ? `Links: ${JSON.stringify(item.content)}` : "No links found.").reduce((acc, rendered) => acc + rendered + `
+  let out = `Web search results for query: "${headerQuery(query)}"
 
-`, "");
-  return (header + `
+`;
+  for (const item of items)
+    out += `${renderItem(item)}
 
-` + body + `
-` + REMINDER).trim();
+`;
+  return `${out}
+${REMINDER}`;
+}
+function renderItem(item) {
+  if (typeof item === "string")
+    return item;
+  return item.content.length > 0 ? `Links: ${JSON.stringify(item.content)}` : "No links found.";
 }
 function renderWebSearchToolResultCapped(query, items, cap) {
   const full = renderWebSearchToolResult(query, items);
@@ -24077,6 +24192,8 @@ function schedulingForCall(name, input, bash) {
       return { kind: "concurrent" };
     if (descriptor.concurrencyLane !== undefined)
       return { kind: "lane", lane: descriptor.concurrencyLane };
+    if (descriptor.concurrencySafe === true)
+      return { kind: "concurrent" };
   }
   return { kind: "serial" };
 }
@@ -24117,16 +24234,19 @@ function createSessionReadState(opts) {
 }
 
 // src/provider/lean-prompt.ts
-var FULL_PROMPT_OPUS_MINORS = new Set(["0", "1", "5", "6", "7"]);
 function claudeModelTakesFullPrompt(modelKey) {
   const id = modelKey.slice(modelKey.lastIndexOf("/") + 1).toLowerCase();
-  if (id.includes("claude-3-") || id.includes("haiku") || id.includes("sonnet"))
+  if (FULL_FAMILY_MARKERS.some((marker) => id.includes(marker)))
     return true;
-  const opus = /^claude-opus-4(?:[-.](\d{1,2}))?(?:-\d{8})?$/.exec(id);
-  if (opus === null)
+  const match = OPUS_4_ID.exec(id);
+  if (match === null)
     return false;
-  return FULL_PROMPT_OPUS_MINORS.has(opus[1] ?? "0");
+  const minor = match[1] ?? "0";
+  return FULL_OPUS_4_MINORS.has(minor);
 }
+var FULL_FAMILY_MARKERS = ["claude-3-", "haiku", "sonnet"];
+var OPUS_4_ID = /^claude-opus-4(?:[-.](\d{1,2}))?(?:-\d{8})?$/;
+var FULL_OPUS_4_MINORS = new Set(["0", "1", "5", "6", "7"]);
 
 // src/provider/first-party.ts
 var FIRST_PARTY_ANTHROPIC_PROVIDER_IDS = new Set(["anthropic", "console"]);
@@ -25254,30 +25374,34 @@ ${escapeAttributionText(msg.body)}
   function isTruthyEnvValue(v) {
     return v === "1" || v === "true";
   }
-  function claudeTierMatches(modelKey, tier) {
-    if (resolveSlot === undefined)
-      return false;
-    const resolution = resolveSlot(tier, modelKey);
-    return resolution.ok && resolution.modelKey === modelKey;
-  }
-  function isAtOrBelowOpusTier(modelKey) {
-    return claudeTierMatches(modelKey, "haiku") || claudeTierMatches(modelKey, "sonnet") || claudeTierMatches(modelKey, "opus");
-  }
   function sessionLeanModel(modelKey) {
     if (!isFirstPartyAnthropic(currentProviderIdentity?.providerId))
       return false;
     return !claudeModelTakesFullPrompt(modelKey);
   }
   function exploreModelCap(parentModel) {
-    const env = engineEnv ?? process.env;
-    if (isTruthyEnvValue(env[envName8(sessionBrand, "DISABLE_EXPLORE_INHERIT_CAP")]))
+    if (exploreCapOptedOut())
       return;
     if (!isFirstPartyAnthropic(currentProviderIdentity?.providerId))
       return;
-    if (isAtOrBelowOpusTier(parentModel))
+    if (modelSitsOnCappedOrLowerTier(parentModel))
       return;
     return "opus";
   }
+  function exploreCapOptedOut() {
+    const env = engineEnv ?? process.env;
+    return isTruthyEnvValue(env[envName8(sessionBrand, "DISABLE_EXPLORE_INHERIT_CAP")]);
+  }
+  function modelSitsOnCappedOrLowerTier(modelKey) {
+    if (resolveSlot === undefined)
+      return false;
+    for (const tier of ["haiku", "sonnet", "opus"]) {
+      const resolution = resolveSlot(tier, modelKey);
+      if (resolution.ok && resolution.modelKey === modelKey)
+        return true;
+    }
+    return false;
+  }
   function resolveChildModel(req) {
     if (req.fork === true)
       return currentModel;
@@ -25519,7 +25643,13 @@ ${escapeAttributionText(msg.body)}
         const toolDefs = serverCfg.tools;
         const toolNames = serverCfg.toolNames;
         const toolLanes = serverCfg.toolLanes;
-        registerMcpServerTools(serverName, toolDefs, { deferredDefault: true, ...toolNames !== undefined ? { toolNames } : {}, ...toolLanes !== undefined ? { toolLanes } : {} });
+        const concurrentTools = serverCfg.concurrentTools;
+        registerMcpServerTools(serverName, toolDefs, {
+          deferredDefault: true,
+          ...toolNames !== undefined ? { toolNames } : {},
+          ...toolLanes !== undefined ? { toolLanes } : {},
+          ...concurrentTools !== undefined ? { concurrentTools } : {}
+        });
         sdkMcpServerNames.push(serverName);
         const perServerTimeoutMs = serverCfg.timeout;
         for (const tool of toolDefs) {
@@ -29016,100 +29146,122 @@ function ancestryChain(byUuid, leafUuid) {
   }
   return chain.reverse();
 }
-function toolUseIdsOf(e) {
-  if (e.type !== "assistant" || !Array.isArray(e.message?.content))
-    return [];
-  return e.message.content.flatMap((b) => isRecord2(b) && b.type === "tool_use" && typeof b.id === "string" ? [b.id] : []);
-}
-function toolResultIdsOf(e) {
-  if (e.type !== "user" || !Array.isArray(e.message?.content))
-    return [];
-  return e.message.content.flatMap((b) => isRecord2(b) && b.type === "tool_result" && typeof b.tool_use_id === "string" ? [b.tool_use_id] : []);
-}
 function recoverParallelToolResults(chain, pool) {
   const onChain = new Set(chain.map((e) => e.uuid));
   const resultsByParent = new Map;
-  const offChainAssistants = [];
-  for (const e of pool) {
-    if (onChain.has(e.uuid) || e.parentUuid === null)
-      continue;
-    if (e.type === "assistant" && e.isApiErrorMessage !== true)
-      offChainAssistants.push(e);
-    if (toolResultIdsOf(e).length === 0)
+  const siblingCandidates = [];
+  for (const entry of pool) {
+    if (onChain.has(entry.uuid) || entry.parentUuid === null)
       continue;
-    const siblings = resultsByParent.get(e.parentUuid);
-    if (siblings !== undefined)
-      siblings.push(e);
-    else
-      resultsByParent.set(e.parentUuid, [e]);
+    if (answerIdsOf(entry).length > 0) {
+      const group = resultsByParent.get(entry.parentUuid);
+      if (group === undefined)
+        resultsByParent.set(entry.parentUuid, [entry]);
+      else
+        group.push(entry);
+    }
+    if (entry.type === "assistant" && entry.isApiErrorMessage !== true)
+      siblingCandidates.push(entry);
   }
-  if (resultsByParent.size === 0 && offChainAssistants.length === 0)
+  if (resultsByParent.size === 0 && siblingCandidates.length === 0)
     return [...chain];
-  const answered = new Set(chain.flatMap(toolResultIdsOf));
-  const recovered = new Set;
-  const resultsFor = (parentUuid, open) => {
-    const results = [];
-    const ids = new Set;
-    for (const candidate of resultsByParent.get(parentUuid) ?? []) {
-      if (recovered.has(candidate.uuid))
+  const satisfied = new Set;
+  for (const entry of chain)
+    for (const id of answerIdsOf(entry))
+      satisfied.add(id);
+  const returned = new Set;
+  const selectResults = (parentUuid, open) => {
+    const taken = [];
+    const claimed = new Set;
+    for (const result of resultsByParent.get(parentUuid) ?? []) {
+      if (returned.has(result.uuid))
         continue;
-      const answers = toolResultIdsOf(candidate);
-      if (!answers.some((id) => open.includes(id) && !ids.has(id)))
+      const ids = answerIdsOf(result);
+      if (!ids.some((id) => open.has(id) && !claimed.has(id)))
         continue;
-      results.push(candidate);
-      for (const id of answers)
-        ids.add(id);
-    }
-    return { results, ids };
-  };
-  const take = (results, ids) => {
-    for (const r of results)
-      recovered.add(r.uuid);
-    for (const id of ids)
-      answered.add(id);
-  };
-  const inserts = new Map;
-  for (let start = 0;start < chain.length; ) {
-    if (chain[start].type !== "assistant") {
-      start++;
+      taken.push(result);
+      for (const id of ids)
+        claimed.add(id);
+    }
+    return { taken, claimed };
+  };
+  const openCallsOf = (entry) => new Set(callIdsOf(entry).filter((id) => !satisfied.has(id)));
+  const insertAfter = new Map;
+  const lastIndex = chain.length - 1;
+  let index = 0;
+  while (index <= lastIndex) {
+    if (chain[index].type !== "assistant") {
+      index++;
       continue;
     }
-    let end = start;
-    while (end + 1 < chain.length && chain[end + 1].type === "assistant")
+    let end = index;
+    while (end + 1 <= lastIndex && chain[end + 1].type === "assistant")
       end++;
-    if (end < chain.length - 1) {
-      const memberResults = [];
-      for (let k = start;k <= end; k++) {
-        const member = chain[k];
-        const { results, ids } = resultsFor(member.uuid, toolUseIdsOf(member).filter((id) => !answered.has(id)));
-        take(results, ids);
-        memberResults.push(...results);
-      }
-      const reachable = new Set(chain.slice(start, end + 1).map((e) => e.uuid));
-      const siblings = [];
-      const siblingResults = [];
-      for (const candidate of offChainAssistants) {
-        if (candidate.parentUuid === null || !reachable.has(candidate.parentUuid) || recovered.has(candidate.uuid))
-          continue;
-        reachable.add(candidate.uuid);
-        const calls = toolUseIdsOf(candidate);
-        const { results, ids } = resultsFor(candidate.uuid, calls.filter((id) => !answered.has(id)));
-        if (!calls.every((id) => answered.has(id) || ids.has(id)))
-          continue;
-        recovered.add(candidate.uuid);
-        take(results, ids);
-        siblings.push(candidate);
-        siblingResults.push(...results);
-      }
-      const found = [...siblings, ...memberResults, ...siblingResults];
-      if (found.length > 0)
-        inserts.set(chain[end].uuid, found);
-    }
-    start = end + 1;
+    const members = chain.slice(index, end + 1);
+    index = end + 1;
+    if (end === lastIndex)
+      continue;
+    const memberResults = [];
+    for (const member of members) {
+      const { taken, claimed } = selectResults(member.uuid, openCallsOf(member));
+      for (const result of taken)
+        returned.add(result.uuid);
+      for (const id of claimed)
+        satisfied.add(id);
+      memberResults.push(...taken);
+    }
+    const attachable = new Set(members.map((m) => m.uuid));
+    const siblings = [];
+    const siblingResults = [];
+    for (const candidate of siblingCandidates) {
+      if (candidate.parentUuid === null || !attachable.has(candidate.parentUuid) || returned.has(candidate.uuid))
+        continue;
+      attachable.add(candidate.uuid);
+      const { taken, claimed } = selectResults(candidate.uuid, openCallsOf(candidate));
+      const complete = callIdsOf(candidate).every((id) => satisfied.has(id) || claimed.has(id));
+      if (!complete)
+        continue;
+      returned.add(candidate.uuid);
+      for (const result of taken)
+        returned.add(result.uuid);
+      for (const id of claimed)
+        satisfied.add(id);
+      siblings.push(candidate);
+      siblingResults.push(...taken);
+    }
+    const spliced = [...siblings, ...memberResults, ...siblingResults];
+    if (spliced.length > 0)
+      insertAfter.set(chain[end].uuid, spliced);
   }
-  if (inserts.size === 0)
-    return [...chain];
-  return chain.flatMap((e) => [e, ...inserts.get(e.uuid) ?? []]);
+  const out = [];
+  for (const entry of chain) {
+    out.push(entry);
+    const extra = insertAfter.get(entry.uuid);
+    if (extra !== undefined)
+      out.push(...extra);
+  }
+  return out;
+}
+function callIdsOf(entry) {
+  if (entry.type !== "assistant")
+    return [];
+  return contentBlockIds(entry, "tool_use", "id");
+}
+function answerIdsOf(entry) {
+  if (entry.type !== "user")
+    return [];
+  return contentBlockIds(entry, "tool_result", "tool_use_id");
+}
+function contentBlockIds(entry, blockType, idKey) {
+  const content = entry.message?.content;
+  if (!Array.isArray(content))
+    return [];
+  const ids = [];
+  for (const block of content) {
+    if (isRecord2(block) && block.type === blockType && typeof block[idKey] === "string")
+      ids.push(block[idKey]);
+  }
+  return ids;
 }
 function isDescendant(byUuid, ancestorUuid, candidateUuid) {
   if (candidateUuid === ancestorUuid)
@@ -29513,7 +29665,7 @@ class TranscriptWriter2 {
     return entries;
   }
 }
-var RUNTIME_ENGINE_VERSION2 = "0.0.40";
+var RUNTIME_ENGINE_VERSION2 = "0.0.43";
 function withPermissionJournal(writer, location) {
   return {
     transcriptPath: join27(location.winterHome, "projects", location.projectKey, `${location.sessionId}.jsonl`),
@@ -30239,4 +30391,4 @@ function selectClassifierRoute2(config, descriptorOf) {
   return { kind: "worker-eligible" };
 }
 
-export { ChildResumeModeIncomparableError, resolveChildResumeMode, ensureDefaultMessagingRuntimeRegistered, buildContinuationChain, AGENT_TOOL_CANONICAL_NAME, computeActiveSlotSet, resolveSlotToProvider, createRpcBridge2, shellWords, escapeRegExpLiteral, validatePermissionRuleString, registerTool2, getRegisteredTool, listRegisteredTools, rebrandStandingServerTools, mcpServerHasRegistrations, onCompaction2, STRUCTURED_OUTPUT_TOOL_NAME, looksLikeCommand, matchFileRule, resolveFileRuleAbsolutePath, resolveFileRuleAbsoluteGlobText, resolvesWithinPluginRoot, buildWorkflowWorkerSeatbeltProfile2, capBytes, neutralizeReminderTags, readWhole, readCappedLinesAndBytes, registerAttachmentRenderer, attachmentsIn, registerChildEngineFactory, rawToRuleValue, sourceRule, parseFrontmatter, parseAgentDefinitionFile, allowedAgentTypesFromTools, validateAgentDefinition, WinterPathsError2, sessionTempDir2, ensureTasksDir2, resolveProjectDirName2, buildForkDirectiveText, buildForkInitialMessages, gitInstructionsEnabled, isUserInvocable, buildSkillListing, registerPluginAgents, clearPluginAgents, registerSkillSessionRuntime, clearSkillSessionRuntime, buildHookEntriesFromSettings, defaultTrustSource, formatValidationErrors, createSchemaValidatorCache, killAllTaskProcessGroups, runGit, listWorktrees, canonicalAliases, WINTER_CANONICAL_ALIASES, DEFAULT_SKILL_BODY_BYTES, skillNameError, pluginNameError, capBytes2, parseSkillFile, validateSkillsOption, isSkillEnabled, autoSkillPermissionEntries, setHostWorkflowWorkerCommand, listWorkflowsForListing, buildWorkflowSkillPrompt, WORKFLOW_SANDBOX_REFUSED_EXIT_CODE2, createToolLaneTails, DEFAULT_CONTEXT_WINDOW_TOKENS2, ProviderTurnError, isProviderTurnError, createContextAccountant2, runEngine2, WINTER_SUMMARY_INSTRUCTION, WINTER_PREFIX_SUMMARY_INSTRUCTION, CARRIED_SUMMARY_NOTE, retainedExchangesNote, buildSummaryInstruction, redactForSummary, summarize, summarizeOverPrefix, recordedProviderSystems2, resetRecordedProviderSystems2, echoProvider2, scriptedProvider2, stubExecutor2, P5_FIXTURE_SKILL_NAME2, P5_WORKFLOW_SCRIPT2, isTestProviderName2, testProviderForNamespace, testProviderByName2, SUBAGENT_CHILD_PROBE_TEXT2, MCP_SDK_TEST_SERVER_NAME2, MCP_SDK_TEST_TOOL_NAME2, BGTASK_TEST_TOOL_NAME2, registerBgTaskTestTool2, ResumeTargetError2, ResumeTruncationError2, findContinueTarget2, findResumeTarget2, toDialectEntries2, truncateAt2, rebuildProviderMessages2, userEntry2, winterMessageIdFor2, assistantEntry2, CLAUDE_COMPACT_SUMMARY_PREAMBLE2, claudeCompactBoundaryEntry2, claudeCompactSummaryEntry2, TranscriptWriterError2, TranscriptWriter2, RUNTIME_ENGINE_VERSION2, childTranscriptSubpath, buildChildTranscriptWriter, listChildAgentIds, resolveEngineSession2, resolveProductionWinterHome2, resolveProductionStoreHome, resolveSessionProvider, redactCredentialRef, createProviderContext, providerCredentialRef2, storeProviderCredential2, deleteProviderCredential2, validateProviderCredential2, CLASSIFIER_TOOL_NAME2, CLASSIFIER_VERDICT_SCHEMA2, CLASSIFIER_NO_VERDICT_REASONS2, DEFAULT_MAX_CONTEXT_CHARS2, CLASSIFIER_SYSTEM_PROMPT2, DEFAULT_CLASSIFIER_TIMEOUT_MS2, createModelClassifier2, selectClassifierRoute2 };
+export { ChildResumeModeIncomparableError, resolveChildResumeMode, ensureDefaultMessagingRuntimeRegistered, buildContinuationChain, AGENT_TOOL_CANONICAL_NAME, computeActiveSlotSet, resolveSlotToProvider, createRpcBridge2, shellWords, validatePermissionRuleString, registerTool2, getRegisteredTool, listRegisteredTools, rebrandStandingServerTools, mcpServerHasRegistrations, onCompaction2, STRUCTURED_OUTPUT_TOOL_NAME, looksLikeCommand, matchFileRule, resolveFileRuleAbsolutePath, resolveFileRuleAbsoluteGlobText, resolvesWithinPluginRoot, buildWorkflowWorkerSeatbeltProfile2, capBytes, neutralizeReminderTags, readWhole, readCappedLinesAndBytes, registerAttachmentRenderer, attachmentsIn, registerChildEngineFactory, rawToRuleValue, sourceRule, parseFrontmatter, parseAgentDefinitionFile, allowedAgentTypesFromTools, validateAgentDefinition, WinterPathsError2, sessionTempDir2, ensureTasksDir2, resolveProjectDirName2, buildForkDirectiveText, buildForkInitialMessages, gitInstructionsEnabled, isUserInvocable, buildSkillListing, registerPluginAgents, clearPluginAgents, registerSkillSessionRuntime, clearSkillSessionRuntime, buildHookEntriesFromSettings, defaultTrustSource, formatValidationErrors, createSchemaValidatorCache, killAllTaskProcessGroups, runGit, listWorktrees, canonicalAliases, WINTER_CANONICAL_ALIASES, DEFAULT_SKILL_BODY_BYTES, skillNameError, pluginNameError, capBytes2, parseSkillFile, validateSkillsOption, isSkillEnabled, autoSkillPermissionEntries, setHostWorkflowWorkerCommand, listWorkflowsForListing, buildWorkflowSkillPrompt, WORKFLOW_SANDBOX_REFUSED_EXIT_CODE2, createToolLaneTails, DEFAULT_CONTEXT_WINDOW_TOKENS2, ProviderTurnError, isProviderTurnError, createContextAccountant2, runEngine2, WINTER_SUMMARY_INSTRUCTION, WINTER_PREFIX_SUMMARY_INSTRUCTION, CARRIED_SUMMARY_NOTE, retainedExchangesNote, buildSummaryInstruction, redactForSummary, summarize, summarizeOverPrefix, recordedProviderSystems2, resetRecordedProviderSystems2, echoProvider2, scriptedProvider2, stubExecutor2, P5_FIXTURE_SKILL_NAME2, P5_WORKFLOW_SCRIPT2, isTestProviderName2, testProviderForNamespace, testProviderByName2, SUBAGENT_CHILD_PROBE_TEXT2, MCP_SDK_TEST_SERVER_NAME2, MCP_SDK_TEST_TOOL_NAME2, BGTASK_TEST_TOOL_NAME2, registerBgTaskTestTool2, ResumeTargetError2, ResumeTruncationError2, findContinueTarget2, findResumeTarget2, toDialectEntries2, truncateAt2, rebuildProviderMessages2, userEntry2, winterMessageIdFor2, assistantEntry2, CLAUDE_COMPACT_SUMMARY_PREAMBLE2, claudeCompactBoundaryEntry2, claudeCompactSummaryEntry2, TranscriptWriterError2, TranscriptWriter2, RUNTIME_ENGINE_VERSION2, childTranscriptSubpath, buildChildTranscriptWriter, listChildAgentIds, resolveEngineSession2, resolveProductionWinterHome2, resolveProductionStoreHome, resolveSessionProvider, redactCredentialRef, createProviderContext, providerCredentialRef2, storeProviderCredential2, deleteProviderCredential2, validateProviderCredential2, CLASSIFIER_TOOL_NAME2, CLASSIFIER_VERDICT_SCHEMA2, CLASSIFIER_NO_VERDICT_REASONS2, DEFAULT_MAX_CONTEXT_CHARS2, CLASSIFIER_SYSTEM_PROMPT2, DEFAULT_CLASSIFIER_TIMEOUT_MS2, createModelClassifier2, selectClassifierRoute2 };