@iowarp/clio-coder 0.3.0

package/dist/chunk-WD6AJM35.js

@@ -0,0 +1,1216 @@
+import {
+  ToolNames,
+  isBuiltinToolName
+} from "./chunk-QV47YRF4.js";
+
+// src/domains/agents/spec.ts
+import { createHash } from "node:crypto";
+
+// src/domains/safety/action-classifier.ts
+import path3 from "node:path";
+
+// src/core/path-canonical.ts
+import { realpathSync } from "node:fs";
+import path from "node:path";
+function canonicalizeExistingPath(absPath) {
+  const resolved = path.resolve(absPath);
+  try {
+    return path.resolve(realpathSync(resolved));
+  } catch {
+  }
+  const tail = [];
+  let cursor = resolved;
+  while (true) {
+    const parent = path.dirname(cursor);
+    if (parent === cursor) {
+      try {
+        return path.resolve(realpathSync(cursor), ...tail);
+      } catch {
+        return resolved;
+      }
+    }
+    tail.unshift(path.basename(cursor));
+    cursor = parent;
+    try {
+      return path.resolve(realpathSync(cursor), ...tail);
+    } catch {
+    }
+  }
+}
+
+// src/domains/safety/protected-artifacts.ts
+import path2 from "node:path";
+
+// src/core/verification-scripts.ts
+var VERIFICATION_SCRIPT_FAMILY_HINT = "test*/lint*/build*/typecheck*/check*/format*/ci*";
+var VERIFICATION_SCRIPT_PATTERN = /^(?:test|lint|build|typecheck|check|format|ci)(?:[:.-].*)?$/;
+function isVerificationScriptName(name) {
+  return VERIFICATION_SCRIPT_PATTERN.test(name);
+}
+function declaredVerificationScripts(scripts) {
+  return Object.keys(scripts).filter((name) => isVerificationScriptName(name)).sort((a, b) => a.localeCompare(b));
+}
+
+// src/domains/safety/protected-artifacts.ts
+var COMMAND_SEPARATORS = /* @__PURE__ */ new Set([";", "&&", "||", "|"]);
+var SHELL_WRAPPERS = /* @__PURE__ */ new Set(["command", "builtin", "sudo", "doas"]);
+function toolMutationPaths(toolName, args) {
+  if (toolName === ToolNames.Artifact) {
+    return [mutationPathArg(args) ?? artifactDefaultPath(args)];
+  }
+  if (toolName === ToolNames.Write || toolName === ToolNames.Edit) {
+    const candidate = mutationPathArg(args);
+    return candidate === null ? [] : [candidate];
+  }
+  return [];
+}
+function protectedArtifactMutationBlockReason(state, toolName, args) {
+  if (state.artifacts.length === 0) return null;
+  for (const candidate of toolMutationPaths(toolName, args)) {
+    if (isProtectedPath(state, candidate)) {
+      return `protected artifact blocked: ${toolName} would modify protected path ${candidate}`;
+    }
+  }
+  if (toolName !== ToolNames.Bash) return null;
+  const command = typeof args?.command === "string" && args.command.length > 0 ? args.command : null;
+  if (command === null) return null;
+  const classification = classifyDestructiveCommand(command, state.artifacts);
+  if (classification.kind === "benign") return null;
+  const affected = classification.matches.map((match) => match.artifactPath).join(", ");
+  return `protected artifact blocked: ${classification.operation} would affect ${affected}`;
+}
+function artifactDefaultPath(args) {
+  if (args?.kind === "review") return "REVIEW.md";
+  if (args?.kind === "report") return "REPORT.md";
+  return "PLAN.md";
+}
+function mutationPathArg(args) {
+  if (!args) return null;
+  const candidate = args.path ?? args.file_path ?? args.filePath;
+  return typeof candidate === "string" && candidate.length > 0 ? candidate : null;
+}
+function protectArtifact(state, artifact) {
+  const artifacts = artifactMap(state.artifacts);
+  const key = normalizePathKey(artifact.path);
+  if (key !== null) artifacts.set(key, cloneArtifact(artifact));
+  return stateFromMap(artifacts);
+}
+function isProtectedPath(state, artifactPath) {
+  const candidate = normalizePathKey(artifactPath);
+  if (candidate === null) return false;
+  for (const artifact of normalizedArtifacts(state.artifacts)) {
+    if (isSameOrDescendant(candidate, artifact.key)) return true;
+  }
+  return false;
+}
+function classifyDestructiveCommand(command, protectedArtifacts) {
+  const artifacts = normalizedArtifacts(protectedArtifacts);
+  if (artifacts.length === 0) return { kind: "benign", matches: [] };
+  const tokens = tokenizeShellLike(command);
+  for (const segment of splitSegments(tokens)) {
+    const redirect = classifyRedirect(segment, artifacts);
+    if (redirect.kind === "destructive") return redirect;
+    const commandIndex = commandTokenIndex(segment);
+    if (commandIndex === null) continue;
+    const executable = basenameToken(segment[commandIndex]);
+    if (executable === "rm") {
+      const result = classifyPathOperation(
+        "rm",
+        "rm can remove protected artifacts",
+        pathArgs(segment, commandIndex),
+        artifacts
+      );
+      if (result.kind === "destructive") return result;
+      continue;
+    }
+    if (executable === "mv") {
+      const result = classifyPathOperation(
+        "mv",
+        "mv can move or overwrite protected artifacts",
+        pathArgs(segment, commandIndex),
+        artifacts
+      );
+      if (result.kind === "destructive") return result;
+      continue;
+    }
+    if (executable === "truncate") {
+      const result = classifyPathOperation(
+        "truncate",
+        "truncate can overwrite protected artifacts",
+        pathArgs(segment, commandIndex),
+        artifacts
+      );
+      if (result.kind === "destructive") return result;
+      continue;
+    }
+    if (executable === "cp") {
+      const args = pathArgs(segment, commandIndex);
+      const destination = args.at(-1);
+      const result = classifyPathOperation(
+        "cp",
+        "cp can overwrite protected artifacts",
+        destination === void 0 ? [] : [destination],
+        artifacts
+      );
+      if (result.kind === "destructive") return result;
+      continue;
+    }
+    if (executable === "git") {
+      const result = classifyGitOperation(segment.slice(commandIndex + 1), artifacts);
+      if (result.kind === "destructive") return result;
+      continue;
+    }
+    if (executable === "find") {
+      const result = classifyFindDelete(segment.slice(commandIndex + 1), artifacts);
+      if (result.kind === "destructive") return result;
+    }
+  }
+  return { kind: "benign", matches: [] };
+}
+function detectValidationCommand(command, scope = "finish-contract") {
+  const tokens = tokenizeShellLike(command);
+  for (const segment of splitSegments(tokens)) {
+    const commandIndex = commandTokenIndex(segment);
+    if (commandIndex === null) continue;
+    const executable = basenameToken(segment[commandIndex]);
+    const args = segment.slice(commandIndex + 1);
+    const matched = validationMatch(executable, args) ?? (scope === "grounding" ? groundingMatch(executable, args) : null);
+    if (matched !== null) return { kind: "validation", matched };
+  }
+  return { kind: "none" };
+}
+function extractCommandWriteTargets(command) {
+  const targets = [];
+  for (const segment of expandedSegments(command)) {
+    collectRedirectTargets(segment, targets);
+    collectInvokedWriteTargets(segment, targets);
+    collectInPlaceEditTargets(segment, targets);
+  }
+  return targets.filter(isInterestingWriteTarget);
+}
+var INNER_SHELLS = /* @__PURE__ */ new Set(["sh", "bash", "zsh", "dash", "ksh"]);
+var INNER_SHELL_MAX_DEPTH = 3;
+function segmentShellScript(segment) {
+  const commandIndex = commandTokenIndex(segment);
+  if (commandIndex === null) return null;
+  if (!INNER_SHELLS.has(basenameToken(segment[commandIndex]))) return null;
+  for (let index = commandIndex + 1; index < segment.length; index += 1) {
+    const token = segment[index];
+    if (token === void 0) continue;
+    if (token.startsWith("-") && token.length > 1) {
+      if (!token.slice(1).includes("c")) continue;
+      const script = segment[index + 1];
+      return script !== void 0 && script.length > 0 ? script : null;
+    }
+    return null;
+  }
+  return null;
+}
+function expandedSegments(command, depth = 0) {
+  const segments = splitSegments(tokenizeShellLike(command));
+  if (depth >= INNER_SHELL_MAX_DEPTH) return segments;
+  const out = [];
+  for (const segment of segments) {
+    out.push(segment);
+    const script = segmentShellScript(segment);
+    if (script !== null) out.push(...expandedSegments(script, depth + 1));
+  }
+  return out;
+}
+function inlineShellScript(command) {
+  const segments = splitSegments(tokenizeShellLike(command));
+  if (segments.length !== 1) return null;
+  const segment = segments[0];
+  if (segment === void 0) return null;
+  return segmentShellScript(segment);
+}
+function extractCommandCdTargets(command) {
+  const targets = [];
+  for (const segment of expandedSegments(command)) {
+    const commandIndex = commandTokenIndex(segment);
+    if (commandIndex === null) continue;
+    const executable = basenameToken(segment[commandIndex]);
+    if (executable !== "cd" && executable !== "pushd") continue;
+    const target = pathArgs(segment, commandIndex).at(0);
+    targets.push(target ?? "~");
+  }
+  return targets;
+}
+function extractCommandDeleteTargets(command) {
+  const targets = [];
+  for (const segment of expandedSegments(command)) {
+    const commandIndex = commandTokenIndex(segment);
+    if (commandIndex === null) continue;
+    const executable = basenameToken(segment[commandIndex]);
+    if (executable === "rm") {
+      targets.push(...pathArgs(segment, commandIndex));
+      continue;
+    }
+    if (executable === "mv") {
+      const args = pathArgs(segment, commandIndex);
+      if (args.length >= 2) targets.push(...args.slice(0, -1));
+      continue;
+    }
+    if (executable === "find" && segment.includes("-delete")) {
+      targets.push(...findRoots(segment.slice(commandIndex + 1)));
+    }
+  }
+  return targets.filter(isInterestingWriteTarget);
+}
+var STANDARD_DEV_TARGETS = /* @__PURE__ */ new Set(["/dev/null", "/dev/stdout", "/dev/stderr", "/dev/tty", "/dev/zero"]);
+function collectRedirectTargets(segment, out) {
+  for (let index = 0; index < segment.length - 1; index += 1) {
+    const token = segment[index];
+    if (token !== ">" && token !== ">>") continue;
+    const target = segment[index + 1];
+    if (target !== void 0) out.push(target);
+  }
+}
+function collectInvokedWriteTargets(segment, out) {
+  const cmdIndex = commandTokenIndex(segment);
+  if (cmdIndex === null) return;
+  const executable = basenameToken(segment[cmdIndex]);
+  if (executable === "tee") {
+    for (const arg of pathArgs(segment, cmdIndex)) out.push(arg);
+    return;
+  }
+  if (executable === "mkdir" || executable === "touch") {
+    for (const arg of pathArgs(segment, cmdIndex)) out.push(arg);
+    return;
+  }
+  if (executable === "ln") {
+    const args = pathArgs(segment, cmdIndex);
+    const destination = args.at(-1);
+    if (args.length >= 2 && destination !== void 0) out.push(destination);
+    return;
+  }
+  if (executable === "cp" || executable === "mv") {
+    const args = pathArgs(segment, cmdIndex);
+    const destination = args.at(-1);
+    if (args.length >= 2 && destination !== void 0) out.push(destination);
+  }
+}
+function collectInPlaceEditTargets(segment, out) {
+  const cmdIndex = commandTokenIndex(segment);
+  if (cmdIndex === null) return;
+  if (basenameToken(segment[cmdIndex]) !== "sed") return;
+  if (!hasSedInPlaceFlag(segment, cmdIndex)) return;
+  for (const operand of sedFileOperands(segment, cmdIndex)) out.push(operand);
+}
+function hasSedInPlaceFlag(segment, cmdIndex) {
+  for (let index = cmdIndex + 1; index < segment.length; index += 1) {
+    const token = segment[index];
+    if (token === void 0) continue;
+    if (COMMAND_SEPARATORS.has(token)) break;
+    if (token === "--") break;
+    if (token === "--in-place" || token.startsWith("--in-place=")) return true;
+    if (token.startsWith("--")) continue;
+    if (token.startsWith("-") && token.length > 1 && token.slice(1).includes("i")) return true;
+  }
+  return false;
+}
+function sedFileOperands(segment, cmdIndex) {
+  const operands = [];
+  let sawScriptFlag = false;
+  let endOfOptions = false;
+  for (let index = cmdIndex + 1; index < segment.length; index += 1) {
+    const token = segment[index];
+    if (token === void 0) continue;
+    if (COMMAND_SEPARATORS.has(token)) break;
+    if (!endOfOptions && token === "--") {
+      endOfOptions = true;
+      continue;
+    }
+    if (!endOfOptions && token.startsWith("-") && token.length > 1) {
+      if (token === "-e" || token === "-f") {
+        sawScriptFlag = true;
+        index += 1;
+        continue;
+      }
+      if (token === "-l") {
+        index += 1;
+        continue;
+      }
+      if (token === "--expression" || token === "--file") {
+        sawScriptFlag = true;
+        index += 1;
+        continue;
+      }
+      if (token.startsWith("--expression=") || token.startsWith("--file=")) {
+        sawScriptFlag = true;
+        continue;
+      }
+      continue;
+    }
+    operands.push(token);
+  }
+  if (!sawScriptFlag && operands.length > 0) operands.shift();
+  return operands;
+}
+function isInterestingWriteTarget(target) {
+  if (target.length === 0) return false;
+  if (target.startsWith("&")) return false;
+  if (STANDARD_DEV_TARGETS.has(target)) return false;
+  if (target.startsWith("/dev/fd/")) return false;
+  return true;
+}
+function classifyRedirect(segment, artifacts) {
+  for (let index = 0; index < segment.length; index += 1) {
+    if (segment[index] !== ">") continue;
+    const target = segment[index + 1];
+    if (target === void 0) continue;
+    const matches = matchesForPaths([target], artifacts, "target", "redirect can overwrite protected artifacts");
+    if (matches.length > 0) {
+      return {
+        kind: "destructive",
+        operation: "redirect",
+        matches
+      };
+    }
+  }
+  return { kind: "benign", matches: [] };
+}
+function classifyGitOperation(args, artifacts) {
+  const subcommand = args[0];
+  if (subcommand === "reset" && args.includes("--hard")) {
+    return {
+      kind: "destructive",
+      operation: "git_reset_hard",
+      matches: artifacts.map(({ artifact }) => ({
+        artifactPath: artifact.path,
+        commandPath: ".",
+        reason: "git reset --hard can overwrite protected artifacts"
+      }))
+    };
+  }
+  if (subcommand === "checkout" && args.includes("--")) {
+    const paths = args.slice(args.indexOf("--") + 1);
+    const matches = matchesForPaths(paths, artifacts, "intersects", "git checkout -- can overwrite protected artifacts");
+    if (matches.length > 0) {
+      return {
+        kind: "destructive",
+        operation: "git_checkout",
+        matches
+      };
+    }
+    return { kind: "benign", matches: [] };
+  }
+  if (subcommand === "restore") {
+    const matches = matchesForPaths(
+      pathArgs(args.slice(1), -1),
+      artifacts,
+      "intersects",
+      "git restore can overwrite protected artifacts"
+    );
+    if (matches.length > 0) {
+      return {
+        kind: "destructive",
+        operation: "git_restore",
+        matches
+      };
+    }
+  }
+  return { kind: "benign", matches: [] };
+}
+function classifyFindDelete(args, artifacts) {
+  if (!args.includes("-delete")) return { kind: "benign", matches: [] };
+  const roots = findRoots(args);
+  const matches = matchesForPaths(
+    roots.length === 0 ? ["."] : roots,
+    artifacts,
+    "intersects",
+    "find -delete can remove protected artifacts"
+  );
+  if (matches.length > 0) {
+    return {
+      kind: "destructive",
+      operation: "find_delete",
+      matches
+    };
+  }
+  return { kind: "benign", matches: [] };
+}
+function findRoots(args) {
+  const roots = [];
+  for (const token of args) {
+    if (token === "-delete" || token.startsWith("-") || token === "(" || token === "!" || token === "not") break;
+    if (token === "--") continue;
+    roots.push(token);
+  }
+  return roots.length === 0 ? ["."] : roots;
+}
+function classifyPathOperation(operation, reason, paths, artifacts) {
+  const matches = matchesForPaths(paths, artifacts, "intersects", reason);
+  if (matches.length === 0) return { kind: "benign", matches: [] };
+  return {
+    kind: "destructive",
+    operation,
+    matches
+  };
+}
+function matchesForPaths(commandPaths, artifacts, mode, reason) {
+  const matches = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const commandPath of commandPaths) {
+    for (const artifact of artifacts) {
+      if (!pathMatchesArtifact(commandPath, artifact.key, mode)) continue;
+      const key = `${artifact.key}\0${commandPath}\0${reason}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      matches.push({
+        artifactPath: artifact.artifact.path,
+        commandPath,
+        reason
+      });
+    }
+  }
+  matches.sort(compareMatches);
+  return matches;
+}
+function pathMatchesArtifact(commandPath, artifactKey, mode) {
+  const wildcardRoot = wildcardRootKey(commandPath);
+  if (wildcardRoot !== null) {
+    return isSameOrDescendant(artifactKey, wildcardRoot);
+  }
+  const commandKey = normalizePathKey(commandPath);
+  if (commandKey === null) return false;
+  if (mode === "target") return isSameOrDescendant(commandKey, artifactKey);
+  return isSameOrDescendant(commandKey, artifactKey) || isSameOrDescendant(artifactKey, commandKey);
+}
+function validationMatch(executable, args) {
+  if (executable === "npm") {
+    if (args[0] === "test") return "npm test";
+    const script = args[0] === "run" && typeof args[1] === "string" ? args[1] : null;
+    if (script !== null && isVerificationScriptName(script)) return `npm run ${script}`;
+  }
+  if (executable === "pytest") return "pytest";
+  if (isPythonExecutable(executable) && moduleArg(args) === "pytest") return "python -m pytest";
+  if (executable === "cargo" && args[0] === "test") return "cargo test";
+  if (executable === "go" && args[0] === "test") return "go test";
+  if (executable === "ctest") return "ctest";
+  if (executable === "make" && args[0] === "test") return "make test";
+  if (executable === "ninja" && args[0] === "test") return "ninja test";
+  if (executable === "mvn" && args[0] === "test") return "mvn test";
+  if ((executable === "gradle" || executable === "gradlew") && args[0] === "test") return "gradle test";
+  return null;
+}
+function groundingMatch(executable, args) {
+  if (executable === "git") {
+    if (args[0] === "diff") return "git diff";
+    if (args[0] === "status") return "git status";
+    return null;
+  }
+  if (executable === "node") {
+    if (args.includes("--test")) return "node --test";
+    if (args.includes("-e") || args.includes("--eval")) return "node -e";
+    return null;
+  }
+  if (executable === "tsc") return typescriptCheckMatch(args);
+  if (executable === "npx") {
+    const inner = npxInvocation(args);
+    return inner === null ? null : npxRunnerMatch(inner.executable, inner.args);
+  }
+  return null;
+}
+var NPX_TEST_RUNNERS = /* @__PURE__ */ new Set(["vitest", "jest", "mocha"]);
+function npxRunnerMatch(executable, args) {
+  if (NPX_TEST_RUNNERS.has(executable)) return `npx ${executable}`;
+  if (executable === "tsx" && args.includes("--test")) return "npx tsx --test";
+  if (executable === "tsc") return typescriptCheckMatch(args);
+  return null;
+}
+function typescriptCheckMatch(args) {
+  return args.some((arg) => arg.toLowerCase() === "--noemit") ? "tsc --noEmit" : "tsc";
+}
+function npxInvocation(args) {
+  const VALUE_FLAGS = /* @__PURE__ */ new Set(["-p", "--package", "-c", "--call", "--shell"]);
+  let index = 0;
+  while (index < args.length) {
+    const token = args[index];
+    if (token === void 0) return null;
+    if (VALUE_FLAGS.has(token)) {
+      index += 2;
+      continue;
+    }
+    if (token.startsWith("-")) {
+      index += 1;
+      continue;
+    }
+    return { executable: basenameToken(token), args: args.slice(index + 1) };
+  }
+  return null;
+}
+function moduleArg(args) {
+  for (let index = 0; index < args.length - 1; index += 1) {
+    if (args[index] === "-m") return args[index + 1] ?? null;
+  }
+  return null;
+}
+function isPythonExecutable(executable) {
+  return executable === "python" || executable === "python3" || /^python3\.\d+$/.test(executable);
+}
+function pathArgs(segment, commandIndex) {
+  const args = [];
+  let endOfOptions = false;
+  for (let index = commandIndex + 1; index < segment.length; index += 1) {
+    const token = segment[index];
+    if (token === void 0) continue;
+    if (COMMAND_SEPARATORS.has(token)) break;
+    if (!endOfOptions && token === "--") {
+      endOfOptions = true;
+      continue;
+    }
+    if (!endOfOptions && token.startsWith("-")) continue;
+    if (token === ">" || token === ">>" || token === "<" || token === "<<") {
+      index += 1;
+      continue;
+    }
+    args.push(token);
+  }
+  return args;
+}
+function tokenizeShellLike(command) {
+  const tokens = [];
+  let current = "";
+  let quote = null;
+  const pushCurrent = () => {
+    if (current.length === 0) return;
+    tokens.push(current);
+    current = "";
+  };
+  for (let index = 0; index < command.length; index += 1) {
+    const char = command[index];
+    if (char === void 0) continue;
+    if (quote !== null) {
+      if (char === quote) {
+        quote = null;
+        continue;
+      }
+      if (quote === '"' && char === "\\" && index + 1 < command.length) {
+        index += 1;
+        current += command[index] ?? "";
+        continue;
+      }
+      current += char;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+    if (char === "\\" && index + 1 < command.length) {
+      index += 1;
+      current += command[index] ?? "";
+      continue;
+    }
+    if (/\s/.test(char)) {
+      pushCurrent();
+      if (char === "\n") tokens.push(";");
+      continue;
+    }
+    if (char === ";") {
+      pushCurrent();
+      tokens.push(";");
+      continue;
+    }
+    if (char === "&" && command[index + 1] === "&") {
+      pushCurrent();
+      tokens.push("&&");
+      index += 1;
+      continue;
+    }
+    if (char === "|") {
+      pushCurrent();
+      if (command[index + 1] === "|") {
+        tokens.push("||");
+        index += 1;
+      } else {
+        tokens.push("|");
+      }
+      continue;
+    }
+    if (char === ">") {
+      pushCurrent();
+      if (command[index + 1] === ">") {
+        tokens.push(">>");
+        index += 1;
+      } else {
+        tokens.push(">");
+      }
+      continue;
+    }
+    if (char === "<") {
+      pushCurrent();
+      if (command[index + 1] === "<") {
+        tokens.push("<<");
+        index += 1;
+      } else {
+        tokens.push("<");
+      }
+      continue;
+    }
+    current += char;
+  }
+  pushCurrent();
+  return tokens;
+}
+function splitSegments(tokens) {
+  const segments = [];
+  let current = [];
+  for (const token of tokens) {
+    if (COMMAND_SEPARATORS.has(token)) {
+      if (current.length > 0) segments.push(current);
+      current = [];
+      continue;
+    }
+    current.push(token);
+  }
+  if (current.length > 0) segments.push(current);
+  return segments;
+}
+function commandTokenIndex(segment) {
+  let index = 0;
+  while (index < segment.length) {
+    const token = segment[index];
+    if (token === void 0) return null;
+    if (isEnvAssignment(token)) {
+      index += 1;
+      continue;
+    }
+    if (token === "env") {
+      index += 1;
+      while (index < segment.length && (segment[index]?.startsWith("-") === true || isEnvAssignment(segment[index] ?? ""))) {
+        index += 1;
+      }
+      continue;
+    }
+    if (SHELL_WRAPPERS.has(token)) {
+      index += 1;
+      while (index < segment.length && segment[index]?.startsWith("-") === true) index += 1;
+      continue;
+    }
+    return index;
+  }
+  return null;
+}
+function isEnvAssignment(token) {
+  return /^[A-Za-z_][A-Za-z0-9_]*=/.test(token);
+}
+function basenameToken(token) {
+  if (token === void 0) return "";
+  const normalized = token.replace(/\\/g, "/");
+  const basename = normalized.slice(normalized.lastIndexOf("/") + 1);
+  return basename.toLowerCase();
+}
+function artifactMap(artifacts) {
+  const out = /* @__PURE__ */ new Map();
+  for (const artifact of artifacts) {
+    const key = normalizePathKey(artifact.path);
+    if (key !== null) out.set(key, cloneArtifact(artifact));
+  }
+  return out;
+}
+function stateFromMap(artifacts) {
+  return {
+    artifacts: Array.from(artifacts.entries()).sort(([left], [right]) => compareStrings(left, right)).map(([, artifact]) => cloneArtifact(artifact))
+  };
+}
+function normalizedArtifacts(artifacts) {
+  const out = Array.from(artifactMap(artifacts).entries()).map(([key, artifact]) => ({ key, artifact }));
+  out.sort((left, right) => compareStrings(left.key, right.key));
+  return out;
+}
+function cloneArtifact(artifact) {
+  const cloned = {
+    path: artifact.path,
+    protectedAt: artifact.protectedAt,
+    reason: artifact.reason,
+    source: artifact.source
+  };
+  if (artifact.validationCommand !== void 0) cloned.validationCommand = artifact.validationCommand;
+  if (artifact.validationExitCode !== void 0) cloned.validationExitCode = artifact.validationExitCode;
+  return cloned;
+}
+function normalizePathKey(input) {
+  const trimmed = input.trim();
+  if (trimmed.length === 0) return null;
+  if (isWindowsAbsolutePath(trimmed) && path2.sep !== "\\") {
+    return toSlashKey(path2.win32.normalize(trimmed));
+  }
+  const resolved = path2.isAbsolute(trimmed) ? trimmed : path2.resolve(trimmed);
+  return toSlashKey(canonicalizeExistingPath(resolved));
+}
+function wildcardRootKey(input) {
+  const normalizedInput = toSlashKey(input.trim());
+  const firstWildcard = firstWildcardIndex(normalizedInput);
+  if (firstWildcard === null) return null;
+  const prefix = normalizedInput.slice(0, firstWildcard);
+  const slash = prefix.lastIndexOf("/");
+  const root = slash >= 0 ? prefix.slice(0, slash + 1) : ".";
+  return normalizePathKey(root);
+}
+function firstWildcardIndex(input) {
+  const indexes = ["*", "?", "["].map((char) => input.indexOf(char)).filter((index) => index >= 0);
+  if (indexes.length === 0) return null;
+  return Math.min(...indexes);
+}
+function isWindowsAbsolutePath(input) {
+  return /^[A-Za-z]:[\\/]/.test(input);
+}
+function toSlashKey(input) {
+  return input.replace(/\\/g, "/");
+}
+function isSameOrDescendant(candidate, parent) {
+  if (candidate === parent) return true;
+  const relative = path2.posix.relative(parent, candidate);
+  return relative !== "" && !relative.startsWith("..") && !path2.posix.isAbsolute(relative);
+}
+function compareMatches(left, right) {
+  return compareStrings(left.artifactPath, right.artifactPath) || compareStrings(left.commandPath, right.commandPath) || compareStrings(left.reason, right.reason);
+}
+function compareStrings(left, right) {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}
+
+// src/domains/safety/action-classifier.ts
+var GIT_DESTRUCTIVE_PATTERNS = [
+  { name: "git-push-force-long", re: /\bgit\s+push\s+--force\b/i },
+  { name: "git-push-force-short", re: /\bgit\s+push\s+-f\b/i },
+  { name: "git-reset-hard", re: /\bgit\s+reset\s+--hard\b/i },
+  { name: "git-clean-fd", re: /\bgit\s+clean\s+-fd?\b/i },
+  { name: "git-checkout-dot", re: /\bgit\s+checkout\s+--\s+\./i },
+  { name: "git-branch-D", re: /\bgit\s+branch\s+-D\b/i },
+  { name: "git-restore-source", re: /\bgit\s+restore\s+--source\b/i }
+];
+var SYSTEM_MODIFY_PATTERNS = [
+  { name: "sudo-or-doas", re: /\b(sudo|doas)\b/i },
+  // allow rm -rf /tmp/... and /var/tmp/... but flag everything else rooted at /
+  { name: "rm-rf-root", re: /\brm\s+-rf?\s+\/(?!(tmp|var\/tmp)(?:\/|\s|$))/i },
+  { name: "apt-install", re: /\bapt(-get)?\s+(install|remove|purge)/i },
+  { name: "brew-install", re: /\bbrew\s+(install|uninstall|reinstall)/i },
+  { name: "npm-install-global", re: /\bnpm\s+install\s+-g\b/i },
+  { name: "pip-install", re: /\bpip\s+install\b/i },
+  { name: "systemctl", re: /\bsystemctl\s+/i },
+  { name: "chmod-root", re: /\bchmod\s+[0-7]{3,4}\s+\//i },
+  { name: "chown", re: /\bchown\s+/i }
+];
+var SYSTEM_WRITE_ROOT_PREFIXES = ["/etc", "/usr", "/var", "/bin", "/sbin", "/run"];
+var SYSTEM_WRITE_EXEMPT_PREFIXES = ["/var/tmp", "/var/folders"];
+function isUnderPrefix(abs, prefix) {
+  return abs === prefix || abs.startsWith(`${prefix}/`);
+}
+function baseClassify(tool) {
+  switch (tool) {
+    case ToolNames.Read:
+    case ToolNames.Grep:
+    case ToolNames.Find:
+    case ToolNames.Ls:
+    case ToolNames.WebFetch:
+    case ToolNames.Git:
+    case ToolNames.CodeNav:
+    case ToolNames.Context:
+    case ToolNames.Monitor:
+    case ToolNames.AskUser:
+    case ToolNames.CredentialPresent:
+    // tasks mutates only the session's task ledger, never the workspace,
+    // so it stays read class and is never gated behind a confirmation.
+    case ToolNames.Tasks:
+    // ledger posts a typed contribution to a coordination board and reads a
+    // local mirror. Neither touches the workspace, so it is never gated
+    // behind a confirmation.
+    case ToolNames.Ledger:
+      return "read";
+    case ToolNames.Write:
+    case ToolNames.Edit:
+    case ToolNames.Artifact:
+      return "write";
+    case ToolNames.Bash:
+    case ToolNames.Verify:
+      return "execute";
+    case ToolNames.Dispatch:
+    case ToolNames.Steer:
+      return "dispatch";
+    default:
+      return null;
+  }
+}
+function scanStringOf(args) {
+  if (!args) return "";
+  const parts = [];
+  for (const value of Object.values(args)) {
+    if (value == null) continue;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      parts.push(String(value));
+    } else {
+      try {
+        parts.push(JSON.stringify(value));
+      } catch {
+      }
+    }
+  }
+  return parts.join(" ");
+}
+function matchFirst(patterns, haystack) {
+  for (const p of patterns) {
+    if (p.re.test(haystack)) return p;
+  }
+  return null;
+}
+function resolveCandidate(p, baseCwd) {
+  if (p.startsWith("~")) return p;
+  const base = canonicalizeExistingPath(path3.resolve(baseCwd ?? process.cwd()));
+  const resolved = path3.isAbsolute(p) ? path3.resolve(p) : path3.resolve(base, p);
+  return canonicalizeExistingPath(resolved);
+}
+function isInsideCwd(abs) {
+  const cwd = canonicalizeExistingPath(path3.resolve(process.cwd()));
+  const candidate = canonicalizeExistingPath(abs);
+  const rel = path3.relative(cwd, candidate);
+  return rel === "" || !rel.startsWith("..") && !path3.isAbsolute(rel);
+}
+function writePathClass(pathArg, baseCwd) {
+  if (pathArg.startsWith("~")) {
+    return { cls: "system_modify", reason: `write-path-home-escape: ${pathArg}` };
+  }
+  const abs = resolveCandidate(pathArg, baseCwd);
+  const exempt = SYSTEM_WRITE_EXEMPT_PREFIXES.some((prefix) => isUnderPrefix(abs, prefix));
+  if (!exempt) {
+    for (const prefix of SYSTEM_WRITE_ROOT_PREFIXES) {
+      if (isUnderPrefix(abs, prefix)) {
+        return { cls: "system_modify", reason: `write-path-system-root: ${prefix}` };
+      }
+    }
+  }
+  if (!isInsideCwd(abs)) {
+    return { cls: "system_modify", reason: `write-path-outside-cwd: ${abs}` };
+  }
+  return { cls: "write" };
+}
+function artifactDefaultPath2(args) {
+  const kind = args?.kind;
+  return kind === "review" ? "REVIEW.md" : kind === "report" ? "REPORT.md" : "PLAN.md";
+}
+function extractWritePath(tool, args) {
+  const candidate = args?.path ?? args?.file_path ?? args?.filePath;
+  if (typeof candidate === "string" && candidate.length > 0) return candidate;
+  return tool === ToolNames.Artifact ? artifactDefaultPath2(args) : null;
+}
+function classify(call) {
+  const base = baseClassify(call.tool);
+  if (base === null) {
+    return { actionClass: "unknown", reasons: [`unknown tool: ${call.tool}`] };
+  }
+  const reasons = [];
+  if (call.tool === ToolNames.Bash) {
+    const scan = scanStringOf(call.args);
+    const gitHit = matchFirst(GIT_DESTRUCTIVE_PATTERNS, scan);
+    if (gitHit) {
+      return { actionClass: "git_destructive", reasons: [`pattern:${gitHit.name}`] };
+    }
+    const sysHit = matchFirst(SYSTEM_MODIFY_PATTERNS, scan);
+    if (sysHit) {
+      return { actionClass: "system_modify", reasons: [`pattern:${sysHit.name}`] };
+    }
+    const command = typeof call.args?.command === "string" ? call.args.command : null;
+    const argCwd = typeof call.args?.cwd === "string" && call.args.cwd.length > 0 ? call.args.cwd : void 0;
+    if (command !== null) {
+      const targetReasons = [];
+      for (const target of extractCommandWriteTargets(command)) {
+        const decision = writePathClass(target, argCwd);
+        if (decision.cls === "system_modify") {
+          targetReasons.push(decision.reason ?? `bash-write-target: ${target}`);
+        }
+      }
+      for (const target of extractCommandCdTargets(command)) {
+        if (target.startsWith("~")) {
+          targetReasons.push(`bash-cd-home-escape: ${target}`);
+          continue;
+        }
+        const abs = resolveCandidate(target, argCwd);
+        if (!isInsideCwd(abs)) {
+          targetReasons.push(`bash-cd-outside-workspace: ${abs}`);
+        }
+      }
+      if (targetReasons.length > 0) {
+        return { actionClass: "system_modify", reasons: targetReasons };
+      }
+    }
+    return { actionClass: "execute", reasons };
+  }
+  if (base === "write") {
+    const pathArg = extractWritePath(call.tool, call.args);
+    if (pathArg) {
+      const decision = writePathClass(pathArg);
+      if (decision.cls === "system_modify") {
+        return { actionClass: "system_modify", reasons: decision.reason ? [decision.reason] : [] };
+      }
+    }
+    return { actionClass: "write", reasons };
+  }
+  return { actionClass: base, reasons };
+}
+
+// src/domains/agents/spec.ts
+var AGENT_AUTOMATION_AUTHORITIES = ["read-only", "verification", "artifact-write", "workspace-edit"];
+var AGENT_PRODUCTS = ["orientation"];
+var AGENT_CATEGORIES = [
+  "explore",
+  "plan",
+  "research",
+  "implement",
+  "quality",
+  "science",
+  "evolution",
+  "operations",
+  "internal"
+];
+var AGENT_CAPABILITY_CLASSES = [
+  "read-only",
+  "artifact-write",
+  "workspace-edit",
+  "verification",
+  "orchestration",
+  "internal"
+];
+var AGENT_LATENCY_CLASSES = ["fast", "balanced", "deep"];
+var AGENT_AUDIENCES = ["base", "shadow", "custom", "internal"];
+var AGENT_PROJECT_CONTEXT_TIERS = ["none", "bounded"];
+function includes(values, value) {
+  return typeof value === "string" && values.includes(value);
+}
+function isAgentCategory(value) {
+  return includes(AGENT_CATEGORIES, value);
+}
+function isAgentCapabilityClass(value) {
+  return includes(AGENT_CAPABILITY_CLASSES, value);
+}
+function isAgentLatencyClass(value) {
+  return includes(AGENT_LATENCY_CLASSES, value);
+}
+function isAgentAudience(value) {
+  return includes(AGENT_AUDIENCES, value);
+}
+function isAgentProjectContextTier(value) {
+  return includes(AGENT_PROJECT_CONTEXT_TIERS, value);
+}
+function isAgentProduct(value) {
+  return includes(AGENT_PRODUCTS, value);
+}
+function actionClassesForTools(tools) {
+  const actions = /* @__PURE__ */ new Set();
+  for (const tool of tools) actions.add(classify({ tool }).actionClass);
+  return actions;
+}
+function normalizeTools(recipe) {
+  const seen = /* @__PURE__ */ new Set();
+  const tools = [];
+  for (const tool of recipe.tools) {
+    if (typeof tool !== "string" || tool.trim().length === 0) {
+      throw new Error(`agent recipe '${recipe.id}' declares an invalid tool name`);
+    }
+    if (seen.has(tool)) continue;
+    seen.add(tool);
+    tools.push(isBuiltinToolName(tool) ? tool : tool);
+  }
+  return tools;
+}
+function asToolName(tool) {
+  return isBuiltinToolName(tool) ? tool : tool;
+}
+function normalizeToolRequirements(recipe, tools) {
+  if (!recipe.toolRequirements) {
+    throw new Error(`agent recipe '${recipe.id}' must declare tools.required and tools.optional`);
+  }
+  const declared = new Set(tools);
+  const required = recipe.toolRequirements.required.map((requirement, index) => {
+    if (typeof requirement === "string") return asToolName(requirement);
+    if (!Array.isArray(requirement.anyOf) || requirement.anyOf.length === 0) {
+      throw new Error(`agent recipe '${recipe.id}' tools.required[${index}].anyOf must be non-empty`);
+    }
+    return { anyOf: requirement.anyOf.map(asToolName) };
+  });
+  const optional = recipe.toolRequirements.optional.map(asToolName);
+  const mentioned = required.flatMap(
+    (requirement) => typeof requirement === "string" ? [requirement] : requirement.anyOf
+  );
+  for (const tool of [...mentioned, ...optional]) {
+    if (!declared.has(tool)) throw new Error(`agent recipe '${recipe.id}' requirement '${tool}' is not declared`);
+  }
+  if ((/* @__PURE__ */ new Set([...mentioned, ...optional])).size !== mentioned.length + optional.length) {
+    throw new Error(`agent recipe '${recipe.id}' contains duplicate tool requirements`);
+  }
+  if ((/* @__PURE__ */ new Set([...mentioned, ...optional])).size !== tools.length) {
+    throw new Error(`agent recipe '${recipe.id}' has declared tools without required/optional semantics`);
+  }
+  return { required, optional };
+}
+function resolveAgentToolCompatibility(spec, effectiveTools, options) {
+  const available = new Set(effectiveTools);
+  const missingRequired = [];
+  for (const requirement of spec.toolRequirements.required) {
+    if (typeof requirement === "string") {
+      if (!available.has(requirement)) missingRequired.push(requirement);
+      continue;
+    }
+    if (!requirement.anyOf.some((tool) => available.has(tool))) {
+      missingRequired.push(`anyOf(${requirement.anyOf.join("|")})`);
+    }
+  }
+  if (available.has(ToolNames.Dispatch) && !options.mediatesDispatch) {
+    missingRequired.push("dispatch(runtime mediation unavailable)");
+  }
+  return {
+    compatible: missingRequired.length === 0,
+    missingRequired,
+    lostOptional: spec.toolRequirements.optional.filter((tool) => !available.has(tool))
+  };
+}
+function normalizeAgentSpec(recipe) {
+  const tools = normalizeTools(recipe);
+  const toolRequirements = normalizeToolRequirements(recipe, tools);
+  return {
+    version: recipe.version,
+    id: recipe.id,
+    name: recipe.name,
+    description: recipe.description,
+    source: recipe.source,
+    filepath: recipe.filepath,
+    tools,
+    toolRequirements,
+    category: recipe.category,
+    capabilityClass: recipe.capabilityClass,
+    latencyClass: recipe.latencyClass,
+    projectContextTier: recipe.projectContextTier,
+    audience: recipe.audience,
+    tags: recipe.tags,
+    skills: recipe.skills,
+    resultContract: recipe.resultContract,
+    ...recipe.product !== void 0 ? { product: recipe.product } : {},
+    budget: recipe.budget,
+    body: recipe.body
+  };
+}
+function agentSpecFingerprint(spec) {
+  const requirement = (entry) => typeof entry === "string" ? entry : `anyOf(${[...entry.anyOf].sort().join("|")})`;
+  const payload = JSON.stringify({
+    id: spec.id,
+    tools: [...spec.tools].sort(),
+    required: spec.toolRequirements.required.map(requirement).sort(),
+    optional: [...spec.toolRequirements.optional].sort(),
+    capabilityClass: spec.capabilityClass,
+    latencyClass: spec.latencyClass,
+    projectContextTier: spec.projectContextTier,
+    audience: spec.audience,
+    skills: [...spec.skills].sort(),
+    resultContract: spec.resultContract,
+    budget: spec.budget,
+    body: createHash("sha256").update(spec.body, "utf8").digest("hex")
+  });
+  return createHash("sha256").update(payload, "utf8").digest("hex");
+}
+function isUserVisibleAgent(spec) {
+  return spec.audience === "base" || spec.audience === "custom";
+}
+function isShadowAgent(spec) {
+  return spec.audience === "shadow" || spec.audience === "internal";
+}
+function agentSpecPolicyErrors(spec) {
+  const errors = [];
+  const actions = actionClassesForTools(spec.tools);
+  const requiredGroups = spec.toolRequirements.required.map(
+    (requirement) => typeof requirement === "string" ? [requirement] : requirement.anyOf
+  );
+  const requiresTool = (tool) => requiredGroups.some((group) => group.length > 0 && group.every((candidate) => candidate === tool));
+  const requiresMutation = requiredGroups.some(
+    (group) => group.length > 0 && group.every((tool) => tool === ToolNames.Write || tool === ToolNames.Edit)
+  );
+  if (spec.capabilityClass === "workspace-edit" && (!requiresTool(ToolNames.Read) || !requiresMutation)) {
+    errors.push(`workspace-edit agent '${spec.id}' must require read and write|edit`);
+  }
+  if (spec.capabilityClass === "verification" && !requiresTool(ToolNames.Verify)) {
+    errors.push(`verification agent '${spec.id}' must require verify`);
+  }
+  if (spec.capabilityClass === "artifact-write" && !requiresTool(ToolNames.Artifact)) {
+    errors.push(`artifact-write agent '${spec.id}' must require artifact`);
+  }
+  if (spec.skills.length > 0 && !requiresTool(ToolNames.Context)) {
+    errors.push(`agent '${spec.id}' must require context for bound skills`);
+  }
+  if (spec.capabilityClass === "orchestration" && spec.tools.includes(ToolNames.Dispatch) && !requiresTool(ToolNames.Dispatch)) {
+    errors.push(`orchestration agent '${spec.id}' must require dispatch when it is declared`);
+  }
+  const toolList = spec.tools.join(", ");
+  if (spec.capabilityClass === "read-only") {
+    for (const action of actions) {
+      if (action !== "read") errors.push(`read-only agent '${spec.id}' requests ${action} tools (${toolList})`);
+    }
+  }
+  if (spec.capabilityClass === "artifact-write") {
+    for (const tool of spec.tools) {
+      const action = classify({ tool }).actionClass;
+      if (action === "execute" || action === "dispatch" || action === "system_modify" || action === "git_destructive") {
+        errors.push(`artifact-write agent '${spec.id}' requests ${action} tool '${tool}'`);
+      }
+      if (action === "write" && tool !== ToolNames.Artifact) {
+        errors.push(`artifact-write agent '${spec.id}' can only write terminal artifacts; got '${tool}'`);
+      }
+    }
+  }
+  if (spec.capabilityClass === "verification") {
+    for (const tool of spec.tools) {
+      const action = classify({ tool }).actionClass;
+      if (action === "write" || action === "dispatch" || action === "system_modify" || action === "git_destructive") {
+        errors.push(`verification agent '${spec.id}' must not request ${action} tool '${tool}'`);
+      }
+      if (tool === ToolNames.Bash)
+        errors.push(`verification agent '${spec.id}' must use typed validation tools, not bash`);
+    }
+  }
+  if (spec.capabilityClass !== "orchestration" && spec.tools.includes(ToolNames.Dispatch)) {
+    errors.push(`agent '${spec.id}' exposes dispatch without orchestration capability`);
+  }
+  if (spec.tools.includes(ToolNames.AskUser)) {
+    errors.push(`agent '${spec.id}' exposes ask_user, which is only available to the orchestrator`);
+  }
+  if (spec.skills.length > 0 && !spec.tools.includes(ToolNames.Context)) {
+    errors.push(`agent '${spec.id}' declares skills but does not expose context`);
+  }
+  return errors;
+}
+function assertAgentSpecPolicy(spec) {
+  const errors = agentSpecPolicyErrors(spec);
+  if (errors.length > 0) throw new Error(`agent policy violation:
+${errors.map((error) => `- ${error}`).join("\n")}`);
+}
+
+export {
+  canonicalizeExistingPath,
+  VERIFICATION_SCRIPT_FAMILY_HINT,
+  isVerificationScriptName,
+  declaredVerificationScripts,
+  toolMutationPaths,
+  protectedArtifactMutationBlockReason,
+  protectArtifact,
+  detectValidationCommand,
+  extractCommandWriteTargets,
+  inlineShellScript,
+  extractCommandDeleteTargets,
+  tokenizeShellLike,
+  classify,
+  AGENT_AUTOMATION_AUTHORITIES,
+  isAgentCategory,
+  isAgentCapabilityClass,
+  isAgentLatencyClass,
+  isAgentAudience,
+  isAgentProjectContextTier,
+  isAgentProduct,
+  resolveAgentToolCompatibility,
+  normalizeAgentSpec,
+  agentSpecFingerprint,
+  isUserVisibleAgent,
+  isShadowAgent,
+  assertAgentSpecPolicy
+};
+//# sourceMappingURL=chunk-WD6AJM35.js.map