@ashx-j/lunr-dev 0.2.13-dev.8.1 → 0.2.19-dev.10.1

package/dist/node-runtime/chunk-ZRDIMBEQ.js

@@ -0,0 +1,651 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  isUserInstructionsPath
+} from "./chunk-M3LZLQW2.js";
+import {
+  computerPolicy
+} from "./chunk-5OLJGVCB.js";
+import {
+  getAgentDir
+} from "./chunk-PCIGF2XK.js";
+
+// packages/coding-agent/dist/core/plan-mode.js
+var PLAN_MODE_ADDENDUM = "You are in plan mode. Investigate read-only, then present your plan by calling the present_plan tool with a concise summary \u2014 the user approves or declines it in a dialog. Do not make changes until the plan is approved. The user can also exit plan mode manually with /plan off.", PLAN_MODE_BLOCK_MESSAGE = "Plan mode is active \u2014 propose a plan; no file changes.", BLOCKED_TOOLS = /* @__PURE__ */ new Set(["edit", "write", "memory_add", "memory_remove", "cron"]), ALLOWED_COMMANDS = /* @__PURE__ */ new Set([
+  "ls",
+  "ll",
+  "cat",
+  "tac",
+  "grep",
+  "rg",
+  "find",
+  "pwd",
+  "echo",
+  "printf",
+  "head",
+  "tail",
+  "wc",
+  "less",
+  "more",
+  "sort",
+  "uniq",
+  "diff",
+  "cmp",
+  "comm",
+  "test",
+  "[",
+  "true",
+  "false",
+  "which",
+  "whereis",
+  "stat",
+  "file",
+  "id",
+  "whoami",
+  "who",
+  "date",
+  "cal",
+  "env",
+  "printenv",
+  "uname",
+  "hostname",
+  "uptime",
+  "nproc",
+  "tput",
+  "git",
+  "gh",
+  "node",
+  "npm",
+  "pnpm",
+  "yarn",
+  "bun"
+]), MUTATING_GIT_SUBCOMMANDS = /* @__PURE__ */ new Set([
+  "add",
+  "commit",
+  "push",
+  "pull",
+  "merge",
+  "rebase",
+  "reset",
+  "checkout",
+  "switch",
+  "restore",
+  "rm",
+  "mv",
+  "stash",
+  "cherry-pick",
+  "revert",
+  "clean",
+  "fetch",
+  "config",
+  "apply",
+  "am",
+  "init",
+  "clone",
+  "submodule",
+  "worktree",
+  "gc",
+  "prune",
+  "update-index"
+]), CONDITIONAL_GIT_SUBCOMMANDS = /* @__PURE__ */ new Set(["branch", "tag", "remote"]), CONDITIONAL_GIT_MUTATING_FLAGS = /* @__PURE__ */ new Set(["-d", "-D", "-m", "-M", "-c", "-C"]), PACKAGE_MANAGER_MUTATIONS = {
+  npm: /* @__PURE__ */ new Set([
+    "install",
+    "add",
+    "remove",
+    "uninstall",
+    "update",
+    "upgrade",
+    "publish",
+    "link",
+    "unlink",
+    "ci",
+    "init"
+  ]),
+  pnpm: /* @__PURE__ */ new Set(["install", "add", "remove", "uninstall", "update", "upgrade", "publish", "link", "unlink", "init"]),
+  yarn: /* @__PURE__ */ new Set(["install", "add", "remove", "uninstall", "upgrade", "publish", "link", "unlink", "init"]),
+  bun: /* @__PURE__ */ new Set(["install", "add", "remove", "uninstall", "update", "upgrade", "publish", "link", "unlink", "init"])
+}, ALWAYS_MUTATING_MANAGERS = /* @__PURE__ */ new Set([
+  "apt",
+  "apt-get",
+  "brew",
+  "dnf",
+  "yum",
+  "pacman",
+  "choco",
+  "winget",
+  "scoop"
+]), EXECUTING_NODE_FLAGS = /* @__PURE__ */ new Set([
+  "-e",
+  "--eval",
+  "-p",
+  "--print",
+  "-r",
+  "--require",
+  "--import",
+  "-i",
+  "--interactive"
+]), EXECUTING_PYTHON_FLAGS = /* @__PURE__ */ new Set(["-c", "-m", "-i", "--interactive"]);
+function isCodeRewriteMutating(input) {
+  return input?.dry_run === !1;
+}
+function planModeBlockReason(toolName, input) {
+  if (toolName.startsWith("computer_"))
+    try {
+      return computerPolicy(toolName, {})?.observation ? void 0 : PLAN_MODE_BLOCK_MESSAGE;
+    } catch {
+      return PLAN_MODE_BLOCK_MESSAGE;
+    }
+  if (BLOCKED_TOOLS.has(toolName) || toolName === "code_rewrite" && isCodeRewriteMutating(input) || toolName.startsWith("settings_") && toolName !== "settings_load" && Object.keys(input ?? {}).length > 0)
+    return PLAN_MODE_BLOCK_MESSAGE;
+  if (toolName === "bash") {
+    let command = readBashCommand(input);
+    if (command && isMutatingBashCommand(command))
+      return `${PLAN_MODE_BLOCK_MESSAGE} Blocked command: ${command}`;
+  }
+}
+function readBashCommand(input) {
+  let command = input?.command;
+  return typeof command == "string" ? command : "";
+}
+function isMutatingBashCommand(command) {
+  if (!command.trim())
+    return !1;
+  if (hasUnquotedRedirect(command) || hasShellSubstitution(command))
+    return !0;
+  for (let segment of splitShellSegments(command))
+    if (isMutatingSegment(segment))
+      return !0;
+  return !1;
+}
+function hasUnquotedRedirect(command) {
+  let quote, escaped = !1;
+  for (let i = 0; i < command.length; i++) {
+    let ch = command[i];
+    if (escaped) {
+      escaped = !1;
+      continue;
+    }
+    if (ch === "\\" && quote !== "'") {
+      escaped = !0;
+      continue;
+    }
+    if (quote) {
+      ch === quote && (quote = void 0);
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      continue;
+    }
+    if (ch === ">")
+      return !0;
+  }
+  return !1;
+}
+function splitShellSegments(command) {
+  let segments = [], quote, escaped = !1, start = 0;
+  for (let i = 0; i < command.length; i++) {
+    let ch = command[i], next = command[i + 1];
+    if (escaped) {
+      escaped = !1;
+      continue;
+    }
+    if (ch === "\\" && quote !== "'") {
+      escaped = !0;
+      continue;
+    }
+    if (quote) {
+      ch === quote && (quote = void 0);
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      continue;
+    }
+    if (ch === "&" && next === "&" || ch === "|" && next === "|") {
+      segments.push(command.slice(start, i)), i++, start = i + 1;
+      continue;
+    }
+    (ch === ";" || ch === "|" || ch === "&" || ch === `
+`) && (segments.push(command.slice(start, i)), start = i + 1);
+  }
+  return segments.push(command.slice(start)), segments.map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function hasShellSubstitution(command) {
+  let quote, escaped = !1;
+  for (let i = 0; i < command.length; i++) {
+    let ch = command[i];
+    if (escaped) {
+      escaped = !1;
+      continue;
+    }
+    if (ch === "\\" && quote !== "'") {
+      escaped = !0;
+      continue;
+    }
+    if (quote) {
+      ch === quote && (quote = void 0);
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      continue;
+    }
+    if (ch === "`" || ch === "$" && command[i + 1] === "(" || ch === "<" && command[i + 1] === "(" || ch === ">" && command[i + 1] === "(" || ch === "&" && command[i + 1] === ">")
+      return !0;
+  }
+  return !1;
+}
+function isMutatingSegment(segment) {
+  let tokens = segment.split(/\s+/).filter((t) => t.length > 0);
+  for (; tokens.length > 0 && /^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[0]); )
+    tokens = tokens.slice(1);
+  if (tokens.length === 0)
+    return !1;
+  let command = basenameOf(tokens[0]).toLowerCase(), args = tokens.slice(1);
+  if (ALWAYS_MUTATING_MANAGERS.has(command))
+    return !0;
+  if (command === "sed")
+    return args.some((a) => a === "-i" || a.startsWith("-i") || a.startsWith("--in-place") || /^-[^-]*i/.test(a));
+  if (command === "find")
+    return args.some((a) => ["-delete", "-exec", "-execdir", "-ok", "-okdir"].includes(a));
+  if (command === "git")
+    return isMutatingGit(args);
+  if (command === "gh") {
+    let sub = `${args[0] ?? ""} ${args[1] ?? ""}`;
+    return ![
+      "pr view",
+      "pr list",
+      "pr status",
+      "issue view",
+      "issue list",
+      "issue status",
+      "repo view",
+      "release view",
+      "release list",
+      "run list",
+      "run view",
+      "status"
+    ].includes(sub.trim());
+  }
+  if (command === "sh" || command === "bash" || command === "zsh" || command === "dash")
+    return args.some((a) => a === "-c" || a === "-s") || args.some((a) => !a.startsWith("-"));
+  let pkgMutations = PACKAGE_MANAGER_MUTATIONS[command];
+  if (pkgMutations) {
+    let subcommand = args.find((a) => !a.startsWith("-"))?.toLowerCase();
+    return subcommand !== void 0 && pkgMutations.has(subcommand);
+  }
+  return command === "node" ? args.some((a) => !a.startsWith("-")) || args.some((a) => EXECUTING_NODE_FLAGS.has(a)) : command === "python" || command === "python3" ? args.some((a) => !a.startsWith("-")) || args.some((a) => EXECUTING_PYTHON_FLAGS.has(a)) : !ALLOWED_COMMANDS.has(command);
+}
+var GIT_GLOBAL_FLAGS = /* @__PURE__ */ new Set([
+  "--no-pager",
+  "--paginate",
+  "-p",
+  "--version",
+  "--help",
+  "-h",
+  "--bare",
+  "--no-replace-objects",
+  "--no-optional-locks",
+  "--literal-pathspecs",
+  "--glob-pathspecs",
+  "--noglob-pathspecs",
+  "--icase-pathspecs"
+]);
+function gitSubcommandIndex(args) {
+  let index = 0;
+  for (; index < args.length; ) {
+    let token = args[index];
+    if (!token.startsWith("-"))
+      return index;
+    if (token === "--")
+      return index + 1;
+    if (GIT_GLOBAL_FLAGS.has(token)) {
+      index++;
+      continue;
+    }
+    if (token === "-C" || token === "-c" || token === "--git-dir" || token === "--work-tree" || token === "--namespace") {
+      if (args[index + 1] === void 0)
+        return -1;
+      index += 2;
+      continue;
+    }
+    if (token.startsWith("--git-dir=") || token.startsWith("--work-tree=") || token.startsWith("--namespace=") || token.startsWith("--config-env=")) {
+      index++;
+      continue;
+    }
+    return -1;
+  }
+  return index;
+}
+function isMutatingGit(args) {
+  let index = gitSubcommandIndex(args);
+  if (index < 0)
+    return !0;
+  let subcommand = args[index]?.toLowerCase();
+  return subcommand ? MUTATING_GIT_SUBCOMMANDS.has(subcommand) ? !0 : CONDITIONAL_GIT_SUBCOMMANDS.has(subcommand) ? args.slice(index + 1).some((a) => !a.startsWith("-") || CONDITIONAL_GIT_MUTATING_FLAGS.has(a)) : !1 : !1;
+}
+function basenameOf(token) {
+  let parts = token.split(/[\\/]/);
+  return parts[parts.length - 1] ?? token;
+}
+
+// packages/coding-agent/dist/core/permissions.js
+import { dirname, join, resolve } from "node:path";
+
+// packages/coding-agent/dist/core/large-subagent-launch.js
+function countEntry(item) {
+  let count = item && typeof item == "object" ? item.count : void 0;
+  return typeof count == "number" && Number.isInteger(count) && count >= 1 ? count : 1;
+}
+function isManagementCall(args) {
+  return typeof args.action == "string" && args.action.length > 0;
+}
+function isAsyncDetached(args) {
+  return args.async === !0 && args.clarify !== !0;
+}
+function effectiveLargeSubagentLaunchCount(args) {
+  let total = 0;
+  if (Array.isArray(args.tasks))
+    for (let task of args.tasks)
+      total += countEntry(task);
+  if (Array.isArray(args.chain))
+    for (let step of args.chain) {
+      let parallel = step && typeof step == "object" ? step.parallel : void 0;
+      if (Array.isArray(parallel))
+        for (let child of parallel)
+          total += countEntry(child);
+    }
+  return total;
+}
+function siblingSingleCount(args) {
+  return isManagementCall(args) || isAsyncDetached(args) || Array.isArray(args.tasks) || Array.isArray(args.chain) ? 0 : typeof args.task == "string" && args.task.length > 0 && typeof args.description == "string" && args.description.length > 0 ? 1 : 0;
+}
+function effectiveLargeSubagentLaunchCountForTurn(args, assistantMessage) {
+  let own = effectiveLargeSubagentLaunchCount(args), siblingSingles = (assistantMessage?.content ?? []).reduce((total, block) => {
+    if (block.type !== "toolCall" || block.name !== "subagent")
+      return total;
+    let siblingArgs = block.arguments && typeof block.arguments == "object" && !Array.isArray(block.arguments) ? block.arguments : void 0;
+    return siblingArgs ? total + siblingSingleCount(siblingArgs) : total;
+  }, 0);
+  return Math.max(own, siblingSingles);
+}
+
+// packages/coding-agent/dist/core/permissions.js
+var PERMISSION_MODES = ["manual", "yolo", "plan", "auto"];
+function nextPermissionMode(current) {
+  let i = PERMISSION_MODES.indexOf(current);
+  return PERMISSION_MODES[(i + 1) % PERMISSION_MODES.length];
+}
+function isPlanModeActive(sessionId) {
+  return getPermissionMode(sessionId) === "plan";
+}
+function restorePermissionModeAfterPlan(previous, defaultMode) {
+  return previous && previous !== "plan" ? previous : defaultMode === "plan" ? "yolo" : defaultMode;
+}
+var READ_ONLY_TOOLS = /* @__PURE__ */ new Set([
+  "read",
+  "grep",
+  "find",
+  "ls",
+  "web_search",
+  "web_fetch",
+  "fetch_content",
+  "get_search_content",
+  "sourcegraph",
+  "repo_map",
+  "symbol_outline",
+  "read_block",
+  "code_overview",
+  "ast_search",
+  "lsp_diagnostics",
+  "lsp_hover",
+  "lsp_definition",
+  "lsp_references",
+  "lsp_symbols",
+  "lsp_code_actions",
+  "lsp_completions",
+  "memory_load",
+  "settings_load"
+]), MUTATING_TOOLS = /* @__PURE__ */ new Set(["bash", "edit", "write", "memory_add", "memory_remove", "cron"]), REJECT_REASON = "Rejected by user (permission mode: manual).", NO_HANDLER_REASON = "Mutating tool blocked in manual mode: no approval channel available.", LARGE_SUBAGENT_LAUNCH_REJECT_REASON = "Large subagent launch rejected by user.", NO_LARGE_SUBAGENT_LAUNCH_HANDLER_REASON = "Large subagent launch blocked: no approval channel available.", LARGE_SUBAGENT_LAUNCH_ACTION = "large-subagent-launch", FULL_CHILD_ACTION = "subagent-full", contexts = /* @__PURE__ */ new Map(), defaultContext = { mode: "manual", approvals: /* @__PURE__ */ new Set() }, approvalHandler, turnLargeLaunchDecisions = /* @__PURE__ */ new WeakMap();
+function getContext(sessionId) {
+  return sessionId ? contexts.get(sessionId) ?? defaultContext : defaultContext;
+}
+function createPermissionContext(sessionId, mode = defaultContext.mode, allowApprovals = !0) {
+  contexts.set(sessionId, { mode, allowApprovals, approvals: /* @__PURE__ */ new Set() });
+}
+function deletePermissionContext(sessionId) {
+  contexts.delete(sessionId);
+}
+function getPermissionMode(sessionId) {
+  return getContext(sessionId).mode;
+}
+function setPermissionMode(mode, sessionId) {
+  getContext(sessionId).mode = mode;
+}
+function resetPermissions(defaultMode = "manual", sessionId) {
+  sessionId ? contexts.set(sessionId, { mode: defaultMode, approvals: /* @__PURE__ */ new Set() }) : defaultContext = { mode: defaultMode, approvals: /* @__PURE__ */ new Set() };
+}
+function registerApprovalHandler(fn) {
+  approvalHandler = fn;
+}
+var PLAN_APPROVED_TEXT = "Plan approved \u2014 implement it now.", PLAN_DECLINED_TEXT = "Plan declined \u2014 revise the plan and call present_plan again.", PLAN_PASS_THROUGH_TEXT = "Plan presented. The user will review and reply.";
+function planApprovalResultText(resp) {
+  let decision = typeof resp == "string" ? resp : resp.decision, feedback = typeof resp == "string" ? void 0 : resp.feedback?.trim();
+  return decision === "reject" ? feedback ? `Plan declined: ${feedback} \u2014 revise the plan and call present_plan again.` : PLAN_DECLINED_TEXT : feedback ? `Plan approved with feedback: ${feedback} \u2014 implement it now.` : PLAN_APPROVED_TEXT;
+}
+async function requestPlanApproval(summary) {
+  if (!approvalHandler)
+    return PLAN_PASS_THROUGH_TEXT;
+  let resp;
+  try {
+    resp = await approvalHandler({ toolName: "present_plan", action: "plan", detail: summary, kind: "plan" });
+  } catch (err) {
+    let message = err instanceof Error ? err.message : "approval request failed";
+    return message === NO_HANDLER_REASON ? PLAN_PASS_THROUGH_TEXT : `Plan declined: ${message} \u2014 revise the plan and call present_plan again.`;
+  }
+  return planApprovalResultText(resp);
+}
+var AUTO_MODE_ADDENDUM = "You are running fully autonomously. Do not ask the user questions or wait for confirmation; make reasonable decisions and complete the task end-to-end.";
+function isPathOutsideCwd(absPath, cwd) {
+  let norm = (p) => p.replace(/\\/g, "/").replace(/\/$/, ""), np = norm(absPath), nc = norm(cwd);
+  return np === nc ? !1 : !np.startsWith(`${nc}/`);
+}
+function resolvePath(cwd, p) {
+  return typeof p != "string" || !p ? "" : resolve(cwd, p);
+}
+var GLOBAL_AGENTS_FILE_WRITE_BLOCK_REASON = "The agents instruction tree is user-managed. The agent cannot change ~/.lunr/agent/agents/.", MEMORY_FILE_DIRECT_WRITE_BLOCK_REASON = "Memory is model-managed through the memory tools. Do not directly change ~/.lunr/simple-memory/memory.md.";
+function protectedFileWriteReason(toolName, input, cwd) {
+  if (toolName !== "edit" && toolName !== "write" && toolName !== "code_rewrite")
+    return;
+  let target = resolvePath(cwd, input.path);
+  if (!target)
+    return;
+  let normalize = (path) => {
+    let normalized = resolve(path).replace(/\\/g, "/").replace(/\/$/, "");
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+  };
+  if (isUserInstructionsPath(target, getAgentDir()))
+    return GLOBAL_AGENTS_FILE_WRITE_BLOCK_REASON;
+  if (normalize(target) === normalize(join(dirname(getAgentDir()), "simple-memory", "memory.md")))
+    return MEMORY_FILE_DIRECT_WRITE_BLOCK_REASON;
+}
+function isMutatingTool(toolName) {
+  return MUTATING_TOOLS.has(toolName);
+}
+function collectRequestedChildLaunches(value, launches) {
+  if (!value || typeof value != "object" || Array.isArray(value))
+    return;
+  let input = value;
+  if (typeof input.task == "string" && input.task.trim()) {
+    launches.push({
+      description: typeof input.description == "string" && input.description.trim() ? input.description.trim() : input.task.trim(),
+      permissions: input.permissions === "read-only" ? "read-only" : "full"
+    });
+    return;
+  }
+  for (let key of ["tasks", "chain", "parallel"]) {
+    let children = input[key];
+    if (Array.isArray(children))
+      for (let child of children)
+        collectRequestedChildLaunches(child, launches);
+    else key === "parallel" && collectRequestedChildLaunches(children, launches);
+  }
+}
+function getRequestedChildLaunches(input) {
+  let launches = [];
+  return collectRequestedChildLaunches(input, launches), launches;
+}
+function requiresManualApproval(toolName, input) {
+  return toolName.startsWith("computer_") ? toolName !== "computer_end" : isMutatingTool(toolName) ? !0 : toolName.startsWith("settings_") && toolName !== "settings_load" ? Object.keys(input).length > 0 : toolName === "subagent" ? getRequestedChildLaunches(input).some((launch) => launch.permissions === "full") : toolName === "code_rewrite" && isCodeRewriteMutating(input);
+}
+function firstTaskText(value) {
+  return typeof value == "string" && value.trim() ? sanitizeDetail(value) : "";
+}
+function largeLaunchTaskSummary(input, assistantMessage) {
+  if (Array.isArray(input.tasks))
+    for (let task of input.tasks) {
+      let text = task && typeof task == "object" ? firstTaskText(task.task) : "";
+      if (text)
+        return text;
+    }
+  let own = firstTaskText(input.task);
+  if (own)
+    return own;
+  for (let block of assistantMessage?.content ?? []) {
+    if (block.type !== "toolCall" || block.name !== "subagent")
+      continue;
+    let args = block.arguments && typeof block.arguments == "object" && !Array.isArray(block.arguments) ? block.arguments : void 0, text = firstTaskText(args?.task);
+    if (text)
+      return text;
+  }
+  return "";
+}
+async function gateLargeSubagentLaunch(input, ctx, options) {
+  if (ctx.mode === "auto" || options?.confirmLargeSubagentLaunches === !1)
+    return;
+  let count = effectiveLargeSubagentLaunchCountForTurn(input, options?.assistantMessage);
+  if (count <= 2)
+    return;
+  if (ctx.approvals.has(LARGE_SUBAGENT_LAUNCH_ACTION))
+    return { fullChildrenApproved: !1 };
+  let turnKey = options?.assistantMessage, cached = turnKey ? turnLargeLaunchDecisions.get(turnKey) : void 0;
+  if (cached)
+    return cached.decision === "reject" ? {
+      block: !0,
+      reason: cached.feedback ? `${LARGE_SUBAGENT_LAUNCH_REJECT_REASON} ${cached.feedback}` : LARGE_SUBAGENT_LAUNCH_REJECT_REASON
+    } : { fullChildrenApproved: cached.fullChildrenApproved };
+  if (!approvalHandler || ctx.allowApprovals === !1)
+    return { block: !0, reason: NO_LARGE_SUBAGENT_LAUNCH_HANDLER_REASON };
+  let summary = largeLaunchTaskSummary(input, options?.assistantMessage), siblingLaunches = (options?.assistantMessage?.content ?? []).flatMap((block) => {
+    if (block.type !== "toolCall" || block.name !== "subagent")
+      return [];
+    let args = block.arguments && typeof block.arguments == "object" && !Array.isArray(block.arguments) ? block.arguments : void 0;
+    return args ? getRequestedChildLaunches(args) : [];
+  }), launches = siblingLaunches.length > 0 ? siblingLaunches : getRequestedChildLaunches(input), fullChildrenApproved = launches.some((launch) => launch.permissions === "full"), launchSummary = launches.map((launch) => `${launch.description}
+permissions: ${launch.permissions}`).join(`
+`), resp;
+  try {
+    resp = await approvalHandler({
+      toolName: "subagent",
+      action: LARGE_SUBAGENT_LAUNCH_ACTION,
+      detail: `large subagent launch (${count} children)${launchSummary || summary ? `
+${launchSummary || summary}` : ""}`,
+      kind: "large-subagent-launch"
+    });
+  } catch (err) {
+    return { block: !0, reason: err instanceof Error ? err.message : NO_LARGE_SUBAGENT_LAUNCH_HANDLER_REASON };
+  }
+  let rawDecision = typeof resp == "string" ? resp : resp.decision, decision = rawDecision === "approve" ? "once" : rawDecision, feedback = typeof resp == "string" ? void 0 : resp.feedback?.trim();
+  return turnKey && turnLargeLaunchDecisions.set(turnKey, { decision, ...feedback ? { feedback } : {}, fullChildrenApproved }), decision === "session" ? (ctx.approvals.add(LARGE_SUBAGENT_LAUNCH_ACTION), fullChildrenApproved && ctx.approvals.add(FULL_CHILD_ACTION), { fullChildrenApproved }) : decision === "reject" ? {
+    block: !0,
+    reason: feedback ? `${LARGE_SUBAGENT_LAUNCH_REJECT_REASON} ${feedback}` : LARGE_SUBAGENT_LAUNCH_REJECT_REASON
+  } : { fullChildrenApproved };
+}
+function sanitizeDetail(value) {
+  let text = String(value ?? "").trim();
+  return text.length > 200 ? `${text.slice(0, 200)}\u2026` : text;
+}
+async function gateToolCall(toolName, input, cwd, sessionId, options) {
+  let ctx = getContext(sessionId);
+  if (toolName.startsWith("computer_"))
+    try {
+      computerPolicy(toolName, input);
+    } catch (error) {
+      return { block: !0, reason: String(error) };
+    }
+  let protectedWriteReason = protectedFileWriteReason(toolName, input, cwd);
+  if (protectedWriteReason)
+    return { block: !0, reason: protectedWriteReason };
+  if (READ_ONLY_TOOLS.has(toolName))
+    return;
+  let largeLaunchCoveredManualApproval = !1;
+  if (toolName === "subagent") {
+    let launchResult = await gateLargeSubagentLaunch(input, ctx, options);
+    if (launchResult && "block" in launchResult)
+      return launchResult;
+    largeLaunchCoveredManualApproval = ctx.mode === "manual" && launchResult?.fullChildrenApproved === !0;
+  }
+  if (ctx.mode === "plan") {
+    let reason = planModeBlockReason(toolName, input);
+    return reason ? { block: !0, reason } : void 0;
+  }
+  if (ctx.mode !== "manual" || !requiresManualApproval(toolName, input) || largeLaunchCoveredManualApproval)
+    return;
+  let action, detail;
+  if (toolName.startsWith("computer_"))
+    action = toolName, detail = sanitizeDetail(JSON.stringify(input));
+  else if (toolName === "bash")
+    action = "bash", detail = sanitizeDetail(input.command);
+  else if (toolName === "edit" || toolName === "write") {
+    let path = resolvePath(cwd, input.path);
+    action = (path ? isPathOutsideCwd(path, cwd) : !1) ? `${toolName}-outside` : toolName, detail = path || String(input.path ?? "");
+  } else if (toolName === "memory_add")
+    action = toolName, detail = sanitizeDetail(input.content);
+  else if (toolName === "memory_remove")
+    action = toolName, detail = sanitizeDetail(input.line);
+  else if (toolName === "cron")
+    action = "cron", detail = sanitizeDetail(input.action);
+  else if (toolName === "subagent") {
+    action = FULL_CHILD_ACTION;
+    let launches = getRequestedChildLaunches(input).filter((launch) => launch.permissions === "full");
+    detail = sanitizeDetail(launches.map((launch) => `${launch.description}
+permissions: ${launch.permissions}`).join(`
+`));
+  } else toolName === "code_rewrite" ? (action = "code_rewrite", detail = sanitizeDetail(input.path ?? input.pattern)) : (action = toolName, detail = "");
+  if (!toolName.startsWith("computer_") && ctx.approvals.has(action))
+    return;
+  if (!approvalHandler || ctx.allowApprovals === !1)
+    return { block: !0, reason: NO_HANDLER_REASON };
+  let resp;
+  try {
+    resp = await approvalHandler({ toolName, action, detail });
+  } catch (err) {
+    return { block: !0, reason: err instanceof Error ? err.message : NO_HANDLER_REASON };
+  }
+  let decision = typeof resp == "string" ? resp : resp.decision;
+  if (decision === "session") {
+    toolName.startsWith("computer_") || ctx.approvals.add(action);
+    return;
+  }
+  if (decision === "reject") {
+    let feedback = typeof resp == "string" ? void 0 : resp.feedback?.trim();
+    return { block: !0, reason: feedback ? `${REJECT_REASON} ${feedback}` : REJECT_REASON };
+  }
+}
+
+export {
+  PLAN_MODE_ADDENDUM,
+  nextPermissionMode,
+  isPlanModeActive,
+  restorePermissionModeAfterPlan,
+  NO_HANDLER_REASON,
+  createPermissionContext,
+  deletePermissionContext,
+  getPermissionMode,
+  setPermissionMode,
+  resetPermissions,
+  registerApprovalHandler,
+  requestPlanApproval,
+  AUTO_MODE_ADDENDUM,
+  gateToolCall
+};