@wrongstack/tools 1.0.6 → 1.0.7

package/dist/{chunk-OVFQC6FU.js → chunk-4DK5WZGR.js}

@@ -1,6 +1,6 @@
 import {
   e2ePlanTool
-} from "./chunk-WKXL5XHU.js";
+} from "./chunk-BVHKBBGA.js";
 import {
   codebaseAstReplaceTool,
   codebaseContextTool,
@@ -15,31 +15,31 @@ import {
   codebaseStatsTool,
   codebaseTargetedTestTool,
   deadCodeScanTool
-} from "./chunk-CYPYJIAF.js";
+} from "./chunk-JB5JLY7V.js";
 import {
   designTool
 } from "./chunk-IXIS7RSG.js";
 import {
   planTool
-} from "./chunk-NKOTOW6X.js";
+} from "./chunk-O6AGFJBO.js";
 import {
   taskTool
-} from "./chunk-OZVGRDCM.js";
+} from "./chunk-B62LKMWQ.js";
 import {
   testTool
-} from "./chunk-S6E2AM4U.js";
+} from "./chunk-KF7GMVNU.js";
 import {
   installTool
-} from "./chunk-ZETZHHV5.js";
+} from "./chunk-H2VB7GCR.js";
 import {
   auditTool
-} from "./chunk-C64UUXTA.js";
+} from "./chunk-HCPSVK7J.js";
 import {
   outdatedTool
-} from "./chunk-YJQQ5F5J.js";
+} from "./chunk-NL45OWEO.js";
 import {
   logsTool
-} from "./chunk-2ZWQIVEW.js";
+} from "./chunk-CAF4L6KN.js";
 import {
   toolSearchTool
 } from "./chunk-YA2ZYCJY.js";
@@ -48,52 +48,52 @@ import {
 } from "./chunk-B3MGJBFI.js";
 import {
   gitTool
-} from "./chunk-2IC5FRD7.js";
+} from "./chunk-ZMCV3XOV.js";
 import {
   patchTool
-} from "./chunk-7EQ2LUXU.js";
+} from "./chunk-5MP76C72.js";
 import {
   jsonTool
-} from "./chunk-MG7CUN6R.js";
+} from "./chunk-EGT5QLCB.js";
 import {
   diffTool
-} from "./chunk-BU6VUXWG.js";
+} from "./chunk-N3OTTQNC.js";
 import {
   treeTool
-} from "./chunk-3F7HQ3KS.js";
+} from "./chunk-YZQSUL5G.js";
 import {
   lintTool
-} from "./chunk-R36RWYXE.js";
+} from "./chunk-R3HIZVFS.js";
 import {
   formatTool
-} from "./chunk-OBVXDVLE.js";
+} from "./chunk-QJARSK2G.js";
 import {
   typecheckTool
-} from "./chunk-D4HWMWGE.js";
+} from "./chunk-AH7J5HWL.js";
 import {
   languageInfoTool,
   languagePackageTool,
   languageTool
-} from "./chunk-JK5WXW4S.js";
+} from "./chunk-SEONDNLN.js";
 import {
   replaceTool
-} from "./chunk-IOOFLBVM.js";
+} from "./chunk-KMXPP32M.js";
 import {
   globTool
-} from "./chunk-IMIHTHF7.js";
+} from "./chunk-JKFIDWQG.js";
 import {
   grepTool
-} from "./chunk-ZSW5KO5S.js";
+} from "./chunk-2W4XTULI.js";
 import {
   bashTool,
   checkAndBlockKillCommand,
   diagnoseBashism,
   shellArgs
-} from "./chunk-4KI4HHID.js";
+} from "./chunk-CLJXKFVS.js";
 import {
   detectDanger,
   execTool
-} from "./chunk-YILT3CSO.js";
+} from "./chunk-A3LNNBYO.js";
 import {
   buildChildEnv
 } from "./chunk-BTSFTGIL.js";
@@ -107,7 +107,7 @@ import {
 } from "./chunk-HDYUBRMF.js";
 import {
   fetchTool
-} from "./chunk-47GYABZW.js";
+} from "./chunk-4SW6BXUR.js";
 import {
   searchTool
 } from "./chunk-62OAECEQ.js";
