@iowarp/clio-coder 0.4.3 → 0.4.5

package/dist/chunk-VLPTKCKT.js

@@ -0,0 +1,396 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  discoverDeclaredChecksAtRoot,
+  discoverDeclaredProjectEntriesAtRoot
+} from "./chunk-HGSLRG33.js";
+import {
+  printError
+} from "./chunk-3T4DXWP6.js";
+import {
+  DISPATCH_INTENT_TIMEOUT_MIN_MS,
+  normalizeIntentExpectedOutputs,
+  normalizeIntentVerification
+} from "./chunk-L4N3DWNW.js";
+import {
+  packageDeclaredCheck
+} from "./chunk-MDU3C27C.js";
+import {
+  CLIO_PROJECT_DIR
+} from "./chunk-NTTS3O53.js";
+import {
+  atomicWrite
+} from "./chunk-FQOOGXBH.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/cli/tasks.ts
+init_esm_shims();
+
+// src/domains/user-tasks/handoff.ts
+init_esm_shims();
+function formatUserTaskHandoff(task) {
+  const note = task.note ? ` ${task.note}.` : "";
+  const acceptance = task.acceptance ? ` Acceptance: ${JSON.stringify(task.acceptance)}.` : "";
+  return `Operator task ${task.id}: ${task.title}.${note}${acceptance} Before working this task, call tasks action="pick" id="${task.id}" and confirm its durable session/board link. Use the returned linked tN for start and done; do not replace the pickup with a self-created plan or pick unrelated inbox tasks. Respect the task's authorized scope, including proposal-only limits. If pickup fails, report the actual state and stop this task's work. After work and required verification, call tasks done on that linked tN with concrete evidence, then tasks list. Claim ${task.id} completed only if the linked board row is completed and the durable operator task is done with the same session/board link. Report the IDs, actual state, and verification results or limitations; an unpicked or still-handed task is not done.`;
+}
+
+// src/domains/user-tasks/store.ts
+init_esm_shims();
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// src/domains/user-tasks/acceptance.ts
+init_esm_shims();
+function normalizeUserTaskAcceptance(raw) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error("acceptance must be an object");
+  }
+  const value = raw;
+  if (Object.keys(value).some((key) => key !== "expectedOutputs" && key !== "verification")) {
+    throw new Error("acceptance contains an unknown field");
+  }
+  if (!Array.isArray(value.expectedOutputs) || !Array.isArray(value.verification)) {
+    throw new Error("acceptance requires expectedOutputs and verification arrays");
+  }
+  const checks = /* @__PURE__ */ new Map();
+  const rawVerification = value.verification.map((entry) => {
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+      throw new Error("acceptance verification must contain check and timeoutMs");
+    }
+    const item = entry;
+    if (Object.keys(item).some((key) => key !== "check" && key !== "timeoutMs")) {
+      throw new Error("acceptance verification contains an unknown field");
+    }
+    if (typeof item.check !== "string" || typeof item.timeoutMs !== "number" || !Number.isSafeInteger(item.timeoutMs) || item.timeoutMs <= 0) {
+      throw new Error("acceptance verification requires a check and a positive integer timeoutMs");
+    }
+    checks.set(item.check.trim(), {
+      id: item.check.trim(),
+      timeoutMs: Math.max(DISPATCH_INTENT_TIMEOUT_MIN_MS, item.timeoutMs, checks.get(item.check.trim())?.timeoutMs ?? 0)
+    });
+    return { check: item.check, timeout_ms: item.timeoutMs };
+  });
+  const expectedOutputs = normalizeIntentExpectedOutputs(value.expectedOutputs);
+  if (!Array.isArray(expectedOutputs))
+    throw new Error(expectedOutputs.ok ? "invalid acceptance outputs" : expectedOutputs.message);
+  const verification = normalizeIntentVerification(rawVerification, checks);
+  if (!Array.isArray(verification))
+    throw new Error(verification.ok ? "invalid acceptance verification" : verification.message);
+  return { expectedOutputs, verification };
+}
+
+// src/domains/user-tasks/store.ts
+var USER_TASKS_FILE_VERSION = 1;
+var USER_TASKS_RELATIVE_PATH = `${CLIO_PROJECT_DIR}/user-tasks.json`;
+var UserTasksStoreError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "UserTasksStoreError";
+  }
+};
+var USER_TASK_STATUSES = ["open", "handed", "picked", "done", "dropped"];
+var FILE_KEYS = /* @__PURE__ */ new Set(["version", "nextId", "tasks"]);
+var TASK_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "title",
+  "note",
+  "acceptance",
+  "status",
+  "createdAt",
+  "updatedAt",
+  "handedSessionId",
+  "boardTaskId"
+]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOnlyKeys(value, allowed) {
+  return Object.keys(value).every((key) => allowed.has(key));
+}
+function isOptionalString(value) {
+  return value === void 0 || typeof value === "string";
+}
+function isUserTask(value) {
+  if (!isRecord(value) || !hasOnlyKeys(value, TASK_KEYS)) return false;
+  if (value.acceptance !== void 0) {
+    try {
+      normalizeUserTaskAcceptance(value.acceptance);
+    } catch {
+      return false;
+    }
+  }
+  return typeof value.id === "string" && /^u[1-9]\d*$/.test(value.id) && typeof value.title === "string" && value.title.trim().length > 0 && typeof value.status === "string" && USER_TASK_STATUSES.includes(value.status) && typeof value.createdAt === "string" && typeof value.updatedAt === "string" && isOptionalString(value.note) && isOptionalString(value.handedSessionId) && isOptionalString(value.boardTaskId);
+}
+function parseFile(body, path) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch (error) {
+    throw new UserTasksStoreError(`user tasks file is corrupt JSON: ${path}`, { cause: error });
+  }
+  if (!isRecord(parsed) || !hasOnlyKeys(parsed, FILE_KEYS)) {
+    throw new UserTasksStoreError(`user tasks file has an invalid top-level shape: ${path}`);
+  }
+  if (parsed.version !== USER_TASKS_FILE_VERSION || !Number.isSafeInteger(parsed.nextId) || parsed.nextId < 1 || !Array.isArray(parsed.tasks) || !parsed.tasks.every(isUserTask)) {
+    throw new UserTasksStoreError(`user tasks file failed schema validation: ${path}`);
+  }
+  const ids = /* @__PURE__ */ new Set();
+  let maxId = 0;
+  for (const task of parsed.tasks) {
+    if (ids.has(task.id)) throw new UserTasksStoreError(`user tasks file contains duplicate id ${task.id}: ${path}`);
+    ids.add(task.id);
+    maxId = Math.max(maxId, Number(task.id.slice(1)));
+  }
+  if (parsed.nextId <= maxId) {
+    throw new UserTasksStoreError(`user tasks file nextId would reuse an existing id: ${path}`);
+  }
+  return {
+    version: USER_TASKS_FILE_VERSION,
+    nextId: parsed.nextId,
+    tasks: parsed.tasks.map(copyTask)
+  };
+}
+function copyTask(task) {
+  return { ...task, ...task.acceptance ? { acceptance: normalizeUserTaskAcceptance(task.acceptance) } : {} };
+}
+function initialFile() {
+  return { version: USER_TASKS_FILE_VERSION, nextId: 1, tasks: [] };
+}
+function createUserTasksStore(deps) {
+  const path = join(deps.cwd, USER_TASKS_RELATIVE_PATH);
+  const exists = deps.exists ?? existsSync;
+  const read = deps.read ?? ((target) => readFileSync(target, "utf8"));
+  const write = deps.write ?? ((target, body) => atomicWrite(target, body));
+  const now = () => (deps.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
+  const load = () => {
+    if (!exists(path)) return initialFile();
+    try {
+      return parseFile(read(path), path);
+    } catch (error) {
+      if (error instanceof UserTasksStoreError) throw error;
+      throw new UserTasksStoreError(`could not read user tasks file: ${path}`, { cause: error });
+    }
+  };
+  const save = (file) => {
+    try {
+      write(path, `${JSON.stringify(file, null, 2)}
+`);
+    } catch (error) {
+      throw new UserTasksStoreError(`could not write user tasks file: ${path}`, { cause: error });
+    }
+  };
+  const mutate = (id, allowed, status, sessionId) => {
+    const file = load();
+    const index = file.tasks.findIndex((task) => task.id === id);
+    const current = file.tasks[index];
+    if (!current) throw new UserTasksStoreError(`operator task ${id} was not found`);
+    if (!allowed.includes(current.status)) {
+      throw new UserTasksStoreError(`operator task ${id} is ${current.status}; it cannot move to ${status}`);
+    }
+    const updated = { ...current, status, updatedAt: now() };
+    if (status === "handed" && sessionId) updated.handedSessionId = sessionId;
+    file.tasks[index] = updated;
+    save(file);
+    return copyTask(updated);
+  };
+  const recordLink = (id, status, sessionId, boardTaskId) => {
+    const file = load();
+    const index = file.tasks.findIndex((task) => task.id === id);
+    const current = file.tasks[index];
+    if (!current) throw new UserTasksStoreError(`operator task ${id} was not found`);
+    if (current.status === "done" || current.status === "dropped") {
+      throw new UserTasksStoreError(`operator task ${id} is ${current.status}; it cannot move to ${status}`);
+    }
+    const updated = {
+      ...current,
+      status,
+      updatedAt: now(),
+      handedSessionId: sessionId,
+      boardTaskId
+    };
+    file.tasks[index] = updated;
+    save(file);
+    return copyTask(updated);
+  };
+  return {
+    path,
+    snapshot() {
+      return load().tasks.map(copyTask);
+    },
+    get(id) {
+      const task = load().tasks.find((candidate) => candidate.id === id);
+      return task ? copyTask(task) : null;
+    },
+    add(title, note, acceptance) {
+      const normalizedAcceptance = acceptance === void 0 ? void 0 : normalizeAcceptance(acceptance);
+      const normalizedTitle = title.trim();
+      if (normalizedTitle.length === 0) throw new UserTasksStoreError("operator task title cannot be empty");
+      const normalizedNote = note?.trim();
+      const file = load();
+      const timestamp = now();
+      const task = {
+        id: `u${file.nextId}`,
+        title: normalizedTitle,
+        ...normalizedNote ? { note: normalizedNote } : {},
+        ...normalizedAcceptance ? { acceptance: normalizedAcceptance } : {},
+        status: "open",
+        createdAt: timestamp,
+        updatedAt: timestamp
+      };
+      file.nextId += 1;
+      file.tasks.push(task);
+      save(file);
+      return copyTask(task);
+    },
+    setAcceptance(id, acceptance) {
+      const normalized = normalizeAcceptance(acceptance);
+      const file = load();
+      const task = file.tasks.find((item) => item.id === id);
+      if (!task) throw new UserTasksStoreError(`operator task ${id} was not found`);
+      task.acceptance = normalized;
+      task.updatedAt = now();
+      save(file);
+      return copyTask(task);
+    },
+    hand(id, sessionId) {
+      return mutate(id, ["open"], "handed", sessionId);
+    },
+    done(id) {
+      return mutate(id, ["open", "handed", "picked"], "done");
+    },
+    drop(id) {
+      return mutate(id, ["open", "handed", "picked"], "dropped");
+    },
+    recordPicked(id, sessionId, boardTaskId) {
+      return recordLink(id, "picked", sessionId, boardTaskId);
+    },
+    recordDone(id, sessionId, boardTaskId) {
+      return recordLink(id, "done", sessionId, boardTaskId);
+    },
+    reconcile(links, sessionId) {
+      const file = load();
+      let changed = false;
+      for (const [index, current] of file.tasks.entries()) {
+        if (current.status === "done" || current.status === "dropped") continue;
+        const candidates = links.filter((link2) => link2.userTaskId === current.id);
+        const completed = candidates.find((link2) => link2.status === "completed");
+        const open = candidates.find((link2) => link2.status === "active" || link2.status === "pending");
+        const link = completed ?? open;
+        if (link) {
+          const status = completed ? "done" : "picked";
+          if (current.status !== status || current.boardTaskId !== link.boardTaskId || current.handedSessionId !== sessionId) {
+            file.tasks[index] = {
+              ...current,
+              status,
+              boardTaskId: link.boardTaskId,
+              handedSessionId: sessionId,
+              updatedAt: now()
+            };
+            changed = true;
+          }
+          continue;
+        }
+        if (current.status === "picked" && current.handedSessionId === sessionId) {
+          const repaired = { ...current, status: "handed", updatedAt: now() };
+          delete repaired.boardTaskId;
+          file.tasks[index] = repaired;
+          changed = true;
+        }
+      }
+      if (changed) save(file);
+      return file.tasks.map(copyTask);
+    }
+  };
+}
+function normalizeAcceptance(raw) {
+  try {
+    return normalizeUserTaskAcceptance(raw);
+  } catch (error) {
+    throw new UserTasksStoreError(error instanceof Error ? error.message : String(error), { cause: error });
+  }
+}
+
+// src/cli/tasks.ts
+function acceptanceFromTaskFlags(cwd, expectedOutputs, verify) {
+  if (expectedOutputs.length === 0 && verify.length === 0) return void 0;
+  const discovery = discoverDeclaredChecksAtRoot(cwd, void 0);
+  if (!discovery.ok) throw new Error(discovery.reason);
+  const checks = new Map(
+    discovery.sources.flatMap((source) => source.checks.map((check) => [check.id, check]))
+  );
+  for (const entry of discoverDeclaredProjectEntriesAtRoot(cwd)) {
+    if (entry.kind === "package-script" && !checks.has(entry.id))
+      checks.set(entry.id, packageDeclaredCheck(entry.id, entry.path, ".", []));
+  }
+  const verification = verify.map((value) => {
+    const suffix = checks.has(value) ? null : /^(.*):([0-9]+)$/.exec(value);
+    const check = suffix?.[1] ?? value;
+    if (!checks.has(check))
+      throw new Error(
+        `Unknown verification check '${check}'. Known ids: ${[...checks.keys()].sort().join(", ") || "(none)"}`
+      );
+    return { check, ...suffix ? { timeout_ms: Number(suffix[2]) } : {} };
+  });
+  const outputs = normalizeIntentExpectedOutputs(expectedOutputs);
+  if (!Array.isArray(outputs)) throw new Error(outputs.ok ? "invalid expected outputs" : outputs.message);
+  const normalized = normalizeIntentVerification(verification, checks);
+  if (!Array.isArray(normalized)) throw new Error(normalized.ok ? "invalid verification" : normalized.message);
+  return { expectedOutputs: outputs, verification: normalized };
+}
+var HELP = `Usage:
+  clio-coder tasks [list]
+  clio-coder tasks add [--expect <path>] [--verify <checkId>[:timeoutMs]] <text>
+  clio-coder tasks hand|done|drop <uN>
+
+--expect and --verify are repeatable. Check ids must be declared in package.json or .clio-coder/verifiers.yaml.`;
+function runTasksCommand(args) {
+  try {
+    if (args.includes("--help") || args.includes("-h")) {
+      console.log(HELP);
+      return 0;
+    }
+    const store = createUserTasksStore({ cwd: process.cwd() });
+    const [action = "list", ...rest] = args;
+    if (action === "add") {
+      const expected = [], verify = [], title = [];
+      for (let index = 0; index < rest.length; index++) {
+        const token = rest[index] ?? "";
+        if (token === "--") {
+          title.push(...rest.slice(index + 1));
+          break;
+        }
+        if (token === "--expect" || token === "--verify") {
+          const value = rest[++index];
+          if (!value || value.startsWith("--")) throw new Error(`${token} requires a value`);
+          (token === "--expect" ? expected : verify).push(value);
+        } else if (token.startsWith("--")) throw new Error(`Unknown flag ${token}`);
+        else title.push(token);
+      }
+      const task = store.add(title.join(" "), void 0, acceptanceFromTaskFlags(process.cwd(), expected, verify));
+      console.log(`logged operator task ${task.id}: ${task.title}`);
+    } else if (action === "list" && rest.length === 0) {
+      console.log(JSON.stringify(store.snapshot(), null, 2));
+    } else if ((action === "hand" || action === "done" || action === "drop") && rest.length === 1) {
+      const task = store[action](rest[0] ?? "");
+      console.log(JSON.stringify(task, null, 2));
+      if (action === "hand") {
+        console.error(
+          "CLI hand records the inbox state only; it does not start a session or submit the interactive /tasks hand turn. Pass this pickup prompt to clio-coder run in the same project:\n" + formatUserTaskHandoff(task)
+        );
+      }
+    } else throw new Error(HELP);
+    return 0;
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+}
+
+export {
+  createUserTasksStore,
+  formatUserTaskHandoff,
+  acceptanceFromTaskFlags,
+  runTasksCommand
+};
+//# sourceMappingURL=chunk-VLPTKCKT.js.map

package/dist/{chunk-336NSSKI.js → chunk-VNBICSS2.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/core/resolve-config-value.ts
 init_esm_shims();
@@ -77,4 +77,4 @@ export {
   expandConfigPath,
   resolveDynamicConfigValue
 };
-//# sourceMappingURL=chunk-336NSSKI.js.map
+//# sourceMappingURL=chunk-VNBICSS2.js.map

package/dist/{chunk-VAVR4IJY.js → chunk-VQD7NH7Z.js}

@@ -1,10 +1,10 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   normalizeClioCoderEventRecord
-} from "./chunk-BTK3SSSK.js";
+} from "./chunk-KMF54VH3.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/worker/protocol.ts
 init_esm_shims();
@@ -353,4 +353,4 @@ export {
   parseControlFrame,
   isReceiptBearingFrame
 };
-//# sourceMappingURL=chunk-VAVR4IJY.js.map
+//# sourceMappingURL=chunk-VQD7NH7Z.js.map

package/dist/{chunk-LBMZMYH2.js → chunk-W2RJEH6Q.js}

@@ -1,10 +1,10 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   safeResourceWrite
-} from "./chunk-WEPFGWHJ.js";
+} from "./chunk-ZZFWWYLX.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/context/codewiki/schema.ts
 init_esm_shims();
