@iowarp/clio-coder 0.4.4 → 0.4.6

package/dist/{chunk-6Q3CYFD3.js → chunk-IKRWLEDA.js}

@@ -1,7 +1,12 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  projectSurfaceTrust,
+  safetySurfaceTrustHash,
+  workspaceTrustDirectory
+} from "./chunk-NTK3WTHM.js";
 import {
   classify
-} from "./chunk-KFV5L5SK.js";
+} from "./chunk-LUL5Z66S.js";
 import {
   extractCommandCdTargets,
   extractCommandDeleteTargets,
@@ -9,39 +14,39 @@ import {
   inlineShellScript,
   invokesClioSkillMutation,
   scanShellLike
-} from "./chunk-NXYCB2VD.js";
+} from "./chunk-M6TAYK66.js";
 import {
   canonicalizeExistingPath
-} from "./chunk-ECH6PKUQ.js";
+} from "./chunk-KQ6IDQIB.js";
 import {
   loadProjectVerifierCatalog
-} from "./chunk-DXKJURES.js";
+} from "./chunk-PZN2LQY6.js";
 import {
   pathBoundaryCovers,
   resolvePathBoundary
-} from "./chunk-HHV2GANA.js";
+} from "./chunk-R2P2U3ZS.js";
 import {
   artifactDefaultPath
-} from "./chunk-GYV6VZOC.js";
-import {
-  ToolNames
-} from "./chunk-4NSRCOYP.js";
+} from "./chunk-NTTS3O53.js";
 import {
   foreignAgentDirs
-} from "./chunk-KXDSS5WJ.js";
+} from "./chunk-5CY4Q6QI.js";
+import {
+  ToolNames
+} from "./chunk-EHOSNVVM.js";
 import {
   resolvePackageRoot
-} from "./chunk-IWHMRKLL.js";
+} from "./chunk-E3LEPLQ2.js";
 import {
   require_dist
-} from "./chunk-APJ265NV.js";
+} from "./chunk-B5GGDIHT.js";
 import {
   clioConfigDir
-} from "./chunk-BYP5D4HI.js";
+} from "./chunk-CTTI7G3T.js";
 import {
   __toESM,
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/safety/path-policy.ts
 init_esm_shims();
@@ -149,6 +154,7 @@ function normalizeSeparators(value) {
 // src/domains/safety/policy-engine.ts
 init_esm_shims();
 import { createHash as createHash2 } from "node:crypto";
+import { readFileSync as readFileSync3 } from "node:fs";
 import path4 from "node:path";
 
 // src/domains/safety/default-path-policy.ts
@@ -269,12 +275,20 @@ function mergePathPolicyInputs(base, override) {
     noDeletePaths: [...base.noDeletePaths ?? [], ...override.noDeletePaths ?? []]
   };
 }
+var OPERATOR_PATH_POLICY = {
+  zeroAccessPaths: DEFAULT_DAMAGE_CONTROL_PATH_POLICY.zeroAccessPaths?.filter((entry) => entry.startsWith("~/")) ?? [],
+  readOnlyPaths: DEFAULT_DAMAGE_CONTROL_PATH_POLICY.readOnlyPaths?.filter(
+    (entry) => entry.startsWith("~/") || entry.startsWith("/") || entry.startsWith(".clio-coder/")
+  ) ?? [],
+  noWritePaths: DEFAULT_DAMAGE_CONTROL_PATH_POLICY.noWritePaths ?? [],
+  noDeletePaths: DEFAULT_DAMAGE_CONTROL_PATH_POLICY.noDeletePaths?.filter((entry) => entry.startsWith("~/")) ?? []
+};
 
 // src/domains/safety/project-policy.ts
 init_esm_shims();
 var import_yaml = __toESM(require_dist(), 1);
 import { createHash } from "node:crypto";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
 import path2 from "node:path";
 var POLICY_RELATIVE_PATH = path2.join(".clio-coder", "safety.yaml");
 var ACTION_CLASSES = /* @__PURE__ */ new Set([
@@ -315,7 +329,7 @@ function projectSafetyPolicyPath(cwd = process.cwd()) {
   }
 }
 function loadProjectSafetyPolicy(cwd = process.cwd()) {
-  const policyPath = projectSafetyPolicyPath(cwd);
+  let policyPath = projectSafetyPolicyPath(cwd);
   if (policyPath === null) {
     return {
       path: null,
@@ -329,6 +343,7 @@ function loadProjectSafetyPolicy(cwd = process.cwd()) {
   }
   let raw;
   try {
+    policyPath = realpathSync(policyPath);
     raw = readFileSync(policyPath, "utf8");
   } catch (err) {
     return {
@@ -772,13 +787,38 @@ function expandHome(value) {
   return value === "~" ? homedir2() : value.startsWith("~/") ? path3.join(homedir2(), value.slice(2)) : value;
 }
 
+// src/domains/safety/workspace-trust.ts
+init_esm_shims();
+function gateProjectSafetyPolicy(workspaceRoot, policy) {
+  if (policy.path === null) return policy;
+  const trustVerdict = policy.hash === null ? "untrusted" : projectSurfaceTrust(workspaceRoot, "safety", safetySurfaceTrustHash(policy.path, policy.hash));
+  if (trustVerdict === "trusted") return { ...policy, trustVerdict };
+  return {
+    ...policy,
+    trustVerdict,
+    // This is the admitted empty policy, whose execution defaults are valid.
+    // Unapproved parse failures retain diagnostics below but cannot acquire the
+    // authority to block execution. An approved malformed policy stays invalid.
+    valid: true,
+    commands: [],
+    pathPolicy: {},
+    disableDefaultPathPolicy: false,
+    errors: [
+      ...policy.errors,
+      `${policy.path} is ${trustVerdict}; project safety ignored. Review with clio-coder config trust safety.`
+    ]
+  };
+}
+
 // src/domains/safety/policy-engine.ts
 var BUILTIN_ALLOWLIST = [
   { id: "builtin:pwd", re: /^pwd$/ },
   { id: "builtin:ls", re: /^ls(?:\s+(-[A-Za-z0-9]+|\.[/\w.-]*|[/\w.-]+))*$/ },
   { id: "builtin:git-status", re: /^git\s+status(?:\s+--short|\s+--branch|\s+-sb)*$/ },
   { id: "builtin:git-diff", re: /^git\s+diff(?:\s+--cached|\s+--stat|\s+--name-only|\s+--\s+[\w./-]+)*$/ },
-  { id: "builtin:git-log", re: /^git\s+log\s+--oneline(?:\s+-n\s+[1-9]\d{0,2})?(?:\s+--\s+[\w./-]+)?$/ },
+  { id: "builtin:git-log", re: /^git\s+log\s+--oneline(?:\s+-n\s+[1-9]\d{0,2})?(?:\s+--\s+[\w./-]+)?$/ }
+];
+var PROJECT_SCRIPT_COMMANDS = [
   { id: "builtin:npm-test", re: /^npm\s+(?:test|run\s+test)(?:\s+--\s+[\w=./:-]+(?:\s+[\w=./:-]+)*)?$/ },
   { id: "builtin:npm-lint", re: /^npm\s+run\s+lint(?:\s+--\s+[\w=./:-]+(?:\s+[\w=./:-]+)*)?$/ },
   { id: "builtin:npm-build", re: /^npm\s+run\s+build(?:\s+--\s+[\w=./:-]+(?:\s+[\w=./:-]+)*)?$/ },
@@ -823,12 +863,12 @@ function createSafetyPolicyEngine(options = {}) {
   const writeRoots = (options.writeRoots ?? []).map((root) => resolvePathBoundary(writeRootCwd, root));
   const skillRoots = activeClioSkillRoots(cwd);
   const packs = options.rulePacks ?? getCachedDefaultRulePacks();
-  const projectPolicy = options.projectPolicy ?? loadProjectSafetyPolicy(cwd);
-  const projectPolicyRoot = projectPolicy.path === null ? cwd : path4.dirname(path4.dirname(canonicalizeExistingPath(projectPolicy.path)));
+  const projectPolicy = options.projectPolicy ?? gateProjectSafetyPolicy(cwd, loadProjectSafetyPolicy(cwd));
+  const projectPolicyRoot = projectPolicy.path === null ? cwd : path4.dirname(path4.dirname(path4.resolve(projectPolicy.path)));
   const pathPolicyInput = projectPolicy.disableDefaultPathPolicy ? projectPolicy.pathPolicy : mergePathPolicyInputs(DEFAULT_DAMAGE_CONTROL_PATH_POLICY, projectPolicy.pathPolicy);
-  const expandedDefaults = projectPolicy.disableDefaultPathPolicy ? pathPolicyInput : mergePathPolicyInputs(pathPolicyInput, {
+  const expandedDefaults = mergePathPolicyInputs(mergePathPolicyInputs(pathPolicyInput, OPERATOR_PATH_POLICY), {
     zeroAccessPaths: clioCredentialStorePaths(),
-    readOnlyPaths: clioSkillsRootPaths()
+    readOnlyPaths: [...clioSkillsRootPaths(), path4.join(clioConfigDir(), "settings.yaml"), workspaceTrustDirectory()]
   });
   const pathPolicy = compilePathPolicy(expandedDefaults, projectPolicyRoot);
   const zeroAccessPolicy = {
@@ -890,6 +930,27 @@ function createSafetyPolicyEngine(options = {}) {
         return blockDecision(base, blockInput);
       }
       const mutationCommand = call.tool === ToolNames.Bash ? command : catalogCommand;
+      if (mutationCommand !== null && invokesTrustMutation(mutationCommand)) {
+        return blockDecision(base, {
+          reasonCode: "trust-authority",
+          ruleId: "trust-authority",
+          reasons: ["workspace trust grants require the operator CLI"],
+          policySource: "builtin-classifier"
+        });
+      }
+      if (skillMutationReason(
+        [path4.join(clioConfigDir(), "settings.yaml"), workspaceTrustDirectory()],
+        pathPolicyTargets(catalogCommand === null ? call : { tool: ToolNames.Bash, args: { command: catalogCommand } }),
+        callCwd,
+        mutationCommand
+      ) !== null) {
+        return blockDecision(base, {
+          reasonCode: "path-policy:readOnlyPaths",
+          ruleId: "path-policy:readOnlyPaths",
+          reasons: ["Clio settings and workspace trust records are operator-owned and cannot be mutated by tools"],
+          policySource: "builtin-classifier"
+        });
+      }
       const skillReason = mutationCommand !== null && invokesClioSkillMutation(mutationCommand) ? "skill installation and updates require the operator CLI or an explicit operator install choice; draft outside active skill roots" : skillMutationReason(
         skillRoots,
         pathPolicyTargets(catalogCommand === null ? call : { tool: ToolNames.Bash, args: { command: catalogCommand } }),
@@ -960,8 +1021,25 @@ function createSafetyPolicyEngine(options = {}) {
         };
         return posture === "confirmed" ? allowDecision(base, input) : askDecision(base, input);
       }
-      if (call.tool === ToolNames.Bash && classification.actionClass === "execute") {
-        const bash = evaluateBashPolicy(command ?? "", callCwd, cwd, posture, projectPolicy);
+      const packageCommand = call.tool === ToolNames.Verify && catalogCheck === null && typeof call.args?.check === "string" && call.args.check !== "frontend" ? `npm run ${call.args.check}` : null;
+      if ((call.tool === ToolNames.Bash || catalogCheck !== null || packageCommand !== null) && classification.actionClass === "execute") {
+        const bash = evaluateBashPolicy(
+          catalogCheck?.command ?? packageCommand ?? command ?? "",
+          catalogCheck === null ? callCwd : path4.resolve(cwd, catalogCheck.cwd),
+          cwd,
+          posture,
+          projectPolicy
+        );
+        if ((catalogCheck !== null || packageCommand !== null) && bash.kind === "allow" && bash.execRecognition !== "recognized" && posture !== "confirmed") {
+          return askDecision(base, {
+            ...bash,
+            reasonCode: "project-verifier-confirm",
+            reasons: [
+              ...bash.reasons,
+              `Repository verifier requires confirmation or an approved safety declaration: ${catalogCommand ?? packageCommand}`
+            ]
+          });
+        }
         if (bash.kind === "block") return blockDecision(base, bash);
         if (bash.kind === "ask") return askDecision(base, bash);
         return allowDecision(base, bash);
@@ -973,15 +1051,7 @@ function createSafetyPolicyEngine(options = {}) {
       };
       if (hit?.match.ruleId !== void 0) allowInput.ruleId = hit.match.ruleId;
       if (hit?.match !== void 0) allowInput.match = hit.match;
-      if (classification.actionClass === "execute") {
-        allowInput.execRecognition = catalogCheck === null ? "recognized" : "unrecognized";
-        if (catalogCheck !== null) {
-          allowInput.reasons = [
-            ...allowInput.reasons,
-            `project verifier '${catalogCheck.id}' runs declared argv: ${catalogCommand ?? ""}`
-          ];
-        }
-      }
+      if (classification.actionClass === "execute") allowInput.execRecognition = "recognized";
       return allowDecision(base, allowInput);
     },
     metadata() {
@@ -994,6 +1064,8 @@ function createSafetyPolicyEngine(options = {}) {
         projectPolicyHash: projectPolicy.hash,
         projectPolicyValid: projectPolicy.valid,
         projectPolicyErrors: [...projectPolicy.errors, ...pathPolicy.diagnostics],
+        disableDefaultPathPolicy: projectPolicy.disableDefaultPathPolicy,
+        workspaceTrustVerdict: projectPolicy.trustVerdict ?? "trusted",
         cwd
       };
     }
@@ -1092,7 +1164,18 @@ function pathPolicyTargets(call) {
       return [];
   }
 }
-function evaluateBashPolicy(command, callCwd, workspaceRoot, posture, policy) {
+function evaluateBashPolicy(input, callCwd, workspaceRoot, posture, policy) {
+  if (typeof input !== "string" && !input.every((arg) => /^[\w=./:-]+$/u.test(arg))) {
+    return {
+      kind: posture === "confirmed" ? "allow" : "ask",
+      ruleId: "verify-unrecognized-argv",
+      reasonCode: "verify-unrecognized-argv",
+      reasons: ["project verifier argv is outside the bare-word no-prompt command set"],
+      policySource: "builtin-command-allowlist",
+      execRecognition: "unrecognized"
+    };
+  }
+  const command = typeof input === "string" ? input : input.join(" ");
   if (command.trim().length === 0) {
     return {
       kind: "block",
@@ -1102,6 +1185,16 @@ function evaluateBashPolicy(command, callCwd, workspaceRoot, posture, policy) {
       policySource: "builtin-command-allowlist"
     };
   }
+  if (typeof input === "string" && (/\$(?:[A-Za-z_{0-9@*#?!-])/.test(command) || /(?:^|[\s;&|])(?:python[\d.]*|node|ruby|perl|php|lua)\s+(?:[^\n]*?\s)?-[ce]\b/.test(command)) && posture !== "confirmed") {
+    return {
+      kind: "ask",
+      reasonCode: "bash-hidden-content",
+      ruleId: "bash-hidden-content",
+      reasons: ["shell variables or interpreter source hide paths from the safety scan and require one-shot confirmation"],
+      policySource: "builtin-command-allowlist",
+      execRecognition: "unrecognized"
+    };
+  }
   const projectMatch = matchingProjectCommand(policy, command, callCwd);
   if (projectMatch) {
     const base = {
@@ -1144,15 +1237,34 @@ function evaluateBashPolicy(command, callCwd, workspaceRoot, posture, policy) {
       execRecognition: "unrecognized"
     };
   }
+  if (PROJECT_SCRIPT_COMMANDS.some((entry) => entry.re.test(recognitionCommand))) {
+    return {
+      kind: posture === "confirmed" ? "allow" : "ask",
+      reasonCode: "project-script-confirm",
+      ruleId: "project-script-confirm",
+      reasons: [
+        "Repository-authored code requires one-shot confirmation or an operator-approved safety command declaration.",
+        projectScriptPreview(recognitionCommand, callCwd)
+      ],
+      policySource: "builtin-command-allowlist",
+      execRecognition: "unrecognized"
+    };
+  }
   const chain = recognizeCommandChain(recognitionCommand, callCwd, workspaceRoot, policy);
   if (chain !== null) {
     const chainReasons = [`every step of the && chain is recognized: ${chain.ruleIds.join(", ")}`];
+    if (chain.requiresConfirmation) {
+      for (const segment of recognitionCommand.split("&&").map((part) => part.trim())) {
+        if (PROJECT_SCRIPT_COMMANDS.some((entry) => entry.re.test(segment)))
+          chainReasons.push(projectScriptPreview(segment, callCwd));
+      }
+    }
     if (chain.requiresConfirmation && posture !== "confirmed") {
       return {
         kind: "ask",
         ruleId: "bash-recognized-chain",
         reasonCode: "bash-recognized-chain",
-        reasons: [...chainReasons, "project policy requires confirmation for one step"],
+        reasons: [...chainReasons, "repository code or project policy requires confirmation for one step"],
         policySource: "builtin-command-allowlist",
         execRecognition: "recognized"
       };
@@ -1167,6 +1279,20 @@ function evaluateBashPolicy(command, callCwd, workspaceRoot, posture, policy) {
     };
   }
   if (hasSequencingOperators(command)) {
+    const scriptSegments = recognitionCommand.split(/&&|\|\||[;|\n]/).map((part) => part.trim()).filter((part) => PROJECT_SCRIPT_COMMANDS.some((entry) => entry.re.test(part)));
+    if (scriptSegments.length > 0 && posture !== "confirmed") {
+      return {
+        kind: "ask",
+        ruleId: "project-script-confirm",
+        reasonCode: "project-script-confirm",
+        reasons: [
+          "Repository scripts in compound commands require one-shot confirmation",
+          ...scriptSegments.map((part) => projectScriptPreview(part, callCwd))
+        ],
+        policySource: "builtin-command-allowlist",
+        execRecognition: "unrecognized"
+      };
+    }
     return {
       kind: "allow",
       ruleId: "bash-shell-operators",
@@ -1316,6 +1442,11 @@ function recognizeCommandChain(command, callCwd, workspaceRoot, policy) {
       if (projectMatch.requireConfirmation) requiresConfirmation = true;
       continue;
     }
+    if (PROJECT_SCRIPT_COMMANDS.some((entry) => entry.re.test(rendered))) {
+      ruleIds.push("project-script-confirm");
+      requiresConfirmation = true;
+      continue;
+    }
     const builtin = BUILTIN_ALLOWLIST.find((entry) => entry.re.test(rendered));
     if (builtin === void 0) return null;
     ruleIds.push(builtin.id);
@@ -1407,10 +1538,30 @@ function packPayload(rules) {
     ...rule.ask !== void 0 ? { ask: rule.ask } : {}
   }));
 }
+function invokesTrustMutation(command) {
+  const words = scanShellLike(command).filter((token) => !token.operator).map((token) => token.value);
+  return words.some((word, index) => word === "config" && words[index + 1] === "trust") || /\bconfig\s+trust\b/.test(inlineShellScript(command) ?? "");
+}
+function projectScriptPreview(command, cwd) {
+  const match = /^npm\s+(?:run\s+)?([\w:-]+)/.exec(command);
+  if (match) {
+    try {
+      const manifest = JSON.parse(readFileSync3(path4.join(cwd, "package.json"), "utf8"));
+      const name = match[1] ?? "test";
+      const scripts = [`pre${name}`, name, `post${name}`].flatMap(
+        (key) => typeof manifest.scripts?.[key] === "string" ? [`${key}: ${manifest.scripts[key]}`] : []
+      );
+      return `package.json scripts (repository data): ${scripts.join("; ") || "no script resolved"}`;
+    } catch {
+      return "package.json script body could not be resolved; repository code will execute.";
+    }
+  }
+  return `Repository command: ${command}. Its test/build files and dependencies execute with the child process permissions.`;
+}
 
 export {
   formatModelRejection,
   WRITE_ROOT_REFUSED_TOOLS,
   createSafetyPolicyEngine
 };
-//# sourceMappingURL=chunk-6Q3CYFD3.js.map
+//# sourceMappingURL=chunk-IKRWLEDA.js.map

package/dist/{chunk-2JH2WHGE.js → chunk-J2FYEQ5L.js}

@@ -1,13 +1,13 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   openAuthStorage
-} from "./chunk-ID64D7PE.js";
+} from "./chunk-HXHFDHB6.js";
 import {
   getRuntimeRegistry
-} from "./chunk-NUGM5KR6.js";
+} from "./chunk-SRCEQKQS.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/providers/credentials.ts
 init_esm_shims();
@@ -30,4 +30,4 @@ function credentialsPresent() {
 export {
   credentialsPresent
 };
-//# sourceMappingURL=chunk-2JH2WHGE.js.map
+//# sourceMappingURL=chunk-J2FYEQ5L.js.map

package/dist/{chunk-BMS5RKQY.js → chunk-JABWPKFY.js}

@@ -2,10 +2,10 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   findExecutableOnPath,
   resolveToolBinary
-} from "./chunk-QSNYB6ZV.js";
+} from "./chunk-XCUDZQLX.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/tools/executables.ts
 init_esm_shims();
@@ -24,4 +24,4 @@ export {
   resolveRgBinary,
   resolveBinary
 };
-//# sourceMappingURL=chunk-BMS5RKQY.js.map
+//# sourceMappingURL=chunk-JABWPKFY.js.map

package/dist/{chunk-2DSOYNFC.js → chunk-JMPL7NUB.js}

@@ -1,24 +1,24 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   truncateToWidth
-} from "./chunk-YAKGTXEV.js";
+} from "./chunk-QRFXEO6Y.js";
 import {
   EVIDENCE_TAGS,
   listEvidenceOverviews,
   loadEvidenceTrustStatus
-} from "./chunk-NRO2BJRH.js";
+} from "./chunk-24T2YZ7A.js";
 import {
   trustVerdict
-} from "./chunk-CUSRQKPU.js";
+} from "./chunk-HZ2T2YED.js";
 import {
   sanitizeCallTargetText
-} from "./chunk-NEDJ26B5.js";
+} from "./chunk-2GPGAE5W.js";
 import {
   clioDataDir
-} from "./chunk-BYP5D4HI.js";
+} from "./chunk-CTTI7G3T.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/evidence/inventory.ts
 init_esm_shims();
@@ -105,4 +105,4 @@ export {
   EVIDENCE_INVENTORY_MAX_IDS,
   evidenceInventorySnapshot
 };
-//# sourceMappingURL=chunk-2DSOYNFC.js.map
+//# sourceMappingURL=chunk-JMPL7NUB.js.map

package/dist/{chunk-QDC3K2U3.js → chunk-K2BLQC5E.js}

@@ -2,10 +2,10 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   clioDataDir,
   resolveClioDirs
-} from "./chunk-BYP5D4HI.js";
+} from "./chunk-CTTI7G3T.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/toolchain/registry.ts
 init_esm_shims();
@@ -259,4 +259,4 @@ export {
   vendoredBinaryPath,
   ensureToolchainRoot
 };
-//# sourceMappingURL=chunk-QDC3K2U3.js.map
+//# sourceMappingURL=chunk-K2BLQC5E.js.map

package/dist/{chunk-AUPNRN7C.js → chunk-K2HL3GBL.js}

@@ -2,13 +2,13 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   gateRouteCorrelation,
   isExecutionRole
-} from "./chunk-H7IXIC72.js";
+} from "./chunk-LY4N4TTL.js";
 import {
   isAgentCapabilityClass
-} from "./chunk-KFV5L5SK.js";
+} from "./chunk-OQM5IVJY.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/dispatch/routing-intent.ts
 init_esm_shims();
@@ -995,4 +995,4 @@ export {
   routingIntentRejection,
   explainRouteDecision
 };
-//# sourceMappingURL=chunk-AUPNRN7C.js.map
+//# sourceMappingURL=chunk-K2HL3GBL.js.map