@iowarp/clio-coder 0.3.8 → 0.4.0

package/dist/{chunk-TTHACPOM.js → chunk-DYJP44XW.js}

@@ -1,7 +1,16 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
-  AGENT_AUTOMATION_AUTHORITIES
-} from "./chunk-AOCYTWAV.js";
+  artifactDefaultPath,
+  extractCommandCdTargets,
+  extractCommandWriteTargets
+} from "./chunk-GCSMB2KY.js";
+import {
+  canonicalizeExistingPath
+} from "./chunk-ECH6PKUQ.js";
+import {
+  ToolNames,
+  isBuiltinToolName
+} from "./chunk-K6BSR66V.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -34,10 +43,431 @@ function parseJsonObjectPayload(text) {
   return { ok: false, reason: parsedSomething ? "not-object" : "not-json" };
 }
 
-// src/domains/agents/result-contract.ts
+// src/domains/agents/spec.ts
 init_esm_shims();
 import { createHash } from "node:crypto";
+
+// src/domains/safety/action-classifier.ts
+init_esm_shims();
 import path from "node:path";
+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 pick mutates only Clio-owned session-ledger and project-local
+    // .clio-coder runtime state, never source-workspace files. By intentional
+    // policy it stays read class and ungated; the tool itself still requires
+    // a durable operator task id before it can mutate either store.
+    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:
+    // panes focuses, opens, and closes terminal panes Clio itself created, in
+    // a pane host that lives outside the workspace. Nothing it does writes a
+    // file, runs a model-supplied command (its schema exposes presets only),
+    // or survives the session, so it is reversible, local, and never gated
+    // behind a confirmation.
+    case ToolNames.Panes:
+      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(path.resolve(baseCwd ?? process.cwd()));
+  const resolved = path.isAbsolute(p) ? path.resolve(p) : path.resolve(base, p);
+  return canonicalizeExistingPath(resolved);
+}
+function isInsideCwd(abs) {
+  const cwd = canonicalizeExistingPath(path.resolve(process.cwd()));
+  const candidate = canonicalizeExistingPath(abs);
+  const rel = path.relative(cwd, candidate);
+  return rel === "" || !rel.startsWith("..") && !path.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 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 ? artifactDefaultPath(args?.kind) : 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")}`);
+}
+
+// src/domains/agents/result-contract.ts
+init_esm_shims();
+import { createHash as createHash2 } from "node:crypto";
+import path2 from "node:path";
 function parseDelegationPlanResult(output) {
   const parsed = parseJson(output);
   if (!parsed.ok || !hasOnlyKeys(parsed.value, ["tasks"]) || !Array.isArray(parsed.value.tasks) || parsed.value.tasks.length === 0)
@@ -155,7 +585,7 @@ function canonical(value) {
   throw new Error(`result contract cannot digest ${typeof value}`);
 }
 function digest(value) {
-  return createHash("sha256").update(canonical(value), "utf8").digest("hex");
+  return createHash2("sha256").update(canonical(value), "utf8").digest("hex");
 }
 function resultContractDigest(contract) {
   return digest(contract);
@@ -358,13 +788,24 @@ function parseChecks(value) {
   }
   return checks;
 }
+function citationWithinWorkspace(cwd, citedPath) {
+  const relative = path2.relative(cwd, citedPath);
+  if (relative === "") return true;
+  return !(relative === ".." || relative.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative));
+}
+function directoryCitationDigest(cwd, citedPath) {
+  const relative = path2.relative(cwd, citedPath);
+  return createHash2("sha256").update(`directory:${relative === "" ? "." : relative}`, "utf8").digest("hex");
+}
 function validateScoutCitation(input, citation) {
-  const cwd = path.resolve(input.cwd);
-  const citedPath = path.resolve(cwd, citation.path);
-  const relative = path.relative(cwd, citedPath);
-  if (relative === "" || relative.startsWith(`..${path.sep}`) || relative === ".." || path.isAbsolute(relative)) {
+  const cwd = path2.resolve(input.cwd);
+  const citedPath = path2.resolve(cwd, citation.path);
+  if (!citationWithinWorkspace(cwd, citedPath)) {
     return { ok: false, reason: `Scout citation path escapes the workspace: ${citation.path}` };
   }
+  if (input.filesystem.isDirectory?.(citedPath) === true) {
+    return { ok: true, evidence: { ...citation, contentDigest: directoryCitationDigest(cwd, citedPath) } };
+  }
   const content = input.filesystem.readFile(citedPath);
   if (content === null) return { ok: false, reason: `Scout citation cannot be read: ${citation.path}` };
   const lineCount = content.split(/\r\n|\r|\n/u).length;
@@ -383,7 +824,7 @@ function validateScoutCitation(input, citation) {
   }
   return {
     ok: true,
-    evidence: { ...citation, contentDigest: createHash("sha256").update(content, "utf8").digest("hex") }
+    evidence: { ...citation, contentDigest: createHash2("sha256").update(content, "utf8").digest("hex") }
   };
 }
 function validateScoutCitations(input, citations) {
@@ -420,14 +861,57 @@ function groundDegradedScout(contract, input, scout, degradedReason) {
 }
 function validateVerifier(contract, output) {
   const parsed = parseJson(output);
-  if (!parsed.ok) return failure(contract, "fail", parsed.reason);
+  if (!parsed.ok) return failure(contract, "fail", `Verifier result payload failed: ${parsed.reason}`);
   const value = parsed.value;
-  if (!hasOnlyKeys(value, ["verdict", "checks"]) || value.verdict !== "pass" && value.verdict !== "fail") {
-    return failure(contract, "fail", "Verifier result must carry pass or fail verdict and checks");
+  const unknown = Object.keys(value).filter((key) => key !== "verdict" && key !== "checks");
+  if (unknown.length > 0) {
+    return failure(
+      contract,
+      "fail",
+      `Verifier result field${unknown.length === 1 ? "" : "s"} ${unknown.join(", ")} ${unknown.length === 1 ? "is" : "are"} not legal; legal top-level fields are verdict and checks`
+    );
   }
-  const checks = parseChecks(value.checks);
-  if (checks === null || value.verdict === "pass" !== checks.every((check) => check.passed)) {
-    return failure(contract, "fail", "Verifier verdict must agree with every typed check");
+  if (value.verdict !== "pass" && value.verdict !== "fail") {
+    return failure(contract, "fail", 'Verifier field "verdict" must be one of: pass | fail');
+  }
+  if (!Array.isArray(value.checks) || value.checks.length === 0) {
+    return failure(
+      contract,
+      "fail",
+      'Verifier field "checks" must be a non-empty array of {name, passed, evidence}; each checks[].passed value must be one of: true | false'
+    );
+  }
+  const checks = [];
+  for (const [index, raw] of value.checks.entries()) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+      return failure(contract, "fail", `Verifier field "checks[${index}]" must be an object`);
+    }
+    const check = raw;
+    const checkUnknown = Object.keys(check).filter((key) => key !== "name" && key !== "passed" && key !== "evidence");
+    if (checkUnknown.length > 0) {
+      return failure(
+        contract,
+        "fail",
+        `Verifier field "checks[${index}].${checkUnknown[0]}" is not legal; legal check fields are name, passed, and evidence`
+      );
+    }
+    if (!string(check.name)) {
+      return failure(contract, "fail", `Verifier field "checks[${index}].name" must be a non-empty string`);
+    }
+    if (typeof check.passed !== "boolean") {
+      return failure(contract, "fail", `Verifier field "checks[${index}].passed" must be one of: true | false`);
+    }
+    if (!string(check.evidence)) {
+      return failure(contract, "fail", `Verifier field "checks[${index}].evidence" must be a non-empty string`);
+    }
+    checks.push({ name: check.name, passed: check.passed, evidence: check.evidence });
+  }
+  if (value.verdict === "pass" !== checks.every((check) => check.passed)) {
+    return failure(
+      contract,
+      "fail",
+      'Verifier field "verdict" must agree with every checks[].passed value; verdict legal values are pass | fail and checks[].passed legal values are true | false'
+    );
   }
   const verifier = { verdict: value.verdict, checks };
   return success(contract, value.verdict, verifier, { verifier });
@@ -520,45 +1004,87 @@ function resultContractAuthorship(contract, output) {
 }
 function validateDebugger(contract, output) {
   const parsed = parseJson(output);
-  if (!parsed.ok) return failure(contract, "unmeasured", parsed.reason);
+  if (!parsed.ok) return failure(contract, "unmeasured", `Debugger result payload failed: ${parsed.reason}`);
   const value = parsed.value;
-  if (!hasOnlyKeys(value, ["diagnosis", "reproduction", "evidence"]) || !string(value.diagnosis) || value.reproduction !== "reproduced" && value.reproduction !== "not-reproduced" && value.reproduction !== "unknown" || !Array.isArray(value.evidence) || value.evidence.some((entry) => !string(entry))) {
+  const unknown = Object.keys(value).filter(
+    (key) => key !== "diagnosis" && key !== "reproduction" && key !== "evidence"
+  );
+  if (unknown.length > 0) {
     return failure(
       contract,
       "unmeasured",
-      "Debugger result must carry diagnosis, reproduction status, and evidence without a verdict"
+      `Debugger result field${unknown.length === 1 ? "" : "s"} ${unknown.join(", ")} ${unknown.length === 1 ? "is" : "are"} not legal; legal top-level fields are diagnosis, reproduction, and evidence`
     );
   }
+  if (!string(value.diagnosis)) {
+    return failure(contract, "unmeasured", 'Debugger field "diagnosis" must be a non-empty string');
+  }
+  if (value.reproduction !== "reproduced" && value.reproduction !== "not-reproduced" && value.reproduction !== "unknown") {
+    return failure(
+      contract,
+      "unmeasured",
+      'Debugger field "reproduction" must be one of: reproduced | not-reproduced | unknown'
+    );
+  }
+  if (!Array.isArray(value.evidence)) {
+    return failure(contract, "unmeasured", 'Debugger field "evidence" must be an array of strings');
+  }
+  const malformedEvidence = value.evidence.findIndex((entry) => !string(entry));
+  if (malformedEvidence >= 0) {
+    return failure(contract, "unmeasured", `Debugger field "evidence[${malformedEvidence}]" must be a non-empty string`);
+  }
   return success(contract, "unmeasured", value);
 }
 function validateResearch(contract, output, networkAllowed) {
   const parsed = parseJson(output);
-  if (!parsed.ok) return failure(contract, "unmeasured", parsed.reason);
+  if (!parsed.ok) return failure(contract, "unmeasured", `Research result payload failed: ${parsed.reason}`);
   const value = parsed.value;
-  if (!hasOnlyKeys(value, ["source", "findings"]) || value.source !== "local" && value.source !== "external" || !Array.isArray(value.findings)) {
+  const unknown = Object.keys(value).filter((key) => key !== "source" && key !== "findings");
+  if (unknown.length > 0) {
     return failure(
       contract,
       "unmeasured",
-      "Research result must distinguish local or external sources and carry findings"
+      `Research result field${unknown.length === 1 ? "" : "s"} ${unknown.join(", ")} ${unknown.length === 1 ? "is" : "are"} not legal; legal top-level fields are source and findings`
     );
   }
+  if (value.source !== "local" && value.source !== "external") {
+    return failure(contract, "unmeasured", 'Research field "source" must be one of: local | external');
+  }
+  if (!Array.isArray(value.findings)) {
+    return failure(contract, "unmeasured", 'Research field "findings" must be an array of {claim, evidence} objects');
+  }
   if (value.source === "external" && !networkAllowed) {
-    return failure(contract, "unmeasured", "external research requires an allowed network posture");
+    return failure(
+      contract,
+      "unmeasured",
+      'Research field "source" is external but the run has no allowed network posture; legal values are local | external, and use local for workspace-only evidence'
+    );
   }
-  for (const finding of value.findings) {
+  for (const [index, finding] of value.findings.entries()) {
     if (finding === null || typeof finding !== "object" || Array.isArray(finding)) {
-      return failure(contract, "unmeasured", "Research findings must be objects");
+      return failure(contract, "unmeasured", `Research field "findings[${index}]" must be an object`);
     }
     const record = finding;
-    if (!hasOnlyKeys(record, ["claim", "evidence"]) || !string(record.claim) || !string(record.evidence)) {
-      return failure(contract, "unmeasured", "Research findings must carry claim and evidence");
+    const findingUnknown = Object.keys(record).filter((key) => key !== "claim" && key !== "evidence");
+    if (findingUnknown.length > 0) {
+      return failure(
+        contract,
+        "unmeasured",
+        `Research field "findings[${index}].${findingUnknown[0]}" is not legal; legal finding fields are claim and evidence`
+      );
+    }
+    if (!string(record.claim)) {
+      return failure(contract, "unmeasured", `Research field "findings[${index}].claim" must be a non-empty string`);
+    }
+    if (!string(record.evidence)) {
+      return failure(contract, "unmeasured", `Research field "findings[${index}].evidence" must be a non-empty string`);
     }
   }
   return success(contract, "unmeasured", value);
 }
 function describeWriteSet(effects, cwd) {
   if (effects.mutatedPaths.size === 0) return "this run wrote nothing";
-  const written = [...effects.mutatedPaths].map((target) => path.relative(cwd, target) || target).sort().slice(0, MUTATION_WRITE_SET_REASON_LIMIT);
+  const written = [...effects.mutatedPaths].map((target) => path2.relative(cwd, target) || target).sort().slice(0, MUTATION_WRITE_SET_REASON_LIMIT);
   const more = effects.mutatedPaths.size - written.length;
   return `this run wrote ${written.join(", ")}${more > 0 ? ` (+${more} more)` : ""}`;
 }
@@ -589,10 +1115,10 @@ function validateMutation(contract, input) {
   const reportedFailure = !validations.every((check) => check.passed);
   const effects = input.observedRunEffects;
   if (effects === void 0) return success(contract, reportedFailure ? "fail" : "pass", value);
-  const cwd = path.resolve(input.cwd);
+  const cwd = path2.resolve(input.cwd);
   let unverifiedMutation = false;
   for (const reported of value.mutatedPaths) {
-    const target = path.resolve(cwd, reported);
+    const target = path2.resolve(cwd, reported);
     if (effects.mutatedPaths.has(target)) continue;
     if (effects.failedMutationPaths.has(target)) {
       return failure(
@@ -631,14 +1157,14 @@ function validateProvenance(contract, output) {
   return success(contract, "unmeasured", value);
 }
 function validateArchitect(contract, input) {
-  const artifactPath = path.resolve(input.cwd, contract.path);
+  const artifactPath = path2.resolve(input.cwd, contract.path);
   const content = input.filesystem.readFile(artifactPath);
   if (content === null || content.trim().length === 0) {
     return failure(contract, "unmeasured", `required plan artifact is missing or empty: ${contract.path}`);
   }
   return success(contract, "unmeasured", {
     path: contract.path,
-    artifactDigest: createHash("sha256").update(content, "utf8").digest("hex")
+    artifactDigest: createHash2("sha256").update(content, "utf8").digest("hex")
   });
 }
 function parseScoutResult(output) {
@@ -742,15 +1268,15 @@ function resultContractShape(contract) {
     case "scout-report":
       return '{"findings":[{"claim":"what you observed","path":"src/file.ts","line":1}],"needsSplit":false,"proposedSubtasks":[]} or {"findings":[],"needsSplit":true,"proposedSubtasks":[{"id":"inspect","task":"Inspect the boundary","dependencies":[],"expectedResultContract":"scout-report","requestedAuthority":"read-only"}]} or, if you cannot produce a citation you are sure of, at least {"findings":[{"claim":"what you observed"}]}, which is accepted as an ungrounded lead rather than losing the run';
     case "verifier-report":
-      return '{"verdict":"pass","checks":[{"name":"npm run typecheck","passed":true,"evidence":"exit 0"}]}';
+      return 'one of {"verdict":"pass","checks":[{"name":"npm run typecheck","passed":true,"evidence":"exit 0"}]} or {"verdict":"fail","checks":[{"name":"npm run typecheck","passed":false,"evidence":"exit 1"}]}; verdict legal values are pass | fail and checks[].passed legal values are true | false';
     case "council-report":
       return '{"members":[{"label":"alpha","runId":"run-1","round":1,"answer":"..."}],"synthesis":{"kind":"none"}}';
     case "council-ballot":
       return COUNCIL_BALLOT_SHAPE;
     case "debugger-report":
-      return '{"diagnosis":"...","reproduction":"reproduced","evidence":["..."]}';
+      return 'one of {"diagnosis":"...","reproduction":"reproduced","evidence":["..."]}, {"diagnosis":"...","reproduction":"not-reproduced","evidence":["..."]}, or {"diagnosis":"...","reproduction":"unknown","evidence":["..."]}; reproduction legal values are reproduced | not-reproduced | unknown';
     case "research-report":
-      return '{"source":"local","findings":[{"claim":"...","evidence":"..."}]}';
+      return 'one of {"source":"local","findings":[{"claim":"...","evidence":"..."}]} or {"source":"external","findings":[{"claim":"...","evidence":"..."}]}; source legal values are local | external';
     case "mutation-report":
       return '{"mutatedPaths":["src/file.ts"],"validations":[{"name":"npm test","passed":true,"evidence":"exit 0"}],"commitMessage":"optional: the commit message for this change","summary":"optional: one line"}';
     case "provenance-report":
@@ -844,7 +1370,7 @@ function parseContract(value, sourcePath, kinds) {
     if (!only("kind", "path") || !string(record.path)) {
       throw new Error(`agent recipe: ${sourcePath}: architect-plan requires only non-empty path`);
     }
-    if (path.isAbsolute(record.path) || record.path.split(/[\\/]/u).includes("..")) {
+    if (path2.isAbsolute(record.path) || record.path.split(/[\\/]/u).includes("..")) {
       throw new Error(`agent recipe: ${sourcePath}: architect-plan path must be workspace-relative`);
     }
     return { kind: "architect-plan", path: record.path };
@@ -861,80 +1387,22 @@ function parseWorkerResultContract(value, sourcePath) {
   return parseContract(value, sourcePath, [...RECIPE_DECLARABLE_KINDS, ...COORDINATOR_AUTHORED_KINDS]);
 }
 
-// src/core/path-boundary.ts
-init_esm_shims();
-import path2 from "node:path";
-var PATH_BOUNDARY_MAX_ENTRIES = 32;
-var PathBoundaryError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "PathBoundaryError";
-    this.code = code;
-  }
-};
-var GLOB_CHARACTERS = /[*?[\]{}]/u;
-function normalizePathBoundaryEntry(entry) {
-  const raw = entry.trim();
-  if (raw.length === 0) throw new PathBoundaryError("empty", "write boundary: entry must be a non-empty path");
-  if (raw.includes("\\")) {
-    throw new PathBoundaryError("separator", `write boundary: entry '${entry}' must use '/' separators`);
-  }
-  if (GLOB_CHARACTERS.test(raw)) {
-    throw new PathBoundaryError("glob", `write boundary: entry '${entry}' looks like a glob, which v1 does not support`);
-  }
-  if (raw.startsWith("/") || /^[A-Za-z]:/u.test(raw)) {
-    throw new PathBoundaryError("absolute", `write boundary: entry '${entry}' must be repository-relative, not absolute`);
-  }
-  const subtree = raw.endsWith("/");
-  const segments = raw.split("/").filter((segment) => segment.length > 0);
-  if (segments.length === 0) {
-    throw new PathBoundaryError("empty", `write boundary: entry '${entry}' must name a path inside the repository`);
-  }
-  for (const segment of segments) {
-    if (segment === "..") {
-      throw new PathBoundaryError("parent", `write boundary: entry '${entry}' must not contain '..'`);
-    }
-    if (segment === ".") {
-      throw new PathBoundaryError("dot", `write boundary: entry '${entry}' must not contain '.' segments`);
-    }
-  }
-  const joined = segments.join("/");
-  return subtree ? `${joined}/` : joined;
-}
-function normalizePathBoundary(entries) {
-  if (entries.length > PATH_BOUNDARY_MAX_ENTRIES) {
-    throw new Error(`write boundary: at most ${PATH_BOUNDARY_MAX_ENTRIES} entries may be declared`);
-  }
-  return [...new Set(entries.map(normalizePathBoundaryEntry))].sort();
-}
-function toPosixBoundaryPath(value) {
-  return value.split("\\").join("/");
-}
-function isDirectoryPathBoundary(entry) {
-  return toPosixBoundaryPath(entry).endsWith("/");
-}
-function asDirectoryPathBoundary(entry) {
-  const normalized = toPosixBoundaryPath(entry);
-  return normalized.endsWith("/") ? normalized : `${normalized}/`;
-}
-function resolvePathBoundary(cwd, entry) {
-  const directory = isDirectoryPathBoundary(entry);
-  const withoutMarker = directory ? entry.slice(0, -1) : entry;
-  const resolved = toPosixBoundaryPath(path2.resolve(cwd, withoutMarker));
-  return directory ? asDirectoryPathBoundary(resolved) : resolved;
-}
-function pathBoundaryEntryCovers(outer, inner) {
-  const normalizedOuter = toPosixBoundaryPath(outer);
-  const normalizedInner = toPosixBoundaryPath(inner);
-  return normalizedOuter.endsWith("/") ? normalizedInner.startsWith(normalizedOuter) : !normalizedInner.endsWith("/") && normalizedInner === normalizedOuter;
-}
-function pathBoundaryCovers(boundary, candidate) {
-  return boundary.some((entry) => pathBoundaryEntryCovers(entry, candidate));
-}
-
 export {
   parseJsonObjectPayload,
+  classify,
+  AGENT_AUTOMATION_AUTHORITIES,
+  isAgentCategory,
+  isAgentCapabilityClass,
+  isAgentLatencyClass,
+  isAgentAudience,
+  isAgentProjectContextTier,
+  isAgentProduct,
+  resolveAgentToolCompatibility,
+  normalizeAgentSpec,
+  agentSpecFingerprint,
+  isUserVisibleAgent,
+  isShadowAgent,
+  assertAgentSpecPolicy,
   COUNCIL_BALLOT_VERDICT_MAX_BYTES,
   COUNCIL_BALLOT_SHAPE,
   parseCouncilReport,
@@ -946,16 +1414,9 @@ export {
   validateResultContract,
   validateRecipeResult,
   RESULT_CONTRACT_REPAIR_LIMIT,
+  resultContractShape,
   resultContractRepairMessages,
   parseResultContract,
-  parseWorkerResultContract,
-  PATH_BOUNDARY_MAX_ENTRIES,
-  PathBoundaryError,
-  normalizePathBoundaryEntry,
-  normalizePathBoundary,
-  asDirectoryPathBoundary,
-  resolvePathBoundary,
-  pathBoundaryEntryCovers,
-  pathBoundaryCovers
+  parseWorkerResultContract
 };
-//# sourceMappingURL=chunk-TTHACPOM.js.map
+//# sourceMappingURL=chunk-DYJP44XW.js.map