@@ -116,22 +116,22 @@ import {
 } from "./chunk-NBDZMMG2.js";
 import {
   todoTool
-} from "./chunk-TGVQMKVH.js";
+} from "./chunk-S6CGSFLX.js";
 import {
   kanbanTool
-} from "./chunk-5UA4TNJJ.js";
+} from "./chunk-2NTHMZV3.js";
 import {
   browserTools
 } from "./chunk-6XYFYLN7.js";
 import {
   readTool
-} from "./chunk-K7Y2IWEB.js";
+} from "./chunk-HIRVCXLP.js";
 import {
   writeTool
-} from "./chunk-TL5T4A4E.js";
+} from "./chunk-GF4JHLCO.js";
 import {
   editTool
-} from "./chunk-G35NLPG5.js";
+} from "./chunk-WKLUOXR4.js";
 import {
   resolvePowerShell
 } from "./chunk-5U5ULQX2.js";
@@ -139,9 +139,10 @@ import {
   normalizeCommandOutput,
   safeResolveProjectPath,
   safeResolveReal
-} from "./chunk-HKR56VNF.js";
+} from "./chunk-2IAEJRLT.js";
 
 // src/clarify.ts
+import { randomUUID } from "node:crypto";
 import { toErrorMessage } from "@wrongstack/core/utils";
 var clarifyTool = {
   name: "clarify",
@@ -149,62 +150,42 @@ var clarifyTool = {
   icon: "meta",
   permission: "auto",
   mutating: false,
-  description: "Ask the user structured multiple-choice clarification question(s) when an architectural, database schema, API, or domain decision has mutually exclusive trade-offs. Supports single or batch questions, recommended defaults, multi-select, and custom write-in responses across TUI, CLI, and WebUI.",
-  usageHint: 'Use when requirements are ambiguous or have critical trade-offs.\n- Single question: pass `question` and `options` (min 2).\n- Multiple questions: pass `questions: [{ question, options, recommendedOption? }]`.\n- Format options as clear user decisions. Prefix best practice choices with "(Recommended)".\n- Autonomous fallback: if running headless without an interactive UI, the recommended option is automatically selected.',
+  description: "Pause and ask the user for required decisions in one structured, tabbed form. Supports single-select, multi-select, free text, option descriptions, write-ins, and explicitly recommended answers. Submit returns all answers to the model at once.",
+  usageHint: 'Prefer `tabs` with stable snake_case ids. Every decision should include a recommended answer and a short recommendationReason. Use `type: "text"` for free-form input. Bounds: 1-8 tabs, 1-12 questions per tab, and 2-8 labeled options per select question. Blank questions, empty tabs, and description-only options are invalid by design. `type` is canonical; legacy isMultiSelect flags may be used only when they do not conflict. Legacy `question`/`questions` inputs remain supported.',
   inputSchema: {
     type: "object",
     properties: {
-      question: {
-        type: "string",
-        description: "The specific architectural, schema, or contract decision to clarify."
-      },
-      context: {
-        type: "string",
-        description: "Brief explanation of tradeoffs or why this decision is needed."
-      },
-      options: {
-        type: "array",
-        items: { type: "string" },
-        description: "2 to 6 distinct options formatted as clear user decisions.",
-        minItems: 2,
-        maxItems: 6
-      },
-      recommendedOption: {
-        type: "string",
-        description: "The assistant-recommended default choice."
-      },
-      isMultiSelect: {
-        type: "boolean",
-        description: "Whether multiple options can be chosen simultaneously."
-      },
-      is_multi_select: {
-        type: "boolean",
-        description: "Snake-case alias for isMultiSelect."
-      },
-      allowCustomResponse: {
-        type: "boolean",
-        description: "Whether to allow the user to type a custom write-in response (default: true)."
-      },
-      questions: {
+      title: { type: "string", description: "Short form title." },
+      description: { type: "string", description: "Why these answers are needed." },
+      submitLabel: { type: "string", description: "Submit button label." },
+      question: { type: "string", minLength: 1 },
+      context: { type: "string" },
+      type: { type: "string", enum: ["single_select", "multi_select", "text"] },
+      options: optionArraySchema(),
+      recommendedOption: { type: "string" },
+      recommendedOptions: { type: "array", items: { type: "string" } },
+      recommendedText: { type: "string" },
+      recommendationReason: { type: "string" },
+      isMultiSelect: { type: "boolean" },
+      is_multi_select: { type: "boolean" },
+      allowCustomResponse: { type: "boolean" },
+      required: { type: "boolean" },
+      placeholder: { type: "string" },
+      questions: { type: "array", minItems: 1, items: questionSchema() },
+      tabs: {
         type: "array",
-        description: "List of questions for batch clarification (Antigravity ask_question parity).",
+        minItems: 1,
+        maxItems: 8,
         items: {
           type: "object",
           properties: {
-            question: { type: "string" },
-            context: { type: "string" },
-            options: {
-              type: "array",
-              items: { type: "string" },
-              minItems: 2,
-              maxItems: 6
-            },
-            recommendedOption: { type: "string" },
-            isMultiSelect: { type: "boolean" },
-            is_multi_select: { type: "boolean" },
-            allowCustomResponse: { type: "boolean" }
+            id: { type: "string" },
+            label: { type: "string", minLength: 1 },
+            description: { type: "string" },
+            questions: { type: "array", minItems: 1, maxItems: 12, items: questionSchema() }
           },
-          required: ["question", "options"]
+          required: ["label", "questions"],
+          additionalProperties: false
         }
       }
     },
@@ -212,84 +193,298 @@ var clarifyTool = {
   },
   async execute(input, ctx, opts) {
     try {
-      const signal = opts?.signal ?? ctx?.signal;
-      signal?.throwIfAborted();
-      const items = [];
-      if (Array.isArray(input.questions) && input.questions.length > 0) {
-        items.push(...input.questions);
-      } else if (input.question && Array.isArray(input.options)) {
-        items.push({
-          question: input.question,
-          context: input.context,
-          options: input.options,
-          recommendedOption: input.recommendedOption,
-          isMultiSelect: input.isMultiSelect ?? input.is_multi_select,
-          allowCustomResponse: input.allowCustomResponse
-        });
-      }
-      if (items.length === 0) {
-        throw new Error("clarify requires either `question` with `options`, or a `questions` array with at least 1 item.");
-      }
-      for (const item of items) {
-        if (!item.options || item.options.length < 2) {
-          throw new Error(`clarify question "${item.question}" requires at least 2 distinct options.`);
-        }
-      }
-      const hostAsk = ctx?.askUserChoices;
-      const answers = [];
-      let isAutoDecided = false;
-      for (const item of items) {
-        const multi = item.isMultiSelect ?? item.is_multi_select ?? false;
-        const options = item.options;
-        if (typeof hostAsk === "function") {
-          const res = await hostAsk(item.question, options, {
-            isMultiSelect: multi,
-            ...item.context === void 0 ? {} : { context: item.context },
-            ...item.recommendedOption === void 0 ? {} : { recommendedOption: item.recommendedOption },
-            allowCustomResponse: item.allowCustomResponse ?? true
-          });
-          const selected = Array.isArray(res?.selected) ? res.selected : [];
-          answers.push({
-            question: item.question,
-            selectedOptions: selected,
-            customResponse: res?.custom
-          });
-        } else {
-          isAutoDecided = true;
-          const rec = item.recommendedOption ?? options.find((opt) => /^\(?recommended\)?/i.test(opt)) ?? options[0] ?? "Default";
-          answers.push({
-            question: item.question,
-            selectedOptions: [rec],
-            customResponse: void 0
-          });
-        }
-      }
+      const signal = opts?.signal ?? ctx.signal;
+      signal.throwIfAborted();
+      const request = normalizeRequest(input);
+      let response;
+      if (typeof ctx.requestUserInput === "function")
+        response = await ctx.requestUserInput(request, signal);
+      else response = await legacyHostResponse(ctx, request);
+      const autoDecided = response === void 0;
+      const resolved = response ?? recommendedResponse(request);
+      if (resolved.status === "cancelled")
+        return skipped(request, "User cancelled the clarification form.");
+      const answers = materializeAnswers(request, resolved.answers);
       const primary = answers[0];
-      const summaries = answers.map((ans) => {
-        const customPart = ans.customResponse ? ` (Custom: "${ans.customResponse}")` : "";
-        return `"${ans.question}": ${ans.selectedOptions.join(", ")}${customPart}`;
-      });
-      const decisionSummary = isAutoDecided ? `Auto-selected recommended option(s) in non-interactive mode: ${summaries.join("; ")}` : `User clarified: ${summaries.join("; ")}`;
+      const decisionSummary = `${autoDecided ? "Auto-selected recommended answers in non-interactive mode" : "User clarified"}: ${answers.map((answer) => {
+        if (answer.delegatedToModel)
+          return `"${answer.question}": model should decide (user delegated)`;
+        const values = [
+          ...answer.selectedOptions,
+          ...answer.customResponse ? [answer.customResponse] : []
+        ];
+        return `"${answer.question}": ${values.join(", ") || "(blank)"}`;
+      }).join("; ")}`;
       return {
-        status: isAutoDecided ? "auto_decided" : "answered",
+        status: autoDecided ? "auto_decided" : "answered",
         question: primary.question,
         selectedOptions: primary.selectedOptions,
         customResponse: primary.customResponse,
         answers,
         decisionSummary
       };
-    } catch (err) {
-      const fallbackQuestion = input.question ?? input.questions?.[0]?.question ?? "";
-      return {
-        status: "skipped",
-        question: fallbackQuestion,
-        selectedOptions: [],
-        decisionSummary: "",
-        error: toErrorMessage(err)
-      };
+    } catch (error) {
+      return skippedFromInput(input, toErrorMessage(error));
     }
   }
 };
+function optionArraySchema() {
+  return {
+    type: "array",
+    minItems: 2,
+    maxItems: 8,
+    items: {
+      oneOf: [
+        { type: "string" },
+        {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            label: { type: "string", minLength: 1 },
+            description: { type: "string" }
+          },
+          required: ["label"],
+          additionalProperties: false
+        }
+      ]
+    }
+  };
+}
+function questionSchema() {
+  return {
+    type: "object",
+    properties: {
+      id: { type: "string" },
+      question: { type: "string", minLength: 1 },
+      context: { type: "string" },
+      type: { type: "string", enum: ["single_select", "multi_select", "text"] },
+      options: optionArraySchema(),
+      recommendedOption: { type: "string" },
+      recommendedOptions: { type: "array", items: { type: "string" } },
+      recommendedText: { type: "string" },
+      recommendationReason: { type: "string" },
+      isMultiSelect: { type: "boolean" },
+      is_multi_select: { type: "boolean" },
+      allowCustomResponse: { type: "boolean" },
+      required: { type: "boolean" },
+      placeholder: { type: "string" }
+    },
+    required: ["question"],
+    additionalProperties: false
+  };
+}
+function slug(value, fallback) {
+  return value.toLocaleLowerCase("tr-TR").replace(/[ıİ]/g, "i").replace(/ğ/g, "g").replace(/ü/g, "u").replace(/ş/g, "s").replace(/ö/g, "o").replace(/ç/g, "c").normalize("NFKD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || fallback;
+}
+function normalizeRequest(input) {
+  const sourceTabs = input.tabs !== void 0 ? input.tabs : [
+    {
+      label: "Questions",
+      questions: input.questions !== void 0 ? input.questions : [input]
+    }
+  ];
+  if (sourceTabs.length === 0) throw new Error("clarify requires at least one tab.");
+  const seen = /* @__PURE__ */ new Set();
+  const tabs = sourceTabs.map((tab, tabIndex) => {
+    if (!tab.label?.trim()) throw new Error("Every clarify tab requires a non-empty `label`.");
+    if (!Array.isArray(tab.questions) || tab.questions.length === 0) {
+      throw new Error(`clarify tab "${tab.label}" requires at least one question.`);
+    }
+    return {
+      id: tab.id ?? slug(tab.label, `tab_${tabIndex + 1}`),
+      label: tab.label,
+      description: tab.description,
+      questions: tab.questions.map((question, questionIndex) => {
+        if (!question.question?.trim())
+          throw new Error("Every clarify question requires non-empty `question`.");
+        const id = question.id ?? slug(question.question, `question_${questionIndex + 1}`);
+        if (seen.has(id)) throw new Error(`Duplicate clarify question id: ${id}`);
+        seen.add(id);
+        const legacyMulti = resolveLegacyMultiSelect(question);
+        if (question.type !== void 0 && legacyMulti !== void 0 && (question.type === "text" || question.type === "multi_select" !== legacyMulti)) {
+          throw new Error(
+            `clarify question "${question.question}" has conflicting \`type\` and \`isMultiSelect\` values. Use \`type\` as the canonical field or remove the legacy flag.`
+          );
+        }
+        const kind = question.type ?? (legacyMulti ? "multi_select" : "single_select");
+        const seenOptions = /* @__PURE__ */ new Set();
+        const options = (question.options ?? []).map((option, index) => {
+          const value = typeof option === "string" ? { label: option } : option;
+          if (!value?.label?.trim()) {
+            throw new Error(
+              `clarify question "${question.question}" option ${index + 1} requires a non-empty \`label\`; \`description\` alone is not selectable.`
+            );
+          }
+          const normalized = {
+            id: value.id ?? slug(value.label, `option_${index + 1}`),
+            label: value.label,
+            description: value.description
+          };
+          if (seenOptions.has(normalized.id)) {
+            throw new Error(
+              `clarify question "${question.question}" has duplicate option id: ${normalized.id}`
+            );
+          }
+          seenOptions.add(normalized.id);
+          return normalized;
+        });
+        if (kind !== "text" && options.length < 2)
+          throw new Error(`clarify question "${question.question}" requires at least 2 options.`);
+        const explicitRecommended = question.recommendedOptions ?? (question.recommendedOption ? [question.recommendedOption] : []);
+        const recommended = explicitRecommended.length > 0 ? explicitRecommended : options.filter((option) => /^\s*\(?recommended\)?\b/i.test(option.label)).slice(0, kind === "single_select" ? 1 : void 0).map((option) => option.id);
+        const recommendedOptionIds = recommended.map(
+          (value) => options.find((option) => option.id === value || option.label === value)?.id ?? value
+        );
+        const unknownRecommendation = recommendedOptionIds.find(
+          (recommendedId) => !options.some((option) => option.id === recommendedId)
+        );
+        if (unknownRecommendation) {
+          throw new Error(
+            `clarify question "${question.question}" recommends unknown option: ${unknownRecommendation}`
+          );
+        }
+        if (kind === "single_select" && recommendedOptionIds.length > 1)
+          throw new Error(
+            `Single-select question "${question.question}" can recommend only one option.`
+          );
+        if (kind === "single_select" && recommendedOptionIds.length > 0 && question.recommendedText?.trim()) {
+          throw new Error(
+            `Single-select question "${question.question}" cannot recommend both an option and a custom text answer.`
+          );
+        }
+        return {
+          id,
+          prompt: question.question,
+          description: question.context,
+          kind,
+          required: question.required ?? true,
+          options: kind === "text" ? void 0 : options,
+          recommendedOptionIds,
+          recommendedText: question.recommendedText,
+          recommendationReason: question.recommendationReason,
+          allowCustomResponse: kind === "text" ? void 0 : question.allowCustomResponse ?? true,
+          placeholder: question.placeholder
+        };
+      })
+    };
+  });
+  return {
+    id: `clarify_${randomUUID()}`,
+    title: input.title?.trim() || "A few decisions are needed",
+    description: input.description,
+    submitLabel: input.submitLabel ?? "Submit answers",
+    tabs
+  };
+}
+function recommendedResponse(request) {
+  return {
+    requestId: request.id,
+    status: "submitted",
+    answers: request.tabs.flatMap(
+      (tab) => tab.questions.map((question) => ({
+        questionId: question.id,
+        selectedOptionIds: question.recommendedOptionIds?.length ? question.recommendedOptionIds : question.kind === "text" ? [] : question.options?.slice(0, 1).map((option) => option.id) ?? [],
+        text: question.recommendedText,
+        delegated: false,
+        usedRecommendation: Boolean(
+          question.recommendedOptionIds?.length || question.recommendedText
+        )
+      }))
+    )
+  };
+}
+function materializeAnswers(request, answers) {
+  const byId = new Map(answers.map((answer) => [answer.questionId, answer]));
+  return request.tabs.flatMap(
+    (tab) => tab.questions.map((question) => {
+      const answer = byId.get(question.id) ?? {
+        questionId: question.id,
+        selectedOptionIds: [],
+        usedRecommendation: false
+      };
+      if (answer.delegated) {
+        return {
+          questionId: question.id,
+          question: question.prompt,
+          selectedOptions: [],
+          delegatedToModel: true,
+          usedRecommendation: false
+        };
+      }
+      return {
+        questionId: question.id,
+        question: question.prompt,
+        selectedOptions: answer.selectedOptionIds.map(
+          (id) => question.options?.find((option) => option.id === id)?.label ?? id
+        ),
+        customResponse: answer.text,
+        delegatedToModel: false,
+        usedRecommendation: matchesRecommendation(question, answer)
+      };
+    })
+  );
+}
+function resolveLegacyMultiSelect(question) {
+  if (question.isMultiSelect !== void 0 && question.is_multi_select !== void 0 && question.isMultiSelect !== question.is_multi_select) {
+    throw new Error(
+      `clarify question "${question.question}" has conflicting \`isMultiSelect\` and \`is_multi_select\` values.`
+    );
+  }
+  return question.isMultiSelect ?? question.is_multi_select;
+}
+function matchesRecommendation(question, answer) {
+  if (answer.delegated) return false;
+  const recommendedOptions = question.recommendedOptionIds ?? [];
+  const recommendedText = question.recommendedText?.trim() ?? "";
+  if (recommendedOptions.length === 0 && recommendedText.length === 0) return false;
+  const selected = answer.selectedOptionIds;
+  return selected.length === recommendedOptions.length && selected.every((id) => recommendedOptions.includes(id)) && (answer.text?.trim() ?? "") === recommendedText;
+}
+async function legacyHostResponse(ctx, request) {
+  const ask = ctx.askUserChoices;
+  if (typeof ask !== "function") return void 0;
+  const answers = [];
+  for (const question of request.tabs.flatMap((tab) => tab.questions)) {
+    const result = await ask(
+      question.prompt,
+      question.options?.map((option) => option.label) ?? [],
+      {
+        isMultiSelect: question.kind === "multi_select",
+        context: question.description,
+        recommendedOption: question.recommendedOptionIds?.[0],
+        allowCustomResponse: question.allowCustomResponse
+      }
+    );
+    const ids = result.selected.map(
+      (value) => question.options?.find((option) => option.label === value || option.id === value)?.id ?? value
+    );
+    answers.push({
+      questionId: question.id,
+      selectedOptionIds: ids,
+      text: result.custom,
+      usedRecommendation: ids.length === (question.recommendedOptionIds?.length ?? 0) && ids.every((id) => question.recommendedOptionIds?.includes(id))
+    });
+  }
+  return { requestId: request.id, status: "submitted", answers };
+}
+function skipped(request, error) {
+  return {
+    status: "skipped",
+    question: request.tabs[0]?.questions[0]?.prompt ?? "",
+    selectedOptions: [],
+    decisionSummary: "",
+    error
+  };
+}
+function skippedFromInput(input, error) {
+  return {
+    status: "skipped",
+    question: input.question ?? input.questions?.[0]?.question ?? input.tabs?.[0]?.questions[0]?.question ?? "",
+    selectedOptions: [],
+    decisionSummary: "",
+    error
+  };
+}
 
 // src/pwsh.ts
 import { spawn } from "node:child_process";
@@ -1497,4 +1692,4 @@ export {
   TIER3_TOOLS,
   builtinTools
 };
-//# sourceMappingURL=chunk-OVFQC6FU.js.map
+//# sourceMappingURL=chunk-4DK5WZGR.js.map

package/dist/{chunk-47GYABZW.js → chunk-4SW6BXUR.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-NBDZMMG2.js";
 import {
   truncateMiddle
-} from "./chunk-HKR56VNF.js";
+} from "./chunk-2IAEJRLT.js";
 
 // src/fetch.ts
 import { FetchError, ToolError, ToolValidationError } from "@wrongstack/core/types";
@@ -281,4 +281,4 @@ function prettyJson(s) {
 export {
   fetchTool
 };
-//# sourceMappingURL=chunk-47GYABZW.js.map
+//# sourceMappingURL=chunk-4SW6BXUR.js.map

package/dist/{chunk-7EQ2LUXU.js → chunk-5MP76C72.js}

@@ -1,11 +1,11 @@
 import {
   enqueueReindex
-} from "./chunk-DOHU3XHS.js";
+} from "./chunk-TU6UVATU.js";
 import {
   resolveRealInsideRoot,
   safeResolveReal,
   sha256hex
-} from "./chunk-HKR56VNF.js";
+} from "./chunk-2IAEJRLT.js";
 
 // src/patch.ts
 import { spawn } from "node:child_process";
@@ -395,4 +395,4 @@ function extractPatchedFiles(output) {
 export {
   patchTool
 };
-//# sourceMappingURL=chunk-7EQ2LUXU.js.map
+//# sourceMappingURL=chunk-5MP76C72.js.map