@@ -282,4 +282,4 @@ export {
   structuralCodewikiHash,
   codewikiEntries
 };
-//# sourceMappingURL=chunk-LBMZMYH2.js.map
+//# sourceMappingURL=chunk-W2RJEH6Q.js.map

package/dist/{chunk-7CR24IG7.js → chunk-WDV62RKY.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/core/c-header-language.ts
 init_esm_shims();
@@ -239,4 +239,4 @@ export {
   isAmbiguousHeaderPath,
   classifyCHeaderLanguage
 };
-//# sourceMappingURL=chunk-7CR24IG7.js.map
+//# sourceMappingURL=chunk-WDV62RKY.js.map

package/dist/{chunk-2UH2KFUP.js → chunk-WFKDPU7U.js}

@@ -1,13 +1,13 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   compileExecutionPlan
-} from "./chunk-E3TPLWFX.js";
+} from "./chunk-ONRTXOZY.js";
 import {
   deriveExecutionRole
-} from "./chunk-H7IXIC72.js";
+} from "./chunk-LY4N4TTL.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/dispatch/scout-transition.ts
 init_esm_shims();
@@ -94,4 +94,4 @@ function compileScoutTransition(input) {
 export {
   compileScoutTransition
 };
-//# sourceMappingURL=chunk-2UH2KFUP.js.map
+//# sourceMappingURL=chunk-WFKDPU7U.js.map

package/dist/{chunk-ZDN3Y73Y.js → chunk-WJIMKGD6.js}

@@ -1,64 +1,25 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
-  VERIFICATION_SCRIPT_FAMILY_HINT
-} from "./chunk-UL3WSD3F.js";
+  typebox_exports
+} from "./chunk-GH5ZR6JP.js";
 import {
   truncateUtf8
-} from "./chunk-6XLNIQDB.js";
-import {
-  typebox_exports
-} from "./chunk-5B2AEOW5.js";
+} from "./chunk-MYI32N4R.js";
 import {
   ToolNames
-} from "./chunk-K6BSR66V.js";
+} from "./chunk-EHOSNVVM.js";
 import {
   SAFE_EXEC_DEFAULT_MAX_OUTPUT_BYTES,
   SAFE_EXEC_DEFAULT_TIMEOUT_MS,
   combineSafeOutput,
   runCommandVector
-} from "./chunk-JSC3U7TI.js";
+} from "./chunk-GJ24ODAX.js";
 import {
   StringEnum
-} from "./chunk-YPC6ZR5L.js";
+} from "./chunk-5CMARGPF.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
-
-// src/tools/verify/surface.ts
-init_esm_shims();
-var BROWSER_MODES = ["auto", "required", "off"];
-function prepareVerifyArguments(args) {
-  if (!args || typeof args !== "object" || Array.isArray(args)) return args;
-  const next = { ...args };
-  if (typeof next.args === "string") {
-    try {
-      const parsed = JSON.parse(next.args);
-      if (Array.isArray(parsed)) next.args = parsed;
-    } catch {
-    }
-  }
-  return next;
-}
-var verifyToolSurface = {
-  name: ToolNames.Verify,
-  description: 'Run a declared verification check: no arguments lists package scripts and .clio-coder/verifiers.yaml entries, check=<id> runs one, and check="frontend" with path validates an HTML/CSS/JS artifact.',
-  parameters: typebox_exports.Object({
-    check: typebox_exports.Optional(
-      typebox_exports.String({
-        description: `Check id, package script (${VERIFICATION_SCRIPT_FAMILY_HINT}), or "frontend"; omit to list.`
-      })
-    ),
-    path: typebox_exports.Optional(typebox_exports.String({ description: "frontend: artifact file under the workspace root." })),
-    args: typebox_exports.Optional(typebox_exports.Array(typebox_exports.String(), { description: "Package scripts only: arguments after --." })),
-    browser: typebox_exports.Optional(StringEnum(BROWSER_MODES, { description: "frontend: headless browser mode (default auto)." })),
-    cwd: typebox_exports.Optional(typebox_exports.String({ description: "Package scripts only: working directory." })),
-    timeout_ms: typebox_exports.Optional(typebox_exports.Number({ description: "Package and frontend checks only: timeout in ms." })),
-    max_output_bytes: typebox_exports.Optional(typebox_exports.Number({ description: "Output cap in bytes (default 600000)." }))
-  }),
-  baseActionClass: "execute",
-  executionMode: "sequential",
-  prepareArguments: prepareVerifyArguments
-};
+} from "./chunk-ECBHH7LU.js";
 
 // src/tools/safe-exec.ts
 init_esm_shims();
@@ -166,9 +127,6 @@ export {
   timeoutArg,
   maxOutputArg,
   runVectorTool,
-  gitTool,
-  BROWSER_MODES,
-  prepareVerifyArguments,
-  verifyToolSurface
+  gitTool
 };
-//# sourceMappingURL=chunk-ZDN3Y73Y.js.map
+//# sourceMappingURL=chunk-WJIMKGD6.js.map