@ashx-j/lunr-dev 0.2.13-dev.8.1 → 0.2.16-dev.9.1

package/dist/node-runtime/pi-prompt-template-model-4QT4LLXF.js

@@ -0,0 +1,3946 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  parseFrontmatter
+} from "./chunk-QFWG2RVL.js";
+import {
+  minimatch
+} from "./chunk-CGBXPL3E.js";
+import {
+  CONFIG_DIR_NAME,
+  getAgentDir
+} from "./chunk-PCIGF2XK.js";
+import "./chunk-Q4Q6D4IY.js";
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-prompt-template-model/index.js
+import { existsSync as existsSync4 } from "node:fs";
+import { resolve as resolvePath } from "node:path";
+
+// packages/coding-agent/dist/builtin-extensions/pi-prompt-template-model/args.js
+function extractLoopCount(argsString) {
+  let loopCount = null, loopFound = !1, fresh = !1, noConverge = !1, tokensToRemove = [], loopTokenRanges = [], i = 0;
+  for (; i < argsString.length; ) {
+    let char = argsString[i];
+    if (char === '"' || char === "'") {
+      let quote = char;
+      for (i++; i < argsString.length && argsString[i] !== quote; )
+        i++;
+      i < argsString.length && i++;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      i++;
+      continue;
+    }
+    let tokenStart = i;
+    for (; i < argsString.length && !/\s/.test(argsString[i]); )
+      i++;
+    let token = argsString.slice(tokenStart, i);
+    if (token.startsWith("--loop=")) {
+      loopTokenRanges.push({ start: tokenStart, end: i });
+      let value = token.slice(7);
+      if (/^\d+$/.test(value)) {
+        let parsed = parseInt(value, 10);
+        parsed >= 1 && parsed <= 999 && !loopFound && (loopFound = !0, loopCount = parsed);
+      }
+      continue;
+    }
+    if (token === "--loop") {
+      let lookahead = i;
+      for (; lookahead < argsString.length && /\s/.test(argsString[lookahead]); )
+        lookahead++;
+      if (lookahead < argsString.length && argsString[lookahead] !== '"' && argsString[lookahead] !== "'") {
+        let nextTokenStart = lookahead;
+        for (; lookahead < argsString.length && !/\s/.test(argsString[lookahead]); )
+          lookahead++;
+        let nextToken = argsString.slice(nextTokenStart, lookahead);
+        if (/^\d+$/.test(nextToken)) {
+          loopTokenRanges.push({ start: tokenStart, end: i }, { start: nextTokenStart, end: lookahead });
+          let parsed = parseInt(nextToken, 10);
+          parsed >= 1 && parsed <= 999 && !loopFound && (loopFound = !0, loopCount = parsed), i = lookahead;
+          continue;
+        }
+      }
+      loopTokenRanges.push({ start: tokenStart, end: i }), loopFound || (loopFound = !0, loopCount = null);
+      continue;
+    }
+    token === "--fresh" && (fresh = !0, tokensToRemove.push({ start: tokenStart, end: i })), token === "--no-converge" && (noConverge = !0, tokensToRemove.push({ start: tokenStart, end: i }));
+  }
+  if (!loopFound)
+    return null;
+  let allRanges = [...tokensToRemove, ...loopTokenRanges];
+  allRanges.sort((a, b) => b.start - a.start);
+  let cleaned = argsString;
+  for (let { start, end } of allRanges)
+    cleaned = cleaned.slice(0, start) + cleaned.slice(end);
+  let converge = !noConverge;
+  return { args: cleaned.trim(), loopCount, fresh, converge };
+}
+function extractLoopFlags(argsString) {
+  let fresh = !1, noConverge = !1, tokensToRemove = [], i = 0;
+  for (; i < argsString.length; ) {
+    let char = argsString[i];
+    if (char === '"' || char === "'") {
+      let quote = char;
+      for (i++; i < argsString.length && argsString[i] !== quote; )
+        i++;
+      i < argsString.length && i++;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      i++;
+      continue;
+    }
+    let tokenStart = i;
+    for (; i < argsString.length && !/\s/.test(argsString[i]); )
+      i++;
+    let token = argsString.slice(tokenStart, i);
+    token === "--fresh" && (fresh = !0, tokensToRemove.push({ start: tokenStart, end: i })), token === "--no-converge" && (noConverge = !0, tokensToRemove.push({ start: tokenStart, end: i }));
+  }
+  tokensToRemove.sort((a, b) => b.start - a.start);
+  let cleaned = argsString;
+  for (let { start, end } of tokensToRemove)
+    cleaned = cleaned.slice(0, start) + cleaned.slice(end);
+  return { args: cleaned.trim(), fresh, converge: !noConverge };
+}
+function extractBooleanFlag(argsString, flag) {
+  let found = !1, tokensToRemove = [], i = 0;
+  for (; i < argsString.length; ) {
+    let char = argsString[i];
+    if (char === '"' || char === "'") {
+      let quote = char;
+      for (i++; i < argsString.length && argsString[i] !== quote; )
+        i++;
+      i < argsString.length && i++;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      i++;
+      continue;
+    }
+    let tokenStart = i;
+    for (; i < argsString.length && !/\s/.test(argsString[i]); )
+      i++;
+    argsString.slice(tokenStart, i) === flag && (found = !0, tokensToRemove.push({ start: tokenStart, end: i }));
+  }
+  if (tokensToRemove.length === 0)
+    return { args: argsString.trim(), found: !1 };
+  tokensToRemove.sort((a, b) => b.start - a.start);
+  let cleaned = argsString;
+  for (let { start, end } of tokensToRemove)
+    cleaned = cleaned.slice(0, start) + cleaned.slice(end);
+  return { args: cleaned.trim(), found };
+}
+function extractChainContextFlag(argsString) {
+  let { args, found } = extractBooleanFlag(argsString, "--chain-context");
+  return { args, chainContext: found };
+}
+function extractWorktreeFlag(argsString) {
+  let { args, found } = extractBooleanFlag(argsString, "--worktree");
+  return { args, worktree: found };
+}
+function extractSubagentOverride(argsString) {
+  let override, cwdRaw, modelRaw, fork = !1, tokensToRemove = [], i = 0;
+  for (; i < argsString.length; ) {
+    let char = argsString[i];
+    if (char === '"' || char === "'") {
+      let quote = char;
+      for (i++; i < argsString.length && argsString[i] !== quote; )
+        i++;
+      i < argsString.length && i++;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      i++;
+      continue;
+    }
+    let tokenStart = i;
+    for (; i < argsString.length && !/\s/.test(argsString[i]); )
+      i++;
+    let token = argsString.slice(tokenStart, i);
+    if (token === "--subagent") {
+      tokensToRemove.push({ start: tokenStart, end: i }), override = { enabled: !0 };
+      continue;
+    }
+    if (token.startsWith("--subagent=") || token.startsWith("--subagent:")) {
+      tokensToRemove.push({ start: tokenStart, end: i });
+      let value = (token.includes("="), token.slice(11));
+      override = value ? { enabled: !0, agent: value } : { enabled: !0 };
+      continue;
+    }
+    if (token.startsWith("--cwd=")) {
+      tokensToRemove.push({ start: tokenStart, end: i }), cwdRaw = token.slice(6) || void 0;
+      continue;
+    }
+    if (token.startsWith("--model=")) {
+      tokensToRemove.push({ start: tokenStart, end: i }), modelRaw = token.slice(8) || void 0;
+      continue;
+    }
+    if (token === "--fork") {
+      tokensToRemove.push({ start: tokenStart, end: i }), fork = !0;
+      continue;
+    }
+  }
+  if (tokensToRemove.length === 0)
+    return { args: argsString.trim() };
+  tokensToRemove.sort((a, b) => b.start - a.start);
+  let cleaned = argsString;
+  for (let { start, end } of tokensToRemove)
+    cleaned = cleaned.slice(0, start) + cleaned.slice(end);
+  return fork && !override && (override = { enabled: !0 }), {
+    args: cleaned.trim(),
+    ...override ? { override } : {},
+    ...cwdRaw !== void 0 ? { cwd: cwdRaw } : {},
+    ...modelRaw !== void 0 ? { model: modelRaw } : {},
+    ...fork ? { fork: !0 } : {}
+  };
+}
+function parseLineupOverrideSlots(raw, target, mode, errors) {
+  let label = `--${target === "finalApplier" ? "final-applier" : `${target}${mode === "append" ? "-append" : ""}`}`;
+  if (!raw) {
+    errors.push(`Invalid ${label}: expected ${target === "finalApplier" ? "a slot object or a one-element JSON array" : "a JSON array of slot objects"}.`);
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    let message = error instanceof Error ? error.message : String(error);
+    errors.push(`Invalid ${label}: expected valid JSON (${message}).`);
+    return;
+  }
+  let entries = target === "finalApplier" ? Array.isArray(parsed) ? parsed.length === 1 ? parsed : null : [parsed] : Array.isArray(parsed) && parsed.length > 0 ? parsed : null;
+  if (!entries) {
+    errors.push(target === "finalApplier" ? `Invalid ${label}: expected a slot object or a one-element JSON array.` : `Invalid ${label}: expected a non-empty JSON array.`);
+    return;
+  }
+  let slots = [];
+  for (let i = 0; i < entries.length; i++) {
+    let entry = entries[i];
+    if (!entry || typeof entry != "object" || Array.isArray(entry)) {
+      errors.push(`Invalid ${label}: slot ${i + 1} must be an object.`);
+      return;
+    }
+    let slot = entry;
+    if (slot.agent !== void 0 && slot.subagent !== void 0) {
+      errors.push(`Invalid ${label}: slot ${i + 1} cannot combine "agent" and "subagent".`);
+      return;
+    }
+    let agent;
+    if (typeof slot.agent == "string" && slot.agent.trim())
+      agent = slot.agent.trim();
+    else if (slot.agent !== void 0) {
+      errors.push(`Invalid ${label}: slot ${i + 1} requires a non-empty string "agent".`);
+      return;
+    }
+    if (!agent && slot.subagent !== void 0)
+      if (slot.subagent === !0)
+        agent = target === "reviewers" ? "reviewer" : "delegate";
+      else if (typeof slot.subagent == "string" && slot.subagent.trim())
+        agent = slot.subagent.trim();
+      else {
+        errors.push(`Invalid ${label}: slot ${i + 1} requires "subagent" to be true or a non-empty string.`);
+        return;
+      }
+    if (!agent) {
+      errors.push(`Invalid ${label}: slot ${i + 1} requires "agent" or "subagent".`);
+      return;
+    }
+    let model = typeof slot.model == "string" && slot.model.trim() ? slot.model.trim() : void 0, task = typeof slot.task == "string" && slot.task.trim() ? slot.task.trim() : void 0, taskSuffix = typeof slot.taskSuffix == "string" && slot.taskSuffix.trim() ? slot.taskSuffix.trim() : void 0;
+    if (target === "finalApplier" && slot.cwd !== void 0) {
+      errors.push(`Invalid ${label}: slot ${i + 1} "cwd" is not supported.`);
+      return;
+    }
+    let cwd = typeof slot.cwd == "string" && slot.cwd.trim() ? slot.cwd.trim() : void 0, count;
+    if (slot.count !== void 0) {
+      if (target === "finalApplier") {
+        errors.push(`Invalid ${label}: slot ${i + 1} "count" is not supported.`);
+        return;
+      }
+      let rawCount = slot.count;
+      if (typeof rawCount != "number" || !Number.isInteger(rawCount) || rawCount < 1) {
+        errors.push(`Invalid ${label}: slot ${i + 1} "count" must be an integer greater than or equal to 1.`);
+        return;
+      }
+      count = rawCount;
+    }
+    slots.push({
+      agent,
+      ...model ? { model } : {},
+      ...task ? { task } : {},
+      ...taskSuffix ? { taskSuffix } : {},
+      ...cwd ? { cwd } : {},
+      ...count !== void 0 ? { count } : {}
+    });
+  }
+  return { target, mode, slots };
+}
+var LINEUP_OVERRIDE_FLAGS = [
+  { flag: "--workers-append=", target: "workers", mode: "append" },
+  { flag: "--reviewers-append=", target: "reviewers", mode: "append" },
+  { flag: "--workers=", target: "workers", mode: "replace" },
+  { flag: "--reviewers=", target: "reviewers", mode: "replace" },
+  { flag: "--final-applier=", target: "finalApplier", mode: "replace" }
+];
+function readQuotedValue(input, start) {
+  let quote = input[start];
+  if (quote !== '"' && quote !== "'")
+    return;
+  let i = start + 1;
+  for (; i < input.length; ) {
+    let char = input[i];
+    if (char === "\\") {
+      i += 2;
+      continue;
+    }
+    if (char === quote)
+      return {
+        value: input.slice(start + 1, i),
+        end: i + 1
+      };
+    i++;
+  }
+}
+function readBalancedValue(input, start, open, close) {
+  if (input[start] !== open)
+    return;
+  let depth = 0, inQuote = null;
+  for (let i = start; i < input.length; i++) {
+    let char = input[i];
+    if (inQuote) {
+      if (char === "\\") {
+        i++;
+        continue;
+      }
+      char === inQuote && (inQuote = null);
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      inQuote = char;
+      continue;
+    }
+    if (char === open) {
+      depth++;
+      continue;
+    }
+    if (char === close && (depth--, depth === 0))
+      return {
+        value: input.slice(start, i + 1),
+        end: i + 1
+      };
+  }
+}
+function readLineupOverrideValue(input, start) {
+  if (start >= input.length)
+    return { value: "", end: start };
+  let bracketed = readBalancedValue(input, start, "[", "]");
+  if (bracketed)
+    return bracketed;
+  let braced = readBalancedValue(input, start, "{", "}");
+  if (braced)
+    return braced;
+  let quoted = readQuotedValue(input, start);
+  if (quoted)
+    return quoted;
+  let end = start;
+  for (; end < input.length && !/\s/.test(input[end]); )
+    end++;
+  return {
+    value: input.slice(start, end),
+    end
+  };
+}
+function parseLineupOverrideToken(input, start) {
+  for (let spec of LINEUP_OVERRIDE_FLAGS) {
+    if (!input.startsWith(spec.flag, start))
+      continue;
+    let valueStart = start + spec.flag.length, parsedValue = readLineupOverrideValue(input, valueStart);
+    return {
+      target: spec.target,
+      mode: spec.mode,
+      raw: parsedValue.value,
+      end: parsedValue.end
+    };
+  }
+}
+function extractLineupOverrides(argsString) {
+  let actions = [], errors = [], tokensToRemove = [], i = 0;
+  for (; i < argsString.length; ) {
+    let char = argsString[i];
+    if (char === '"' || char === "'") {
+      let quote = char;
+      for (i++; i < argsString.length && argsString[i] !== quote; )
+        i++;
+      i < argsString.length && i++;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      i++;
+      continue;
+    }
+    let token = parseLineupOverrideToken(argsString, i);
+    if (token) {
+      tokensToRemove.push({ start: i, end: token.end });
+      let action = parseLineupOverrideSlots(token.raw, token.target, token.mode, errors);
+      action && actions.push(action), i = token.end;
+      continue;
+    }
+    for (; i < argsString.length && !/\s/.test(argsString[i]); )
+      i++;
+  }
+  tokensToRemove.sort((a, b) => b.start - a.start);
+  let cleaned = argsString;
+  for (let { start, end } of tokensToRemove)
+    cleaned = cleaned.slice(0, start) + cleaned.slice(end);
+  return { args: cleaned.trim(), actions, errors };
+}
+function parseCommandArgs(argsString) {
+  let args = [], current = "", inQuote = null;
+  for (let i = 0; i < argsString.length; i++) {
+    let char = argsString[i];
+    inQuote ? char === inQuote ? inQuote = null : current += char : char === '"' || char === "'" ? inQuote = char : /\s/.test(char) ? current && (args.push(current), current = "") : current += char;
+  }
+  return current && args.push(current), args;
+}
+function substituteArgs(content, args) {
+  let result = content;
+  result = result.replace(/\$(\d+)/g, (_, num) => {
+    let index = parseInt(num, 10) - 1;
+    return args[index] ?? "";
+  }), result = result.replace(/\$\{@:(\d+)(?::(\d+))?\}/g, (_, startStr, lengthStr) => {
+    let start = parseInt(startStr, 10) - 1;
+    if (start < 0 && (start = 0), lengthStr) {
+      let length = parseInt(lengthStr, 10);
+      return args.slice(start, start + length).join(" ");
+    }
+    return args.slice(start).join(" ");
+  });
+  let allArgs = args.join(" ");
+  return result = result.replace(/\$ARGUMENTS/g, allArgs), result = result.replace(/\$@/g, allArgs), result = result.replace(/@\$/g, allArgs), result;
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-prompt-template-model/chain-parser.js
+function scanSegmentTokens(segment) {
+  let tokens = [], i = 0;
+  for (; i < segment.length; ) {
+    for (; i < segment.length && /\s/.test(segment[i]); )
+      i++;
+    if (i >= segment.length)
+      break;
+    let start = i, inQuote = null, value = "", sawQuoted = !1, sawUnquoted = !1;
+    for (; i < segment.length; ) {
+      let char = segment[i];
+      if (inQuote) {
+        char === inQuote ? inQuote = null : value += char, i++;
+        continue;
+      }
+      if (char === '"' || char === "'") {
+        inQuote = char, sawQuoted = !0, i++;
+        continue;
+      }
+      if (/\s/.test(char))
+        break;
+      value += char, sawUnquoted = !0, i++;
+    }
+    tokens.push({
+      start,
+      end: i,
+      value,
+      quoted: sawQuoted && !sawUnquoted
+    });
+  }
+  return tokens;
+}
+function extractStepFlags(segment) {
+  let tokens = scanSegmentTokens(segment), loopTokenRanges = [], withContextTokenRanges = [], loopCount, withContext = !1;
+  for (let i = 1; i < tokens.length; i++) {
+    let token = tokens[i];
+    if (!token.quoted) {
+      if (token.value === "--with-context") {
+        withContext = !0, withContextTokenRanges.push({ start: token.start, end: token.end });
+        continue;
+      }
+      if (token.value.startsWith("--loop=")) {
+        loopTokenRanges.push({ start: token.start, end: token.end });
+        let value = token.value.slice(7);
+        if (!/^\d+$/.test(value))
+          continue;
+        let parsed = parseInt(value, 10);
+        parsed >= 1 && parsed <= 999 && loopCount === void 0 && (loopCount = parsed);
+        continue;
+      }
+      if (token.value === "--loop") {
+        if (loopTokenRanges.push({ start: token.start, end: token.end }), i + 1 < tokens.length) {
+          let next = tokens[i + 1];
+          if (!next.quoted && /^\d+$/.test(next.value)) {
+            loopTokenRanges.push({ start: next.start, end: next.end });
+            let parsed = parseInt(next.value, 10);
+            parsed >= 1 && parsed <= 999 && loopCount === void 0 && (loopCount = parsed), i++;
+            continue;
+          }
+        }
+        loopCount === void 0 && (loopCount = null);
+        continue;
+      }
+    }
+  }
+  let loopRangesToRemove = loopCount !== void 0 ? loopTokenRanges : [];
+  if (loopRangesToRemove.length === 0 && withContextTokenRanges.length === 0)
+    return { cleanedSegment: segment, withContext: !1 };
+  let rangesToRemove = [...loopRangesToRemove, ...withContextTokenRanges].sort((a, b) => b.start - a.start), cleanedSegment = segment;
+  for (let { start, end } of rangesToRemove)
+    cleanedSegment = `${cleanedSegment.slice(0, start)}${cleanedSegment.slice(end)}`;
+  return { cleanedSegment: cleanedSegment.trim(), loopCount, withContext };
+}
+function splitByTopLevelSeparator(input, separator) {
+  let parts = [], start = 0, inQuote = null, parenDepth = 0;
+  for (let i = 0; i < input.length; i++) {
+    let char = input[i];
+    if (inQuote) {
+      char === inQuote && (inQuote = null);
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      inQuote = char;
+      continue;
+    }
+    if (char === "(") {
+      parenDepth++;
+      continue;
+    }
+    if (char === ")" && parenDepth > 0) {
+      parenDepth--;
+      continue;
+    }
+    parenDepth === 0 && i <= input.length - separator.length && input.startsWith(separator, i) && (parts.push(input.slice(start, i)), start = i + separator.length, i += separator.length - 1);
+  }
+  return parts.push(input.slice(start)), parts;
+}
+function findMatchingParen(segment, openIndex) {
+  let inQuote = null, depth = 0;
+  for (let i = openIndex; i < segment.length; i++) {
+    let char = segment[i];
+    if (inQuote) {
+      char === inQuote && (inQuote = null);
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      inQuote = char;
+      continue;
+    }
+    if (char === "(") {
+      depth++;
+      continue;
+    }
+    if (char === ")" && (depth--, depth === 0))
+      return i;
+  }
+  return -1;
+}
+function parseSingleStepSegment(segment) {
+  let { cleanedSegment, loopCount, withContext } = extractStepFlags(segment), tokens = parseCommandArgs(cleanedSegment);
+  if (tokens.length !== 0)
+    return { name: tokens[0], args: tokens.slice(1), loopCount, ...withContext ? { withContext: !0 } : {} };
+}
+function parseParallelStepSegment(segment) {
+  if (!/^parallel\s*\(/.test(segment))
+    return;
+  let openIndex = segment.indexOf("(");
+  if (openIndex < 0)
+    return;
+  let closeIndex = findMatchingParen(segment, openIndex);
+  if (closeIndex < 0 || segment.slice(closeIndex + 1).trim().length > 0)
+    return;
+  let inner = segment.slice(openIndex + 1, closeIndex).trim();
+  if (!inner)
+    return;
+  let parsedSteps = [];
+  for (let rawEntry of splitByTopLevelSeparator(inner, ",")) {
+    let entry = rawEntry.trim();
+    if (!entry || /^parallel\s*\(/.test(entry))
+      return;
+    let parsed = parseSingleStepSegment(entry);
+    if (!parsed)
+      return;
+    parsedSteps.push(parsed);
+  }
+  if (parsedSteps.length !== 0)
+    return { parallel: parsedSteps };
+}
+function parseChainSegment(segment) {
+  let parallelStep = parseParallelStepSegment(segment);
+  if (parallelStep)
+    return parallelStep;
+  if (!/^parallel\s*\(/.test(segment))
+    return parseSingleStepSegment(segment);
+}
+function parseChainSteps(args) {
+  let sharedArgsSplit = splitByTopLevelSeparator(args, " -- "), templatesPart = sharedArgsSplit[0], argsPart = sharedArgsSplit.length > 1 ? sharedArgsSplit.slice(1).join(" -- ") : "", invalidSegments = [], steps = [];
+  for (let rawSegment of splitByTopLevelSeparator(templatesPart, "->")) {
+    let segment = rawSegment.trim();
+    if (!segment) {
+      invalidSegments.push(rawSegment);
+      continue;
+    }
+    let parsedSegment = parseChainSegment(segment);
+    if (!parsedSegment) {
+      invalidSegments.push(segment);
+      continue;
+    }
+    steps.push(parsedSegment);
+  }
+  return { steps, sharedArgs: parseCommandArgs(argsPart), invalidSegments };
+}
+function parseChainDeclaration(chain) {
+  let invalidSegments = [], steps = [];
+  for (let rawSegment of splitByTopLevelSeparator(chain, "->")) {
+    let segment = rawSegment.trim();
+    if (!segment) {
+      invalidSegments.push(rawSegment);
+      continue;
+    }
+    let parsedSegment = parseChainSegment(segment);
+    if (!parsedSegment) {
+      invalidSegments.push(segment);
+      continue;
+    }
+    steps.push(parsedSegment);
+  }
+  return { steps, invalidSegments };
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-prompt-template-model/subagent-runtime.js
+var PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT = "prompt-template:subagent:request", PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT = "prompt-template:subagent:started", PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT = "prompt-template:subagent:response", PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT = "prompt-template:subagent:update", PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT = "prompt-template:subagent:cancel", PROMPT_TEMPLATE_SUBAGENT_MESSAGE_TYPE = "prompt-template-subagent", DEFAULT_SUBAGENT_NAME = "delegate", delegatedLiveState = /* @__PURE__ */ new Map();
+function updateDelegatedLiveState(requestId, update) {
+  let now = Date.now(), existing = delegatedLiveState.get(requestId) ?? {
+    recentOutput: [],
+    recentTools: [],
+    toolCount: 0,
+    durationMs: 0,
+    tokens: 0,
+    taskProgress: [],
+    startedAt: now,
+    updatedAt: now
+  }, next = {
+    ...existing,
+    ...update,
+    recentOutput: update.recentOutput ?? existing.recentOutput,
+    recentTools: update.recentTools ?? existing.recentTools,
+    model: update.model ?? existing.model,
+    toolCount: update.toolCount ?? existing.toolCount,
+    durationMs: update.durationMs ?? now - existing.startedAt,
+    tokens: update.tokens ?? existing.tokens,
+    taskProgress: update.taskProgress ?? existing.taskProgress,
+    startedAt: existing.startedAt,
+    updatedAt: now
+  };
+  delegatedLiveState.set(requestId, next);
+}
+function appendDelegatedLiveOutput(requestId, line) {
+  if (!line || !line.trim() || line.trim() === "(running...)")
+    return;
+  let fallbackNow = Date.now(), existing = delegatedLiveState.get(requestId) ?? {
+    recentOutput: [],
+    recentTools: [],
+    toolCount: 0,
+    durationMs: 0,
+    tokens: 0,
+    taskProgress: [],
+    startedAt: fallbackNow,
+    updatedAt: fallbackNow
+  }, recentOutput = [...existing.recentOutput, line];
+  delegatedLiveState.set(requestId, {
+    ...existing,
+    recentOutput,
+    updatedAt: Date.now()
+  });
+}
+function getDelegatedLiveState(requestId) {
+  return delegatedLiveState.get(requestId);
+}
+function clearDelegatedLiveState(requestId) {
+  delegatedLiveState.delete(requestId);
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-prompt-template-model/loop-utils.js
+function collectAssistantActions(messages, filesRead, filesWritten) {
+  let commandCount = 0, lastText = "";
+  for (let msg of messages)
+    if (msg.role === "assistant")
+      for (let block of msg.content) {
+        if (block.type === "text") {
+          lastText = block.text;
+          continue;
+        }
+        if (block.type !== "toolCall")
+          continue;
+        if (block.name === "bash") {
+          commandCount++;
+          continue;
+        }
+        let path = block.arguments.path;
+        block.name === "read" && path && filesRead.add(path), (block.name === "write" || block.name === "edit") && path && filesWritten.add(path);
+      }
+  return { commandCount, lastText };
+}
+function delegatedDetails(entry) {
+  if (entry.type === "custom_message" && entry.customType === PROMPT_TEMPLATE_SUBAGENT_MESSAGE_TYPE && !(!entry.details || typeof entry.details != "object"))
+    return entry.details;
+}
+function collectSummaryData(entries) {
+  let filesRead = /* @__PURE__ */ new Set(), filesWritten = /* @__PURE__ */ new Set(), commandCount = 0, lastAssistantText = "";
+  for (let entry of entries) {
+    if (entry.type === "message") {
+      let msg = entry.message;
+      if (msg.role !== "assistant")
+        continue;
+      let collected = collectAssistantActions([msg], filesRead, filesWritten);
+      commandCount += collected.commandCount, collected.lastText && (lastAssistantText = collected.lastText);
+      continue;
+    }
+    let delegated = delegatedDetails(entry);
+    if (!delegated)
+      continue;
+    let messageGroups = delegated.parallelResults && delegated.parallelResults.length > 0 ? delegated.parallelResults.map((result) => result.messages ?? []) : delegated.messages ? [delegated.messages] : [];
+    for (let messages of messageGroups) {
+      let collected = collectAssistantActions(messages, filesRead, filesWritten);
+      commandCount += collected.commandCount, collected.lastText && (lastAssistantText = collected.lastText);
+    }
+    typeof delegated.text == "string" && delegated.text.trim() && (lastAssistantText = delegated.text);
+  }
+  return {
+    filesRead,
+    filesWritten,
+    commandCount,
+    lastAssistantText
+  };
+}
+function formatSummary(header, entries, preserveOutcome = !1) {
+  let { filesRead, filesWritten, commandCount, lastAssistantText } = collectSummaryData(entries), summary = header, actionParts = [];
+  if (filesRead.size > 0 && actionParts.push(`read ${filesRead.size} file(s)`), filesWritten.size > 0 && actionParts.push(`modified ${[...filesWritten].join(", ")}`), commandCount > 0 && actionParts.push(`ran ${commandCount} command(s)`), actionParts.length > 0 && (summary += `
+Actions: ${actionParts.join(", ")}.`), lastAssistantText) {
+    let cleaned = preserveOutcome ? lastAssistantText.replace(/\r\n?/g, `
+`).trim() : lastAssistantText.replace(/\n+/g, " ").trim(), outcome = preserveOutcome || cleaned.length <= 500 ? cleaned : `${cleaned.slice(0, 500)}...`;
+    summary += `
+Outcome: ${outcome}`;
+  }
+  return summary;
+}
+function generateIterationSummary(entries, task, iteration, totalIterations) {
+  let header = totalIterations !== null ? `[Loop iteration ${iteration}/${totalIterations}]
+Task: "${task}"` : `[Loop iteration ${iteration}]
+Task: "${task}"`;
+  return formatSummary(header, entries);
+}
+function generateBoomerangSummary(entries, task) {
+  return formatSummary(`[Boomerang]
+Task: "${task}"`, entries, !0);
+}
+function generateChainStepSummary(entries, stepLabel, stepNumber) {
+  return formatSummary(`Step ${stepNumber} \u2014 ${stepLabel}:`, entries);
+}
+function didIterationMakeChanges(entries) {
+  for (let entry of entries) {
+    if (entry.type === "message") {
+      if (entry.message.role !== "assistant")
+        continue;
+      for (let block of entry.message.content)
+        if (block.type === "toolCall" && (block.name === "write" || block.name === "edit"))
+          return !0;
+      continue;
+    }
+    let delegated = delegatedDetails(entry);
+    if (!delegated)
+      continue;
+    if (delegated.changed === !0)
+      return !0;
+    let delegatedGroups = delegated.parallelResults && delegated.parallelResults.length > 0 ? delegated.parallelResults.map((result) => result.messages ?? []) : [delegated.messages ?? []];
+    for (let messages of delegatedGroups)
+      for (let message of messages)
+        if (message.role === "assistant") {
+          for (let block of message.content)
+            if (block.type === "toolCall" && (block.name === "write" || block.name === "edit"))
+              return !0;
+        }
+  }
+  return !1;
+}
+function getIterationEntries(ctx, startId) {
+  let branch = ctx.sessionManager.getBranch();
+  if (!startId)
+    return branch;
+  let startIdx = branch.findIndex((e) => e.id === startId);
+  return startIdx < 0 ? branch : branch.slice(startIdx + 1);
+}
+function wasIterationAborted(entries) {
+  for (let entry of entries)
+    if (!(entry.type !== "message" || entry.message.role !== "assistant") && entry.message.stopReason === "aborted")
+      return !0;
+  return !1;
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-prompt-template-model/model-selection.js
+var PREFERRED_PROVIDERS = ["openai-codex", "anthropic", "github-copilot", "openrouter"];
+function isSameModel(a, b) {
+  return a.provider === b.provider && a.id === b.id;
+}
+function modelSpecMatches(modelSpec, model) {
+  let slashIndex = modelSpec.indexOf("/");
+  if (slashIndex !== -1) {
+    let provider = modelSpec.slice(0, slashIndex), modelId = modelSpec.slice(slashIndex + 1);
+    return provider === model.provider && modelId === model.id;
+  }
+  return modelSpec === model.id;
+}
+function orderMatchesByProviderPreference(models) {
+  let prioritized = [], seen = /* @__PURE__ */ new Set();
+  for (let provider of PREFERRED_PROVIDERS)
+    for (let model of models) {
+      let key = `${model.provider}/${model.id}`;
+      model.provider === provider && !seen.has(key) && (prioritized.push(model), seen.add(key));
+    }
+  for (let model of models) {
+    let key = `${model.provider}/${model.id}`;
+    seen.has(key) || (prioritized.push(model), seen.add(key));
+  }
+  return prioritized;
+}
+function getModelCandidates(modelSpec, registry) {
+  let slashIndex = modelSpec.indexOf("/");
+  if (slashIndex !== -1) {
+    let provider = modelSpec.slice(0, slashIndex), modelId = modelSpec.slice(slashIndex + 1);
+    if (!provider || !modelId)
+      return [];
+    if (modelId.split("/").some((segment) => segment.length === 0))
+      return [];
+    let model = registry.find(provider, modelId);
+    return model ? [model] : [];
+  }
+  let allMatches = registry.getAll().filter((model) => model.id === modelSpec);
+  return allMatches.length <= 1 ? allMatches : orderMatchesByProviderPreference(allMatches);
+}
+async function hasUsableAuth(model, registry) {
+  return registry.getAvailable().some((candidate) => isSameModel(candidate, model)) ? !0 : registry.isUsingOAuth(model) ? registry.hasConfiguredAuth ? registry.hasConfiguredAuth(model) : registry.getApiKeyAndHeaders ? (await registry.getApiKeyAndHeaders(model)).ok : !1 : !1;
+}
+async function selectModelCandidate(modelSpecs, currentModel, registry) {
+  if (currentModel && modelSpecs.some((spec) => modelSpecMatches(spec, currentModel)))
+    return { model: currentModel, alreadyActive: !0 };
+  for (let spec of modelSpecs)
+    for (let model of getModelCandidates(spec, registry))
+      if (await hasUsableAuth(model, registry))
+        return { model, alreadyActive: !1 };
+}
+function getResolvedModelRef(model) {
+  return { provider: model.provider, id: model.id };
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-prompt-template-model/notifications.js
+function notify(ctx, message, type = "info") {
+  if (ctx?.hasUI) {
+    ctx.ui.notify(message, type);
+    return;
+  }
+  process.stderr.write(`${message}
+`);
+}
+function summarizePromptDiagnostics(diagnostics) {
+  if (diagnostics.length === 0)
+    return;
+  let lines = diagnostics.slice(0, 4).map((diagnostic) => `- ${diagnostic.message}`), remaining = diagnostics.length - lines.length;
+  return remaining > 0 && lines.push(`- ... and ${remaining} more prompt template issue(s)`), [`[pi-prompt-template-model] Found ${diagnostics.length} prompt template issue(s):`, ...lines].join(`
+`);
+}
+function diagnosticsFingerprint(diagnostics) {
+  return diagnostics.map((diagnostic) => diagnostic.key).sort().join(`
+`);
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-prompt-template-model/template-conditionals.js
+function isValidSpec(spec) {
+  if (!spec || /\s/.test(spec))
+    return !1;
+  if (spec.includes("*")) {
+    let segments = spec.split("/");
+    return segments.length === 2 && segments[0].length > 0 && segments[1] === "*";
+  }
+  let slashIndex = spec.indexOf("/");
+  if (slashIndex === -1)
+    return !0;
+  if (slashIndex === 0)
+    return !1;
+  let modelId = spec.slice(slashIndex + 1);
+  return !(modelId.length === 0 || modelId.split("/").some((segment) => segment.length === 0));
+}
+function matchSpec(spec, model) {
+  return spec === `${model.provider}/${model.id}` || spec === model.id || spec === `${model.provider}/*`;
+}
+function parseIfModelTag(tagContent) {
+  let cursor = 0, attributes = /* @__PURE__ */ new Map();
+  for (; cursor < tagContent.length; ) {
+    for (; cursor < tagContent.length && /\s/.test(tagContent[cursor]); )
+      cursor++;
+    if (cursor >= tagContent.length)
+      break;
+    let nameStart = cursor;
+    for (; cursor < tagContent.length && /[a-z-]/.test(tagContent[cursor]); )
+      cursor++;
+    if (nameStart === cursor)
+      return { ok: !1, error: { message: "Invalid `<if-model>` attribute syntax." } };
+    let name = tagContent.slice(nameStart, cursor);
+    for (; cursor < tagContent.length && /\s/.test(tagContent[cursor]); )
+      cursor++;
+    if (tagContent[cursor] !== "=")
+      return { ok: !1, error: { message: `Attribute "${name}" in \`<if-model>\` must use =.` } };
+    for (cursor++; cursor < tagContent.length && /\s/.test(tagContent[cursor]); )
+      cursor++;
+    if (tagContent[cursor] !== '"')
+      return { ok: !1, error: { message: `Attribute "${name}" in \`<if-model>\` must use double quotes.` } };
+    cursor++;
+    let valueStart = cursor;
+    for (; cursor < tagContent.length && tagContent[cursor] !== '"'; )
+      cursor++;
+    if (cursor >= tagContent.length)
+      return { ok: !1, error: { message: "Unterminated quoted attribute in `<if-model>`." } };
+    let value = tagContent.slice(valueStart, cursor);
+    if (cursor++, attributes.has(name))
+      return { ok: !1, error: { message: `Duplicate attribute "${name}" in \`<if-model>\`.` } };
+    attributes.set(name, value);
+  }
+  if (!attributes.has("is"))
+    return { ok: !1, error: { message: "`<if-model>` requires an `is` attribute." } };
+  for (let name of attributes.keys())
+    if (name !== "is")
+      return { ok: !1, error: { message: `Unknown attribute "${name}" in \`<if-model>\`.` } };
+  let specs = attributes.get("is").split(",").map((spec) => spec.trim()).filter(Boolean);
+  if (specs.length === 0)
+    return { ok: !1, error: { message: "`<if-model>` must declare at least one model spec." } };
+  for (let spec of specs)
+    if (!isValidSpec(spec))
+      return { ok: !1, error: { message: `Invalid model spec ${JSON.stringify(spec)} in \`<if-model>\`.` } };
+  return { type: "open", specs };
+}
+function isDirectiveBoundaryChar(char) {
+  return char === void 0 || char === ">" || /\s/.test(char);
+}
+function readToken(input, index) {
+  if (input.startsWith("</if-model>", index))
+    return { token: { type: "close" }, length: 11 };
+  if (input.startsWith("</if-model", index) && isDirectiveBoundaryChar(input[index + 10]))
+    return { ok: !1, error: { message: "`</if-model>` cannot have attributes or extra characters." } };
+  if (input.startsWith("<else>", index))
+    return { token: { type: "else" }, length: 6 };
+  if (input.startsWith("<else", index) && isDirectiveBoundaryChar(input[index + 5]))
+    return { ok: !1, error: { message: "`<else>` cannot have attributes or extra characters." } };
+  if (input.startsWith("</else>", index))
+    return { ok: !1, error: { message: "`</else>` is not valid. `<else>` is a separator, not a container - use `<else>content</if-model>` instead." } };
+  if (input.startsWith("</else", index) && isDirectiveBoundaryChar(input[index + 6]))
+    return { ok: !1, error: { message: "`</else>` is not valid. `<else>` is a separator, not a container - use `<else>content</if-model>` instead." } };
+  if (!input.startsWith("<if-model", index))
+    return;
+  let closeIndex = input.indexOf(">", index);
+  if (closeIndex === -1)
+    return { ok: !1, error: { message: "Missing closing `>` for `<if-model>`." } };
+  let nextChar = input[index + 9];
+  if (nextChar !== void 0 && nextChar !== ">" && !/\s/.test(nextChar))
+    return;
+  let tagContent = input.slice(index + 9, closeIndex), parsed = parseIfModelTag(tagContent);
+  return "ok" in parsed && !parsed.ok ? parsed : { token: parsed, length: closeIndex - index + 1 };
+}
+function appendNode(stack, root, node) {
+  let frame = stack[stack.length - 1];
+  if (!frame) {
+    root.push(node);
+    return;
+  }
+  frame.inElse ? frame.falsy.push(node) : frame.truthy.push(node);
+}
+function parseNodes(input) {
+  let root = [], stack = [], cursor = 0, textStart = 0;
+  for (; cursor < input.length; ) {
+    if (input[cursor] !== "<") {
+      cursor++;
+      continue;
+    }
+    let tokenResult = readToken(input, cursor);
+    if (!tokenResult) {
+      cursor++;
+      continue;
+    }
+    if ("ok" in tokenResult && !tokenResult.ok)
+      return tokenResult;
+    textStart < cursor && appendNode(stack, root, { type: "text", value: input.slice(textStart, cursor) });
+    let { token, length } = tokenResult;
+    if (token.type === "open")
+      stack.push({ specs: token.specs, truthy: [], falsy: [], inElse: !1 });
+    else if (token.type === "else") {
+      let frame = stack[stack.length - 1];
+      if (!frame)
+        return { ok: !1, error: { message: "Found orphan `<else>` outside `<if-model>`." } };
+      if (frame.inElse)
+        return { ok: !1, error: { message: "Found multiple `<else>` tags in one `<if-model>` block." } };
+      frame.inElse = !0;
+    } else {
+      let frame = stack.pop();
+      if (!frame)
+        return { ok: !1, error: { message: "Found closing `</if-model>` without a matching `<if-model>`." } };
+      appendNode(stack, root, { type: "if", specs: frame.specs, truthy: frame.truthy, falsy: frame.falsy });
+    }
+    cursor += length, textStart = cursor;
+  }
+  return textStart < input.length && appendNode(stack, root, { type: "text", value: input.slice(textStart) }), stack.length > 0 ? { ok: !1, error: { message: "Missing closing `</if-model>` tag." } } : { ok: !0, nodes: root };
+}
+function renderNodes(nodes, model) {
+  let output = "";
+  for (let node of nodes) {
+    if (node.type === "text") {
+      output += node.value;
+      continue;
+    }
+    let branch = node.specs.some((spec) => matchSpec(spec, model)) ? node.truthy : node.falsy;
+    output += renderNodes(branch, model);
+  }
+  return output;
+}
+function renderTemplateConditionals(content, model, commandName) {
+  if (!content.includes("<if-model") && !content.includes("<else") && !content.includes("</if-model") && !content.includes("</else"))
+    return { content };
+  let parsed = parseNodes(content);
+  if (parsed.ok)
+    return { content: renderNodes(parsed.nodes, model) };
+  let label = commandName ? ` in prompt \`${commandName}\`` : "", error = parsed.error;
+  return {
+    content,
+    error: `Invalid <if-model> markup${label}: ${error.message}`
+  };
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-prompt-template-model/prompt-execution.js
+function renderPromptForResolvedModel(prompt, args, model) {
+  let rendered = renderTemplateConditionals(prompt.content, getResolvedModelRef(model), prompt.name), content = substituteArgs(rendered.content, args);
+  return content.trim().length === 0 ? {
+    empty: `Prompt \`${prompt.name}\` rendered to an empty message.`,
+    warning: rendered.error
+  } : {
+    content,
+    warning: rendered.error
+  };
+}
+function sameModel(a, b) {
+  return !a || !b ? a === b : a.provider === b.provider && a.id === b.id;
+}
+async function preparePromptExecution(prompt, args, currentModel, modelRegistry, options) {
+  let selectedModel = prompt.models.length === 0 ? (() => {
+    let inheritedModel = options !== void 0 && Object.hasOwn(options, "inheritedModel") ? options.inheritedModel : currentModel;
+    return inheritedModel ? {
+      model: inheritedModel,
+      alreadyActive: sameModel(currentModel, inheritedModel)
+    } : {
+      message: `Prompt \`${prompt.name}\` has no \`model\` configured and there is no active session model to inherit.`
+    };
+  })() : await selectModelCandidate(prompt.models, currentModel, modelRegistry);
+  if (!selectedModel)
+    return;
+  if ("message" in selectedModel)
+    return selectedModel;
+  let rendered = renderPromptForResolvedModel(prompt, args, selectedModel.model);
+  return rendered.empty ? {
+    message: rendered.empty,
+    warning: rendered.warning
+  } : {
+    selectedModel,
+    content: rendered.content ?? "",
+    warning: rendered.warning
+  };
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-prompt-template-model/prompt-loader.js
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+var VALID_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"], RESERVED_COMMAND_NAMES = /* @__PURE__ */ new Set([
+  "chain-prompts",
+  "prompt-tool",
+  "settings",
+  "model",
+  "scoped-models",
+  "export",
+  "share",
+  "copy",
+  "name",
+  "session",
+  "hotkeys",
+  "fork",
+  "tree",
+  "login",
+  "logout",
+  // lunr: /auth and /deauth aliases of /login and /logout
+  "auth",
+  "deauth",
+  "new",
+  "compact",
+  "resume",
+  "reload",
+  "quit",
+  // lunr: /exit alias of /quit
+  "exit",
+  "mode",
+  "manual",
+  "yolo",
+  "auto",
+  "processes",
+  "rollback"
+]);
+function createDiagnostic(code, filePath, source, message) {
+  return {
+    code,
+    message,
+    filePath,
+    source,
+    key: `${code}:${filePath}:${message}`
+  };
+}
+function lexicalCompare(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function normalizeStringField(field, value, filePath, source, diagnostics) {
+  if (value === void 0)
+    return;
+  if (typeof value != "string") {
+    diagnostics.push(createDiagnostic(`invalid-${field}`, filePath, source, `Ignoring invalid ${field} value in ${filePath}: expected a string.`));
+    return;
+  }
+  let normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function isValidModelSelectionSpec(spec) {
+  if (!spec || spec.includes("*") || /\s/.test(spec))
+    return !1;
+  let slashIndex = spec.indexOf("/");
+  if (slashIndex === -1)
+    return !0;
+  if (slashIndex === 0)
+    return !1;
+  let modelId = spec.slice(slashIndex + 1);
+  return !(modelId.length === 0 || modelId.split("/").some((segment) => segment.length === 0));
+}
+function normalizeFrontmatterRecord(value, filePath, source, diagnostics) {
+  if (value && typeof value == "object" && !Array.isArray(value))
+    return value;
+  diagnostics.push(createDiagnostic("invalid-frontmatter", filePath, source, `Skipping prompt template at ${filePath}: frontmatter must be a key-value object.`));
+}
+function normalizeModelSpecs(value, filePath, source, diagnostics) {
+  if (value === void 0)
+    return;
+  if (typeof value != "string") {
+    diagnostics.push(createDiagnostic("invalid-model", filePath, source, `Skipping prompt template at ${filePath}: frontmatter field "model" must be a string.`));
+    return;
+  }
+  let models = value.split(",").map((item) => item.trim()).filter(Boolean);
+  if (models.length === 0) {
+    diagnostics.push(createDiagnostic("empty-model", filePath, source, `Skipping prompt template at ${filePath}: frontmatter field "model" is empty.`));
+    return;
+  }
+  let invalidSpec = models.find((model) => !isValidModelSelectionSpec(model));
+  if (invalidSpec) {
+    diagnostics.push(createDiagnostic("invalid-model-spec", filePath, source, `Skipping prompt template at ${filePath}: invalid model spec ${JSON.stringify(invalidSpec)} in frontmatter field "model".`));
+    return;
+  }
+  return models;
+}
+function normalizeRestore(value, filePath, source, diagnostics) {
+  if (value === void 0)
+    return !0;
+  if (typeof value == "boolean")
+    return value;
+  if (typeof value == "string") {
+    let normalized = value.trim().toLowerCase();
+    if (normalized === "true")
+      return !0;
+    if (normalized === "false")
+      return !1;
+  }
+  return diagnostics.push(createDiagnostic("invalid-restore", filePath, source, `Using default restore=true for ${filePath}: frontmatter field "restore" must be true or false.`)), !0;
+}
+function normalizeFresh(value, filePath, source, diagnostics) {
+  if (value === void 0)
+    return !1;
+  if (typeof value == "boolean")
+    return value;
+  if (typeof value == "string") {
+    let normalized = value.trim().toLowerCase();
+    if (normalized === "true")
+      return !0;
+    if (normalized === "false")
+      return !1;
+  }
+  return diagnostics.push(createDiagnostic("invalid-fresh", filePath, source, `Using default fresh=false for ${filePath}: frontmatter field "fresh" must be true or false.`)), !1;
+}
+function normalizeRotate(value, filePath, source, diagnostics) {
+  if (value === void 0)
+    return !1;
+  if (typeof value == "boolean")
+    return value;
+  if (typeof value == "string") {
+    let normalized = value.trim().toLowerCase();
+    if (normalized === "true")
+      return !0;
+    if (normalized === "false")
+      return !1;
+  }
+  return diagnostics.push(createDiagnostic("invalid-rotate", filePath, source, `Using default rotate=false for ${filePath}: frontmatter field "rotate" must be true or false.`)), !1;
+}
+function normalizeBoomerang(value, filePath, source, diagnostics) {
+  if (value === void 0)
+    return !1;
+  if (typeof value == "boolean")
+    return value;
+  if (typeof value == "string") {
+    let normalized = value.trim().toLowerCase();
+    if (normalized === "true")
+      return !0;
+    if (normalized === "false")
+      return !1;
+  }
+  return diagnostics.push(createDiagnostic("invalid-boomerang", filePath, source, `Using default boomerang=false for ${filePath}: frontmatter field "boomerang" must be true or false.`)), !1;
+}
+function normalizeLoop(value, filePath, source, diagnostics) {
+  if (value === void 0)
+    return;
+  if (value === !0 || typeof value == "string" && value.trim().toLowerCase() === "unlimited")
+    return null;
+  let normalizedValue;
+  if (typeof value == "number" ? normalizedValue = value : typeof value == "string" && /^\d+$/.test(value.trim()) && (normalizedValue = parseInt(value.trim(), 10)), normalizedValue !== void 0 && Number.isInteger(normalizedValue) && normalizedValue >= 1 && normalizedValue <= 999)
+    return normalizedValue;
+  diagnostics.push(createDiagnostic("invalid-loop", filePath, source, `Ignoring invalid loop value in ${filePath}: frontmatter field "loop" must be an integer between 1 and 999, true, or "unlimited".`));
+}
+function normalizeParallel(value, filePath, source, diagnostics) {
+  if (value === void 0)
+    return;
+  let normalizedValue;
+  if (typeof value == "number" ? normalizedValue = value : typeof value == "string" && /^\d+$/.test(value.trim()) && (normalizedValue = parseInt(value.trim(), 10)), normalizedValue !== void 0 && Number.isInteger(normalizedValue) && normalizedValue >= 2)
+    return normalizedValue;
+  diagnostics.push(createDiagnostic("invalid-parallel", filePath, source, `Ignoring invalid parallel value in ${filePath}: frontmatter field "parallel" must be an integer greater than or equal to 2.`));
+}
+function normalizeStringArrayField(field, value, filePath, source, diagnostics) {
+  if (value === void 0)
+    return [];
+  if (!Array.isArray(value)) {
+    diagnostics.push(createDiagnostic(`invalid-${field}`, filePath, source, `Ignoring invalid ${field} value in ${filePath}: expected an array of strings.`));
+    return;
+  }
+  let args = [];
+  for (let entry of value) {
+    if (typeof entry != "string") {
+      diagnostics.push(createDiagnostic(`invalid-${field}`, filePath, source, `Ignoring invalid ${field} value in ${filePath}: expected an array of strings.`));
+      return;
+    }
+    args.push(entry);
+  }
+  return args;
+}
+function normalizeDeterministicHandoff(value, filePath, source, diagnostics) {
+  if (value === void 0)
+    return "always";
+  if (typeof value == "string") {
+    let normalized = value.trim().toLowerCase();
+    if (normalized === "always" || normalized === "never" || normalized === "on-success" || normalized === "on-failure")
+      return normalized;
+  }
+  return diagnostics.push(createDiagnostic("invalid-deterministic-handoff", filePath, source, `Using default deterministic handoff=always for ${filePath}: expected "always", "never", "on-success", or "on-failure".`)), "always";
+}
+function normalizeTimeoutMs(value, filePath, source, diagnostics) {
+  if (value === void 0)
+    return;
+  let timeoutMs;
+  if (typeof value == "number" && (timeoutMs = value), typeof value == "string" && /^\d+$/.test(value.trim()) && (timeoutMs = parseInt(value.trim(), 10)), timeoutMs !== void 0 && Number.isInteger(timeoutMs) && timeoutMs >= 1)
+    return timeoutMs;
+  diagnostics.push(createDiagnostic("invalid-deterministic-timeout", filePath, source, `Ignoring invalid deterministic timeout in ${filePath}: expected an integer greater than or equal to 1 (milliseconds).`));
+}
+function normalizeDeterministicEnv(value, filePath, source, diagnostics) {
+  if (value === void 0)
+    return;
+  if (!value || typeof value != "object" || Array.isArray(value)) {
+    diagnostics.push(createDiagnostic("invalid-deterministic-env", filePath, source, `Ignoring invalid deterministic env in ${filePath}: expected an object with string/number/boolean values.`));
+    return;
+  }
+  let env = {};
+  for (let [key, raw] of Object.entries(value)) {
+    if (!key.trim()) {
+      diagnostics.push(createDiagnostic("invalid-deterministic-env", filePath, source, `Ignoring invalid deterministic env in ${filePath}: env keys must be non-empty strings.`));
+      return;
+    }
+    if (typeof raw != "string" && typeof raw != "number" && typeof raw != "boolean") {
+      diagnostics.push(createDiagnostic("invalid-deterministic-env", filePath, source, `Ignoring invalid deterministic env in ${filePath}: env value for ${JSON.stringify(key)} must be a string, number, or boolean.`));
+      return;
+    }
+    env[key] = String(raw);
+  }
+  return Object.keys(env).length > 0 ? env : void 0;
+}
+function normalizeDeterministicNonInteractive(value, filePath, source, diagnostics) {
+  if (value === void 0)
+    return !0;
+  if (typeof value == "boolean")
+    return value;
+  if (typeof value == "string") {
+    let normalized = value.trim().toLowerCase();
+    if (normalized === "true")
+      return !0;
+    if (normalized === "false")
+      return !1;
+  }
+  return diagnostics.push(createDiagnostic("invalid-deterministic-non-interactive", filePath, source, `Using default deterministic nonInteractive=true for ${filePath}: expected true or false.`)), !0;
+}
+function normalizeDeterministicRunValue(value, filePath, source, diagnostics) {
+  if (typeof value == "string") {
+    let command2 = value.trim();
+    if (command2)
+      return { kind: "run", command: command2 };
+    diagnostics.push(createDiagnostic("invalid-deterministic-run", filePath, source, `Ignoring invalid deterministic run value in ${filePath}: expected a non-empty string or an object with command/args.`));
+    return;
+  }
+  if (!value || typeof value != "object" || Array.isArray(value)) {
+    diagnostics.push(createDiagnostic("invalid-deterministic-run", filePath, source, `Ignoring invalid deterministic run value in ${filePath}: expected a non-empty string or an object with command/args.`));
+    return;
+  }
+  let record = value, command = normalizeStringField("deterministic.run.command", record.command, filePath, source, diagnostics);
+  if (!command) {
+    diagnostics.push(createDiagnostic("invalid-deterministic-run", filePath, source, `Ignoring invalid deterministic run value in ${filePath}: expected object field "command" to be a non-empty string.`));
+    return;
+  }
+  let args = normalizeStringArrayField("deterministic.run.args", record.args, filePath, source, diagnostics);
+  if (!args)
+    return;
+  let shell = !1;
+  if (record.shell !== void 0)
+    if (typeof record.shell == "boolean")
+      shell = record.shell;
+    else {
+      diagnostics.push(createDiagnostic("invalid-deterministic-run", filePath, source, `Ignoring invalid deterministic run value in ${filePath}: object field "shell" must be true or false.`));
+      return;
+    }
+  return { kind: "command", command, args, shell };
+}
+function normalizeDeterministicScriptValue(value, filePath, source, diagnostics) {
+  if (typeof value == "string") {
+    let path2 = value.trim();
+    if (path2)
+      return { kind: "script", path: path2, args: [] };
+    diagnostics.push(createDiagnostic("invalid-deterministic-script", filePath, source, `Ignoring invalid deterministic script value in ${filePath}: expected a non-empty string or an object with path/args.`));
+    return;
+  }
+  if (!value || typeof value != "object" || Array.isArray(value)) {
+    diagnostics.push(createDiagnostic("invalid-deterministic-script", filePath, source, `Ignoring invalid deterministic script value in ${filePath}: expected a non-empty string or an object with path/args.`));
+    return;
+  }
+  let record = value, path = normalizeStringField("deterministic.script.path", record.path, filePath, source, diagnostics);
+  if (!path) {
+    diagnostics.push(createDiagnostic("invalid-deterministic-script", filePath, source, `Ignoring invalid deterministic script value in ${filePath}: expected object field "path" to be a non-empty string.`));
+    return;
+  }
+  let args = normalizeStringArrayField("deterministic.script.args", record.args, filePath, source, diagnostics);
+  if (args)
+    return { kind: "script", path, args };
+}
+function normalizeDeterministic(frontmatter, filePath, source, diagnostics) {
+  let hasNested = Object.hasOwn(frontmatter, "deterministic"), hasRun = Object.hasOwn(frontmatter, "run"), hasScript = Object.hasOwn(frontmatter, "script"), hasHandoff = Object.hasOwn(frontmatter, "handoff"), hasTimeout = Object.hasOwn(frontmatter, "timeout"), hasEnv = Object.hasOwn(frontmatter, "env"), hasNonInteractive = Object.hasOwn(frontmatter, "nonInteractive");
+  if (!hasNested && !hasRun && !hasScript && !hasHandoff && !hasTimeout && !hasEnv && !hasNonInteractive)
+    return;
+  hasNested && (hasRun || hasScript || hasHandoff || hasTimeout || hasEnv || hasNonInteractive) && diagnostics.push(createDiagnostic("invalid-deterministic-mixed-shorthand", filePath, source, `Ignoring top-level deterministic shorthand in ${filePath}: use either "deterministic" or top-level run/script/handoff/timeout/env/nonInteractive, not both.`));
+  let record;
+  if (hasNested) {
+    let raw = frontmatter.deterministic;
+    if (!raw || typeof raw != "object" || Array.isArray(raw)) {
+      diagnostics.push(createDiagnostic("invalid-deterministic", filePath, source, `Ignoring invalid deterministic config in ${filePath}: frontmatter field "deterministic" must be an object.`));
+      return;
+    }
+    record = raw;
+  } else
+    record = {
+      run: frontmatter.run,
+      script: frontmatter.script,
+      handoff: frontmatter.handoff,
+      timeout: frontmatter.timeout,
+      env: frontmatter.env,
+      nonInteractive: frontmatter.nonInteractive
+    };
+  let runValue = Object.hasOwn(record, "run") ? record.run : void 0, scriptValue = Object.hasOwn(record, "script") ? record.script : void 0;
+  if (runValue !== void 0 && scriptValue !== void 0) {
+    diagnostics.push(createDiagnostic("invalid-deterministic", filePath, source, `Ignoring deterministic config in ${filePath}: "run" and "script" cannot be declared together.`));
+    return;
+  }
+  let execution = runValue !== void 0 ? normalizeDeterministicRunValue(runValue, filePath, source, diagnostics) : scriptValue !== void 0 ? normalizeDeterministicScriptValue(scriptValue, filePath, source, diagnostics) : void 0;
+  if (!execution) {
+    diagnostics.push(createDiagnostic("invalid-deterministic", filePath, source, `Ignoring deterministic config in ${filePath}: expected either "run" or "script".`));
+    return;
+  }
+  let handoff = normalizeDeterministicHandoff(record.handoff, filePath, source, diagnostics), timeoutMs = normalizeTimeoutMs(record.timeout, filePath, source, diagnostics), cwd = normalizeCwd(record.cwd, filePath, source, diagnostics), env = normalizeDeterministicEnv(record.env, filePath, source, diagnostics), nonInteractive = normalizeDeterministicNonInteractive(record.nonInteractive, filePath, source, diagnostics);
+  return {
+    execution,
+    handoff,
+    nonInteractive,
+    ...timeoutMs !== void 0 ? { timeoutMs } : {},
+    ...cwd ? { cwd } : {},
+    ...env ? { env } : {}
+  };
+}
+function normalizeLineupSlot(value, field, filePath, source, diagnostics, index) {
+  if (!value || typeof value != "object" || Array.isArray(value)) {
+    diagnostics.push(createDiagnostic(`invalid-${field}`, filePath, source, `Ignoring invalid ${field} value in ${filePath}: slot ${index + 1} must be an object.`));
+    return;
+  }
+  let slot = value;
+  if (slot.agent !== void 0 && slot.subagent !== void 0) {
+    diagnostics.push(createDiagnostic(`invalid-${field}`, filePath, source, `Ignoring invalid ${field} value in ${filePath}: slot ${index + 1} cannot combine "agent" and "subagent".`));
+    return;
+  }
+  let agent;
+  if (typeof slot.agent == "string" && slot.agent.trim())
+    agent = slot.agent.trim();
+  else if (slot.agent !== void 0) {
+    diagnostics.push(createDiagnostic(`invalid-${field}`, filePath, source, `Ignoring invalid ${field} value in ${filePath}: slot ${index + 1} requires a non-empty string "agent".`));
+    return;
+  }
+  if (!agent && slot.subagent !== void 0)
+    if (slot.subagent === !0)
+      agent = field === "reviewers" ? "reviewer" : "delegate";
+    else if (typeof slot.subagent == "string" && slot.subagent.trim())
+      agent = slot.subagent.trim();
+    else {
+      diagnostics.push(createDiagnostic(`invalid-${field}`, filePath, source, `Ignoring invalid ${field} value in ${filePath}: slot ${index + 1} requires "subagent" to be true or a non-empty string.`));
+      return;
+    }
+  agent || (agent = field === "reviewers" ? "reviewer" : "delegate");
+  let normalized = {
+    agent
+  };
+  if (slot.model !== void 0) {
+    if (typeof slot.model != "string" || !slot.model.trim()) {
+      diagnostics.push(createDiagnostic(`invalid-${field}`, filePath, source, `Ignoring invalid ${field} value in ${filePath}: slot ${index + 1} has an invalid "model".`));
+      return;
+    }
+    let modelSpec = slot.model.trim();
+    if (!isValidModelSelectionSpec(modelSpec)) {
+      diagnostics.push(createDiagnostic(`invalid-${field}`, filePath, source, `Ignoring invalid ${field} value in ${filePath}: slot ${index + 1} has invalid model spec ${JSON.stringify(modelSpec)}.`));
+      return;
+    }
+    normalized.model = modelSpec;
+  }
+  if (slot.task !== void 0) {
+    if (typeof slot.task != "string") {
+      diagnostics.push(createDiagnostic(`invalid-${field}`, filePath, source, `Ignoring invalid ${field} value in ${filePath}: slot ${index + 1} has a non-string "task".`));
+      return;
+    }
+    let task = slot.task.trim();
+    task && (normalized.task = task);
+  }
+  if (slot.taskSuffix !== void 0) {
+    if (typeof slot.taskSuffix != "string") {
+      diagnostics.push(createDiagnostic(`invalid-${field}`, filePath, source, `Ignoring invalid ${field} value in ${filePath}: slot ${index + 1} has a non-string "taskSuffix".`));
+      return;
+    }
+    let taskSuffix = slot.taskSuffix.trim();
+    taskSuffix && (normalized.taskSuffix = taskSuffix);
+  }
+  if (slot.cwd !== void 0) {
+    if (typeof slot.cwd != "string") {
+      diagnostics.push(createDiagnostic(`invalid-${field}`, filePath, source, `Ignoring invalid ${field} value in ${filePath}: slot ${index + 1} has a non-string "cwd".`));
+      return;
+    }
+    let cwdRaw = slot.cwd.trim();
+    if (cwdRaw) {
+      let expanded = expandCwdPath(cwdRaw);
+      if (!expanded) {
+        diagnostics.push(createDiagnostic(`invalid-${field}`, filePath, source, `Ignoring invalid ${field} value in ${filePath}: slot ${index + 1} "cwd" must be an absolute path.`));
+        return;
+      }
+      normalized.cwd = expanded;
+    }
+  }
+  if (slot.count !== void 0) {
+    let count;
+    if (typeof slot.count == "number" ? count = slot.count : typeof slot.count == "string" && /^\d+$/.test(slot.count.trim()) && (count = parseInt(slot.count.trim(), 10)), count === void 0 || !Number.isInteger(count) || count < 1) {
+      diagnostics.push(createDiagnostic(`invalid-${field}`, filePath, source, `Ignoring invalid ${field} value in ${filePath}: slot ${index + 1} "count" must be an integer greater than or equal to 1.`));
+      return;
+    }
+    normalized.count = count;
+  }
+  return normalized;
+}
+function normalizeLineup(value, field, filePath, source, diagnostics) {
+  if (value === void 0)
+    return;
+  if (!Array.isArray(value)) {
+    diagnostics.push(createDiagnostic(`invalid-${field}`, filePath, source, `Ignoring invalid ${field} value in ${filePath}: expected an array of slot objects.`));
+    return;
+  }
+  if (value.length === 0) {
+    diagnostics.push(createDiagnostic(`invalid-${field}`, filePath, source, `Ignoring invalid ${field} value in ${filePath}: expected at least one slot.`));
+    return;
+  }
+  let slots = [];
+  for (let i = 0; i < value.length; i++) {
+    let normalized = normalizeLineupSlot(value[i], field, filePath, source, diagnostics, i);
+    if (!normalized)
+      return;
+    slots.push(normalized);
+  }
+  return slots;
+}
+function normalizeFinalApplier(value, filePath, source, diagnostics) {
+  if (value === void 0)
+    return;
+  let normalized = normalizeLineupSlot(value, "finalApplier", filePath, source, diagnostics, 0);
+  if (!normalized)
+    return;
+  let slot = value;
+  if (Object.hasOwn(slot, "count")) {
+    diagnostics.push(createDiagnostic("invalid-final-applier", filePath, source, `Ignoring invalid finalApplier value in ${filePath}: slot 1 "count" is not supported.`));
+    return;
+  }
+  if (Object.hasOwn(slot, "cwd")) {
+    diagnostics.push(createDiagnostic("invalid-final-applier", filePath, source, `Ignoring invalid finalApplier value in ${filePath}: slot 1 "cwd" is not supported.`));
+    return;
+  }
+  return normalized;
+}
+function normalizeBestOfN(value, filePath, source, diagnostics) {
+  if (value !== void 0) {
+    if (value && typeof value == "object" && !Array.isArray(value))
+      return value;
+    diagnostics.push(createDiagnostic("invalid-best-of-n", filePath, source, `Ignoring invalid bestOfN value in ${filePath}: frontmatter field "bestOfN" must be an object.`));
+  }
+}
+function pushLegacyCompareFieldDiagnostic(field, filePath, source, diagnostics) {
+  diagnostics.push(createDiagnostic(`invalid-${field}`, filePath, source, `Ignoring top-level ${field} in ${filePath}: compare template authoring moved to "bestOfN.${field}".`));
+}
+function normalizeConverge(value, filePath, source, diagnostics) {
+  if (value === void 0)
+    return !0;
+  if (typeof value == "boolean")
+    return value;
+  if (typeof value == "string") {
+    let normalized = value.trim().toLowerCase();
+    if (normalized === "true")
+      return !0;
+    if (normalized === "false")
+      return !1;
+  }
+  return diagnostics.push(createDiagnostic("invalid-converge", filePath, source, `Using default converge=true for ${filePath}: frontmatter field "converge" must be true or false.`)), !0;
+}
+function normalizeWorktree(value, filePath, source, diagnostics) {
+  if (value === void 0)
+    return !1;
+  if (typeof value == "boolean")
+    return value;
+  if (typeof value == "string") {
+    let normalized = value.trim().toLowerCase();
+    if (normalized === "true")
+      return !0;
+    if (normalized === "false")
+      return !1;
+  }
+  return diagnostics.push(createDiagnostic("invalid-worktree", filePath, source, `Using default worktree=false for ${filePath}: frontmatter field "worktree" must be true or false.`)), !1;
+}
+function normalizeSubagent(value, filePath, source, diagnostics) {
+  if (value === void 0)
+    return;
+  if (value === !0)
+    return !0;
+  if (value === !1)
+    return;
+  if (typeof value != "string") {
+    diagnostics.push(createDiagnostic("invalid-subagent", filePath, source, `Ignoring invalid subagent value in ${filePath}: frontmatter field "subagent" must be true or a non-empty string.`));
+    return;
+  }
+  let normalized = value.trim();
+  if (!normalized) {
+    diagnostics.push(createDiagnostic("invalid-subagent", filePath, source, `Ignoring invalid subagent value in ${filePath}: frontmatter field "subagent" must be true or a non-empty string.`));
+    return;
+  }
+  return normalized;
+}
+function expandCwdPath(raw) {
+  let expanded = raw.startsWith("~/") ? join(homedir(), raw.slice(2)) : raw;
+  return isAbsolute(expanded) ? expanded : void 0;
+}
+function normalizeCwd(value, filePath, source, diagnostics) {
+  if (value === void 0)
+    return;
+  if (typeof value != "string") {
+    diagnostics.push(createDiagnostic("invalid-cwd", filePath, source, `Ignoring invalid cwd in ${filePath}: expected a string.`));
+    return;
+  }
+  let trimmed = value.trim();
+  if (!trimmed)
+    return;
+  let expanded = expandCwdPath(trimmed);
+  if (!expanded) {
+    diagnostics.push(createDiagnostic("invalid-cwd", filePath, source, `Ignoring cwd in ${filePath}: must be an absolute path.`));
+    return;
+  }
+  return expanded;
+}
+function normalizeInheritContext(value, filePath, source, diagnostics) {
+  if (value === void 0)
+    return !1;
+  if (typeof value == "boolean")
+    return value;
+  if (typeof value == "string") {
+    let normalized = value.trim().toLowerCase();
+    if (normalized === "true")
+      return !0;
+    if (normalized === "false")
+      return !1;
+  }
+  return diagnostics.push(createDiagnostic("invalid-inherit-context", filePath, source, `Using default inheritContext=false for ${filePath}: frontmatter field "inheritContext" must be true or false.`)), !1;
+}
+function normalizeChain(value, filePath, source, diagnostics) {
+  if (value === void 0)
+    return;
+  if (typeof value != "string") {
+    diagnostics.push(createDiagnostic("invalid-chain", filePath, source, `Ignoring invalid chain value in ${filePath}: frontmatter field "chain" must be a string.`));
+    return;
+  }
+  let normalized = value.trim();
+  if (normalized.length > 0)
+    return normalized;
+  diagnostics.push(createDiagnostic("empty-chain", filePath, source, `Ignoring invalid chain value in ${filePath}: frontmatter field "chain" must be a non-empty string.`));
+}
+function normalizeChainContext(value, filePath, source, diagnostics) {
+  if (value !== void 0) {
+    if (typeof value == "string" && value.trim().toLowerCase() === "summary")
+      return "summary";
+    diagnostics.push(createDiagnostic("invalid-chain-context", filePath, source, `Ignoring invalid chainContext value in ${filePath}: frontmatter field "chainContext" must be "summary".`));
+  }
+}
+function normalizeThinking(value, filePath, source, diagnostics) {
+  let thinking = normalizeStringField("thinking", value, filePath, source, diagnostics);
+  if (thinking === void 0)
+    return;
+  let normalized = thinking.toLowerCase();
+  if (VALID_THINKING_LEVELS.includes(normalized))
+    return normalized;
+  diagnostics.push(createDiagnostic("invalid-thinking", filePath, source, `Ignoring invalid thinking level in ${filePath}: ${JSON.stringify(thinking)}.`));
+}
+function normalizeThinkingLevels(value, modelCount, filePath, source, diagnostics) {
+  if (typeof value != "string")
+    return;
+  let levels = value.split(",").map((item) => item.trim()).filter(Boolean), invalidLevel = levels.find((level) => !VALID_THINKING_LEVELS.includes(level.toLowerCase()));
+  if (invalidLevel) {
+    diagnostics.push(createDiagnostic("invalid-thinking-levels", filePath, source, `Ignoring invalid thinking level in ${filePath}: ${JSON.stringify(invalidLevel)}.`));
+    return;
+  }
+  if (levels.length !== modelCount) {
+    diagnostics.push(createDiagnostic("invalid-thinking-level-count", filePath, source, `Ignoring comma-separated thinking levels in ${filePath}: expected ${modelCount} entries to match frontmatter field "model".`));
+    return;
+  }
+  return levels.map((level) => level.toLowerCase());
+}
+function expandConfiguredPromptPath(rawPath, baseDir) {
+  let trimmed = rawPath.trim(), expanded = trimmed === "~" ? homedir() : trimmed.startsWith("~/") ? join(homedir(), trimmed.slice(2)) : trimmed;
+  return isAbsolute(expanded) ? resolve(expanded) : resolve(baseDir, expanded);
+}
+function isSettingsPromptPattern(value) {
+  return value.startsWith("!") || value.startsWith("+") || value.startsWith("-") || value.includes("*") || value.includes("?");
+}
+function isSettingsPromptOverridePattern(value) {
+  return value.startsWith("!") || value.startsWith("+") || value.startsWith("-");
+}
+function toPosixPath(path) {
+  return path.replace(/\\/g, "/");
+}
+function normalizeExactPromptPattern(pattern) {
+  let normalized = pattern.startsWith("./") || pattern.startsWith(".\\") ? pattern.slice(2) : pattern;
+  return toPosixPath(normalized);
+}
+function matchesPromptPattern(filePath, pattern, baseDir) {
+  let normalizedPattern = toPosixPath(pattern), rel = toPosixPath(relative(baseDir, filePath)), name = basename(filePath), filePathPosix = toPosixPath(filePath);
+  return [rel, name, filePathPosix].some((candidate) => minimatch(candidate, normalizedPattern));
+}
+function matchesExactPromptPattern(filePath, pattern, baseDir) {
+  let normalizedPattern = normalizeExactPromptPattern(pattern), rel = toPosixPath(relative(baseDir, filePath)), filePathPosix = toPosixPath(filePath);
+  return normalizedPattern === rel || normalizedPattern === filePathPosix;
+}
+function shouldLoadPromptFile(filePath, patterns, baseDir) {
+  let includes = [], excludes = [], forceIncludes = [], forceExcludes = [];
+  for (let pattern of patterns)
+    pattern.startsWith("+") ? forceIncludes.push(pattern.slice(1)) : pattern.startsWith("-") ? forceExcludes.push(pattern.slice(1)) : pattern.startsWith("!") ? excludes.push(pattern.slice(1)) : includes.push(pattern);
+  let enabled = includes.length === 0 || includes.some((pattern) => matchesPromptPattern(filePath, pattern, baseDir));
+  return excludes.some((pattern) => matchesPromptPattern(filePath, pattern, baseDir)) && (enabled = !1), forceIncludes.some((pattern) => matchesExactPromptPattern(filePath, pattern, baseDir)) && (enabled = !0), forceExcludes.some((pattern) => matchesExactPromptPattern(filePath, pattern, baseDir)) && (enabled = !1), enabled;
+}
+function createPromptFileFilter(patterns, baseDir) {
+  return patterns.length === 0 ? void 0 : (filePath) => shouldLoadPromptFile(filePath, patterns, baseDir);
+}
+function loadConfiguredPromptPaths(settingsPath, source, baseDir, diagnostics) {
+  if (!existsSync(settingsPath))
+    return { paths: [], patterns: [] };
+  let rawSettings;
+  try {
+    rawSettings = readFileSync(settingsPath, "utf-8");
+  } catch (error) {
+    return diagnostics.push(createDiagnostic("unreadable-settings", settingsPath, source, `Skipping prompt settings at ${settingsPath}: ${error instanceof Error ? error.message : String(error)}.`)), { paths: [], patterns: [] };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(rawSettings);
+  } catch (error) {
+    return diagnostics.push(createDiagnostic("invalid-settings-json", settingsPath, source, `Skipping prompt settings at ${settingsPath}: ${error instanceof Error ? error.message : String(error)}.`)), { paths: [], patterns: [] };
+  }
+  if (!parsed || typeof parsed != "object" || Array.isArray(parsed))
+    return diagnostics.push(createDiagnostic("invalid-settings", settingsPath, source, `Skipping prompt settings at ${settingsPath}: settings must be a JSON object.`)), { paths: [], patterns: [] };
+  let prompts = parsed.prompts;
+  if (prompts === void 0)
+    return { paths: [], patterns: [] };
+  if (!Array.isArray(prompts))
+    return diagnostics.push(createDiagnostic("invalid-settings-prompts", settingsPath, source, `Ignoring prompts in ${settingsPath}: expected "prompts" to be an array of strings.`)), { paths: [], patterns: [] };
+  let configuredPaths = [], patterns = [];
+  for (let index = 0; index < prompts.length; index++) {
+    let rawPath = prompts[index];
+    if (typeof rawPath != "string" || rawPath.trim().length === 0) {
+      diagnostics.push(createDiagnostic("invalid-settings-prompt-entry", settingsPath, source, `Ignoring prompts[${index}] in ${settingsPath}: expected a non-empty string.`));
+      continue;
+    }
+    let trimmed = rawPath.trim();
+    if (isSettingsPromptPattern(trimmed)) {
+      patterns.push(trimmed);
+      continue;
+    }
+    configuredPaths.push({
+      rawPath: trimmed,
+      resolvedPath: expandConfiguredPromptPath(trimmed, baseDir),
+      settingsPath,
+      source,
+      baseDir
+    });
+  }
+  return { paths: configuredPaths.map((path) => ({ ...path, patterns })), patterns };
+}
+function canonicalizePromptFile(filePath) {
+  try {
+    return realpathSync(filePath);
+  } catch {
+    return resolve(filePath);
+  }
+}
+function loadPromptsWithModelFromDir(dir, source, includePlainPrompts, subdir = "", visitedDirectories = /* @__PURE__ */ new Set(), onlyFileName, seenFiles, shouldLoadFile) {
+  let prompts = [], diagnostics = [];
+  if (!existsSync(dir))
+    return { prompts, diagnostics };
+  let canonicalDir;
+  try {
+    canonicalDir = realpathSync(dir);
+  } catch (error) {
+    return diagnostics.push(createDiagnostic("unreadable-directory", dir, source, `Skipping prompt directory ${dir}: ${error instanceof Error ? error.message : String(error)}.`)), { prompts, diagnostics };
+  }
+  if (visitedDirectories.has(canonicalDir))
+    return diagnostics.push(createDiagnostic("directory-cycle", dir, source, `Skipping already visited prompt directory at ${dir}.`)), { prompts, diagnostics };
+  visitedDirectories.add(canonicalDir);
+  try {
+    let entries = readdirSync(dir, { withFileTypes: !0 }).sort((a, b) => lexicalCompare(a.name, b.name));
+    for (let entry of entries) {
+      if (onlyFileName && entry.name !== onlyFileName)
+        continue;
+      let fullPath = join(dir, entry.name), isFile = entry.isFile(), isDirectory = entry.isDirectory();
+      if (entry.isSymbolicLink())
+        try {
+          let stats = statSync(fullPath);
+          isFile = stats.isFile(), isDirectory = stats.isDirectory();
+        } catch (error) {
+          diagnostics.push(createDiagnostic("unreadable-symlink", fullPath, source, `Skipping unreadable symlink at ${fullPath}: ${error instanceof Error ? error.message : String(error)}.`));
+          continue;
+        }
+      if (isDirectory) {
+        if (onlyFileName)
+          continue;
+        let nextSubdir = subdir ? `${subdir}:${entry.name}` : entry.name, nested = loadPromptsWithModelFromDir(fullPath, source, includePlainPrompts, nextSubdir, visitedDirectories, void 0, seenFiles, shouldLoadFile);
+        prompts.push(...nested.prompts), diagnostics.push(...nested.diagnostics);
+        continue;
+      }
+      if (!isFile || !entry.name.endsWith(".md") || shouldLoadFile && !shouldLoadFile(fullPath))
+        continue;
+      let canonicalFile = canonicalizePromptFile(fullPath);
+      if (!seenFiles?.has(canonicalFile)) {
+        seenFiles?.add(canonicalFile);
+        try {
+          let rawContent = readFileSync(fullPath, "utf-8"), parsed = parseFrontmatter(rawContent), frontmatter = normalizeFrontmatterRecord(parsed.frontmatter, fullPath, source, diagnostics);
+          if (!frontmatter)
+            continue;
+          let { body } = parsed, chain = normalizeChain(frontmatter.chain, fullPath, source, diagnostics), parsedChainDeclarationResult, chainContext = chain ? normalizeChainContext(frontmatter.chainContext, fullPath, source, diagnostics) : void 0;
+          if (chain && /\bparallel\s*\(/.test(chain) && (parsedChainDeclarationResult = parseChainDeclaration(chain), parsedChainDeclarationResult.invalidSegments.length > 0 || parsedChainDeclarationResult.steps.length === 0)) {
+            diagnostics.push(createDiagnostic("invalid-chain-declaration", fullPath, source, `Skipping prompt template at ${fullPath}: invalid chain declaration segment ${JSON.stringify(parsedChainDeclarationResult.invalidSegments[0] ?? chain)}.`));
+            continue;
+          }
+          let subagent = normalizeSubagent(frontmatter.subagent, fullPath, source, diagnostics), cwd = normalizeCwd(frontmatter.cwd, fullPath, source, diagnostics), inheritContext = normalizeInheritContext(frontmatter.inheritContext, fullPath, source, diagnostics), parallel = normalizeParallel(frontmatter.parallel, fullPath, source, diagnostics), hasBestOfN = Object.hasOwn(frontmatter, "bestOfN"), bestOfN = normalizeBestOfN(frontmatter.bestOfN, fullPath, source, diagnostics), deterministic = normalizeDeterministic(frontmatter, fullPath, source, diagnostics), hasLegacyWorkers = Object.hasOwn(frontmatter, "workers"), hasLegacyReviewers = Object.hasOwn(frontmatter, "reviewers"), hasLegacyFinalApplier = Object.hasOwn(frontmatter, "finalApplier"), hasLegacyCompareFields = hasLegacyWorkers || hasLegacyReviewers || hasLegacyFinalApplier;
+          hasLegacyWorkers && pushLegacyCompareFieldDiagnostic("workers", fullPath, source, diagnostics), hasLegacyReviewers && pushLegacyCompareFieldDiagnostic("reviewers", fullPath, source, diagnostics), hasLegacyFinalApplier && pushLegacyCompareFieldDiagnostic("finalApplier", fullPath, source, diagnostics), hasBestOfN && Object.hasOwn(frontmatter, "worktree") && diagnostics.push(createDiagnostic("invalid-worktree", fullPath, source, `Ignoring top-level worktree in ${fullPath}: use "bestOfN.worktree" for compare template authoring.`));
+          let workers = normalizeLineup(hasBestOfN ? bestOfN?.workers : void 0, "workers", fullPath, source, diagnostics), reviewers = normalizeLineup(hasBestOfN ? bestOfN?.reviewers : void 0, "reviewers", fullPath, source, diagnostics), finalApplier = normalizeFinalApplier(hasBestOfN ? bestOfN?.finalApplier : void 0, fullPath, source, diagnostics), safeWorkers = workers, safeReviewers = reviewers, safeFinalApplier = finalApplier;
+          chain && subagent !== void 0 && (diagnostics.push(createDiagnostic("invalid-subagent-chain", fullPath, source, `Ignoring subagent in ${fullPath}: frontmatter fields "chain" and "subagent" cannot be combined.`)), subagent = void 0), chain && deterministic !== void 0 && (diagnostics.push(createDiagnostic("invalid-deterministic-chain", fullPath, source, `Ignoring deterministic config in ${fullPath}: frontmatter field "deterministic" cannot be combined with "chain".`)), deterministic = void 0), chain && (safeWorkers !== void 0 || safeReviewers !== void 0 || safeFinalApplier !== void 0) && (diagnostics.push(createDiagnostic("invalid-lineup-chain", fullPath, source, `Ignoring compare lineup config in ${fullPath}: frontmatter fields "workers"/"reviewers"/"finalApplier" cannot be combined with "chain".`)), safeWorkers = void 0, safeReviewers = void 0, safeFinalApplier = void 0), subagent !== void 0 && (safeWorkers !== void 0 || safeReviewers !== void 0 || safeFinalApplier !== void 0) && (diagnostics.push(createDiagnostic("invalid-lineup-subagent", fullPath, source, `Ignoring compare lineup config in ${fullPath}: frontmatter fields "workers"/"reviewers"/"finalApplier" cannot be combined with "subagent".`)), safeWorkers = void 0, safeReviewers = void 0, safeFinalApplier = void 0), subagent !== void 0 && deterministic !== void 0 && (diagnostics.push(createDiagnostic("invalid-deterministic-subagent", fullPath, source, `Ignoring deterministic config in ${fullPath}: frontmatter field "deterministic" cannot be combined with "subagent".`)), deterministic = void 0), subagent === void 0 && inheritContext && diagnostics.push(createDiagnostic("invalid-inherit-context", fullPath, source, `Ignoring inheritContext in ${fullPath}: frontmatter field "inheritContext" requires "subagent".`));
+          let safeParallel = parallel;
+          safeParallel !== void 0 && chain && (diagnostics.push(createDiagnostic("invalid-parallel", fullPath, source, `Ignoring parallel in ${fullPath}: frontmatter field "parallel" cannot be combined with "chain".`)), safeParallel = void 0), safeParallel !== void 0 && subagent === void 0 && (diagnostics.push(createDiagnostic("invalid-parallel", fullPath, source, `Ignoring parallel in ${fullPath}: frontmatter field "parallel" requires "subagent".`)), safeParallel = void 0), safeParallel !== void 0 && (safeWorkers !== void 0 || safeReviewers !== void 0 || safeFinalApplier !== void 0) && (diagnostics.push(createDiagnostic("invalid-lineup-parallel", fullPath, source, `Ignoring compare lineup config in ${fullPath}: frontmatter fields "workers"/"reviewers"/"finalApplier" cannot be combined with "parallel".`)), safeWorkers = void 0, safeReviewers = void 0, safeFinalApplier = void 0), safeParallel !== void 0 && deterministic !== void 0 && (diagnostics.push(createDiagnostic("invalid-deterministic-parallel", fullPath, source, `Ignoring deterministic config in ${fullPath}: frontmatter field "deterministic" cannot be combined with "parallel".`)), deterministic = void 0);
+          let hasLineup = safeWorkers !== void 0 || safeReviewers !== void 0 || safeFinalApplier !== void 0;
+          if (!hasBestOfN && hasLegacyCompareFields) {
+            diagnostics.push(createDiagnostic("invalid-compare-frontmatter", fullPath, source, `Skipping prompt template at ${fullPath}: compare template authoring moved under "bestOfN:".`));
+            continue;
+          }
+          if (hasBestOfN && !hasLineup) {
+            diagnostics.push(createDiagnostic("invalid-best-of-n", fullPath, source, `Skipping prompt template at ${fullPath}: "bestOfN" did not produce a valid compare configuration.`));
+            continue;
+          }
+          !chain && subagent === void 0 && !hasLineup && cwd && (deterministic ? deterministic = { ...deterministic, ...deterministic.cwd ? {} : { cwd } } : diagnostics.push(createDiagnostic("invalid-cwd", fullPath, source, `Ignoring cwd in ${fullPath}: frontmatter field "cwd" requires "subagent", "chain", or compare lineups ("workers"/"reviewers"/"finalApplier").`)));
+          let hasModelField = Object.hasOwn(frontmatter, "model"), parsedModels = chain ? [] : normalizeModelSpecs(frontmatter.model, fullPath, source, diagnostics);
+          if (!chain && hasModelField && !parsedModels)
+            continue;
+          let models = chain ? [] : parsedModels ?? [], rotate = chain ? !1 : normalizeRotate(frontmatter.rotate, fullPath, source, diagnostics), name = entry.name.slice(0, -3);
+          if (RESERVED_COMMAND_NAMES.has(name)) {
+            diagnostics.push(createDiagnostic("reserved-command-name", fullPath, source, `Skipping prompt template at ${fullPath}: command name "${name}" is reserved.`));
+            continue;
+          }
+          let safeInheritContext = subagent !== void 0 && inheritContext, safeCwd = chain || subagent !== void 0 || hasLineup ? cwd : void 0, description = normalizeStringField("description", frontmatter.description, fullPath, source, diagnostics) ?? "", skill = chain ? void 0 : normalizeStringField("skill", frontmatter.skill, fullPath, source, diagnostics), thinking, thinkingLevels;
+          chain || (rotate && typeof frontmatter.thinking == "string" && frontmatter.thinking.includes(",") ? thinkingLevels = normalizeThinkingLevels(frontmatter.thinking, models.length, fullPath, source, diagnostics) : thinking = normalizeThinking(frontmatter.thinking, fullPath, source, diagnostics));
+          let restore = normalizeRestore(frontmatter.restore, fullPath, source, diagnostics), fresh = normalizeFresh(frontmatter.fresh, fullPath, source, diagnostics), loop = normalizeLoop(frontmatter.loop, fullPath, source, diagnostics), converge = normalizeConverge(frontmatter.converge, fullPath, source, diagnostics), boomerang = normalizeBoomerang(frontmatter.boomerang, fullPath, source, diagnostics);
+          chain && boomerang && (diagnostics.push(createDiagnostic("invalid-boomerang-chain", fullPath, source, `Ignoring boomerang in ${fullPath}: frontmatter fields "chain" and "boomerang" cannot be combined.`)), boomerang = !1), loop !== void 0 && deterministic !== void 0 && (diagnostics.push(createDiagnostic("invalid-deterministic-loop", fullPath, source, `Ignoring deterministic config in ${fullPath}: frontmatter field "deterministic" cannot be combined with "loop" in v1.`)), deterministic = void 0);
+          let worktreeInput = hasBestOfN ? bestOfN?.worktree : frontmatter.worktree, worktree = normalizeWorktree(worktreeInput, fullPath, source, diagnostics), safeWorktree;
+          if (worktree)
+            if (chain) {
+              let parsedChain = parsedChainDeclarationResult ?? parseChainDeclaration(chain), hasParallelStep = parsedChain.steps.some((step) => "parallel" in step);
+              parsedChain.invalidSegments.length > 0 || parsedChain.steps.length === 0 || !hasParallelStep ? diagnostics.push(createDiagnostic("invalid-worktree", fullPath, source, `Ignoring worktree in ${fullPath}: frontmatter field "worktree" requires either "chain" with at least one parallel() step, "subagent" with frontmatter field "parallel", or compare lineups ("workers"/"reviewers"/"finalApplier").`)) : safeWorktree = !0;
+            } else subagent !== void 0 && safeParallel !== void 0 || hasLineup ? safeWorktree = !0 : diagnostics.push(createDiagnostic("invalid-worktree", fullPath, source, `Ignoring worktree in ${fullPath}: frontmatter field "worktree" requires either "chain" with at least one parallel() step, "subagent" with frontmatter field "parallel", or compare lineups ("workers"/"reviewers"/"finalApplier").`));
+          let hasModelConditionalDirectives = /<if-model(?:\s|>)|<else(?:\s|>)|<\/if-model\s*>|<\/else(?:\s|>)/.test(body);
+          if (!chain && !hasModelField && !(skill !== void 0 || thinking !== void 0 || fresh === !0 || loop !== void 0 || converge === !1 || boomerang === !0 || safeParallel !== void 0 || deterministic !== void 0 || hasLineup || safeWorktree === !0 || subagent !== void 0 || safeInheritContext || hasModelConditionalDirectives) && !includePlainPrompts)
+            continue;
+          prompts.push({
+            name,
+            description,
+            content: body,
+            models,
+            chain: chain || void 0,
+            chainContext,
+            restore,
+            skill,
+            thinking,
+            thinkingLevels,
+            rotate: rotate || void 0,
+            fresh: fresh || void 0,
+            loop: loop !== void 0 ? loop : void 0,
+            converge: converge === !1 ? !1 : void 0,
+            boomerang: boomerang || void 0,
+            parallel: safeParallel,
+            worktree: safeWorktree,
+            deterministic,
+            subagent,
+            inheritContext: safeInheritContext || void 0,
+            cwd: safeCwd || void 0,
+            workers: safeWorkers,
+            reviewers: safeReviewers,
+            finalApplier: safeFinalApplier,
+            source,
+            subdir: subdir || void 0,
+            filePath: fullPath
+          });
+        } catch (error) {
+          diagnostics.push(createDiagnostic("invalid-prompt-file", fullPath, source, `Skipping prompt template at ${fullPath}: ${error instanceof Error ? error.message : String(error)}.`));
+        }
+      }
+    }
+  } catch (error) {
+    diagnostics.push(createDiagnostic("unreadable-directory", dir, source, `Skipping prompt directory ${dir}: ${error instanceof Error ? error.message : String(error)}.`));
+  }
+  return { prompts, diagnostics };
+}
+function loadPromptsWithModelFromConfiguredPath(configuredPath, includePlainPrompts, seenFiles) {
+  let diagnostics = [], { rawPath, resolvedPath, settingsPath, source, baseDir, patterns } = configuredPath, shouldLoadFile = createPromptFileFilter(patterns, baseDir);
+  if (!existsSync(resolvedPath))
+    return diagnostics.push(createDiagnostic("missing-prompt-path", resolvedPath, source, `Skipping configured prompt path ${JSON.stringify(rawPath)} from ${settingsPath}: resolved path ${resolvedPath} does not exist.`)), { prompts: [], diagnostics };
+  let stats;
+  try {
+    stats = statSync(resolvedPath);
+  } catch (error) {
+    return diagnostics.push(createDiagnostic("unreadable-prompt-path", resolvedPath, source, `Skipping configured prompt path ${JSON.stringify(rawPath)} from ${settingsPath}: ${error instanceof Error ? error.message : String(error)}.`)), { prompts: [], diagnostics };
+  }
+  return stats.isDirectory() ? loadPromptsWithModelFromDir(resolvedPath, source, includePlainPrompts, "", /* @__PURE__ */ new Set(), void 0, seenFiles, shouldLoadFile) : !stats.isFile() || !resolvedPath.endsWith(".md") ? (diagnostics.push(createDiagnostic("invalid-prompt-path", resolvedPath, source, `Skipping configured prompt path ${JSON.stringify(rawPath)} from ${settingsPath}: expected a directory or .md file.`)), { prompts: [], diagnostics }) : loadPromptsWithModelFromDir(dirname(resolvedPath), source, includePlainPrompts, "", /* @__PURE__ */ new Set(), basename(resolvedPath), seenFiles, shouldLoadFile);
+}
+function loadPromptsWithModel(cwd, includePlainPrompts = !1) {
+  let agentDir = getAgentDir(), globalDir = join(agentDir, "prompts"), projectBaseDir = resolve(cwd, CONFIG_DIR_NAME), projectDir = join(projectBaseDir, "prompts"), promptMap = /* @__PURE__ */ new Map(), diagnostics = [], seenPromptFiles = /* @__PURE__ */ new Set();
+  function addPrompt(prompt) {
+    let existing = promptMap.get(prompt.name);
+    if (!existing) {
+      promptMap.set(prompt.name, prompt);
+      return;
+    }
+    existing.source === prompt.source && diagnostics.push(createDiagnostic("duplicate-command-name", prompt.filePath, prompt.source, `Skipping ${prompt.source} prompt template "${prompt.name}" at ${prompt.filePath} because it conflicts with ${existing.filePath}.`));
+  }
+  function addResult(result) {
+    diagnostics.push(...result.diagnostics);
+    for (let prompt of result.prompts)
+      addPrompt(prompt);
+  }
+  let projectSettingsPaths = loadConfiguredPromptPaths(join(projectBaseDir, "settings.json"), "project", projectBaseDir, diagnostics), globalSettingsPaths = loadConfiguredPromptPaths(join(agentDir, "settings.json"), "user", agentDir, diagnostics), projectDefaultFilter = createPromptFileFilter(projectSettingsPaths.patterns.filter(isSettingsPromptOverridePattern), projectBaseDir), globalDefaultFilter = createPromptFileFilter(globalSettingsPaths.patterns.filter(isSettingsPromptOverridePattern), agentDir);
+  for (let configuredPath of projectSettingsPaths.paths)
+    addResult(loadPromptsWithModelFromConfiguredPath(configuredPath, includePlainPrompts, seenPromptFiles));
+  addResult(loadPromptsWithModelFromDir(projectDir, "project", includePlainPrompts, "", /* @__PURE__ */ new Set(), void 0, seenPromptFiles, projectDefaultFilter));
+  for (let configuredPath of globalSettingsPaths.paths)
+    addResult(loadPromptsWithModelFromConfiguredPath(configuredPath, includePlainPrompts, seenPromptFiles));
+  return addResult(loadPromptsWithModelFromDir(globalDir, "user", includePlainPrompts, "", /* @__PURE__ */ new Set(), void 0, seenPromptFiles, globalDefaultFilter)), { prompts: promptMap, diagnostics };
+}
+function effectiveLineupCount(slots) {
+  return slots?.reduce((total, slot) => total + (slot.count ?? 1), 0) ?? 0;
+}
+function buildPromptCommandDescription(prompt) {
+  let sourceLabel = prompt.subdir ? `(${prompt.source}:${prompt.subdir})` : `(${prompt.source})`;
+  if (prompt.chain) {
+    let chainContextLabel = prompt.chainContext ? ` ${prompt.chainContext}` : "", cwdLabel2 = prompt.cwd ? ` cwd:${prompt.cwd}` : "", worktreeLabel2 = prompt.worktree ? " worktree" : "", details2 = `[chain: ${prompt.chain}${chainContextLabel}${cwdLabel2}${worktreeLabel2}] ${sourceLabel}`;
+    return prompt.description ? `${prompt.description} ${details2}` : details2;
+  }
+  let modelLabel = prompt.models.length > 0 ? prompt.models.map((model) => model.split("/").pop() || model).join("|") : "current", rotateLabel = prompt.rotate ? " rotate" : "", skillLabel = prompt.skill ? ` +${prompt.skill}` : "", thinkingValue = prompt.thinkingLevels ? prompt.thinkingLevels.join(",") : prompt.thinking, thinkingLabel = thinkingValue ? ` ${thinkingValue}` : "", loopLabel = prompt.loop !== void 0 ? ` loop:${prompt.loop === null ? "unlimited" : prompt.loop}` : "", boomerangLabel = prompt.boomerang ? " boomerang" : "", subagentLabel = prompt.subagent ? ` subagent:${prompt.subagent === !0 ? "delegate" : prompt.subagent}` : "", parallelLabel = prompt.parallel !== void 0 ? ` parallel:${prompt.parallel}` : "", deterministicLabel = prompt.deterministic ? ` deterministic-step:${prompt.deterministic.handoff}` : "", workersLabel = prompt.workers ? ` workers:${effectiveLineupCount(prompt.workers)}` : "", reviewersLabel = prompt.reviewers ? ` reviewers:${effectiveLineupCount(prompt.reviewers)}` : "", finalApplierLabel = prompt.finalApplier ? " final-applier" : "", cwdLabel = prompt.cwd ? ` cwd:${prompt.cwd}` : "", inheritContextLabel = prompt.inheritContext ? " fork" : "", worktreeLabel = prompt.worktree ? " worktree" : "", details = `[${modelLabel}${rotateLabel}${thinkingLabel}${skillLabel}${loopLabel}${boomerangLabel}${subagentLabel}${parallelLabel}${deterministicLabel}${workersLabel}${reviewersLabel}${finalApplierLabel}${cwdLabel}${inheritContextLabel}${worktreeLabel}] ${sourceLabel}`;
+  return prompt.description ? `${prompt.description} ${details}` : details;
+}
+function getSkillCandidates(baseDir, skillName) {
+  return [join(baseDir, skillName, "SKILL.md"), join(baseDir, `${skillName}.md`)];
+}
+function* walkAncestors(startDir, stopDir) {
+  let current = startDir;
+  for (; ; ) {
+    if (yield current, stopDir && current === stopDir)
+      return;
+    let parent = dirname(current);
+    if (parent === current)
+      return;
+    current = parent;
+  }
+}
+function findRepoRoot(startDir) {
+  for (let dir of walkAncestors(startDir))
+    if (existsSync(join(dir, ".git")))
+      return dir;
+}
+function findFirstExisting(paths) {
+  for (let path of paths)
+    if (existsSync(path))
+      return path;
+}
+function resolveSkillPath(skillName, cwd) {
+  let projectDir = resolve(cwd), projectPiSkill = findFirstExisting(getSkillCandidates(resolve(projectDir, CONFIG_DIR_NAME, "skills"), skillName));
+  if (projectPiSkill)
+    return projectPiSkill;
+  let repoRoot = findRepoRoot(projectDir);
+  for (let dir of walkAncestors(projectDir, repoRoot)) {
+    let projectAgentsSkill = findFirstExisting(getSkillCandidates(join(dir, ".agents", "skills"), skillName));
+    if (projectAgentsSkill)
+      return projectAgentsSkill;
+  }
+  let globalPiSkill = findFirstExisting(getSkillCandidates(join(getAgentDir(), "skills"), skillName));
+  return globalPiSkill || findFirstExisting(getSkillCandidates(join(homedir(), ".agents", "skills"), skillName));
+}
+function readSkillContent(skillPath) {
+  let raw = readFileSync(skillPath, "utf-8");
+  return parseFrontmatter(raw).body;
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-prompt-template-model/skill-loaded-renderer.js
+import { Box, Container, Spacer, Text } from "@ashx-j/lunr-tui";
+var SKILL_PREVIEW_LINES = 5;
+function renderSkillLoaded(message, options, theme) {
+  let container = new Container();
+  if (!message.details)
+    return container.addChild(new Spacer(1)), container.addChild(new Text(theme.fg("warning", "Skill loaded message is missing details."), 0, 0)), container;
+  let { skillName, skillContent, skillPath } = message.details;
+  container.addChild(new Spacer(1));
+  let box = new Box(1, 1, (text) => theme.bg("toolSuccessBg", text));
+  box.addChild(new Text(theme.fg("toolTitle", theme.bold(`Skill loaded: ${skillName}`)), 0, 0)), box.addChild(new Text(theme.fg("toolOutput", `   ${skillPath}`), 0, 0)), box.addChild(new Spacer(1));
+  let lines = skillContent.split(`
+`);
+  if (options.expanded)
+    box.addChild(new Text(lines.map((line) => theme.fg("toolOutput", line)).join(`
+`), 0, 0));
+  else {
+    let previewLines = lines.slice(0, SKILL_PREVIEW_LINES), remaining = lines.length - SKILL_PREVIEW_LINES;
+    box.addChild(new Text(previewLines.map((line) => theme.fg("toolOutput", line)).join(`
+`), 0, 0)), remaining > 0 && box.addChild(new Text(theme.fg("warning", `
+... (${remaining} more lines)`), 0, 0));
+  }
+  return container.addChild(box), container;
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-prompt-template-model/tool-manager.js
+import { mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+import { Type } from "typebox";
+function createToolManager(pi, deps) {
+  let toolEnabled = !1, toolGuidance = null, toolRegistered = !1, toolQueuedCommand = null, configPath = join2(getAgentDir(), "prompt-template-model.json");
+  try {
+    let rawConfig = JSON.parse(readFileSync2(configPath, "utf-8"));
+    if (rawConfig && typeof rawConfig == "object") {
+      let config = rawConfig;
+      typeof config.toolEnabled == "boolean" && (toolEnabled = config.toolEnabled), typeof config.toolGuidance == "string" && (toolGuidance = config.toolGuidance);
+    }
+  } catch (error) {
+    error.code !== "ENOENT" && process.stderr.write(`[pi-prompt-template-model] Failed to read ${configPath}: ${error instanceof Error ? error.message : String(error)}
+`);
+  }
+  function saveToolConfig() {
+    try {
+      mkdirSync(getAgentDir(), { recursive: !0 }), writeFileSync(configPath, JSON.stringify({ toolEnabled, toolGuidance }, null, 2));
+    } catch (error) {
+      process.stderr.write(`[pi-prompt-template-model] Failed to write ${configPath}: ${error instanceof Error ? error.message : String(error)}
+`);
+    }
+  }
+  function ensureRegistered() {
+    toolRegistered || (toolRegistered = !0, pi.registerTool({
+      name: "run-prompt",
+      label: "Run Prompt",
+      description: "Run a prompt template command. Pass the template name and any arguments. Supports --loop for loops (e.g. 'deslop --loop 5', 'deslop --loop=5', 'deslop --loop' for unlimited until convergence with a 999-iteration cap), --fresh for context collapse between iterations, and --no-converge to disable early stopping for bounded loops. Supports runtime delegation override via --subagent, --subagent=<name>, or --subagent:<name>. Use 'chain-prompts template1 -> template2' for chaining and add --chain-context to pass previous step summaries into delegated steps.",
+      promptSnippet: "Use this to run slash/prompt templates by name with args (including --loop/--fresh and chain-prompts flows) when the user asks to execute a prompt template.",
+      parameters: Type.Object({
+        command: Type.String({
+          description: "Template name and arguments (e.g. 'deslop --loop 5 --fresh', 'deslop --subagent:worker', 'deslop --subagent', 'chain-prompts analyze -> fix --chain-context', 'chain-prompts analyze -> fix --loop=3')"
+        })
+      }),
+      execute: async (_id, params) => {
+        if (!toolEnabled)
+          return {
+            content: [{ type: "text", text: "run-prompt tool is disabled. User must run `/prompt-tool on` to enable." }],
+            details: {}
+          };
+        if (deps.isActive())
+          return {
+            content: [{ type: "text", text: "A prompt command is already running. Wait for it to complete." }],
+            details: {}
+          };
+        if (!deps.getStoredCtx())
+          return {
+            content: [{ type: "text", text: "No command context. Run any prompt command first to initialize." }],
+            details: {},
+            isError: !0
+          };
+        let commandParam = params.command, command = typeof commandParam == "string" ? commandParam.trim() : "";
+        return command ? toolQueuedCommand ? {
+          content: [{ type: "text", text: "A prompt command is already queued. Wait for it to execute." }],
+          details: {},
+          isError: !0
+        } : (toolQueuedCommand = command, {
+          content: [{ type: "text", text: `Prompt command queued: "${command}". Will execute when this turn ends.` }],
+          details: {}
+        }) : {
+          content: [{ type: "text", text: "No command specified." }],
+          details: {},
+          isError: !0
+        };
+      }
+    }));
+  }
+  function registerCommand() {
+    pi.registerCommand("prompt-tool", {
+      description: "Manage the run-prompt tool (agent-accessible prompt execution)",
+      handler: async (args, ctx) => {
+        deps.setStoredCtx(ctx);
+        let trimmed = args.trim();
+        if (trimmed === "on" || trimmed.startsWith("on ")) {
+          toolEnabled = !0, ensureRegistered();
+          let guidanceRaw = trimmed.slice(2).trim();
+          guidanceRaw ? (toolGuidance = guidanceRaw.replace(/^["']|["']$/g, ""), notify(ctx, `run-prompt tool enabled with guidance: "${toolGuidance}"`, "info")) : notify(ctx, "run-prompt tool enabled.", "info"), saveToolConfig();
+          return;
+        }
+        if (trimmed === "off") {
+          toolEnabled = !1, saveToolConfig(), notify(ctx, "run-prompt tool disabled.", "info");
+          return;
+        }
+        if (trimmed === "guidance" || trimmed.startsWith("guidance ")) {
+          trimmed === "guidance" || trimmed === "guidance show" ? toolGuidance ? notify(ctx, `Current guidance: "${toolGuidance}"`, "info") : notify(ctx, "No guidance set. Use `/prompt-tool guidance <text>` to set.", "info") : trimmed === "guidance clear" ? (toolGuidance = null, saveToolConfig(), notify(ctx, "Guidance cleared.", "info")) : (toolGuidance = trimmed.slice(8).trim().replace(/^["']|["']$/g, ""), saveToolConfig(), notify(ctx, `Guidance set: "${toolGuidance}"`, "info"));
+          return;
+        }
+        if (!trimmed) {
+          if (toolEnabled) {
+            let guidanceInfo = toolGuidance ? ` | Guidance: "${toolGuidance}"` : "";
+            notify(ctx, `run-prompt tool is enabled${guidanceInfo}`, "info");
+          } else
+            notify(ctx, "run-prompt tool is disabled", "info");
+          return;
+        }
+        notify(ctx, "Usage: /prompt-tool [on [guidance] | off | guidance [text|clear]]", "error");
+      }
+    });
+  }
+  async function processQueue(ctx, restoreFn) {
+    if (!toolQueuedCommand)
+      return !1;
+    let storedCtx = deps.getStoredCtx();
+    if (!storedCtx)
+      return toolQueuedCommand = null, !1;
+    let command = toolQueuedCommand;
+    toolQueuedCommand = null, await restoreFn();
+    try {
+      await deps.executeCommand(command, storedCtx);
+    } catch (error) {
+      notify(ctx, `Failed to execute queued prompt command "${command}": ${error instanceof Error ? error.message : String(error)}`, "error");
+    }
+    return !0;
+  }
+  return {
+    isEnabled() {
+      return toolEnabled;
+    },
+    getGuidance() {
+      return toolGuidance;
+    },
+    hasQueuedCommand() {
+      return toolQueuedCommand !== null;
+    },
+    clearQueue() {
+      toolQueuedCommand = null;
+    },
+    ensureRegistered,
+    registerCommand,
+    processQueue
+  };
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-prompt-template-model/subagent-step.js
+import { existsSync as existsSync2 } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { Key, matchesKey } from "@ashx-j/lunr-tui";
+
+// packages/coding-agent/dist/builtin-extensions/pi-prompt-template-model/subagent-widget.js
+import { Box as Box2, Container as Container2, Spacer as Spacer2, Text as Text2 } from "@ashx-j/lunr-tui";
+var DELEGATED_WIDGET_KEY = "prompt-subagent-progress";
+function formatDuration(ms) {
+  let seconds = Math.floor(ms / 1e3);
+  if (seconds < 60)
+    return `${seconds}s`;
+  let minutes = Math.floor(seconds / 60), remaining = seconds % 60;
+  return `${minutes}m${remaining}s`;
+}
+function formatTokens(n) {
+  return n ? n >= 1e3 ? `${(n / 1e3).toFixed(1)}k` : String(n) : "0";
+}
+function normalizeModelLabel(model) {
+  if (model)
+    return model.includes("/") ? model.split("/").pop() : model;
+}
+function formatToolCall(tool, args) {
+  let safeArgs = args ?? "";
+  switch (tool) {
+    case "bash": {
+      let cmd = safeArgs.replace(/[\n\t]/g, " ").trim();
+      return `$ ${cmd.length > 80 ? cmd.slice(0, 80) + "..." : cmd}`;
+    }
+    case "read":
+      return `[read: ${safeArgs}]`;
+    case "write":
+      return `[write: ${safeArgs}]`;
+    case "edit":
+      return `[edit: ${safeArgs}]`;
+    default: {
+      let short = safeArgs.length > 60 ? safeArgs.slice(0, 60) + "..." : safeArgs;
+      return `[${tool}: ${short}]`;
+    }
+  }
+}
+function stateKey(state, elapsed) {
+  if (!state)
+    return "none";
+  let elapsedBucket = Math.floor(elapsed / 1e3), tool = state.currentTool ?? "", outputLen = state.recentOutput.length, outputTail = state.recentOutput.length > 0 ? state.recentOutput[state.recentOutput.length - 1]?.slice(0, 80) ?? "" : "", toolsLen = state.recentTools.length, taskProgressKey = state.taskProgress.map((entry) => {
+    let recentOutputLines = (entry.recentOutputLines ?? []).slice(-3).join("\u241F"), recentTool = entry.recentTools?.[entry.recentTools.length - 1];
+    return [
+      entry.index ?? "",
+      entry.agent,
+      entry.status ?? "",
+      entry.currentTool ?? "",
+      entry.toolCount ?? 0,
+      entry.tokens ?? 0,
+      entry.model ?? "",
+      recentTool?.tool ?? "",
+      recentTool?.args ?? "",
+      recentOutputLines
+    ].join(":");
+  }).join("|");
+  return `${state.status}|${tool}|${state.toolCount}|${state.tokens}|${outputLen}:${outputTail}|${toolsLen}|${state.model ?? ""}|${taskProgressKey}|${elapsedBucket}`;
+}
+function getParallelPreviewLimits(taskCount) {
+  return taskCount <= 2 ? { tools: 3, output: 6 } : taskCount <= 4 ? { tools: 2, output: 4 } : { tools: 2, output: 3 };
+}
+function resolveTaskProgress(taskProgress, task, index) {
+  return taskProgress.find((entry) => entry.index === index) ?? taskProgress.find((entry) => entry.index === void 0 && entry.agent === task.agent) ?? taskProgress[index];
+}
+function getTaskOutputLines(progress) {
+  return progress ? progress.recentOutputLines && progress.recentOutputLines.length > 0 ? progress.recentOutputLines.filter((line) => line.trim()) : progress.recentOutput?.trim() ? progress.recentOutput.split(`
+`).filter((line) => line.trim()) : [] : [];
+}
+function getTaskHeader(index, task, progress, theme) {
+  let status = progress?.status ?? "pending", modelLabel = normalizeModelLabel(progress?.model ?? task.model), modelSuffix = modelLabel ? ` ${theme.fg("dim", modelLabel)}` : "", label = `task ${index + 1} \xB7 ${task.agent}`;
+  return status === "running" ? `${theme.fg("toolTitle", label)}${modelSuffix} ${theme.fg("warning", "running")}` : status === "completed" ? `${theme.fg("toolTitle", label)}${modelSuffix} ${theme.fg("success", "completed")}` : status === "failed" ? `${theme.fg("toolTitle", label)}${modelSuffix} ${theme.fg("error", "failed")}` : `${theme.fg("toolTitle", label)}${modelSuffix} ${theme.fg("dim", status)}`;
+}
+function addParallelTaskPreview(box, task, progress, index, taskCount, theme) {
+  box.addChild(new Text2(getTaskHeader(index, task, progress, theme), 0, 0));
+  let limits = getParallelPreviewLimits(taskCount);
+  if (!progress) {
+    box.addChild(new Text2(theme.fg("dim", "    waiting for updates"), 0, 0));
+    return;
+  }
+  progress.currentTool && box.addChild(new Text2(theme.fg("warning", `    > ${formatToolCall(progress.currentTool, progress.currentToolArgs ?? "")}`), 0, 0));
+  let recentTools = (progress.recentTools ?? []).slice(-limits.tools);
+  for (let tool of recentTools)
+    box.addChild(new Text2(theme.fg("dim", `    ${formatToolCall(tool.tool, tool.args)}`), 0, 0));
+  let outputLines = getTaskOutputLines(progress), visibleOutputLines = outputLines.slice(-limits.output);
+  for (let line of visibleOutputLines)
+    box.addChild(new Text2(theme.fg("dim", `    ${line}`), 0, 0));
+  let hiddenLineCount = outputLines.length - visibleOutputLines.length;
+  if (hiddenLineCount > 0 && box.addChild(new Text2(theme.fg("warning", `    ... (${hiddenLineCount} older line${hiddenLineCount === 1 ? "" : "s"})`), 0, 0)), !progress.currentTool && recentTools.length === 0 && visibleOutputLines.length === 0)
+    if (progress.status === "completed") {
+      let toolCount = progress.toolCount ?? 0;
+      box.addChild(new Text2(theme.fg("dim", `    completed (${toolCount} tool${toolCount === 1 ? "" : "s"})`), 0, 0));
+    } else progress.status === "failed" ? box.addChild(new Text2(theme.fg("error", "    task failed"), 0, 0)) : box.addChild(new Text2(theme.fg("dim", "    waiting for output"), 0, 0));
+}
+function rebuildBox(box, agent, contextSuffix, taskPreview, parallelTasks, isParallel, state, elapsed, theme, requestModel) {
+  box.clear();
+  let taskProgress = state?.taskProgress ?? [], baseToolCount = state?.toolCount ?? 0, baseTokens = state?.tokens ?? 0, parallelToolCount = taskProgress.reduce((sum, entry) => sum + (entry.toolCount ?? 0), 0), parallelTokens = taskProgress.reduce((sum, entry) => sum + (entry.tokens ?? 0), 0), toolCount = isParallel && parallelToolCount > 0 ? parallelToolCount : baseToolCount, tokens = isParallel && parallelTokens > 0 ? parallelTokens : baseTokens, tokensLabel = formatTokens(tokens), duration = formatDuration(elapsed), isThinking = toolCount === 0 && tokens === 0, icon = theme.fg("warning", "..."), modelLabel = isParallel ? requestModel : normalizeModelLabel(state?.model ?? requestModel), modelSuffix = modelLabel ? ` ${theme.fg("dim", modelLabel)}` : "", stats = isThinking ? `thinking, ${duration}` : `${toolCount} tool${toolCount === 1 ? "" : "s"}, ${tokensLabel} tok, ${duration}`;
+  if (isParallel) {
+    let runningLabel = `parallel ${taskProgress.filter((entry) => entry.status === "completed").length}/${parallelTasks.length} running`;
+    box.addChild(new Text2(`${icon} ${theme.fg("toolTitle", theme.bold(runningLabel))}${contextSuffix}${modelSuffix} | ${stats}`, 0, 0));
+  } else
+    box.addChild(new Text2(`${icon} ${theme.fg("toolTitle", theme.bold(agent))}${contextSuffix}${modelSuffix} | ${stats}`, 0, 0));
+  if (box.addChild(new Spacer2(1)), isParallel || (box.addChild(new Text2(theme.fg("dim", `Task: ${taskPreview}`), 0, 0)), box.addChild(new Spacer2(1))), isParallel) {
+    for (let index = 0; index < parallelTasks.length; index++) {
+      let task = parallelTasks[index], progress = resolveTaskProgress(taskProgress, task, index);
+      addParallelTaskPreview(box, task, progress, index, parallelTasks.length, theme), index < parallelTasks.length - 1 && box.addChild(new Spacer2(1));
+    }
+    return;
+  }
+  let recentTools = state?.recentTools ?? [];
+  for (let tool of recentTools)
+    box.addChild(new Text2(theme.fg("dim", formatToolCall(tool.tool, tool.args)), 0, 0));
+  if (state?.currentTool) {
+    let active = formatToolCall(state.currentTool, state.currentToolArgs ?? "");
+    box.addChild(new Text2(theme.fg("warning", `> ${active}`), 0, 0));
+  }
+  if (state && state.recentOutput.length > 0) {
+    (recentTools.length > 0 || state.currentTool) && box.addChild(new Spacer2(1));
+    for (let line of state.recentOutput)
+      box.addChild(new Text2(theme.fg("dim", `  ${line}`), 0, 0));
+  }
+}
+function createDelegatedProgressWidget(requestId, agent, context, task, tasks, theme, model) {
+  let contextSuffix = context === "fork" ? theme.fg("warning", " [fork]") : "", taskPreview = task.length > 200 ? `${task.slice(0, 200)}...` : task, parallelTasks = tasks ?? [], isParallel = parallelTasks.length > 0, parallelModels = [...new Set(parallelTasks.map((task2) => normalizeModelLabel(task2.model)).filter((entry) => !!entry))], requestModel = isParallel ? parallelModels.length === 1 ? parallelModels[0] : void 0 : normalizeModelLabel(model), container = new Container2();
+  container.addChild(new Spacer2(1));
+  let box = new Box2(1, 1, (text) => theme.bg("toolPendingBg", text));
+  container.addChild(box);
+  let lastKey = "";
+  return container.render = (width) => {
+    let state = getDelegatedLiveState(requestId), elapsed = state ? Date.now() - state.startedAt : 0, key = stateKey(state, elapsed);
+    return key !== lastKey && (lastKey = key, rebuildBox(box, agent, contextSuffix, taskPreview, parallelTasks, isParallel, state, elapsed, theme, requestModel)), Container2.prototype.render.call(container, width);
+  }, container;
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-prompt-template-model/subagent-step.js
+function extractTextFromBlocks(content) {
+  for (let i = content.length - 1; i >= 0; i--) {
+    let block = content[i];
+    if (block.type === "text") {
+      let trimmed = block.text.trim();
+      if (trimmed)
+        return trimmed;
+    }
+  }
+  return "";
+}
+function extractDelegatedText(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    let message = messages[i];
+    if (message.role !== "assistant")
+      continue;
+    let text = extractTextFromBlocks(message.content);
+    if (text)
+      return text;
+  }
+  return "";
+}
+function delegatedMessagesChanged(messages) {
+  for (let message of messages)
+    if (message.role === "assistant") {
+      for (let block of message.content)
+        if (block.type === "toolCall" && (block.name === "write" || block.name === "edit"))
+          return !0;
+    }
+  return !1;
+}
+function coerceMessages(messages) {
+  return Array.isArray(messages) ? messages : [];
+}
+function coerceParallelResults(parallelResults) {
+  return Array.isArray(parallelResults) ? parallelResults.map((result) => {
+    let messages = coerceMessages(result.messages);
+    return {
+      agent: result.agent,
+      text: extractDelegatedText(messages),
+      messages,
+      isError: result.isError === !0,
+      errorText: result.errorText
+    };
+  }) : [];
+}
+function renderParallelDelegatedText(results) {
+  return results.map((result, index) => {
+    let body = extractDelegatedText(result.messages) || "(no assistant text)";
+    return `=== Parallel Task ${index + 1} (${result.agent}) ===
+${body}`;
+  }).join(`
+
+`);
+}
+function resolveDelegationName(prompt, override) {
+  if (override)
+    return override.agent || (typeof prompt.subagent == "string" ? prompt.subagent : DEFAULT_SUBAGENT_NAME);
+  if (prompt.subagent === !0)
+    return DEFAULT_SUBAGENT_NAME;
+  if (typeof prompt.subagent == "string")
+    return prompt.subagent;
+}
+async function prepareDelegatedTask(task, ctx, currentModel, override, inheritedModel, taskPreamble) {
+  let requestedAgent = resolveDelegationName(task.prompt, override);
+  if (!requestedAgent)
+    throw new Error(`Prompt \`${task.prompt.name}\` is not configured for delegated execution.`);
+  let effectiveCwd = task.prompt.cwd ?? ctx.cwd;
+  if (effectiveCwd !== ctx.cwd && !existsSync2(effectiveCwd))
+    throw new Error(`cwd directory does not exist: ${effectiveCwd}`);
+  let agent = requestedAgent, preparationOptions = inheritedModel === void 0 ? void 0 : { inheritedModel }, prepared = await preparePromptExecution(task.prompt, task.args, currentModel, ctx.modelRegistry, preparationOptions);
+  if (!prepared)
+    throw new Error(`No available model from: ${task.prompt.models.join(", ")}`);
+  if ("message" in prepared)
+    throw prepared.warning && notify(ctx, prepared.warning, "warning"), new Error(prepared.message);
+  prepared.warning && notify(ctx, prepared.warning, "warning");
+  let taskText = prepared.content;
+  return !task.prompt.inheritContext && taskPreamble && (taskText = `${taskPreamble}
+
+---
+
+${prepared.content}`), task.taskPrefix && (taskText = `${task.taskPrefix}
+
+${taskText}`), {
+    promptName: task.prompt.name,
+    agent,
+    task: taskText,
+    context: task.prompt.inheritContext ? "fork" : "fresh",
+    model: `${prepared.selectedModel.model.provider}/${prepared.selectedModel.model.id}`,
+    cwd: effectiveCwd
+  };
+}
+function formatProgressStatus(update) {
+  if (update.currentTool)
+    return `running ${update.currentTool}${update.currentToolArgs ? ` ${update.currentToolArgs}` : ""}`;
+  if (update.taskProgress?.some((task) => task.status === "running"))
+    return "running";
+  if (update.toolCount && update.toolCount > 0)
+    return `completed ${update.toolCount} tool${update.toolCount === 1 ? "" : "s"}`;
+}
+function formatParallelProgressStatus(update) {
+  return !update.taskProgress || update.taskProgress.length === 0 ? void 0 : `parallel ${update.taskProgress.filter((task) => task.status === "completed").length}/${update.taskProgress.length} running`;
+}
+function hasOwn(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+function sanitizeOutputLines(lines) {
+  return !lines || lines.length === 0 ? [] : lines.filter((line) => typeof line == "string" && line.trim() && line.trim() !== "(running...)");
+}
+function collectNewOutputLines(previous, next) {
+  let previousLines = sanitizeOutputLines(previous), nextLines = sanitizeOutputLines(next);
+  if (nextLines.length === 0)
+    return [];
+  if (previousLines.length === 0)
+    return nextLines;
+  let overlapLimit = Math.min(previousLines.length, nextLines.length);
+  for (let overlap = overlapLimit; overlap > 0; overlap--) {
+    let matches = !0;
+    for (let index = 0; index < overlap; index++)
+      if (previousLines[previousLines.length - overlap + index] !== nextLines[index]) {
+        matches = !1;
+        break;
+      }
+    if (matches)
+      return nextLines.slice(overlap);
+  }
+  return nextLines;
+}
+function mergeTaskProgress(requestTasks, existingProgress, incomingProgress) {
+  if (!requestTasks || requestTasks.length === 0)
+    return incomingProgress;
+  let merged = requestTasks.map((task, index) => {
+    let existing = existingProgress?.find((entry) => entry.index === index) ?? existingProgress?.[index] ?? existingProgress?.find((entry) => entry.agent === task.agent);
+    return {
+      index,
+      agent: task.agent,
+      status: existing?.status ?? "pending",
+      currentTool: existing?.currentTool,
+      currentToolArgs: existing?.currentToolArgs,
+      recentOutput: existing?.recentOutput,
+      recentOutputLines: existing?.recentOutputLines,
+      recentTools: existing?.recentTools,
+      model: existing?.model ?? task.model,
+      toolCount: existing?.toolCount,
+      durationMs: existing?.durationMs,
+      tokens: existing?.tokens
+    };
+  });
+  if (!incomingProgress || incomingProgress.length === 0)
+    return merged;
+  let consumed = /* @__PURE__ */ new Set();
+  for (let entry of incomingProgress) {
+    let targetIndex = typeof entry.index == "number" && entry.index >= 0 && entry.index < merged.length ? entry.index : -1;
+    if (targetIndex < 0 && (targetIndex = merged.findIndex((task, index) => task.agent === entry.agent && !consumed.has(index))), targetIndex < 0)
+      continue;
+    consumed.add(targetIndex);
+    let current = merged[targetIndex];
+    merged[targetIndex] = {
+      index: targetIndex,
+      agent: current.agent,
+      status: entry.status ?? current.status,
+      currentTool: hasOwn(entry, "currentTool") ? entry.currentTool : current.currentTool,
+      currentToolArgs: hasOwn(entry, "currentToolArgs") ? entry.currentToolArgs : current.currentToolArgs,
+      recentOutput: entry.recentOutput ?? current.recentOutput,
+      recentOutputLines: entry.recentOutputLines ?? current.recentOutputLines,
+      recentTools: entry.recentTools ?? current.recentTools,
+      model: entry.model ?? current.model,
+      toolCount: entry.toolCount ?? current.toolCount,
+      durationMs: entry.durationMs ?? current.durationMs,
+      tokens: entry.tokens ?? current.tokens
+    };
+  }
+  return merged;
+}
+async function requestDelegatedRun(pi, ctx, request, signal) {
+  return await new Promise((resolve3, reject) => {
+    let requestLabel = request.tasks && request.tasks.length > 0 ? `parallel(${request.tasks.length})` : request.agent, done = !1, started = !1, startTimeoutMs = Number(process.env.PI_PROMPT_SUBAGENT_START_TIMEOUT_MS ?? "15000"), effectiveTimeout = Number.isFinite(startTimeoutMs) && startTimeoutMs > 0 ? startTimeoutMs : 15e3, startTimeout = setTimeout(() => {
+      finish(() => reject(new Error(`Delegated subagent \`${requestLabel}\` did not start within ${Math.round(effectiveTimeout / 1e3)}s. Check that the pi-subagents extension is loaded.`)));
+    }, effectiveTimeout), onStarted = (data) => {
+      done || !data || typeof data != "object" || data.requestId !== request.requestId || (started = !0, clearTimeout(startTimeout), updateDelegatedLiveState(request.requestId, {
+        status: "running...",
+        toolCount: 0,
+        recentOutput: [],
+        taskProgress: request.tasks?.map((task, index) => ({ index, agent: task.agent, status: "pending" })) ?? []
+      }), showWidget());
+    }, onResponse = (data) => {
+      if (done || !data || typeof data != "object")
+        return;
+      let payload = data;
+      payload.requestId === request.requestId && (clearTimeout(startTimeout), updateDelegatedLiveState(request.requestId, {
+        status: payload.isError ? "failed" : "completed",
+        taskProgress: payload.parallelResults?.map((result, index) => ({
+          index,
+          agent: result.agent,
+          status: result.isError ? "failed" : "completed"
+        }))
+      }), clearWidget(), finish(() => resolve3(payload)));
+    }, lastProgressStatus = "", widgetSet = !1, refreshTimer = null, showWidget = () => {
+      !ctx.hasUI || widgetSet || (widgetSet = !0, ctx.ui.setWidget(DELEGATED_WIDGET_KEY, (_tui, theme) => createDelegatedProgressWidget(request.requestId, request.agent, request.context, request.task, request.tasks, theme, preparedTasks[0]?.model), { placement: "aboveEditor" }), refreshTimer = setInterval(() => {
+        if (done)
+          return;
+        let statusLine = lastProgressStatus || "running...";
+        ctx.ui.setStatus("prompt-subagent", `delegating to ${requestLabel} \xB7 ${statusLine}`);
+      }, 1e3));
+    }, clearWidget = () => {
+      refreshTimer && (clearInterval(refreshTimer), refreshTimer = null), ctx.hasUI && widgetSet && (ctx.ui.setWidget(DELEGATED_WIDGET_KEY, void 0), widgetSet = !1);
+    }, onUpdate = (data) => {
+      if (done || !data || typeof data != "object")
+        return;
+      let update = data;
+      if (update.requestId !== request.requestId)
+        return;
+      let previousTaskProgress = getDelegatedLiveState(request.requestId)?.taskProgress, mergedTaskProgress = mergeTaskProgress(request.tasks, previousTaskProgress, update.taskProgress), isParallel = (request.tasks?.length ?? 0) > 0, progressStatus = isParallel ? formatParallelProgressStatus({
+        ...update,
+        taskProgress: mergedTaskProgress
+      }) ?? formatProgressStatus(update) : formatProgressStatus(update);
+      if (progressStatus && (lastProgressStatus = progressStatus), updateDelegatedLiveState(request.requestId, {
+        status: progressStatus ?? (lastProgressStatus || "running..."),
+        currentTool: update.currentTool,
+        currentToolArgs: update.currentToolArgs,
+        recentTools: update.recentTools,
+        model: update.model,
+        toolCount: update.toolCount,
+        durationMs: update.durationMs,
+        tokens: update.tokens,
+        taskProgress: mergedTaskProgress
+      }), isParallel || (update.recentOutputLines && update.recentOutputLines.length > 0 ? updateDelegatedLiveState(request.requestId, {
+        recentOutput: sanitizeOutputLines(update.recentOutputLines)
+      }) : appendDelegatedLiveOutput(request.requestId, update.recentOutput)), isParallel && mergedTaskProgress)
+        for (let task of mergedTaskProgress) {
+          let previousTask = previousTaskProgress?.find((entry) => entry.index === task.index) ?? previousTaskProgress?.find((entry) => entry.agent === task.agent), newOutputLines = collectNewOutputLines(previousTask?.recentOutputLines, task.recentOutputLines);
+          if (newOutputLines.length > 0) {
+            for (let line of newOutputLines)
+              appendDelegatedLiveOutput(request.requestId, line);
+            continue;
+          }
+          !task.recentOutput || task.recentOutput === previousTask?.recentOutput || appendDelegatedLiveOutput(request.requestId, task.recentOutput);
+        }
+      if (!ctx.hasUI)
+        return;
+      let statusLine = progressStatus ?? (lastProgressStatus || "running...");
+      ctx.ui.setStatus("prompt-subagent", `delegating to ${requestLabel} \xB7 ${statusLine}`);
+    }, onTerminalInput = ctx.hasUI ? ctx.ui.onTerminalInput((input) => {
+      if (matchesKey(input, Key.escape))
+        return pi.events.emit(PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT, {
+          requestId: request.requestId,
+          reason: "escape"
+        }), finish(() => reject(new Error("Delegated prompt cancelled."))), { consume: !0 };
+    }) : void 0, unsubscribeStarted = pi.events.on(PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT, onStarted), unsubscribeResponse = pi.events.on(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, onResponse), unsubscribeUpdate = pi.events.on(PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT, onUpdate), onAbort, finish = (next) => {
+      done || (done = !0, clearTimeout(startTimeout), unsubscribeStarted(), unsubscribeResponse(), unsubscribeUpdate(), onTerminalInput?.(), clearWidget(), signal && onAbort && signal.removeEventListener("abort", onAbort), next());
+    };
+    if (onAbort = () => {
+      pi.events.emit(PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT, {
+        requestId: request.requestId,
+        reason: "abort"
+      }), finish(() => reject(new Error("Delegated prompt cancelled.")));
+    }, signal) {
+      if (signal.aborted) {
+        onAbort();
+        return;
+      }
+      signal.addEventListener("abort", onAbort, { once: !0 });
+    }
+    if (pi.events.emit(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, request), !(!started && done) && !started) {
+      finish(() => reject(new Error(`No loaded pi-subagents bridge responded for \`${requestLabel}\`. Install or load pi-subagents and make sure no extension name conflicts are blocking it.`)));
+      return;
+    }
+  });
+}
+async function executeSubagentPromptStep(options) {
+  let { pi, ctx, currentModel, override, signal, inheritedModel, taskPreamble, allowPartialFailures } = options, isParallelRequest = "parallel" in options, tasks = isParallelRequest ? options.parallel : [{ prompt: options.prompt, args: options.args }];
+  if (tasks.length === 0)
+    return;
+  let preparedTasks2 = [];
+  for (let task of tasks) {
+    let preparedTask = await prepareDelegatedTask(task, ctx, currentModel, override, inheritedModel, taskPreamble);
+    preparedTasks2.push(preparedTask);
+  }
+  let requestContext = preparedTasks2[0].context, requestCwd = preparedTasks2[0].cwd;
+  for (let preparedTask of preparedTasks2) {
+    if (preparedTask.context !== requestContext)
+      throw new Error("Parallel delegated prompts must share the same inheritContext setting.");
+    if (options.worktree === !0 && preparedTask.cwd !== requestCwd)
+      throw new Error("Parallel delegated prompts with worktree enabled must share the same cwd setting.");
+  }
+  let request = {
+    requestId: randomUUID(),
+    agent: preparedTasks2[0].agent,
+    task: preparedTasks2[0].task,
+    ...isParallelRequest ? {
+      tasks: preparedTasks2.map((task) => ({
+        agent: task.agent,
+        task: task.task,
+        tier: "standard",
+        cwd: task.cwd
+      }))
+    } : {},
+    context: requestContext,
+    tier: "standard",
+    cwd: requestCwd,
+    ...options.worktree ? { worktree: !0 } : {}
+  }, promptLabel = preparedTasks2.map((task) => task.promptName).join(", "), statusLabel = isParallelRequest ? `parallel(${preparedTasks2.length})` : preparedTasks2[0].agent;
+  ctx.hasUI && (ctx.ui.setStatus("prompt-subagent", `delegating to ${statusLabel}`), ctx.ui.setWorkingMessage(isParallelRequest ? `Running delegated parallel prompts with ${statusLabel}...` : `Running delegated prompt with ${statusLabel}...`)), notify(ctx, isParallelRequest ? `Delegating parallel prompts (${promptLabel})` : `Delegating prompt \`${preparedTasks2[0].promptName}\` to subagent \`${preparedTasks2[0].agent}\``, "info");
+  try {
+    let response = await requestDelegatedRun(pi, ctx, request, signal);
+    if (response.isError)
+      throw new Error(`Delegated prompt execution failed: ${response.errorText || "unknown delegated error"}`);
+    if (isParallelRequest) {
+      let parallelResults = coerceParallelResults(response.parallelResults);
+      if (parallelResults.length === 0)
+        throw new Error("Delegated parallel execution returned no results.");
+      let failures = parallelResults.filter((result) => result.isError);
+      if (!allowPartialFailures && failures.length > 0) {
+        let failureText = failures.map((failure) => `${failure.agent}: ${failure.errorText || "unknown delegated error"}`).join("; ");
+        throw new Error(`Delegated parallel execution failed: ${failureText}`);
+      }
+      let text2 = response.contentText?.trim() || renderParallelDelegatedText(parallelResults), changed2 = parallelResults.some((result) => delegatedMessagesChanged(result.messages)) || text2.includes("=== Worktree Changes ===");
+      return pi.sendMessage({
+        customType: PROMPT_TEMPLATE_SUBAGENT_MESSAGE_TYPE,
+        content: text2,
+        display: !0,
+        details: {
+          requestId: response.requestId,
+          agent: request.agent,
+          task: preparedTasks2.map((task) => task.task).join(`
+
+`),
+          context: response.context,
+          model: response.model,
+          messages: [],
+          parallelResults,
+          text: text2,
+          changed: changed2,
+          isError: !1,
+          errorText: response.errorText
+        }
+      }), {
+        changed: changed2,
+        text: text2,
+        agent: request.agent,
+        parallelResults
+      };
+    }
+    let messages = coerceMessages(response.messages), text = extractDelegatedText(messages);
+    if (!text)
+      throw new Error("Delegated subagent returned no assistant text.");
+    let changed = delegatedMessagesChanged(messages);
+    return pi.sendMessage({
+      customType: PROMPT_TEMPLATE_SUBAGENT_MESSAGE_TYPE,
+      content: text,
+      display: !0,
+      details: {
+        requestId: response.requestId,
+        agent: preparedTasks2[0].agent,
+        task: request.task,
+        context: response.context,
+        model: response.model,
+        messages,
+        text,
+        changed,
+        isError: !1,
+        errorText: response.errorText
+      }
+    }), {
+      changed,
+      text,
+      agent: preparedTasks2[0].agent
+    };
+  } catch (error) {
+    let cause = error instanceof Error ? error : new Error(String(error)), responseText = cause.message;
+    throw isParallelRequest ? new Error(`Parallel delegated prompts (${promptLabel}) failed: ${responseText}`, { cause }) : new Error(`Prompt \`${preparedTasks2[0].promptName}\` delegated subagent \`${preparedTasks2[0].agent}\` failed: ${responseText}`, { cause });
+  } finally {
+    clearDelegatedLiveState(request.requestId), ctx.hasUI && (ctx.ui.setStatus("prompt-subagent", void 0), ctx.ui.setWorkingMessage());
+  }
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-prompt-template-model/subagent-renderer.js
+import { Box as Box3, Container as Container3, Spacer as Spacer3, Text as Text3 } from "@ashx-j/lunr-tui";
+var DEFAULT_AGENT = "delegate", PREVIEW_LINES = 8;
+function extractTextContent(content) {
+  if (typeof content == "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  let lines = [];
+  for (let part of content) {
+    if (!part || typeof part != "object" || part.type !== "text")
+      continue;
+    let text = part.text;
+    typeof text == "string" && lines.push(text);
+  }
+  return lines.join(`
+`);
+}
+function formatToolCall2(name, args) {
+  switch (name) {
+    case "bash": {
+      let cmd = String(args.command ?? "").replace(/[\n\t]/g, " ").trim();
+      return `$ ${cmd.length > 80 ? cmd.slice(0, 80) + "..." : cmd}`;
+    }
+    case "read":
+      return `[read: ${args.path ?? args.file_path ?? ""}]`;
+    case "write":
+      return `[write: ${args.path ?? args.file_path ?? ""}]`;
+    case "edit":
+      return `[edit: ${args.path ?? args.file_path ?? ""}]`;
+    case "grep":
+      return `[grep: /${args.pattern ?? ""}/ in ${args.path ?? "."}]`;
+    case "find":
+      return `[find: ${args.pattern ?? ""} in ${args.path ?? "."}]`;
+    case "ls":
+      return `[ls: ${args.path ?? "."}]`;
+    default: {
+      let a = JSON.stringify(args).slice(0, 50);
+      return `[${name}: ${a}${JSON.stringify(args).length > 50 ? "..." : ""}]`;
+    }
+  }
+}
+function extractToolCalls(messages) {
+  let calls = [];
+  for (let msg of messages)
+    if (!(msg.role !== "assistant" || !Array.isArray(msg.content)))
+      for (let block of msg.content)
+        block.type === "toolCall" && block.name && calls.push(formatToolCall2(block.name, block.arguments ?? {}));
+  return calls;
+}
+function extractAssistantText(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    let msg = messages[i];
+    if (msg.role !== "assistant")
+      continue;
+    let text = extractTextContent(msg.content);
+    if (text.trim())
+      return text;
+  }
+  return "";
+}
+function extractUsage(messages) {
+  let input = 0, output = 0, cacheRead = 0, cacheWrite = 0, cost = 0, turns = 0, model;
+  for (let msg of messages)
+    msg.role === "assistant" && (turns++, msg.usage && (input += msg.usage.input ?? 0, output += msg.usage.output ?? 0, cacheRead += msg.usage.cacheRead ?? 0, cacheWrite += msg.usage.cacheWrite ?? 0, cost += msg.usage.cost?.total ?? 0), msg.model && (model = msg.model));
+  return { input, output, cacheRead, cacheWrite, cost, model, turns };
+}
+function formatTokensShort(n) {
+  return n >= 1e3 ? `${Math.round(n / 1e3)}k` : String(n);
+}
+function renderDelegatedSubagentResult(message, options, theme) {
+  let details = message.details, parallelResults = details?.parallelResults ?? [], hasParallelResults = parallelResults.length > 0, agent = hasParallelResults ? "parallel" : details?.agent ?? DEFAULT_AGENT, context = details?.context === "fork" ? theme.fg("warning", " [fork]") : "", messages = hasParallelResults ? parallelResults.flatMap((result) => result.messages ?? []) : details?.messages ?? [], text = extractTextContent(message.content), usage = extractUsage(messages), toolCalls = extractToolCalls(messages), toolCount = toolCalls.length, tokensLabel = `${formatTokensShort(usage.output)} tok`, container = new Container3();
+  container.addChild(new Spacer3(1));
+  let box = new Box3(1, 1, (text2) => theme.bg("toolSuccessBg", text2)), icon = theme.fg("success", "ok"), stats = hasParallelResults ? `${parallelResults.length} task${parallelResults.length === 1 ? "" : "s"}, ${toolCount} tool${toolCount === 1 ? "" : "s"}, ${tokensLabel}` : `${toolCount} tool${toolCount === 1 ? "" : "s"}, ${tokensLabel}`;
+  if (box.addChild(new Text3(`${icon} ${theme.fg("toolTitle", theme.bold(agent))}${context} | ${stats}`, 0, 0)), box.addChild(new Spacer3(1)), details?.task) {
+    let taskPreview = details.task.length > 120 ? `${details.task.slice(0, 120)}...` : details.task;
+    box.addChild(new Text3(theme.fg("dim", `Task: ${taskPreview}`), 0, 0)), box.addChild(new Spacer3(1));
+  }
+  if (hasParallelResults)
+    for (let index = 0; index < parallelResults.length; index++) {
+      let result = parallelResults[index], taskLabel = result.agent || `task-${index + 1}`;
+      box.addChild(new Text3(theme.fg("toolTitle", `=== Task ${index + 1}: ${taskLabel} ===`), 0, 0));
+      let taskMessages = result.messages ?? [], taskText = extractAssistantText(taskMessages);
+      if (result.isError) {
+        let errorText = result.errorText || "Task failed.";
+        box.addChild(new Text3(theme.fg("error", errorText), 0, 0)), box.addChild(new Spacer3(1));
+        continue;
+      }
+      if (!taskText) {
+        box.addChild(new Text3(theme.fg("dim", "(no assistant text)"), 0, 0)), box.addChild(new Spacer3(1));
+        continue;
+      }
+      let lines = taskText.split(`
+`);
+      options.expanded || lines.length <= PREVIEW_LINES ? box.addChild(new Text3(theme.fg("toolOutput", taskText), 0, 0)) : (box.addChild(new Text3(theme.fg("toolOutput", lines.slice(0, PREVIEW_LINES).join(`
+`)), 0, 0)), box.addChild(new Text3(theme.fg("warning", `
+... (${lines.length - PREVIEW_LINES} more lines \u2014 Ctrl+O to expand)`), 0, 0))), box.addChild(new Spacer3(1));
+    }
+  else {
+    if (toolCalls.length > 0) {
+      let showCalls = options.expanded ? toolCalls : toolCalls.slice(0, 5);
+      for (let call of showCalls)
+        box.addChild(new Text3(theme.fg("dim", call), 0, 0));
+      !options.expanded && toolCalls.length > 5 && box.addChild(new Text3(theme.fg("warning", `... (${toolCalls.length - 5} more tool calls)`), 0, 0)), box.addChild(new Spacer3(1));
+    }
+    if (text) {
+      let lines = text.split(`
+`);
+      options.expanded || lines.length <= PREVIEW_LINES ? box.addChild(new Text3(theme.fg("toolOutput", text), 0, 0)) : (box.addChild(new Text3(theme.fg("toolOutput", lines.slice(0, PREVIEW_LINES).join(`
+`)), 0, 0)), box.addChild(new Text3(theme.fg("warning", `
+... (${lines.length - PREVIEW_LINES} more lines \u2014 Ctrl+O to expand)`), 0, 0))), box.addChild(new Spacer3(1));
+    }
+  }
+  let statsLine = `${usage.turns} turn${usage.turns === 1 ? "" : "s"} in:${usage.input} out:${usage.output} R${formatTokensShort(usage.cacheRead)} W${formatTokensShort(usage.cacheWrite)}${usage.cost ? ` $${usage.cost.toFixed(4)}` : ""} ${usage.model ?? details?.model ?? ""}`;
+  return box.addChild(new Text3(theme.fg("dim", statsLine), 0, 0)), container.addChild(box), container;
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-prompt-template-model/deterministic-step.js
+import { spawn } from "node:child_process";
+import { existsSync as existsSync3 } from "node:fs";
+import { dirname as dirname2, isAbsolute as isAbsolute2, resolve as resolve2 } from "node:path";
+var PROMPT_TEMPLATE_DETERMINISTIC_MESSAGE_TYPE = "prompt-template-deterministic", PROMPT_TEMPLATE_DETERMINISTIC_COMPLETION_MESSAGE_TYPE = "prompt-template-deterministic-complete", DEFAULT_MAX_CAPTURE_STDOUT_CHARS = 16e3, DEFAULT_MAX_CAPTURE_STDERR_CHARS = 16e3, DEFAULT_TIMEOUT_KILL_AFTER_MS = 1e3;
+function createCapturedOutput(maxChars) {
+  return {
+    text: "",
+    totalChars: 0,
+    totalNewlines: 0,
+    trailingNewlineRun: 0,
+    sawNonNewline: !1,
+    truncated: !1,
+    maxChars
+  };
+}
+function appendCapturedOutput(output, chunk) {
+  if (!chunk)
+    return;
+  output.totalChars += chunk.length;
+  let newlines = chunk.match(/\n/g)?.length ?? 0;
+  output.totalNewlines += newlines, /[^\n]/.test(chunk) && (output.sawNonNewline = !0);
+  let trailingRun = chunk.match(/\n+$/)?.[0].length ?? 0;
+  if (trailingRun === 0 ? output.trailingNewlineRun = 0 : trailingRun === chunk.length ? output.trailingNewlineRun += trailingRun : output.trailingNewlineRun = trailingRun, output.text.length < output.maxChars) {
+    let remaining = output.maxChars - output.text.length;
+    output.text += chunk.slice(0, remaining);
+  }
+  output.totalChars > output.maxChars && (output.truncated = !0);
+}
+function capturedLineCount(output) {
+  return output.totalChars === 0 ? 0 : output.sawNonNewline ? output.totalNewlines - output.trailingNewlineRun + 1 : 1;
+}
+function countLines(value) {
+  if (!value)
+    return 0;
+  let normalized = value.replace(/\n+$/g, "");
+  return normalized ? normalized.split(`
+`).length : 1;
+}
+function buildTextPreview(label, value, totalChars, maxChars) {
+  let shownChars = Math.min(value.length, maxChars), preview = value.slice(0, shownChars), omittedChars = Math.max(0, totalChars - shownChars);
+  return omittedChars === 0 ? { text: preview, truncated: !1, omittedChars: 0 } : {
+    text: `${preview}
+...[${label} truncated, ${omittedChars} more chars omitted]`,
+    truncated: !0,
+    omittedChars
+  };
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function formatDeterministicExecution(execution, resolvedScriptPath) {
+  switch (execution.kind) {
+    case "run":
+      return execution.command;
+    case "command": {
+      let parts = [execution.command, ...execution.args].map((part) => shellQuote(part));
+      return execution.shell ? `${parts.join(" ")} (shell)` : parts.join(" ");
+    }
+    case "script":
+      return [resolvedScriptPath ?? execution.path, ...execution.args].map((part) => shellQuote(part)).join(" ");
+  }
+}
+function shouldHandoffToLlm(step, result) {
+  switch (step.handoff) {
+    case "always":
+      return !0;
+    case "never":
+      return !1;
+    case "on-success":
+      return result.exitCode === 0;
+    case "on-failure":
+      return result.exitCode !== 0;
+  }
+}
+function buildOutputPreambleSectionFromResult(label, value, meta, maxChars) {
+  let preview = buildTextPreview(label, value, meta.totalChars, maxChars);
+  return [
+    `[${label}]`,
+    `lineCount: ${meta.totalLines}`,
+    `charCount: ${meta.totalChars}`,
+    `truncated: ${preview.truncated ? "true" : "false"}`,
+    preview.truncated ? `omittedChars: ${preview.omittedChars}` : void 0,
+    "preview:",
+    preview.text || "(empty)"
+  ];
+}
+function buildDeterministicPreamble(result, options = {}) {
+  let maxStdoutChars = options.maxStdoutChars ?? 8e3, maxStderrChars = options.maxStderrChars ?? 4e3, command = formatDeterministicExecution(result.execution, result.resolvedScriptPath);
+  return [
+    "[Deterministic step]",
+    `status: ${result.exitCode === 0 ? "succeeded" : "failed"}`,
+    `executionKind: ${result.execution.kind}`,
+    `command: ${command.includes(`
+`) ? JSON.stringify(command) : command}`,
+    result.resolvedScriptPath ? `resolvedScript: ${result.resolvedScriptPath}` : void 0,
+    `cwd: ${result.cwd}`,
+    `nonInteractive: ${result.nonInteractive ? "true" : "false"}`,
+    `exitCode: ${result.exitCode}`,
+    result.signal ? `signal: ${result.signal}` : void 0,
+    `durationMs: ${result.durationMs}`,
+    `timedOut: ${result.timedOut ? "true" : "false"}`,
+    "",
+    ...buildOutputPreambleSectionFromResult("stdout", result.stdout, {
+      totalChars: result.stdoutTotalChars,
+      totalLines: result.stdoutTotalLines
+    }, maxStdoutChars),
+    "",
+    ...buildOutputPreambleSectionFromResult("stderr", result.stderr, {
+      totalChars: result.stderrTotalChars,
+      totalLines: result.stderrTotalLines
+    }, maxStderrChars)
+  ].filter((line) => line !== void 0).join(`
+`);
+}
+function resolveScriptPath(prompt, cwd, execution) {
+  if (isAbsolute2(execution.path))
+    return execution.path;
+  let promptRelative = resolve2(dirname2(prompt.filePath), execution.path);
+  return existsSync3(promptRelative) ? promptRelative : resolve2(cwd, execution.path);
+}
+function buildDeterministicEnv(step) {
+  let nonInteractiveDefaults = step.nonInteractive ? {
+    CI: "1",
+    GIT_TERMINAL_PROMPT: "0",
+    PAGER: "cat",
+    GIT_PAGER: "cat"
+  } : {};
+  return {
+    ...process.env,
+    ...nonInteractiveDefaults,
+    ...step.env ?? {}
+  };
+}
+function spawnProcess(command, args, options) {
+  return spawn(command, args, {
+    cwd: options.cwd,
+    shell: options.shell ?? !1,
+    env: options.env,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+}
+async function runDeterministicStep(prompt, step, cwd) {
+  let startedAt = Date.now(), execution = step.execution, resolvedCwd = step.cwd ?? cwd, env = buildDeterministicEnv(step), resolvedScriptPath = execution.kind === "script" ? resolveScriptPath(prompt, resolvedCwd, execution) : void 0, child = execution.kind === "run" ? spawnProcess("/bin/bash", ["-lc", execution.command], { cwd: resolvedCwd, env }) : execution.kind === "command" ? spawnProcess(execution.command, execution.args, { cwd: resolvedCwd, shell: execution.shell, env }) : spawnProcess(resolvedScriptPath, execution.args, { cwd: resolvedCwd, env }), stdout = createCapturedOutput(DEFAULT_MAX_CAPTURE_STDOUT_CHARS), stderr = createCapturedOutput(DEFAULT_MAX_CAPTURE_STDERR_CHARS), timedOut = !1, timeoutKillHandle;
+  child.stdout.on("data", (chunk) => {
+    appendCapturedOutput(stdout, chunk.toString());
+  }), child.stderr.on("data", (chunk) => {
+    appendCapturedOutput(stderr, chunk.toString());
+  });
+  let timeoutHandle = step.timeoutMs ? setTimeout(() => {
+    timedOut = !0, child.kill("SIGTERM"), timeoutKillHandle = setTimeout(() => {
+      child.kill("SIGKILL");
+    }, DEFAULT_TIMEOUT_KILL_AFTER_MS);
+  }, step.timeoutMs) : void 0;
+  return await new Promise((resolveResult) => {
+    let settled = !1;
+    child.on("error", (error) => {
+      settled || (settled = !0, timeoutHandle && clearTimeout(timeoutHandle), timeoutKillHandle && clearTimeout(timeoutKillHandle), resolveResult({
+        execution,
+        cwd: resolvedCwd,
+        nonInteractive: step.nonInteractive,
+        resolvedScriptPath,
+        exitCode: 1,
+        stdout: stdout.text,
+        stdoutTotalChars: stdout.totalChars,
+        stdoutTotalLines: capturedLineCount(stdout),
+        stdoutTruncated: stdout.truncated,
+        stderr: stderr.text ? `${stderr.text}
+${error.message}` : error.message,
+        stderrTotalChars: stderr.totalChars + (stderr.text ? error.message.length + 1 : error.message.length),
+        stderrTotalLines: countLines(stderr.text ? `${stderr.text}
+${error.message}` : error.message),
+        stderrTruncated: stderr.truncated,
+        durationMs: Date.now() - startedAt,
+        timedOut
+      }));
+    }), child.on("close", (exitCode, signal) => {
+      settled || (settled = !0, timeoutHandle && clearTimeout(timeoutHandle), timeoutKillHandle && clearTimeout(timeoutKillHandle), resolveResult({
+        execution,
+        cwd: resolvedCwd,
+        nonInteractive: step.nonInteractive,
+        resolvedScriptPath,
+        exitCode: exitCode ?? (timedOut ? 124 : 1),
+        signal: signal ?? void 0,
+        stdout: stdout.text,
+        stdoutTotalChars: stdout.totalChars,
+        stdoutTotalLines: capturedLineCount(stdout),
+        stdoutTruncated: stdout.truncated,
+        stderr: stderr.text,
+        stderrTotalChars: stderr.totalChars,
+        stderrTotalLines: capturedLineCount(stderr),
+        stderrTruncated: stderr.truncated,
+        durationMs: Date.now() - startedAt,
+        timedOut
+      }));
+    });
+  });
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-prompt-template-model/deterministic-renderer.js
+import { Box as Box4, Container as Container4, Spacer as Spacer4, Text as Text4 } from "@ashx-j/lunr-tui";
+var PREVIEW_LINES2 = 8;
+function formatDuration2(durationMs) {
+  return durationMs < 1e3 ? `${durationMs}ms` : durationMs < 1e4 ? `${(durationMs / 1e3).toFixed(1)}s` : `${Math.round(durationMs / 1e3)}s`;
+}
+function buildCapturedOutputLabel(label, meta) {
+  if (meta.totalChars === 0)
+    return `${label} \xB7 empty`;
+  let lineCount = meta.totalLines, charCount = meta.totalChars.toLocaleString(), truncated = meta.truncated ? " \xB7 capped" : "";
+  return `${label} \xB7 ${lineCount} line${lineCount === 1 ? "" : "s"} \xB7 ${charCount} chars${truncated}`;
+}
+function renderOutputSection(box, label, value, meta, options, theme) {
+  if (box.addChild(new Text4(theme.fg("toolTitle", buildCapturedOutputLabel(label, meta)), 0, 0)), !value) {
+    box.addChild(new Text4(theme.fg("dim", "(empty)"), 0, 0));
+    return;
+  }
+  let lines = value.split(`
+`);
+  if (options.expanded || lines.length <= PREVIEW_LINES2) {
+    box.addChild(new Text4(theme.fg("toolOutput", value), 0, 0)), meta.truncated && box.addChild(new Text4(theme.fg("warning", `
+... (stored preview capped, ${Math.max(0, meta.totalChars - value.length)} more chars hidden)`), 0, 0));
+    return;
+  }
+  box.addChild(new Text4(theme.fg("toolOutput", lines.slice(0, PREVIEW_LINES2).join(`
+`)), 0, 0)), box.addChild(new Text4(theme.fg("warning", `
+... (${lines.length - PREVIEW_LINES2} more lines hidden \u2014 Ctrl+O to expand)`), 0, 0)), meta.truncated && box.addChild(new Text4(theme.fg("warning", `
+... (stored preview capped, ${Math.max(0, meta.totalChars - value.length)} more chars hidden)`), 0, 0));
+}
+function renderDeterministicResult(message, options, theme) {
+  let details = message.details, container = new Container4();
+  if (container.addChild(new Spacer4(1)), !details)
+    return container.addChild(new Text4(theme.fg("warning", "Deterministic step message is missing details."), 0, 0)), container;
+  let failed = details.exitCode !== 0, box = new Box4(1, 1, (text) => theme.bg(failed ? "toolPendingBg" : "toolSuccessBg", text)), icon = theme.fg(failed ? "error" : "success", failed ? "fail" : "ok"), status = failed ? "failed" : "succeeded", title = formatDeterministicExecution(details.execution, details.resolvedScriptPath);
+  return box.addChild(new Text4(`${icon} ${theme.fg("toolTitle", theme.bold("deterministic"))} | ${status} \xB7 exit ${details.exitCode} \xB7 ${formatDuration2(details.durationMs)}`, 0, 0)), box.addChild(new Spacer4(1)), box.addChild(new Text4(theme.fg("dim", `command: ${title}`), 0, 0)), details.resolvedScriptPath && box.addChild(new Text4(theme.fg("dim", `script: ${details.resolvedScriptPath}`), 0, 0)), box.addChild(new Text4(theme.fg("dim", `cwd: ${details.cwd}`), 0, 0)), details.signal && box.addChild(new Text4(theme.fg("dim", `signal: ${details.signal}`), 0, 0)), details.timedOut && box.addChild(new Text4(theme.fg("error", "timeout reached before the process exited"), 0, 0)), box.addChild(new Text4(theme.fg("dim", `nonInteractive: ${details.nonInteractive ? "true" : "false"}`), 0, 0)), box.addChild(new Spacer4(1)), renderOutputSection(box, "stdout", details.stdout, {
+    totalChars: details.stdoutTotalChars,
+    totalLines: details.stdoutTotalLines,
+    truncated: details.stdoutTruncated
+  }, options, theme), box.addChild(new Spacer4(1)), renderOutputSection(box, "stderr", details.stderr, {
+    totalChars: details.stderrTotalChars,
+    totalLines: details.stderrTotalLines,
+    truncated: details.stderrTruncated
+  }, options, theme), container.addChild(box), container;
+}
+function renderDeterministicCompletion(message, _options, theme) {
+  let details = message.details, container = new Container4();
+  if (container.addChild(new Spacer4(1)), !details)
+    return container.addChild(new Text4(theme.fg("warning", "Deterministic completion message is missing details."), 0, 0)), container;
+  let failed = details.status === "failed", box = new Box4(1, 1, (text) => theme.bg(failed ? "toolPendingBg" : "toolSuccessBg", text)), icon = theme.fg(failed ? "error" : "success", failed ? "fail" : "ok");
+  return box.addChild(new Text4(`${icon} ${theme.fg("toolTitle", theme.bold("deterministic complete"))} | ${details.status} \xB7 exit ${details.exitCode}`, 0, 0)), box.addChild(new Spacer4(1)), box.addChild(new Text4(theme.fg("dim", `prompt: ${details.promptName}`), 0, 0)), box.addChild(new Text4(theme.fg("dim", "model handoff: skipped"), 0, 0)), details.timedOut && box.addChild(new Text4(theme.fg("error", "the command hit its timeout before completion"), 0, 0)), container.addChild(box), container;
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-prompt-template-model/index.js
+var DEFAULT_COMPARE_REVIEWER_TASK = [
+  "Review the worker variants and produce findings only.",
+  "Required output:",
+  "1. Summarize concrete strengths with patch/diff evidence, including worktree change summaries when present.",
+  "2. Call out concrete correctness risks and regression risks.",
+  "3. Extract cherry-pick ideas from non-winning variants.",
+  "4. Do not rank variants or select a winner.",
+  "5. Do not include manual apply commands."
+].join(`
+`), DEFAULT_COMPARE_FINAL_APPLIER_TASK = [
+  "Apply the final implementation directly in the current repo.",
+  "Required output:",
+  "1. Pick the best single variant or synthesize/cherry-pick across variants.",
+  "2. Apply changes directly on the current branch.",
+  "3. Keep edits minimal and focused on the implementation task.",
+  "4. Run obvious relevant verification when practical.",
+  "5. Report changed files and verification commands run."
+].join(`
+`);
+function promptModelExtension(pi) {
+  let prompts = /* @__PURE__ */ new Map(), chainPrompts = /* @__PURE__ */ new Map(), previousModel, previousThinking, pendingSkillMessage, runtimeModel, chainActive = !1, loopState = null, freshCollapse = null, boomerangCollapse = null, accumulatedSummaries = [], lastDiagnostics = "", storedCommandCtx = null, UNLIMITED_LOOP_CAP = 999, toolManager = createToolManager(pi, {
+    isActive: () => !!(loopState || chainActive),
+    getStoredCtx: () => storedCommandCtx,
+    setStoredCtx: (ctx) => {
+      storedCommandCtx = ctx;
+    },
+    executeCommand: executeToolCommand
+  });
+  function sameModel2(a, b) {
+    return !a || !b ? a === b : a.provider === b.provider && a.id === b.id;
+  }
+  function getCurrentModel(ctx) {
+    return runtimeModel ?? ctx.model;
+  }
+  pi.registerMessageRenderer("skill-loaded", renderSkillLoaded), pi.registerMessageRenderer(PROMPT_TEMPLATE_SUBAGENT_MESSAGE_TYPE, renderDelegatedSubagentResult), pi.registerMessageRenderer(PROMPT_TEMPLATE_DETERMINISTIC_MESSAGE_TYPE, renderDeterministicResult), pi.registerMessageRenderer(PROMPT_TEMPLATE_DETERMINISTIC_COMPLETION_MESSAGE_TYPE, renderDeterministicCompletion);
+  function registerPromptCommand(name) {
+    pi.registerCommand(name, {
+      description: buildPromptCommandDescription(prompts.get(name)),
+      handler: async (args, ctx) => {
+        await runPromptCommand(name, args, ctx);
+      }
+    });
+  }
+  function refreshPrompts(cwd, ctx) {
+    let result = loadPromptsWithModel(cwd), chainResult = loadPromptsWithModel(cwd, !0);
+    prompts = result.prompts, chainPrompts = chainResult.prompts;
+    for (let name of prompts.keys())
+      registerPromptCommand(name);
+    let summary = summarizePromptDiagnostics(result.diagnostics), fingerprint = diagnosticsFingerprint(result.diagnostics);
+    summary && fingerprint !== lastDiagnostics && notify(ctx, summary, "warning"), lastDiagnostics = fingerprint;
+  }
+  function consumePendingSkillMessage() {
+    if (!pendingSkillMessage)
+      return;
+    let message = pendingSkillMessage;
+    return pendingSkillMessage = void 0, message;
+  }
+  function normalizeSkillName(skillName) {
+    return skillName.startsWith("skill:") ? skillName.slice(6) : skillName;
+  }
+  function isPathResolvableSkillName(skillName) {
+    return !(skillName === "." || skillName === ".." || skillName.includes("/") || skillName.includes("\\"));
+  }
+  function resolveRegisteredSkillPath(skillName) {
+    let normalizedSkillName = normalizeSkillName(skillName);
+    if (!normalizedSkillName)
+      return;
+    let candidates = /* @__PURE__ */ new Set([normalizedSkillName, `skill:${normalizedSkillName}`]);
+    for (let command of pi.getCommands()) {
+      if (command.source !== "skill")
+        continue;
+      let sourceInfo = "sourceInfo" in command ? command.sourceInfo : void 0;
+      if (sourceInfo?.path && candidates.has(command.name))
+        return sourceInfo.path;
+    }
+  }
+  function resolveSkillMessage(skillName, cwd) {
+    if (!skillName)
+      return { kind: "none" };
+    let normalizedSkillName = normalizeSkillName(skillName);
+    if (!normalizedSkillName)
+      return { kind: "error", error: `Skill "${skillName}" not found` };
+    let skillPath = resolveRegisteredSkillPath(skillName) ?? (isPathResolvableSkillName(normalizedSkillName) ? resolveSkillPath(normalizedSkillName, cwd) : void 0);
+    if (!skillPath)
+      return { kind: "error", error: `Skill "${skillName}" not found` };
+    try {
+      let skillContent = readSkillContent(skillPath);
+      return {
+        kind: "ready",
+        message: {
+          customType: "skill-loaded",
+          content: `<skill name="${normalizedSkillName}">
+${skillContent}
+</skill>`,
+          display: !0,
+          details: { skillName: normalizedSkillName, skillContent, skillPath }
+        }
+      };
+    } catch (error) {
+      return {
+        kind: "error",
+        error: `Failed to read skill "${skillName}": ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  async function waitForTurnStart(ctx) {
+    for (; ctx.isIdle(); )
+      await new Promise((resolve3) => setTimeout(resolve3, 10));
+  }
+  function shouldDelegatePrompt(prompt, override) {
+    return prompt.subagent !== void 0 || override?.enabled === !0;
+  }
+  function isParallelChainStep(step) {
+    return "parallel" in step;
+  }
+  async function executePromptStep(prompt, args, ctx, currentModel, override, inheritedModel, taskPreamble, loopContext, promptTurnRestore) {
+    let deterministicPreamble;
+    if (prompt.deterministic)
+      try {
+        let deterministicResult = await runDeterministicStep(prompt, prompt.deterministic, ctx.cwd), deterministicPreambleText = buildDeterministicPreamble(deterministicResult);
+        if (pi.sendMessage({
+          customType: PROMPT_TEMPLATE_DETERMINISTIC_MESSAGE_TYPE,
+          content: deterministicPreambleText,
+          display: !0,
+          details: deterministicResult
+        }), !shouldHandoffToLlm(prompt.deterministic, deterministicResult))
+          return pi.sendMessage({
+            customType: PROMPT_TEMPLATE_DETERMINISTIC_COMPLETION_MESSAGE_TYPE,
+            content: `[Deterministic complete: ${prompt.name}]`,
+            display: !0,
+            details: {
+              promptName: prompt.name,
+              exitCode: deterministicResult.exitCode,
+              timedOut: deterministicResult.timedOut,
+              status: deterministicResult.exitCode === 0 ? "succeeded" : "failed"
+            }
+          }), { changed: !1 };
+        deterministicPreamble = deterministicPreambleText;
+      } catch (error) {
+        return notify(ctx, `Deterministic step failed: ${error instanceof Error ? error.message : String(error)}`, "error"), "aborted";
+      }
+    let combinedTaskPreamble = [taskPreamble, deterministicPreamble].filter(Boolean).join(`
+
+`);
+    if (shouldDelegatePrompt(prompt, override))
+      try {
+        let delegated = prompt.parallel && prompt.parallel > 1 ? await executeSubagentPromptStep({
+          pi,
+          ctx,
+          currentModel,
+          override,
+          signal: ctx.signal,
+          inheritedModel,
+          taskPreamble: combinedTaskPreamble || void 0,
+          parallel: Array.from({ length: prompt.parallel }, (_, index) => ({
+            prompt,
+            args,
+            taskPrefix: `[Parallel subagent ${index + 1}/${prompt.parallel}]`
+          })),
+          worktree: prompt.worktree === !0
+        }) : await executeSubagentPromptStep({
+          pi,
+          prompt,
+          args,
+          ctx,
+          currentModel,
+          override,
+          signal: ctx.signal,
+          inheritedModel,
+          taskPreamble: combinedTaskPreamble || void 0
+        });
+        return delegated ? { changed: delegated.changed, text: delegated.text } : (notify(ctx, `Prompt \`${prompt.name}\` is not configured for delegated execution.`, "error"), "aborted");
+      } catch (error) {
+        return notify(ctx, error instanceof Error ? error.message : String(error), "error"), { changed: !1 };
+      }
+    let prepared = inheritedModel === void 0 ? await preparePromptExecution(prompt, args, currentModel, ctx.modelRegistry) : await preparePromptExecution(prompt, args, currentModel, ctx.modelRegistry, { inheritedModel });
+    if (!prepared)
+      return notify(ctx, `No available model from: ${prompt.models.join(", ")}`, "error"), "aborted";
+    if ("message" in prepared)
+      return prepared.warning && notify(ctx, prepared.warning, "warning"), notify(ctx, prepared.message, "error"), "aborted";
+    prepared.warning && notify(ctx, prepared.warning, "warning");
+    let skillResolution = resolveSkillMessage(prompt.skill, ctx.cwd);
+    if (skillResolution.kind === "error")
+      return notify(ctx, skillResolution.error, "error"), "aborted";
+    if (!prepared.selectedModel.alreadyActive) {
+      if (!await pi.setModel(prepared.selectedModel.model))
+        return notify(ctx, `Failed to switch to model ${prepared.selectedModel.model.provider}/${prepared.selectedModel.model.id}`, "error"), "aborted";
+      runtimeModel = prepared.selectedModel.model;
+    }
+    if (prompt.thinking && pi.setThinkingLevel(prompt.thinking), pendingSkillMessage = skillResolution.kind === "ready" ? skillResolution.message : void 0, promptTurnRestore) {
+      let currentModel2 = getCurrentModel(ctx);
+      promptTurnRestore.originalModel && currentModel2 && !sameModel2(promptTurnRestore.originalModel, currentModel2) && (previousModel = promptTurnRestore.originalModel, previousThinking = promptTurnRestore.originalThinking), prompt.thinking && previousThinking === void 0 && prompt.thinking !== promptTurnRestore.originalThinking && (previousThinking = promptTurnRestore.originalThinking);
+    }
+    let startId = ctx.sessionManager.getLeafId(), effectiveContent = combinedTaskPreamble ? `${combinedTaskPreamble}
+
+${prepared.content}` : prepared.content, content = loopContext ? `[${loopContext}]
+
+${effectiveContent}` : effectiveContent;
+    pi.sendUserMessage(content), await waitForTurnStart(ctx), await ctx.waitForIdle();
+    let entries = getIterationEntries(ctx, startId);
+    return wasIterationAborted(entries) ? "aborted" : { changed: didIterationMakeChanges(entries) };
+  }
+  async function restoreSessionState(ctx, originalModel, originalThinking, currentModel, currentThinking) {
+    let restoredParts = [], shouldRestoreThinking = originalThinking !== void 0 && (currentThinking === void 0 || currentThinking !== originalThinking);
+    originalModel && !sameModel2(originalModel, currentModel) && (await pi.setModel(originalModel) ? (runtimeModel = originalModel, restoredParts.push(originalModel.id)) : notify(ctx, `Failed to restore model ${originalModel.provider}/${originalModel.id}`, "error")), shouldRestoreThinking && (restoredParts.push(`thinking:${originalThinking}`), pi.setThinkingLevel(originalThinking)), restoredParts.length > 0 && notify(ctx, `Restored to ${restoredParts.join(", ")}`, "info");
+  }
+  async function restoreAfterExecution(ctx, shouldRestore, originalModel, originalThinking, currentModel, currentThinking, errorState, phase) {
+    if (!shouldRestore)
+      return errorState;
+    try {
+      await restoreSessionState(ctx, originalModel, originalThinking, currentModel, currentThinking);
+    } catch (error) {
+      return errorState.hasError ? (notify(ctx, `Failed to restore session state after ${phase} error: ${error instanceof Error ? error.message : String(error)}`, "error"), errorState) : { hasError: !0, error };
+    }
+    return errorState;
+  }
+  function notifyLoopCompletion(ctx, completedIterations, totalIterations, effectiveMax, converged, requireMultipleIterations) {
+    if (converged) {
+      let convergedLabel = totalIterations !== null ? `${completedIterations}/${totalIterations}` : `${completedIterations}`;
+      notify(ctx, `Loop converged at ${convergedLabel} (no changes)`, "info");
+      return;
+    }
+    if (completedIterations !== 0 && !(requireMultipleIterations && effectiveMax <= 1)) {
+      if (totalIterations !== null) {
+        notify(ctx, `Loop finished: ${completedIterations}/${totalIterations} iterations`, "info");
+        return;
+      }
+      if (completedIterations === effectiveMax) {
+        notify(ctx, `Loop finished: ${completedIterations} iterations (cap reached)`, "info");
+        return;
+      }
+      notify(ctx, `Loop finished: ${completedIterations} iterations`, "info");
+    }
+  }
+  function updateLoopStatus(ctx) {
+    if (ctx.hasUI)
+      if (loopState) {
+        let suffix = loopState.rotationLabel ? ` \xB7 ${loopState.rotationLabel}` : "", label = loopState.totalIterations !== null ? `loop ${loopState.currentIteration}/${loopState.totalIterations}${suffix}` : `loop ${loopState.currentIteration}${suffix}`;
+        ctx.ui.setStatus("prompt-loop", ctx.ui.theme.fg("warning", label));
+      } else
+        ctx.ui.setStatus("prompt-loop", void 0);
+  }
+  async function executeToolCommand(command, ctx) {
+    let stripped = command.startsWith("/") ? command.slice(1) : command, spaceIdx = stripped.indexOf(" "), name = spaceIdx >= 0 ? stripped.slice(0, spaceIdx) : stripped, args = spaceIdx >= 0 ? stripped.slice(spaceIdx + 1) : "";
+    name === "chain-prompts" ? await runChainCommand(args, ctx) : await runPromptCommand(name, args, ctx);
+  }
+  function cloneLineup(slots) {
+    return slots?.map((slot) => ({ ...slot }));
+  }
+  function expandLineupCounts(slots) {
+    let expanded = [];
+    for (let slot of slots) {
+      let { count, ...concreteSlot } = slot;
+      for (let index = 0; index < (count ?? 1); index++)
+        expanded.push({ ...concreteSlot });
+    }
+    return expanded;
+  }
+  function applyLineupActions(defaultSlots, actions, target) {
+    let lineup = cloneLineup(defaultSlots);
+    for (let action of actions) {
+      if (action.target !== target)
+        continue;
+      let incoming = action.slots.map((slot) => ({ ...slot }));
+      lineup = action.mode === "replace" ? incoming : [...lineup ?? [], ...incoming];
+    }
+    return lineup;
+  }
+  function applyFinalApplierAction(defaultSlot, actions) {
+    let slot = defaultSlot ? { ...defaultSlot } : void 0;
+    for (let action of actions)
+      action.target === "finalApplier" && (slot = action.slots[0] ? { ...action.slots[0] } : void 0);
+    return slot;
+  }
+  async function resolveCompareBaseModel(prompt, currentModel, ctx, modelOverride) {
+    let requestedModels = modelOverride ? [modelOverride] : prompt.models;
+    if (requestedModels.length > 0) {
+      let selected = await selectModelCandidate(requestedModels, currentModel, ctx.modelRegistry);
+      if (!selected) {
+        notify(ctx, `No available model from: ${requestedModels.join(", ")}`, "error");
+        return;
+      }
+      return selected.model;
+    }
+    if (currentModel)
+      return currentModel;
+    notify(ctx, `Prompt \`${prompt.name}\` requires an active model or a runtime --model override.`, "error");
+  }
+  function resolveCompareCwd(raw, ctx) {
+    return expandCwdPath(raw) ?? resolvePath(ctx.cwd, raw);
+  }
+  function normalizeLineupCwds(slots, defaultCwd, ctx) {
+    let normalized = [];
+    for (let slot of slots) {
+      let slotCwd = slot.cwd ? resolveCompareCwd(slot.cwd, ctx) : defaultCwd;
+      if (!existsSync4(slotCwd)) {
+        notify(ctx, `cwd directory does not exist: ${slotCwd}`, "error");
+        return;
+      }
+      normalized.push({
+        ...slot,
+        cwd: slotCwd
+      });
+    }
+    return normalized;
+  }
+  function formatCompareSlotLabel(slot, fallbackAgent) {
+    return slot.model ? `${fallbackAgent}, ${slot.model}` : fallbackAgent;
+  }
+  function renderComparePhaseResults(label, entries) {
+    return entries.map(({ index, slot, result }) => {
+      let body = result.text || "(no assistant text)";
+      return `=== ${label} ${index + 1} (${formatCompareSlotLabel(slot, result.agent)}) ===
+${body}`;
+    }).join(`
+
+`);
+  }
+  function formatPhaseFailureSummary(label, entries) {
+    if (entries.length !== 0)
+      return [
+        `[${label} failures]`,
+        ...entries.map(({ index, slot, result }) => `- ${label} ${index + 1} (${formatCompareSlotLabel(slot, result.agent)}): ${result.errorText || "unknown delegated error"}`)
+      ].join(`
+`);
+  }
+  function extractSuccessfulWorktreeChanges(aggregateText, successfulIndexes) {
+    if (!aggregateText)
+      return;
+    let marker = "=== Worktree Changes ===", markerIndex = aggregateText.indexOf(marker);
+    if (markerIndex < 0)
+      return;
+    let worktreeText = aggregateText.slice(markerIndex + marker.length).trim();
+    if (!worktreeText)
+      return;
+    let successfulTaskNumbers = new Set(successfulIndexes.map((index) => index + 1)), sections = worktreeText.split(/\n(?=--- Task \d+ \()/).map((section) => section.trim()).filter(Boolean).filter((section) => {
+      let match = section.match(/^--- Task (\d+) \(/);
+      return match ? successfulTaskNumbers.has(parseInt(match[1], 10)) : !1;
+    });
+    if (sections.length !== 0)
+      return `${marker}
+
+${sections.join(`
+
+`)}`;
+  }
+  function buildReviewerPreamble(sharedTask, workerAggregation, workerFailureSummary) {
+    return [
+      "[Original implementation task]",
+      sharedTask,
+      "",
+      "[Worker outputs and worktree summaries]",
+      workerAggregation,
+      ...workerFailureSummary ? ["", workerFailureSummary] : []
+    ].join(`
+`);
+  }
+  function buildFinalApplierPreamble(sharedTask, workerAggregation, workerFailureSummary, reviewerAggregation, reviewerFailureSummary) {
+    return [
+      "[Original implementation task]",
+      sharedTask,
+      "",
+      "[Worker outputs and worktree summaries]",
+      workerAggregation,
+      ...workerFailureSummary ? ["", workerFailureSummary] : [],
+      "",
+      "[Reviewer findings]",
+      reviewerAggregation ?? "All reviewer runs failed. Synthesize directly from the worker variants.",
+      ...reviewerFailureSummary ? ["", reviewerFailureSummary] : [],
+      "",
+      "[Final apply instructions]",
+      "Pick one winner or synthesize/cherry-pick from multiple variants, apply the final patch directly in the current repo, keep edits minimal, run obvious relevant verification when practical, and report changed files plus verification run."
+    ].join(`
+`);
+  }
+  function buildLineupSlotTask(baseTask, slot, taskArgs) {
+    let effectiveBaseTask = slot.task ? substituteArgs(slot.task, taskArgs) : baseTask;
+    return slot.taskSuffix ? `${effectiveBaseTask}
+
+${substituteArgs(slot.taskSuffix, taskArgs)}` : effectiveBaseTask;
+  }
+  function buildComparePrompt(base, options) {
+    return {
+      ...base,
+      name: options.name,
+      content: options.task,
+      models: options.model ? [options.model] : [],
+      chain: void 0,
+      chainContext: void 0,
+      parallel: void 0,
+      worktree: void 0,
+      subagent: options.agent,
+      inheritContext: options.inheritContext ? !0 : void 0,
+      cwd: options.cwd,
+      workers: void 0,
+      reviewers: void 0,
+      finalApplier: void 0
+    };
+  }
+  async function runComparePrompt(name, prompt, args, ctx, currentModel, runtime) {
+    runtime.subagentOverride && notify(ctx, "--subagent is not supported for compare prompts (ignored)", "warning"), runtime.fork && notify(ctx, "--fork is not supported for compare prompts (ignored)", "warning");
+    let lineupExtraction = extractLineupOverrides(args);
+    if (lineupExtraction.errors.length > 0) {
+      for (let error of lineupExtraction.errors)
+        notify(ctx, error, "error");
+      return;
+    }
+    let taskArgs = parseCommandArgs(lineupExtraction.args), compareCwd = runtime.cwd ?? prompt.cwd ?? ctx.cwd;
+    if (name === "parallel-patch-compare-at-path") {
+      if (taskArgs.length === 0) {
+        notify(ctx, "parallel-patch-compare-at-path requires a repo path as the first argument.", "error");
+        return;
+      }
+      if (runtime.cwd && notify(ctx, "--cwd is ignored for parallel-patch-compare-at-path (using first positional path).", "warning"), compareCwd = resolveCompareCwd(taskArgs[0], ctx), taskArgs = taskArgs.slice(1), taskArgs.length === 0) {
+        notify(ctx, "parallel-patch-compare-at-path requires an implementation task after the repo path.", "error");
+        return;
+      }
+    }
+    if (!existsSync4(compareCwd)) {
+      notify(ctx, `cwd directory does not exist: ${compareCwd}`, "error");
+      return;
+    }
+    let baseModel = await resolveCompareBaseModel(prompt, currentModel, ctx, runtime.model);
+    if (!baseModel)
+      return;
+    let rendered = renderPromptForResolvedModel(prompt, taskArgs, baseModel);
+    if (rendered.warning && notify(ctx, rendered.warning, "warning"), rendered.empty || !rendered.content) {
+      notify(ctx, rendered.empty ?? `Prompt \`${prompt.name}\` rendered to an empty message.`, "error");
+      return;
+    }
+    let sharedTask = rendered.content, requestedWorkers = applyLineupActions(prompt.workers, lineupExtraction.actions, "workers") ?? [], requestedReviewers = applyLineupActions(prompt.reviewers, lineupExtraction.actions, "reviewers") ?? [], requestedFinalApplier = applyFinalApplierAction(prompt.finalApplier, lineupExtraction.actions);
+    if (requestedFinalApplier && prompt.worktree !== !0) {
+      notify(ctx, "Compare prompts with finalApplier require worktree: true.", "error");
+      return;
+    }
+    let workerSlots = expandLineupCounts(requestedWorkers.length > 0 ? requestedWorkers : [{ agent: DEFAULT_SUBAGENT_NAME }]), reviewerSlots = expandLineupCounts(requestedReviewers.length > 0 ? requestedReviewers : [{ agent: "reviewer" }]), normalizedWorkers = normalizeLineupCwds(workerSlots, compareCwd, ctx);
+    if (!normalizedWorkers)
+      return;
+    let normalizedReviewers = normalizeLineupCwds(reviewerSlots, compareCwd, ctx);
+    if (!normalizedReviewers)
+      return;
+    let normalizedFinalApplier = requestedFinalApplier ? {
+      ...requestedFinalApplier,
+      cwd: compareCwd
+    } : void 0;
+    if (prompt.worktree === !0 && new Set(normalizedWorkers.map((slot) => slot.cwd)).size > 1) {
+      notify(ctx, "worktree compare runs require all worker slots to use the same cwd.", "error");
+      return;
+    }
+    try {
+      let workerResult = await executeSubagentPromptStep({
+        pi,
+        ctx,
+        currentModel: baseModel,
+        signal: ctx.signal,
+        worktree: prompt.worktree === !0,
+        allowPartialFailures: !0,
+        parallel: normalizedWorkers.map((slot, index) => ({
+          prompt: buildComparePrompt(prompt, {
+            name: `${prompt.name}-worker-${index + 1}`,
+            agent: slot.agent,
+            task: buildLineupSlotTask(sharedTask, slot, taskArgs),
+            model: slot.model,
+            cwd: slot.cwd,
+            inheritContext: !0
+          }),
+          args: []
+        }))
+      }), workerPairs = (workerResult?.parallelResults ?? []).map((result, index) => ({
+        index,
+        slot: normalizedWorkers[index],
+        result
+      }));
+      if (workerPairs.length === 0)
+        return;
+      let successfulWorkers = workerPairs.filter((entry) => !entry.result.isError), failedWorkers = workerPairs.filter((entry) => entry.result.isError);
+      if (successfulWorkers.length === 0) {
+        notify(ctx, "Compare worker phase failed: all worker slots failed.", "error");
+        return;
+      }
+      let successfulWorkerText = [
+        renderComparePhaseResults("Worker", successfulWorkers),
+        extractSuccessfulWorktreeChanges(workerResult.text, successfulWorkers.map((entry) => entry.index))
+      ].filter((value) => !!value).join(`
+
+`), workerFailureSummary = formatPhaseFailureSummary("Worker", failedWorkers), reviewerPreamble = buildReviewerPreamble(sharedTask, successfulWorkerText, workerFailureSummary), reviewerPairs = ((await executeSubagentPromptStep({
+        pi,
+        ctx,
+        currentModel: baseModel,
+        signal: ctx.signal,
+        taskPreamble: reviewerPreamble,
+        allowPartialFailures: !0,
+        parallel: normalizedReviewers.map((slot, index) => ({
+          prompt: buildComparePrompt(prompt, {
+            name: `${prompt.name}-reviewer-${index + 1}`,
+            agent: slot.agent,
+            task: buildLineupSlotTask(DEFAULT_COMPARE_REVIEWER_TASK, slot, taskArgs),
+            model: slot.model,
+            cwd: slot.cwd,
+            inheritContext: !1
+          }),
+          args: []
+        }))
+      }))?.parallelResults ?? []).map((result, index) => ({
+        index,
+        slot: normalizedReviewers[index],
+        result
+      }));
+      if (reviewerPairs.length === 0)
+        return;
+      let successfulReviewers = reviewerPairs.filter((entry) => !entry.result.isError), failedReviewers = reviewerPairs.filter((entry) => entry.result.isError), successfulReviewerText = successfulReviewers.length > 0 ? renderComparePhaseResults("Reviewer", successfulReviewers) : void 0, reviewerFailureSummary = formatPhaseFailureSummary("Reviewer", failedReviewers);
+      if (!normalizedFinalApplier) {
+        if (!successfulReviewerText) {
+          notify(ctx, "Compare reviewer phase failed: all reviewer slots failed.", "error");
+          return;
+        }
+        let finalText = reviewerFailureSummary ? `${successfulReviewerText}
+
+${reviewerFailureSummary}` : successfulReviewerText;
+        pi.sendUserMessage(`[Compare review complete: ${name}]
+
+${finalText}`), await waitForTurnStart(ctx), await ctx.waitForIdle();
+        return;
+      }
+      let finalResult = await executeSubagentPromptStep({
+        pi,
+        ctx,
+        currentModel: baseModel,
+        signal: ctx.signal,
+        taskPreamble: buildFinalApplierPreamble(sharedTask, successfulWorkerText, workerFailureSummary, successfulReviewerText, reviewerFailureSummary),
+        prompt: buildComparePrompt(prompt, {
+          name: `${prompt.name}-final-applier`,
+          agent: normalizedFinalApplier.agent,
+          task: buildLineupSlotTask(DEFAULT_COMPARE_FINAL_APPLIER_TASK, normalizedFinalApplier, taskArgs),
+          model: normalizedFinalApplier.model,
+          cwd: compareCwd,
+          inheritContext: !1
+        }),
+        args: []
+      });
+      if (!finalResult?.text)
+        return;
+      pi.sendUserMessage(`[Compare apply complete: ${name}]
+
+${finalResult.text}`), await waitForTurnStart(ctx), await ctx.waitForIdle();
+    } catch (error) {
+      notify(ctx, error instanceof Error ? error.message : String(error), "error");
+    }
+  }
+  async function collapseBoomerangPrompt(ctx, name, targetId, previousSummaries = []) {
+    if (!targetId) {
+      notify(ctx, `Cannot boomerang prompt \`${name}\`: no session entry to return to.`, "warning");
+      return;
+    }
+    boomerangCollapse = { targetId, task: name, previousSummaries };
+    try {
+      globalThis.__boomerangCollapseInProgress = !0, (await ctx.navigateTree(targetId, { summarize: !0 })).cancelled && notify(ctx, `Boomerang cancelled for prompt \`${name}\``, "warning");
+    } finally {
+      globalThis.__boomerangCollapseInProgress = !1, boomerangCollapse = null;
+    }
+  }
+  async function runPromptLoop(name, cleanedArgs, totalIterations, freshFlag, converge, ctx, subagentOverride, cwdOverride, promptOverrides) {
+    refreshPrompts(ctx.cwd, ctx);
+    let initialPrompt = prompts.get(name);
+    if (!initialPrompt) {
+      notify(ctx, `Prompt "${name}" no longer exists`, "error");
+      return;
+    }
+    let savedModel = getCurrentModel(ctx), savedThinking = pi.getThinkingLevel(), currentModel = savedModel, currentThinking = savedThinking, shouldRestore = initialPrompt.restore, useFresh = freshFlag || initialPrompt.fresh === !0, shouldBoomerang = initialPrompt.boomerang === !0, effectiveMax = totalIterations ?? UNLIMITED_LOOP_CAP, isUnlimited = totalIterations === null, useConverge = converge && initialPrompt.converge !== !1, anchorId = useFresh || shouldBoomerang ? ctx.sessionManager.getLeafId() : null;
+    loopState = { currentIteration: 1, totalIterations }, accumulatedSummaries = [], updateLoopStatus(ctx);
+    let completedIterations = 0, converged = !1, loopErrorState = { hasError: !1, error: void 0 }, lastDelegatedText, loopAborted = !1, boomerangPreviousSummaries = [];
+    try {
+      for (let i = 0; i < effectiveMax; i++) {
+        loopState.currentIteration = i + 1;
+        let iterationLabel = totalIterations !== null ? `${i + 1}/${totalIterations}` : `${i + 1}`;
+        refreshPrompts(ctx.cwd, ctx);
+        let prompt = prompts.get(name);
+        if (!prompt) {
+          notify(ctx, `Prompt "${name}" no longer exists`, "error"), loopAborted = !0;
+          break;
+        }
+        let effectivePrompt = { ...prompt, ...cwdOverride ? { cwd: cwdOverride } : {}, ...promptOverrides }, iterationPrompt = effectivePrompt;
+        if (loopState.rotationLabel = void 0, effectivePrompt.rotate && effectivePrompt.models.length > 1) {
+          let rotationIndex = i % effectivePrompt.models.length, rotatedThinking = effectivePrompt.thinkingLevels ? effectivePrompt.thinkingLevels[rotationIndex] : effectivePrompt.thinking;
+          iterationPrompt = {
+            ...effectivePrompt,
+            models: [effectivePrompt.models[rotationIndex]],
+            thinking: rotatedThinking
+          };
+          let shortModel = effectivePrompt.models[rotationIndex].split("/").pop() || effectivePrompt.models[rotationIndex], thinkingLabel = rotatedThinking ? ` ${rotatedThinking}` : "";
+          loopState.rotationLabel = `${shortModel}${thinkingLabel}`;
+        }
+        updateLoopStatus(ctx);
+        let rotationSuffix = loopState.rotationLabel ? ` [${loopState.rotationLabel}]` : "";
+        notify(ctx, `Loop ${iterationLabel}: ${name}${rotationSuffix}`, "info");
+        let loopContext = loopState.rotationLabel ? `Loop ${iterationLabel} \xB7 ${loopState.rotationLabel}` : `Loop ${iterationLabel}`, iterationStartId = ctx.sessionManager.getLeafId(), stepResult = await executePromptStep(iterationPrompt, parseCommandArgs(cleanedArgs), ctx, currentModel, subagentOverride, void 0, void 0, loopContext);
+        if (stepResult === "aborted") {
+          loopAborted = !0;
+          break;
+        }
+        let delegatedStep = shouldDelegatePrompt(iterationPrompt, subagentOverride);
+        delegatedStep && (lastDelegatedText = stepResult.text), currentModel = getCurrentModel(ctx), currentThinking = pi.getThinkingLevel(), completedIterations++;
+        let iterationChanged = delegatedStep ? stepResult.changed : didIterationMakeChanges(getIterationEntries(ctx, iterationStartId));
+        if (useConverge && (isUnlimited || effectiveMax > 1) && !iterationChanged) {
+          converged = !0;
+          break;
+        }
+        if (useFresh && anchorId && i < effectiveMax - 1) {
+          freshCollapse = { targetId: anchorId, task: name, iteration: i + 1, totalIterations };
+          let result = await ctx.navigateTree(anchorId, { summarize: !0 });
+          if (freshCollapse = null, result.cancelled) {
+            loopAborted = !0, notify(ctx, "Loop cancelled", "warning");
+            break;
+          }
+        }
+      }
+    } catch (error) {
+      loopErrorState = { hasError: !0, error };
+    } finally {
+      loopErrorState = await restoreAfterExecution(ctx, shouldRestore, savedModel, savedThinking, getCurrentModel(ctx), pi.getThinkingLevel(), loopErrorState, "loop"), boomerangPreviousSummaries = accumulatedSummaries, loopState = null, pendingSkillMessage = void 0, freshCollapse = null, boomerangCollapse = null, accumulatedSummaries = [], updateLoopStatus(ctx), loopErrorState.hasError || notifyLoopCompletion(ctx, completedIterations, totalIterations, effectiveMax, converged, !1);
+    }
+    if (lastDelegatedText && !loopErrorState.hasError && !loopAborted) {
+      let label = converged ? `Delegated loop converged after ${completedIterations} iteration(s): ${name}` : `Delegated loop completed ${completedIterations} iteration(s): ${name}`;
+      pi.sendUserMessage(`[${label}]
+
+${lastDelegatedText}`), await waitForTurnStart(ctx), await ctx.waitForIdle();
+    }
+    if (!loopErrorState.hasError && !loopAborted && shouldBoomerang && await collapseBoomerangPrompt(ctx, name, anchorId, boomerangPreviousSummaries), loopErrorState.hasError)
+      throw loopErrorState.error;
+  }
+  async function runSharedChainExecution(steps, sharedArgs, totalIterations, fresh, converge, shouldRestore, ctx, subagentOverride, cwdOverride, chainContextEnabled = !1, chainTemplateWorktree = !1, cliWorktree = !1) {
+    let worktreeEnabled = chainTemplateWorktree || cliWorktree;
+    worktreeEnabled && !steps.some(isParallelChainStep) && (notify(ctx, "--worktree ignored: chain has no parallel() steps", "warning"), worktreeEnabled = !1);
+    let flattenChainSteps = () => {
+      let flattened = [];
+      for (let step of steps)
+        isParallelChainStep(step) ? flattened.push(...step.parallel) : flattened.push(step);
+      return flattened;
+    }, validateChainSteps = () => {
+      let missingTemplates = flattenChainSteps().filter((step) => !chainPrompts.has(step.name));
+      if (missingTemplates.length > 0)
+        return notify(ctx, `Templates not found: ${missingTemplates.map((step) => step.name).join(", ")}`, "error"), !1;
+      for (let step of steps) {
+        if (isParallelChainStep(step)) {
+          for (let parallelStep of step.parallel) {
+            if (parallelStep.loopCount !== void 0)
+              return notify(ctx, `Step "${parallelStep.name}" in parallel() does not support per-task --loop.`, "error"), !1;
+            if (parallelStep.withContext === !0)
+              return notify(ctx, `Step "${parallelStep.name}" in parallel() does not support per-task --with-context.`, "error"), !1;
+            let stepPrompt2 = chainPrompts.get(parallelStep.name);
+            if (stepPrompt2) {
+              if (stepPrompt2.chain)
+                return notify(ctx, `Step "${parallelStep.name}" is a chain template. Chain nesting is not supported.`, "error"), !1;
+              if (!shouldDelegatePrompt(stepPrompt2, subagentOverride))
+                return notify(ctx, `Step "${parallelStep.name}" in parallel() must use delegated execution (subagent).`, "error"), !1;
+            }
+          }
+          continue;
+        }
+        let stepPrompt = chainPrompts.get(step.name);
+        if (stepPrompt && stepPrompt.chain)
+          return notify(ctx, `Step "${step.name}" is a chain template. Chain nesting is not supported.`, "error"), !1;
+      }
+      return !0;
+    };
+    if (!validateChainSteps())
+      return;
+    let originalModel = getCurrentModel(ctx), chainInheritedModel = originalModel, originalThinking = pi.getThinkingLevel(), currentModel = originalModel, currentThinking = originalThinking;
+    chainActive = !0, pendingSkillMessage = void 0;
+    let effectiveMax = totalIterations ?? UNLIMITED_LOOP_CAP, isUnlimited = totalIterations === null, useConverge = converge, anchorId = fresh ? ctx.sessionManager.getLeafId() : null, chainStepNames = steps.map((step) => isParallelChainStep(step) ? `parallel(${step.parallel.map((item) => item.name).join(", ")})` : step.name).join(" -> "), completedIterations = 0, converged = !1, chainErrorState = { hasError: !1, error: void 0 }, lastDelegatedText, chainAborted = !1;
+    effectiveMax > 1 && (loopState = { currentIteration: 1, totalIterations }, accumulatedSummaries = [], updateLoopStatus(ctx));
+    try {
+      for (let iteration = 0; iteration < effectiveMax; iteration++) {
+        if (effectiveMax > 1 && (loopState.currentIteration = iteration + 1, updateLoopStatus(ctx), refreshPrompts(ctx.cwd, ctx), !validateChainSteps())) {
+          chainAborted = !0;
+          break;
+        }
+        let templates = steps.map((step) => isParallelChainStep(step) ? {
+          kind: "parallel",
+          tasks: step.parallel.map((item) => ({
+            name: item.name,
+            args: item.args,
+            prompt: {
+              ...chainPrompts.get(item.name),
+              ...cwdOverride ? { cwd: cwdOverride } : {}
+            }
+          }))
+        } : {
+          kind: "single",
+          singleStep: {
+            prompt: {
+              ...chainPrompts.get(step.name),
+              ...cwdOverride ? { cwd: cwdOverride } : {}
+            },
+            stepArgs: step.args,
+            stepLoop: step.loopCount !== void 0 ? step.loopCount : 1,
+            stepWithContext: step.withContext === !0
+          }
+        }), chainStepSummaries = [], aborted = !1, iterationChanged = !1, loopPrefix = "";
+        effectiveMax > 1 && (loopPrefix = `Loop ${totalIterations !== null ? `${iteration + 1}/${totalIterations}` : `${iteration + 1}`}, `);
+        for (let [index, stepTemplate] of templates.entries()) {
+          let stepNumber = index + 1;
+          if (stepTemplate.kind === "parallel") {
+            let stepNames = stepTemplate.tasks.map((task) => task.name).join(", "), stepLabel = `parallel(${stepNames})`;
+            notify(ctx, `${loopPrefix}Step ${stepNumber}/${templates.length}: parallel(${stepNames})`, "info"), ctx.hasUI && ctx.ui.setStatus("prompt-chain", ctx.ui.theme.fg("warning", `step ${stepNumber}/${templates.length}: parallel(${stepNames})`));
+            let stepStartId2 = ctx.sessionManager.getLeafId(), taskPreamble, isForkedParallelContext = stepTemplate.tasks.some((task) => task.prompt.inheritContext === !0);
+            chainContextEnabled && !isForkedParallelContext && chainStepSummaries.length > 0 && (taskPreamble = `[Previous chain steps]
+
+${chainStepSummaries.join(`
+
+`)}`);
+            let delegated;
+            try {
+              delegated = await executeSubagentPromptStep({
+                pi,
+                ctx,
+                currentModel,
+                override: subagentOverride,
+                signal: ctx.signal,
+                inheritedModel: chainInheritedModel,
+                parallel: stepTemplate.tasks.map((task) => ({
+                  prompt: task.prompt,
+                  args: task.args.length > 0 ? task.args : sharedArgs
+                })),
+                taskPreamble,
+                worktree: worktreeEnabled
+              });
+            } catch (error) {
+              notify(ctx, error instanceof Error ? error.message : String(error), "error"), aborted = !0;
+              break;
+            }
+            if (!delegated) {
+              notify(ctx, "Parallel chain step was not delegated.", "error"), aborted = !0;
+              break;
+            }
+            lastDelegatedText = delegated.text, currentModel = getCurrentModel(ctx), currentThinking = pi.getThinkingLevel();
+            let stepEntries2 = getIterationEntries(ctx, stepStartId2);
+            delegated.changed && (iterationChanged = !0), chainStepSummaries.push(generateChainStepSummary(stepEntries2, stepLabel, stepNumber));
+            continue;
+          }
+          let singleStep = stepTemplate.singleStep, stepLoopTotal = singleStep.stepLoop, stepLoopMax = stepLoopTotal ?? UNLIMITED_LOOP_CAP, isStepLooping = stepLoopMax > 1, effectiveArgs = singleStep.stepArgs.length > 0 ? singleStep.stepArgs : sharedArgs, shouldInjectSummary = shouldDelegatePrompt(singleStep.prompt, subagentOverride) && singleStep.prompt.inheritContext !== !0 && (chainContextEnabled || singleStep.stepWithContext === !0), outerLoopState = loopState ? { ...loopState } : null, stepStartId = ctx.sessionManager.getLeafId();
+          isStepLooping && (loopState = { currentIteration: 1, totalIterations: stepLoopTotal }, updateLoopStatus(ctx));
+          try {
+            for (let stepIteration = 0; stepIteration < stepLoopMax; stepIteration++) {
+              isStepLooping && (loopState = { currentIteration: stepIteration + 1, totalIterations: stepLoopTotal }, updateLoopStatus(ctx));
+              let iterSuffix = isStepLooping ? stepLoopTotal !== null ? ` (iter ${stepIteration + 1}/${stepLoopTotal})` : ` (iter ${stepIteration + 1})` : "";
+              notify(ctx, `${loopPrefix}Step ${stepNumber}/${templates.length}: ${singleStep.prompt.name}${iterSuffix} ${buildPromptCommandDescription(singleStep.prompt)}`, "info"), ctx.hasUI && ctx.ui.setStatus("prompt-chain", ctx.ui.theme.fg("warning", `step ${stepNumber}/${templates.length}: ${singleStep.prompt.name}`));
+              let taskPreamble = shouldInjectSummary && chainStepSummaries.length > 0 ? `[Previous chain steps]
+
+${chainStepSummaries.join(`
+
+`)}` : void 0, stepLoopContext = isStepLooping ? `Step ${stepNumber}/${templates.length}: ${singleStep.prompt.name}${iterSuffix}` : void 0, stepIterationStartId = ctx.sessionManager.getLeafId(), stepResult = await executePromptStep(singleStep.prompt, effectiveArgs, ctx, currentModel, subagentOverride, chainInheritedModel, taskPreamble, stepLoopContext);
+              if (stepResult === "aborted") {
+                chainAborted = !0, aborted = !0;
+                break;
+              }
+              shouldDelegatePrompt(singleStep.prompt, subagentOverride) && (lastDelegatedText = stepResult.text), currentModel = getCurrentModel(ctx), currentThinking = pi.getThinkingLevel();
+              let stepIterationEntries = getIterationEntries(ctx, stepIterationStartId), stepIterationChanged = didIterationMakeChanges(stepIterationEntries);
+              if (isStepLooping && singleStep.prompt.converge !== !1 && !stepIterationChanged)
+                break;
+            }
+          } finally {
+            isStepLooping && (loopState = outerLoopState ? { ...outerLoopState } : null, updateLoopStatus(ctx));
+          }
+          if (aborted)
+            break;
+          let stepEntries = getIterationEntries(ctx, stepStartId);
+          didIterationMakeChanges(stepEntries) && (iterationChanged = !0), chainStepSummaries.push(generateChainStepSummary(stepEntries, singleStep.prompt.name, stepNumber));
+        }
+        if (aborted) {
+          chainAborted = !0;
+          break;
+        }
+        if (completedIterations++, useConverge && (isUnlimited || effectiveMax > 1) && !iterationChanged) {
+          converged = !0;
+          break;
+        }
+        if (anchorId && iteration < effectiveMax - 1) {
+          freshCollapse = { targetId: anchorId, task: chainStepNames, iteration: iteration + 1, totalIterations };
+          let result = await ctx.navigateTree(anchorId, { summarize: !0 });
+          if (freshCollapse = null, result.cancelled) {
+            chainAborted = !0, notify(ctx, "Loop cancelled", "warning");
+            break;
+          }
+        }
+      }
+    } catch (error) {
+      chainErrorState = { hasError: !0, error };
+    } finally {
+      chainErrorState = await restoreAfterExecution(ctx, shouldRestore, originalModel, originalThinking, getCurrentModel(ctx), pi.getThinkingLevel(), chainErrorState, "chain"), pendingSkillMessage = void 0, chainActive = !1, loopState = null, freshCollapse = null, boomerangCollapse = null, accumulatedSummaries = [], updateLoopStatus(ctx), ctx.hasUI && ctx.ui.setStatus("prompt-chain", void 0), chainErrorState.hasError || notifyLoopCompletion(ctx, completedIterations, totalIterations, effectiveMax, converged, !0);
+    }
+    if (lastDelegatedText && !chainErrorState.hasError && !chainAborted && (pi.sendUserMessage(`[Delegated chain complete: ${chainStepNames}]
+
+${lastDelegatedText}`), await waitForTurnStart(ctx), await ctx.waitForIdle()), chainErrorState.hasError)
+      throw chainErrorState.error;
+  }
+  async function runPromptCommand(name, args, ctx) {
+    storedCommandCtx = ctx, refreshPrompts(ctx.cwd, ctx);
+    let prompt = prompts.get(name);
+    if (!prompt) {
+      notify(ctx, `Prompt "${name}" no longer exists`, "error");
+      return;
+    }
+    let subagent = extractSubagentOverride(args), runtimeCwd = subagent.cwd ? expandCwdPath(subagent.cwd) : void 0;
+    if (subagent.cwd && !runtimeCwd) {
+      notify(ctx, "Invalid --cwd path: must be absolute", "error");
+      return;
+    }
+    let argsWithoutSubagent = subagent.args;
+    if (prompt.deterministic) {
+      if (subagent.override || subagent.fork) {
+        notify(ctx, "Deterministic prompts do not support runtime --subagent/--fork in v1", "error");
+        return;
+      }
+      if (extractLoopCount(argsWithoutSubagent)) {
+        notify(ctx, "Deterministic prompts do not support runtime --loop in v1", "error");
+        return;
+      }
+    }
+    if (prompt.workers !== void 0 || prompt.reviewers !== void 0 || prompt.finalApplier !== void 0) {
+      await runComparePrompt(name, prompt, argsWithoutSubagent, ctx, getCurrentModel(ctx), {
+        cwd: runtimeCwd,
+        model: subagent.model,
+        subagentOverride: subagent.override,
+        fork: subagent.fork
+      });
+      return;
+    }
+    if (prompt.chain) {
+      subagent.model && notify(ctx, "--model is not supported on chain prompts (ignored)", "warning"), subagent.fork && notify(ctx, "--fork is not supported on chain prompts (ignored)", "warning");
+      let worktreeExtraction = extractWorktreeFlag(argsWithoutSubagent), extracted = extractChainContextFlag(worktreeExtraction.args), chainContextEnabled = extracted.chainContext || prompt.chainContext === "summary", cliWorktree = worktreeExtraction.worktree, loop2 = extractLoopCount(extracted.args), totalIterations = prompt.loop !== void 0 ? prompt.loop : 1, fresh = !1, converge = !0, cleanedArgs = extracted.args;
+      if (loop2)
+        totalIterations = loop2.loopCount, fresh = loop2.fresh, converge = loop2.converge, cleanedArgs = loop2.args;
+      else if (prompt.loop !== void 0) {
+        let flags = extractLoopFlags(extracted.args);
+        fresh = flags.fresh, converge = flags.converge, cleanedArgs = flags.args;
+      }
+      let { steps, invalidSegments } = parseChainDeclaration(prompt.chain);
+      if (invalidSegments.length > 0) {
+        notify(ctx, `Invalid chain step: ${invalidSegments[0]}`, "error");
+        return;
+      }
+      if (steps.length === 0) {
+        notify(ctx, "No templates specified", "error");
+        return;
+      }
+      let cwdOverride = runtimeCwd ?? prompt.cwd;
+      await runSharedChainExecution(steps, parseCommandArgs(cleanedArgs), totalIterations, fresh || prompt.fresh === !0, converge && prompt.converge !== !1, prompt.restore, ctx, subagent.override, cwdOverride, chainContextEnabled, prompt.worktree === !0, cliWorktree);
+      return;
+    }
+    let promptOverrides = {
+      ...subagent.model ? { models: [subagent.model] } : {},
+      ...subagent.fork ? { inheritContext: !0 } : {}
+    }, loop = extractLoopCount(argsWithoutSubagent);
+    if (loop) {
+      await runPromptLoop(name, loop.args, loop.loopCount, loop.fresh, loop.converge, ctx, subagent.override, runtimeCwd, promptOverrides);
+      return;
+    }
+    if (prompt.loop !== void 0) {
+      let flags = extractLoopFlags(argsWithoutSubagent);
+      await runPromptLoop(name, flags.args, prompt.loop, flags.fresh, flags.converge, ctx, subagent.override, runtimeCwd, promptOverrides);
+      return;
+    }
+    let effectivePrompt = {
+      ...prompt,
+      ...runtimeCwd ? {
+        cwd: runtimeCwd,
+        ...prompt.deterministic ? { deterministic: { ...prompt.deterministic, cwd: runtimeCwd } } : {}
+      } : {},
+      ...promptOverrides
+    }, savedModel = getCurrentModel(ctx), savedThinking = pi.getThinkingLevel(), isDelegatedPrompt = shouldDelegatePrompt(effectivePrompt, subagent.override), promptTurnRestore = !isDelegatedPrompt && prompt.restore ? { originalModel: savedModel, originalThinking: savedThinking } : void 0, boomerangTargetId = effectivePrompt.boomerang ? ctx.sessionManager.getLeafId() : null, stepResult = await executePromptStep(effectivePrompt, parseCommandArgs(argsWithoutSubagent), ctx, savedModel, subagent.override, void 0, void 0, void 0, promptTurnRestore);
+    stepResult !== "aborted" && (isDelegatedPrompt && stepResult.text && (pi.sendUserMessage(`[Delegated result: ${name}]
+
+${stepResult.text}`), await waitForTurnStart(ctx), await ctx.waitForIdle()), effectivePrompt.boomerang && await collapseBoomerangPrompt(ctx, name, boomerangTargetId));
+  }
+  function resetSessionScopedState(ctx) {
+    storedCommandCtx = null, pendingSkillMessage = void 0, previousModel = void 0, previousThinking = void 0, runtimeModel = ctx.model, boomerangCollapse = null, toolManager.clearQueue(), refreshPrompts(ctx.cwd, ctx);
+  }
+  pi.on("session_start", async (_event, ctx) => {
+    resetSessionScopedState(ctx);
+  }), pi.on("model_select", async (event) => {
+    runtimeModel = event.model;
+  }), pi.on("before_agent_start", async (event) => {
+    let systemPrompt = event.systemPrompt;
+    if (toolManager.isEnabled() && !loopState && !chainActive) {
+      let toolGuidance = toolManager.getGuidance(), guidance = toolGuidance ? `The run-prompt tool is available for running prompt template commands. ${toolGuidance}` : "The run-prompt tool is available for running prompt template commands.";
+      systemPrompt += `
+
+${guidance}`;
+    }
+    if (loopState) {
+      let iterText = loopState.totalIterations !== null ? `iteration ${loopState.currentIteration} of ${loopState.totalIterations}` : `iteration ${loopState.currentIteration}`;
+      systemPrompt += `
+
+You are on ${iterText} of the same prompt. Previous iterations and their results are visible in the conversation above. Build on that work \u2014 focus on what remains to improve.`;
+    }
+    let skillMessage = consumePendingSkillMessage(), hasSystemPromptOverride = systemPrompt !== event.systemPrompt;
+    if (!(!hasSystemPromptOverride && !skillMessage))
+      return {
+        ...hasSystemPromptOverride ? { systemPrompt } : {},
+        ...skillMessage ? { message: skillMessage } : {}
+      };
+  }), pi.on("agent_end", async (_event, ctx) => {
+    if (chainActive || loopState)
+      return;
+    let restoreModel = previousModel, restoreThinking = previousThinking;
+    if (!restoreModel && restoreThinking === void 0 && !toolManager.hasQueuedCommand())
+      return;
+    runtimeModel = ctx.model, previousModel = void 0, previousThinking = void 0;
+    let restoreFn = async () => {
+      (restoreModel || restoreThinking !== void 0) && await restoreSessionState(ctx, restoreModel, restoreThinking, getCurrentModel(ctx), pi.getThinkingLevel());
+    };
+    await toolManager.processQueue(ctx, restoreFn) || await restoreFn();
+  }), pi.on("session_before_tree", async (event) => {
+    if (boomerangCollapse && event.preparation.targetId === boomerangCollapse.targetId) {
+      let summary2 = generateBoomerangSummary(event.preparation.entriesToSummarize, boomerangCollapse.task);
+      return {
+        summary: {
+          summary: [...boomerangCollapse.previousSummaries, summary2].join(`
+
+---
+
+`)
+        }
+      };
+    }
+    if (!freshCollapse || event.preparation.targetId !== freshCollapse.targetId)
+      return;
+    let summary = generateIterationSummary(event.preparation.entriesToSummarize, freshCollapse.task, freshCollapse.iteration, freshCollapse.totalIterations);
+    return accumulatedSummaries.push(summary), {
+      summary: {
+        summary: accumulatedSummaries.join(`
+
+---
+
+`)
+      }
+    };
+  });
+  async function runChainCommand(args, ctx) {
+    storedCommandCtx = ctx, refreshPrompts(ctx.cwd, ctx);
+    let subagent = extractSubagentOverride(args), runtimeCwd = subagent.cwd ? expandCwdPath(subagent.cwd) : void 0;
+    if (subagent.cwd && !runtimeCwd) {
+      notify(ctx, "Invalid --cwd path: must be absolute", "error");
+      return;
+    }
+    let worktreeExtraction = extractWorktreeFlag(subagent.args), extracted = extractChainContextFlag(worktreeExtraction.args), loop = extractLoopCount(extracted.args), cleanedArgs = loop ? loop.args : extracted.args, { steps, sharedArgs, invalidSegments } = parseChainSteps(cleanedArgs);
+    if (invalidSegments.length > 0) {
+      notify(ctx, `Invalid chain step: ${invalidSegments[0]}`, "error");
+      return;
+    }
+    if (steps.length === 0) {
+      notify(ctx, "No templates specified", "error");
+      return;
+    }
+    await runSharedChainExecution(steps, sharedArgs, loop ? loop.loopCount : 1, loop?.fresh === !0, loop?.converge ?? !0, !0, ctx, subagent.override, runtimeCwd, extracted.chainContext, !1, worktreeExtraction.worktree);
+  }
+  toolManager.isEnabled() && toolManager.ensureRegistered(), pi.registerCommand("chain-prompts", {
+    description: "Chain prompt templates sequentially [template -> template -> ...]",
+    handler: async (args, ctx) => {
+      await runChainCommand(args, ctx);
+    }
+  }), toolManager.registerCommand();
+}
+export {
+  promptModelExtension as default
+};