@wrongstack/core 0.313.0 → 0.316.1

package/dist/chunk-U4FWBSO3.js

@@ -0,0 +1,509 @@
+import {
+  CHRONICLE_MAX_APPEND_BATCH
+} from "./chunk-4BMVPOHO.js";
+import {
+  mapWithConcurrency
+} from "./chunk-SZ6AYUIZ.js";
+import {
+  DEFAULT_WALK_IGNORE_DIRS,
+  watchProjectTree
+} from "./chunk-J2WRWR37.js";
+
+// src/chronicle/context.ts
+import { randomUUID } from "node:crypto";
+function createChronicleContext(scope, traceId = randomUUID()) {
+  return {
+    scope: { ...scope },
+    correlation: { traceId, spanId: randomUUID() }
+  };
+}
+function childChronicleContext(parent, overrides = {}) {
+  return {
+    scope: { ...parent.scope, ...overrides.scope },
+    correlation: {
+      ...parent.correlation,
+      ...overrides.correlation,
+      traceId: parent.correlation.traceId,
+      parentSpanId: parent.correlation.spanId,
+      spanId: overrides.correlation?.spanId ?? randomUUID()
+    }
+  };
+}
+
+// src/chronicle/file-observer.ts
+import { createHash } from "node:crypto";
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+var DEFAULT_EXCLUDED = [
+  ...DEFAULT_WALK_IGNORE_DIRS,
+  ".wrongstack",
+  ".claude",
+  ".temp_files"
+];
+var SCAN_HASH_CONCURRENCY = 32;
+var DEFAULT_FULL_RESCAN_MIN_INTERVAL_MS = 3e4;
+var MAX_RECENT_TOOL_MUTATIONS = 500;
+var JOURNAL_FLUSH_CHUNK = CHRONICLE_MAX_APPEND_BATCH;
+async function startChronicleFileObserver(options) {
+  const root = path.resolve(options.projectRoot);
+  const excluded = new Set(options.excludedDirectories ?? DEFAULT_EXCLUDED);
+  const excludedPaths = normalizeExcludedPaths(root, options.excludedPaths ?? []);
+  const debounceMs = options.debounceMs ?? 120;
+  const maxHashBytes = options.maxHashBytes ?? 8 * 1024 * 1024;
+  const known = (await scanProject(root, excluded, excludedPaths, maxHashBytes, options.onError)).files;
+  const recentToolMutations = /* @__PURE__ */ new Map();
+  const noteToolMutation = (hint) => {
+    const absolute = path.isAbsolute(hint.path) ? path.normalize(hint.path) : path.resolve(root, hint.path);
+    const relative2 = normalizeRelative(path.relative(root, absolute));
+    if (relative2.startsWith("../") || isExcluded(relative2, excluded, excludedPaths)) return;
+    recentToolMutations.set(relative2, {
+      at: hint.at ?? Date.now(),
+      toolUseId: hint.toolUseId,
+      toolName: hint.toolName,
+      agentId: hint.agentId,
+      sessionId: hint.sessionId
+    });
+    if (recentToolMutations.size > MAX_RECENT_TOOL_MUTATIONS) {
+      const overflow = recentToolMutations.size - MAX_RECENT_TOOL_MUTATIONS;
+      const keys = [...recentToolMutations.keys()];
+      for (let i = 0; i < overflow && i < keys.length; i++) {
+        recentToolMutations.delete(keys[i]);
+      }
+    }
+  };
+  const offToolProgress = options.events?.on("tool.progress", (event) => {
+    if (event.event.type !== "file_changed" || !event.event.path) return;
+    noteToolMutation({
+      path: event.event.path,
+      toolUseId: event.id,
+      toolName: event.name,
+      agentId: event.agentId,
+      sessionId: event.sessionId
+    });
+  });
+  const pending = /* @__PURE__ */ new Set();
+  let timer;
+  let closed = false;
+  let flushTail = null;
+  let drainFailure;
+  const minFullRescanIntervalMs = options.minFullRescanIntervalMs ?? DEFAULT_FULL_RESCAN_MIN_INTERVAL_MS;
+  let lastFullScanAt = Date.now();
+  let fullRescanTimer;
+  const bumpDebounce = () => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = void 0;
+      drainPending();
+    }, debounceMs);
+  };
+  const requestFullRescan = () => {
+    if (closed) return;
+    const since = Date.now() - lastFullScanAt;
+    if (since >= minFullRescanIntervalMs) {
+      pending.add("*");
+      bumpDebounce();
+      return;
+    }
+    if (fullRescanTimer) return;
+    fullRescanTimer = setTimeout(() => {
+      fullRescanTimer = void 0;
+      if (closed) return;
+      pending.add("*");
+      bumpDebounce();
+    }, minFullRescanIntervalMs - since);
+    if (typeof fullRescanTimer.unref === "function") fullRescanTimer.unref();
+  };
+  const schedule = (filename) => {
+    if (closed) return;
+    if (filename === null) {
+      requestFullRescan();
+      return;
+    }
+    const relative2 = normalizeRelative(String(filename));
+    if (!relative2 || isExcluded(relative2, excluded, excludedPaths)) return;
+    pending.add(relative2);
+    bumpDebounce();
+  };
+  const reconcile = async (changedPaths) => {
+    const wantsFullScan = changedPaths.includes("*");
+    if (wantsFullScan) lastFullScanAt = Date.now();
+    const fullScan = wantsFullScan ? await scanProject(root, excluded, excludedPaths, maxHashBytes, options.onError, known) : void 0;
+    const candidates = (fullScan ? unionKeys(known, fullScan.files) : changedPaths).filter(
+      (relative2) => !isExcluded(relative2, excluded, excludedPaths)
+    );
+    const changes = [];
+    for (const relative2 of candidates) {
+      const before = known.get(relative2);
+      const cached = fullScan?.files.get(relative2);
+      const after = cached ?? (fullScan?.complete ? void 0 : await fingerprint(path.join(root, relative2), maxHashBytes));
+      if (sameFingerprint(before, after)) continue;
+      changes.push({ relative: relative2, before, after });
+    }
+    const deleted = changes.filter((change) => change.before && !change.after);
+    const created = changes.filter((change) => !change.before && change.after);
+    const consumed = /* @__PURE__ */ new Set();
+    const pendingEvents = [];
+    const pushPending = (eventType, relativePath, state, attributes, stateWrites) => {
+      const attribution = peekAttribution(relativePath, recentToolMutations);
+      const { input, emitActivity } = buildMutation(
+        options,
+        eventType,
+        relativePath,
+        state,
+        attributes,
+        attribution
+      );
+      pendingEvents.push({
+        input,
+        state: stateWrites,
+        emitActivity,
+        attribution,
+        attributionKey: attribution ? relativePath : void 0
+      });
+    };
+    const createdByHash = /* @__PURE__ */ new Map();
+    for (const to of created) {
+      const hash = to.after?.hash;
+      if (hash === void 0) continue;
+      const bucket = createdByHash.get(hash);
+      if (bucket) bucket.entries.push(to);
+      else createdByHash.set(hash, { entries: [to], cursor: 0 });
+    }
+    const claimCreated = (hash) => {
+      const bucket = createdByHash.get(hash);
+      if (!bucket) return void 0;
+      return bucket.cursor < bucket.entries.length ? bucket.entries[bucket.cursor++] : void 0;
+    };
+    for (const from of deleted) {
+      const fromHash = from.before?.hash;
+      if (fromHash === void 0) continue;
+      const match = claimCreated(fromHash);
+      if (!match) continue;
+      consumed.add(from.relative);
+      consumed.add(match.relative);
+      pushPending(
+        "file.external.renamed",
+        match.relative,
+        match.after,
+        {
+          operation: "rename",
+          previousPath: from.relative,
+          previousResourceId: resourceId(from.relative),
+          actor: "external"
+        },
+        [
+          [from.relative, void 0],
+          [match.relative, match.after]
+        ]
+      );
+    }
+    for (const change of changes) {
+      if (consumed.has(change.relative)) continue;
+      if (!change.after) {
+        pushPending(
+          "file.external.deleted",
+          change.relative,
+          change.before,
+          {
+            operation: "delete",
+            actor: "external",
+            previousHash: change.before?.hash,
+            previousSize: change.before?.size
+          },
+          [[change.relative, void 0]]
+        );
+      } else if (!change.before) {
+        pushPending(
+          "file.external.created",
+          change.relative,
+          change.after,
+          {
+            operation: "write",
+            actor: "external"
+          },
+          [[change.relative, change.after]]
+        );
+      } else {
+        pushPending(
+          "file.external.modified",
+          change.relative,
+          change.after,
+          {
+            operation: "edit",
+            actor: "external",
+            previousHash: change.before.hash,
+            previousSize: change.before.size
+          },
+          [[change.relative, change.after]]
+        );
+      }
+    }
+    try {
+      await flushJournalInputs(options, pendingEvents, (committed) => {
+        for (const event of committed) {
+          for (const [relative2, after] of event.state) {
+            if (after) known.set(relative2, after);
+            else known.delete(relative2);
+          }
+          if (event.attributionKey && recentToolMutations.get(event.attributionKey) === event.attribution) {
+            recentToolMutations.delete(event.attributionKey);
+          }
+          event.emitActivity?.();
+        }
+      });
+    } catch (error) {
+      for (const event of pendingEvents) {
+        if (!event.attribution || !event.attributionKey) continue;
+        const held = recentToolMutations.get(event.attributionKey);
+        if (held !== event.attribution) continue;
+        recentToolMutations.set(event.attributionKey, { ...event.attribution, at: Date.now() });
+      }
+      requestFullRescan();
+      throw error;
+    }
+  };
+  const drainPending = () => {
+    if (flushTail) return flushTail;
+    const drain = (async () => {
+      while (pending.size > 0) {
+        const paths = [...pending];
+        pending.clear();
+        try {
+          await reconcile(paths);
+        } catch (error) {
+          drainFailure = error;
+          options.onError?.(error);
+        }
+      }
+    })().finally(() => {
+      if (flushTail === drain) flushTail = null;
+      if (!closed && pending.size > 0) drainPending();
+    });
+    flushTail = drain;
+    return drain;
+  };
+  let watcher;
+  try {
+    watcher = watchProjectTree(root, (event) => schedule(event.filename), {
+      onError: (error) => options.onError?.(error)
+    });
+  } catch (error) {
+    options.onError?.(error);
+    throw error;
+  }
+  return {
+    get watchedFiles() {
+      return known.size;
+    },
+    noteToolMutation,
+    /**
+     * Shut down the observer. If the final drain (an in-flight drain plus
+     * anything still pending at close time) fails, close() REJECTS with
+     * that error — a failed shutdown flush is surfaced, not silently
+     * dropped. The failure is still not retried after close returns:
+     * `requestFullRescan()` no-ops once `closed` is set, and `known` is
+     * in-memory state that dies here, so uncommitted changes are not
+     * re-derived by a future boot (the startup scan builds fresh
+     * fingerprints without diffing against this process's history). The
+     * journal remains authoritative for everything that did commit. A
+     * second close() call is a no-op and does not re-throw.
+     */
+    async close() {
+      if (closed) return;
+      closed = true;
+      drainFailure = void 0;
+      offToolProgress?.();
+      watcher.close();
+      if (timer) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+      if (fullRescanTimer) {
+        clearTimeout(fullRescanTimer);
+        fullRescanTimer = void 0;
+        pending.add("*");
+      }
+      if (pending.size > 0) drainPending();
+      await flushTail;
+      recentToolMutations.clear();
+      if (drainFailure !== void 0) throw drainFailure;
+    }
+  };
+}
+function buildMutation(options, eventType, relativePath, state, attributes, attribution) {
+  const context = typeof options.context === "function" ? options.context() : options.context;
+  const operation = attributes["operation"];
+  const bus = options.events;
+  const activity = {
+    filePath: path.join(options.projectRoot, relativePath),
+    operation,
+    phase: "changed",
+    source: attribution ? "tool" : "external",
+    at: Date.now(),
+    sessionId: context.scope.sessionId,
+    traceId: context.correlation.traceId,
+    agentId: attribution?.agentId ?? context.scope.agentId,
+    ...attribution ? { toolUseId: attribution.toolUseId, toolName: attribution.toolName } : {}
+  };
+  const emitActivity = bus ? () => {
+    bus.emit("file.activity", activity);
+  } : void 0;
+  const input = {
+    eventType: attribution ? eventType.replace(".external.", ".tool.") : eventType,
+    scope: {
+      ...context.scope,
+      ...attribution?.sessionId ? { sessionId: attribution.sessionId } : {},
+      ...attribution?.agentId ? { agentId: attribution.agentId } : {}
+    },
+    correlation: {
+      ...context.correlation,
+      ...attribution ? { toolCallId: attribution.toolUseId } : {}
+    },
+    outcome: "success",
+    resource: {
+      kind: "file",
+      id: resourceId(relativePath),
+      path: normalizeRelative(relativePath),
+      ...state?.hash ? { contentHashAfter: state.hash } : {}
+    },
+    attributes: {
+      ...attributes,
+      actor: attribution ? "agent" : attributes["actor"],
+      source: attribution ? "tool" : "external",
+      toolName: attribution?.toolName,
+      size: state?.size,
+      mtimeMs: state?.mtimeMs,
+      observedBy: "fs.watch"
+    }
+  };
+  return { input, emitActivity };
+}
+async function flushJournalInputs(options, events, onCommitted) {
+  if (events.length === 0) return;
+  const batch = options.journal.appendBatch?.bind(options.journal);
+  if (!batch) {
+    const settled = await Promise.allSettled(
+      events.map(async (event) => {
+        await options.journal.append(event.input);
+        onCommitted([event]);
+      })
+    );
+    const failure = settled.find((result) => result.status === "rejected");
+    if (failure) throw failure.reason;
+    return;
+  }
+  for (let index = 0; index < events.length; index += JOURNAL_FLUSH_CHUNK) {
+    const chunk = events.slice(index, index + JOURNAL_FLUSH_CHUNK);
+    await batch(chunk.map((event) => event.input));
+    onCommitted(chunk);
+  }
+}
+function peekAttribution(relativePath, recent) {
+  const value = recent.get(relativePath);
+  if (!value) return void 0;
+  return Date.now() - value.at <= 2e3 ? value : void 0;
+}
+async function scanProject(root, excluded, excludedPaths, maxHashBytes, onError, previous) {
+  const result = /* @__PURE__ */ new Map();
+  const dirs = [""];
+  let complete = true;
+  while (dirs.length > 0) {
+    const relativeDir = dirs.pop();
+    try {
+      const entries = await fsp.readdir(path.join(root, relativeDir), { withFileTypes: true });
+      const filePaths = [];
+      for (const entry of entries) {
+        const relative2 = normalizeRelative(path.join(relativeDir, entry.name));
+        if (isExcluded(relative2, excluded, excludedPaths)) continue;
+        if (entry.isDirectory()) {
+          dirs.push(relative2);
+        } else if (entry.isFile()) {
+          filePaths.push(relative2);
+        }
+      }
+      const fingerprints = await mapWithConcurrency(
+        filePaths,
+        SCAN_HASH_CONCURRENCY,
+        async (relative2) => {
+          try {
+            const value = await fingerprint(
+              path.join(root, relative2),
+              maxHashBytes,
+              previous?.get(relative2)
+            );
+            return value ? [relative2, value] : null;
+          } catch (error) {
+            complete = false;
+            onError?.(error);
+            return null;
+          }
+        }
+      );
+      for (const entry of fingerprints) {
+        if (entry) result.set(entry[0], entry[1]);
+      }
+    } catch (error) {
+      complete = false;
+      onError?.(error);
+    }
+  }
+  return { files: result, complete };
+}
+async function fingerprint(filePath, maxHashBytes, previous) {
+  try {
+    const stat2 = await fsp.stat(filePath);
+    if (!stat2.isFile()) return void 0;
+    const base = { size: stat2.size, mtimeMs: stat2.mtimeMs };
+    if (previous?.hash !== void 0 && previous.size === stat2.size && previous.mtimeMs === stat2.mtimeMs) {
+      base.hash = previous.hash;
+      return base;
+    }
+    if (stat2.size <= maxHashBytes) {
+      base.hash = createHash("sha256").update(await fsp.readFile(filePath)).digest("hex");
+    }
+    return base;
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT")
+      return void 0;
+    throw error;
+  }
+}
+function sameFingerprint(a, b) {
+  if (!a || !b) return a === b;
+  if (a.hash !== void 0 && b.hash !== void 0) return a.hash === b.hash;
+  return a.size === b.size && a.mtimeMs === b.mtimeMs;
+}
+function isExcluded(relative2, excluded, excludedPaths) {
+  const normalized = normalizeRelative(relative2);
+  if (normalized.split("/").some((segment) => excluded.has(segment))) return true;
+  for (const prefix of excludedPaths) {
+    if (normalized === prefix || normalized.startsWith(`${prefix}/`)) return true;
+  }
+  return false;
+}
+function normalizeExcludedPaths(root, values) {
+  const result = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    const relative2 = path.isAbsolute(value) ? path.relative(root, path.resolve(value)) : value;
+    const normalized = normalizeRelative(relative2).replace(/\/+$/u, "");
+    if (!normalized || normalized === "." || normalized.startsWith("../")) continue;
+    result.add(normalized);
+  }
+  return result;
+}
+function normalizeRelative(value) {
+  return value.replaceAll("\\", "/").replace(/^\.\//, "");
+}
+function resourceId(relativePath) {
+  return `file_${createHash("sha256").update(normalizeRelative(relativePath)).digest("hex").slice(0, 24)}`;
+}
+function unionKeys(a, b) {
+  return [.../* @__PURE__ */ new Set([...a.keys(), ...b.keys()])];
+}
+
+export {
+  createChronicleContext,
+  childChronicleContext,
+  startChronicleFileObserver
+};
+//# sourceMappingURL=chunk-U4FWBSO3.js.map

package/dist/chunk-UBGDX6FI.js

@@ -0,0 +1,147 @@
+// src/security/capabilities.ts
+var ToolCapabilities = {
+  /** Can execute arbitrary commands in the user's shell (the `bash` tool). */
+  SHELL_ARBITRARY: "shell.arbitrary",
+  /**
+   * Can execute the `exec` tool's allowlisted commands.
+   *
+   * "Restricted" describes the command NAME check, not the resulting power.
+   * Treat this as equivalent to {@link SHELL_ARBITRARY} when deciding what to
+   * grant: the allowlist includes general-purpose interpreters (`node`,
+   * `python`, `perl`, `ruby`) and, on Windows, the platform shells (`cmd`,
+   * `powershell`, `pwsh`) — deliberately, since without them `exec` cannot run
+   * `dir`/`type`/any cmdlet. `node -e …` or `cmd /c …` therefore reaches
+   * arbitrary execution, and per-argument denylisting cannot close that while
+   * the shells remain (blocking `node -e` still leaves `cmd /c node -e`).
+   *
+   * What actually bounds this is downstream, not the name check: the permission
+   * policy reconstructs the full command line and runs it through the
+   * destructive classifier, so destructive calls still require confirmation.
+   *
+   * Granting `shell.restricted` while withholding `shell.arbitrary` therefore
+   * buys no meaningful reduction in blast radius. Documented rather than
+   * silently implied, because the two read as a narrow/wide pair (WS-083).
+   */
+  SHELL_RESTRICTED: "shell.restricted",
+  /** Can run a restricted project formatter/linter-style command. */
+  SHELL_EXEC: "shell.exec",
+  /** Can read files inside the project (and possibly outside via symlinks if not guarded). */
+  FS_READ: "fs.read",
+  /** Can write / modify / delete files inside the project. */
+  FS_WRITE: "fs.write",
+  /** Can write files outside the current project root (very high risk). */
+  FS_WRITE_OUTSIDE_PROJECT: "fs.write.outside-project",
+  /** Can perform outbound network requests. */
+  NET_OUTBOUND: "net.outbound",
+  /** Can mutate in-memory session todos only. */
+  SESSION_TODO: "session.todo",
+  /**
+   * Can post an ephemeral same-session note to the leader or a peer
+   * (`session_note` / `session.note`). In-process only — not the durable
+   * cross-session mailbox (`coordination.mail`).
+   */
+  SESSION_NOTE: "session.note",
+  /** Can park after-task `<nextsteps>` suggestions for the current turn. */
+  SESSION_NEXTSTEPS: "session.nextsteps",
+  /** Can mutate in-memory session mode only. */
+  SESSION_MODE: "session.mode",
+  /** Can inspect registered tool metadata. */
+  TOOL_META: "tool.meta",
+  /** Can invoke arbitrary registered tools through a meta-tool. */
+  TOOL_MUTATE_ANY: "tool.mutate.any",
+  /** Can read persistent memory. */
+  MEMORY_READ: "memory.read",
+  /** Can write persistent memory. */
+  MEMORY_WRITE: "memory.write",
+  /** Can delete persistent memory. */
+  MEMORY_DELETE: "memory.delete",
+  /** Proxies tools from external MCP servers (unknown capability). */
+  MCP_PROXY: "mcp.proxy",
+  /** Can spawn or manage subagents / multi-agent tasks. */
+  SUBAGENT_SPAWN: "subagent.spawn",
+  /** Can inspect fleet/subagent coordination state without mutating it. */
+  COORDINATION_FLEET_READ: "coordination.fleet.read",
+  /** Can publish attributed, schema-checked events onto the fleet bus. */
+  COORDINATION_FLEET_EMIT: "coordination.fleet.emit",
+  /** Can submit a task-local structured result to the parent Director. */
+  COORDINATION_RESULT_SUBMIT: "coordination.result.submit",
+  /** Can read or write inter-agent mailbox messages. */
+  COORDINATION_MAIL: "coordination.mail",
+  /** Can schedule, inspect, or cancel in-session cron jobs. */
+  COORDINATION_CRON: "coordination.cron",
+  /** Can mutate global or session configuration / trust state. */
+  CONFIG_MUTATE: "config.mutate",
+  /** Can install packages or run package managers with side effects. */
+  PACKAGE_INSTALL: "package.install"
+};
+var DANGEROUS_FOR_SUBAGENTS = [
+  ToolCapabilities.SHELL_ARBITRARY,
+  ToolCapabilities.SHELL_RESTRICTED,
+  ToolCapabilities.SHELL_EXEC,
+  ToolCapabilities.FS_WRITE,
+  ToolCapabilities.FS_WRITE_OUTSIDE_PROJECT,
+  ToolCapabilities.TOOL_MUTATE_ANY,
+  ToolCapabilities.MEMORY_WRITE,
+  ToolCapabilities.MEMORY_DELETE,
+  ToolCapabilities.MCP_PROXY,
+  ToolCapabilities.SUBAGENT_SPAWN,
+  ToolCapabilities.CONFIG_MUTATE,
+  ToolCapabilities.PACKAGE_INSTALL
+];
+var WIDE_SUBAGENT_CAPABILITIES = [
+  ToolCapabilities.FS_READ,
+  ToolCapabilities.FS_WRITE,
+  ToolCapabilities.NET_OUTBOUND,
+  ToolCapabilities.SESSION_TODO,
+  ToolCapabilities.SESSION_NOTE,
+  ToolCapabilities.TOOL_META,
+  ToolCapabilities.MEMORY_READ,
+  ToolCapabilities.SHELL_ARBITRARY,
+  ToolCapabilities.SHELL_RESTRICTED,
+  ToolCapabilities.SHELL_EXEC,
+  ToolCapabilities.PACKAGE_INSTALL,
+  // Read-only fleet visibility (fleet_status) — peer awareness has no blast
+  // radius and every fleet worker should coordinate around its peers.
+  ToolCapabilities.COORDINATION_FLEET_READ,
+  ToolCapabilities.COORDINATION_RESULT_SUBMIT
+];
+function clampSubagentCapabilities(requested, ceiling = WIDE_SUBAGENT_CAPABILITIES) {
+  const ceilingSet = new Set(ceiling);
+  const requestedSet = new Set(requested);
+  return {
+    granted: ceiling.filter((capability) => requestedSet.has(capability)),
+    dropped: [...requestedSet].filter((capability) => !ceilingSet.has(capability))
+  };
+}
+function hasDangerousCapabilityForSubagents(toolOrCaps) {
+  if (!toolOrCaps) return false;
+  const input = toolOrCaps;
+  const caps = Array.isArray(toolOrCaps) ? toolOrCaps : input.capabilities ?? [];
+  return caps.some((c) => DANGEROUS_FOR_SUBAGENTS.includes(c));
+}
+function hasCapability(toolOrCaps, capability) {
+  if (!toolOrCaps) return false;
+  const input = toolOrCaps;
+  const caps = Array.isArray(toolOrCaps) ? toolOrCaps : input.capabilities ?? [];
+  const toCheck = Array.isArray(capability) ? capability : [capability];
+  return toCheck.some((c) => caps.includes(c));
+}
+function getDangerousCapabilities(toolOrCaps) {
+  if (!toolOrCaps) return [];
+  const input = toolOrCaps;
+  const caps = Array.isArray(toolOrCaps) ? toolOrCaps : input.capabilities ?? [];
+  return caps.filter(
+    (c) => DANGEROUS_FOR_SUBAGENTS.includes(c)
+  );
+}
+
+export {
+  ToolCapabilities,
+  DANGEROUS_FOR_SUBAGENTS,
+  WIDE_SUBAGENT_CAPABILITIES,
+  clampSubagentCapabilities,
+  hasDangerousCapabilityForSubagents,
+  hasCapability,
+  getDangerousCapabilities
+};
+//# sourceMappingURL=chunk-UBGDX6FI.js.map