@iowarp/clio-coder 0.4.6 → 0.4.8

package/dist/chunk-ARRUMZ7X.js

@@ -0,0 +1,1377 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  classify
+} from "./chunk-YXFKLMX2.js";
+import {
+  ToolNames,
+  isBuiltinToolName
+} from "./chunk-WLHX3MM5.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/core/json-payload.ts
+init_esm_shims();
+function jsonPayloadCandidates(text) {
+  const trimmed = text.trim();
+  const candidates = [trimmed];
+  const fenced = /```[A-Za-z0-9_-]*\s*\n?([\s\S]*?)```/.exec(trimmed)?.[1]?.trim();
+  if (fenced !== void 0 && fenced.length > 0) candidates.push(fenced);
+  const start = trimmed.indexOf("{");
+  const end = trimmed.lastIndexOf("}");
+  if (start >= 0 && end > start) candidates.push(trimmed.slice(start, end + 1));
+  return candidates;
+}
+function parseJsonObjectPayload(text) {
+  let parsedSomething = false;
+  for (const candidate of jsonPayloadCandidates(text)) {
+    let value;
+    try {
+      value = JSON.parse(candidate);
+    } catch {
+      continue;
+    }
+    parsedSomething = true;
+    if (value === null || typeof value !== "object" || Array.isArray(value)) continue;
+    return { ok: true, value };
+  }
+  return { ok: false, reason: parsedSomething ? "not-object" : "not-json" };
+}
+
+// src/domains/agents/spec.ts
+init_esm_shims();
+import { createHash } from "node:crypto";
+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 path 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)
+    return null;
+  const tasks = [];
+  for (const raw of parsed.value.tasks) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return null;
+    const task = raw;
+    if (!hasOnlyKeys(task, ["id", "agent", "description", "depends_on", "writes", "mode"]) || !string(task.id) || !string(task.agent) || !string(task.description) || !Array.isArray(task.depends_on) || task.depends_on.some((entry) => !string(entry)) || !Array.isArray(task.writes) || task.writes.some((entry) => !string(entry)) || task.mode !== void 0 && task.mode !== "sequential" && task.mode !== "parallel")
+      return null;
+    tasks.push({
+      id: task.id,
+      agent: task.agent,
+      description: task.description,
+      depends_on: [...task.depends_on],
+      writes: [...task.writes],
+      ...task.mode !== void 0 ? { mode: task.mode } : {}
+    });
+  }
+  return { tasks };
+}
+var COUNCIL_BALLOT_VERDICT_MAX_BYTES = 64;
+var COUNCIL_BALLOT_SHAPE = '{"verdict":"yes","text":"the answer and the evidence behind it"}';
+function parseCouncilBallot(output) {
+  const parsed = parseJson(output);
+  if (!parsed.ok) return null;
+  const value = parsed.value;
+  if (!hasOnlyKeys(value, ["verdict", "text"]) || !string(value.verdict) || !string(value.text)) return null;
+  const verdict = value.verdict.trim();
+  if (verdict.includes("\n") || Buffer.byteLength(verdict, "utf8") > COUNCIL_BALLOT_VERDICT_MAX_BYTES) return null;
+  return { verdict, text: value.text.trim() };
+}
+function validateCouncilBallot(contract, output) {
+  const parsed = parseJson(output);
+  if (!parsed.ok) return failure(contract, "unmeasured", parsed.reason);
+  const ballot = parseCouncilBallot(output);
+  if (ballot === null) {
+    return failure(
+      contract,
+      "unmeasured",
+      `A council ballot must carry only verdict and text, both non-empty strings, with verdict a single line of at most ${COUNCIL_BALLOT_VERDICT_MAX_BYTES} bytes so the tally can match it against the other members`
+    );
+  }
+  return success(contract, "unmeasured", ballot);
+}
+function parseCouncilReport(output) {
+  if (output === null) return null;
+  const parsed = parseJsonObjectPayload(output);
+  if (!parsed.ok) return null;
+  const value = parsed.value;
+  if (!hasOnlyKeys(value, ["members", "synthesis"]) || !Array.isArray(value.members) || value.members.length === 0) {
+    return null;
+  }
+  const members = [];
+  for (const raw of value.members) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return null;
+    const member = raw;
+    if (!hasOnlyKeys(member, ["label", "runId", "round", "answer", "verdict", "failed"]) || !string(member.label) || !string(member.runId) || !Number.isInteger(member.round) || Number(member.round) < 1 || typeof member.answer !== "string" || member.verdict !== void 0 && !string(member.verdict))
+      return null;
+    let failed;
+    if (member.failed !== void 0) {
+      if (member.failed === null || typeof member.failed !== "object" || Array.isArray(member.failed) || !hasOnlyKeys(member.failed, ["reason"]) || !string(member.failed.reason))
+        return null;
+      failed = { reason: member.failed.reason };
+    }
+    members.push({
+      label: member.label,
+      runId: member.runId,
+      round: Number(member.round),
+      answer: member.answer,
+      ...member.verdict !== void 0 ? { verdict: member.verdict } : {},
+      ...failed !== void 0 ? { failed } : {}
+    });
+  }
+  if (value.synthesis === null || typeof value.synthesis !== "object" || Array.isArray(value.synthesis)) return null;
+  const rawSynthesis = value.synthesis;
+  if (!hasOnlyKeys(rawSynthesis, ["kind", "text", "verdict", "tally", "judgeRunId"])) return null;
+  if (rawSynthesis.kind !== "none" && rawSynthesis.kind !== "judge" && rawSynthesis.kind !== "vote") return null;
+  for (const key of ["text", "verdict", "judgeRunId"]) {
+    if (rawSynthesis[key] !== void 0 && !string(rawSynthesis[key])) return null;
+  }
+  let tally;
+  if (rawSynthesis.tally !== void 0) {
+    if (rawSynthesis.tally === null || typeof rawSynthesis.tally !== "object" || Array.isArray(rawSynthesis.tally))
+      return null;
+    tally = {};
+    for (const [key, count] of Object.entries(rawSynthesis.tally)) {
+      if (!key || !Number.isInteger(count) || Number(count) < 0) return null;
+      tally[key] = Number(count);
+    }
+  }
+  return {
+    members,
+    synthesis: {
+      kind: rawSynthesis.kind,
+      ...rawSynthesis.text !== void 0 ? { text: rawSynthesis.text } : {},
+      ...rawSynthesis.verdict !== void 0 ? { verdict: rawSynthesis.verdict } : {},
+      ...tally !== void 0 ? { tally } : {},
+      ...rawSynthesis.judgeRunId !== void 0 ? { judgeRunId: rawSynthesis.judgeRunId } : {}
+    }
+  };
+}
+function canonical(value) {
+  if (value === null) return "null";
+  if (typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new Error("result contract cannot digest non-finite numbers");
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (typeof value === "object") {
+    const record = value;
+    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonical(record[key])}`).join(",")}}`;
+  }
+  throw new Error(`result contract cannot digest ${typeof value}`);
+}
+function digest(value) {
+  return createHash2("sha256").update(canonical(value), "utf8").digest("hex");
+}
+function resultContractDigest(contract) {
+  return digest(contract);
+}
+function resultContractSourceId(contract) {
+  return `agent-result-contract:${contract.kind}:${resultContractDigest(contract)}`;
+}
+function failure(contract, quality, reason) {
+  return {
+    conformance: "fail",
+    quality,
+    sourceId: resultContractSourceId(contract),
+    validatorDigest: digest({ contract, reason }),
+    reason
+  };
+}
+function success(contract, quality, value, extra = {}) {
+  return {
+    conformance: "pass",
+    quality,
+    sourceId: resultContractSourceId(contract),
+    validatorDigest: digest({ contract, value }),
+    ...extra
+  };
+}
+function parseJson(output) {
+  if (output === null || output.trim().length === 0) return { ok: false, reason: "missing final result" };
+  const parsed = parseJsonObjectPayload(output);
+  if (parsed.ok) return parsed;
+  return {
+    ok: false,
+    reason: parsed.reason === "not-object" ? "result must be a JSON object" : "result must be valid JSON"
+  };
+}
+function hasOnlyKeys(value, keys) {
+  const allowed = new Set(keys);
+  return Object.keys(value).every((key) => allowed.has(key));
+}
+function string(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function parseFindings(value) {
+  if (!Array.isArray(value)) return null;
+  const findings = [];
+  for (const entry of value) {
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry)) return null;
+    const finding = entry;
+    const line = finding.line;
+    if (!hasOnlyKeys(finding, ["claim", "path", "line"]) || !string(finding.claim) || !string(finding.path) || typeof line !== "number" || !Number.isSafeInteger(line) || line < 1) {
+      return null;
+    }
+    findings.push({ claim: finding.claim, path: finding.path, line });
+  }
+  return findings;
+}
+var RESULT_CONTRACT_KINDS = [
+  "architect-plan",
+  "scout-report",
+  "verifier-report",
+  "council-report",
+  "debugger-report",
+  "research-report",
+  "world-knowledge-report",
+  "mutation-report",
+  "provenance-report",
+  "external-delegation"
+];
+function parseSubtasks(value) {
+  if (!Array.isArray(value) || value.length > 4) return null;
+  const subtasks = [];
+  const ids = /* @__PURE__ */ new Set();
+  for (const entry of value) {
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry)) return null;
+    const subtask = entry;
+    if (!hasOnlyKeys(subtask, ["id", "task", "dependencies", "expectedResultContract", "requestedAuthority"]) || !string(subtask.id) || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u.test(subtask.id) || ids.has(subtask.id) || !string(subtask.task) || Buffer.byteLength(subtask.task, "utf8") > 4096 || !Array.isArray(subtask.dependencies) || subtask.dependencies.length > 4 || subtask.dependencies.some((dependency) => !string(dependency)) || new Set(subtask.dependencies).size !== subtask.dependencies.length || !RESULT_CONTRACT_KINDS.includes(subtask.expectedResultContract) || !AGENT_AUTOMATION_AUTHORITIES.includes(subtask.requestedAuthority)) {
+      return null;
+    }
+    ids.add(subtask.id);
+    subtasks.push({
+      id: subtask.id,
+      task: subtask.task,
+      dependencies: [...subtask.dependencies],
+      expectedResultContract: subtask.expectedResultContract,
+      requestedAuthority: subtask.requestedAuthority
+    });
+  }
+  for (const subtask of subtasks) {
+    if (subtask.dependencies.some((dependency) => dependency === subtask.id || !ids.has(dependency))) return null;
+  }
+  const remaining = new Set(ids);
+  const completed = /* @__PURE__ */ new Set();
+  while (remaining.size > 0) {
+    const ready = subtasks.filter(
+      (subtask) => remaining.has(subtask.id) && subtask.dependencies.every((dependency) => completed.has(dependency))
+    );
+    if (ready.length === 0) return null;
+    for (const subtask of ready) {
+      remaining.delete(subtask.id);
+      completed.add(subtask.id);
+    }
+  }
+  return subtasks;
+}
+function isContextHandbookResult(value) {
+  if (!hasOnlyKeys(value, ["projectName", "identity", "conventions", "invariants", "sections"])) return false;
+  if (!string(value.projectName) || !string(value.identity)) return false;
+  if (!Array.isArray(value.conventions) || value.conventions.some((entry) => !string(entry))) return false;
+  if (!Array.isArray(value.invariants) || value.invariants.some((entry) => !string(entry))) return false;
+  if (!Array.isArray(value.sections)) return false;
+  return value.sections.every((entry) => {
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry)) return false;
+    const section = entry;
+    return hasOnlyKeys(section, ["title", "body"]) && string(section.title) && string(section.body);
+  });
+}
+function validateContextHandbook(contract, output) {
+  const parsed = parseJson(output);
+  if (!parsed.ok) return failure(contract, "fail", parsed.reason);
+  if (!isContextHandbookResult(parsed.value)) {
+    return failure(
+      contract,
+      "fail",
+      "context handbook result must carry projectName, identity, conventions[], invariants[], and sections[{title, body}] and nothing else"
+    );
+  }
+  return success(contract, "unmeasured", parsed.value);
+}
+function salvageScoutClaims(value) {
+  const grounded = [];
+  const ungrounded = [];
+  if (!Array.isArray(value)) return { grounded, ungrounded };
+  for (const entry of value) {
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry)) continue;
+    const finding = entry;
+    if (!string(finding.claim)) continue;
+    const line = finding.line;
+    if (string(finding.path) && typeof line === "number" && Number.isSafeInteger(line) && line >= 1) {
+      grounded.push({ claim: finding.claim, path: finding.path, line });
+      continue;
+    }
+    ungrounded.push(finding.claim);
+  }
+  return { grounded, ungrounded };
+}
+function degradedScout(contract, value, reason) {
+  const salvaged = salvageScoutClaims(value.findings);
+  if (salvaged.grounded.length === 0 && salvaged.ungrounded.length === 0) return null;
+  const degradedReason = `${reason} (accepted as a degraded reconnaissance result; findings are leads, not validation evidence)`;
+  const scout = {
+    findings: salvaged.grounded,
+    citations: salvaged.grounded.map(({ path: citedPath, line }) => ({ path: citedPath, line })),
+    needsSplit: false,
+    proposedSubtasks: [],
+    ungroundedClaims: salvaged.ungrounded,
+    degradedReason
+  };
+  return success(contract, "unmeasured", scout, { scout, reason: degradedReason });
+}
+function validateScout(contract, output) {
+  const parsed = parseJson(output);
+  if (!parsed.ok) return failure(contract, "fail", parsed.reason);
+  const value = parsed.value;
+  const degrade = (reason) => degradedScout(contract, value, reason) ?? failure(contract, "fail", reason);
+  if (!hasOnlyKeys(value, ["findings", "needsSplit", "proposedSubtasks"])) {
+    return degrade("Scout result has unknown fields");
+  }
+  const findings = parseFindings(value.findings);
+  const proposedSubtasks = parseSubtasks(value.proposedSubtasks);
+  if (findings === null || typeof value.needsSplit !== "boolean" || proposedSubtasks === null) {
+    return degrade(
+      "Scout result must carry findings as {claim, path, line} objects, needsSplit, and 0..4 typed proposed subtasks"
+    );
+  }
+  if (value.needsSplit !== proposedSubtasks.length > 0) {
+    return degrade("Scout needsSplit must agree with proposedSubtasks");
+  }
+  if (findings.length === 0 && !value.needsSplit) {
+    return degrade("Scout result must carry at least one cited finding, or set needsSplit");
+  }
+  if (value.needsSplit && findings.length > 0) {
+    return degrade("Scout split recommendations carry typed subtasks instead of findings");
+  }
+  const scout = {
+    findings,
+    citations: findings.map(({ path: citedPath, line }) => ({ path: citedPath, line })),
+    needsSplit: value.needsSplit,
+    proposedSubtasks
+  };
+  return success(contract, "pass", scout, { scout });
+}
+function parseChecks(value) {
+  if (!Array.isArray(value) || value.length === 0) return null;
+  const checks = [];
+  for (const entry of value) {
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry)) return null;
+    const check = entry;
+    if (!hasOnlyKeys(check, ["name", "passed", "evidence"]) || !string(check.name) || typeof check.passed !== "boolean" || !string(check.evidence)) {
+      return null;
+    }
+    checks.push({ name: check.name, passed: check.passed, evidence: check.evidence });
+  }
+  return checks;
+}
+function citationWithinWorkspace(cwd, citedPath) {
+  const relative = path.relative(cwd, citedPath);
+  if (relative === "") return true;
+  return !(relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative));
+}
+function directoryCitationDigest(cwd, citedPath) {
+  const relative = path.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);
+  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;
+  if (citation.line > lineCount) {
+    return { ok: false, reason: `Scout citation is past end of file: ${citation.path}:${citation.line}` };
+  }
+  if (input.observedReadRanges !== void 0) {
+    const spans = input.observedReadRanges.get(citedPath) ?? [];
+    if (!spans.some(([start, end]) => citation.line >= start && citation.line <= end)) {
+      const observed = spans.length === 0 ? "this run never read that file" : `this run read only ${spans.map(([start, end]) => `${start}-${end}`).join(", ")}`;
+      return {
+        ok: false,
+        reason: `Scout citation is not grounded in a live read: ${citation.path}:${citation.line} (${observed})`
+      };
+    }
+  }
+  return {
+    ok: true,
+    evidence: { ...citation, contentDigest: createHash2("sha256").update(content, "utf8").digest("hex") }
+  };
+}
+function validateScoutCitations(input, citations) {
+  const evidence = [];
+  for (const citation of citations) {
+    const checked = validateScoutCitation(input, citation);
+    if (!checked.ok) return checked;
+    evidence.push(checked.evidence);
+  }
+  return { ok: true, evidence };
+}
+function groundDegradedScout(contract, input, scout, degradedReason) {
+  const grounded = [];
+  const evidence = [];
+  const demoted = [];
+  for (const finding of scout.findings) {
+    const checked = validateScoutCitation(input, { path: finding.path, line: finding.line });
+    if (checked.ok) {
+      grounded.push(finding);
+      evidence.push(checked.evidence);
+      continue;
+    }
+    demoted.push(finding.claim);
+  }
+  const degraded = {
+    findings: grounded,
+    citations: grounded.map(({ path: citedPath, line }) => ({ path: citedPath, line })),
+    needsSplit: false,
+    proposedSubtasks: [],
+    ungroundedClaims: [...scout.ungroundedClaims ?? [], ...demoted],
+    degradedReason
+  };
+  return success(contract, "unmeasured", { scout: degraded, evidence }, { scout: degraded, reason: degradedReason });
+}
+function validateVerifier(contract, output) {
+  const parsed = parseJson(output);
+  if (!parsed.ok) return failure(contract, "fail", `Verifier result payload failed: ${parsed.reason}`);
+  const value = parsed.value;
+  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`
+    );
+  }
+  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 });
+}
+function parseVerifierResult(output) {
+  const validation = validateVerifier({ kind: "verifier-report" }, output);
+  return validation.verifier ?? null;
+}
+function validateOracle(contract, output) {
+  const parsed = parseJson(output);
+  if (!parsed.ok) return failure(contract, "unmeasured", parsed.reason);
+  const value = parsed.value;
+  if (!hasOnlyKeys(value, ["verdict", "challenge", "changesMyMind", "citedDecisions"]) || !string(value.verdict) || !string(value.challenge) || !string(value.changesMyMind) || !Array.isArray(value.citedDecisions) || value.citedDecisions.some((entry) => !string(entry))) {
+    return failure(
+      contract,
+      "unmeasured",
+      'Oracle result must carry verdict, challenge, changesMyMind, and a citedDecisions array of strings, for example {"verdict":"consistent with decision routing.target","challenge":"...","changesMyMind":"...","citedDecisions":["routing.target"]}'
+    );
+  }
+  return success(contract, "unmeasured", value);
+}
+function parseOracleResult(output) {
+  const validation = validateOracle({ kind: "oracle-report" }, output);
+  if (validation.conformance !== "pass") return null;
+  const parsed = parseJson(output);
+  if (!parsed.ok) return null;
+  return {
+    verdict: String(parsed.value.verdict),
+    challenge: String(parsed.value.challenge),
+    changesMyMind: String(parsed.value.changesMyMind),
+    citedDecisions: parsed.value.citedDecisions.map((entry) => String(entry))
+  };
+}
+function validateCodeReport(contract, output) {
+  const parsed = parseJson(output);
+  if (!parsed.ok) return failure(contract, "unmeasured", parsed.reason);
+  const value = parsed.value;
+  if (!hasOnlyKeys(value, ["passed", "exitCode", "checks", "artifactPaths", "outputExcerpt"]) || typeof value.passed !== "boolean" || typeof value.exitCode !== "number" || !Number.isSafeInteger(value.exitCode) || typeof value.outputExcerpt !== "string" || !Array.isArray(value.artifactPaths) || value.artifactPaths.some((entry) => !string(entry))) {
+    return failure(
+      contract,
+      "unmeasured",
+      "Code result must carry passed, integer exitCode, checks, artifactPaths, and outputExcerpt"
+    );
+  }
+  const checks = parseChecks(value.checks);
+  if (checks === null) return failure(contract, "unmeasured", "Code result must carry typed checks");
+  if (value.passed !== (value.exitCode === 0) || value.passed !== checks.every((check) => check.passed)) {
+    return failure(contract, "unmeasured", "Code result passed must agree with its exit code and every check");
+  }
+  return success(contract, "unmeasured", value);
+}
+var RESULT_COMMIT_MESSAGE_MAX_BYTES = 1e3;
+var RESULT_SUMMARY_DEFAULT_MAX_BYTES = 16384;
+var RESULT_SUMMARY_MAX_BYTES_CEILING = 32768;
+var RESULT_OUTPUT_ENVELOPE_HEADROOM_BYTES = 4096;
+function resultSummaryMaxBytes(contract) {
+  if (contract.kind !== "mutation-report") return RESULT_COMMIT_MESSAGE_MAX_BYTES;
+  return contract.maxSummaryBytes ?? RESULT_SUMMARY_DEFAULT_MAX_BYTES;
+}
+function parseResultSummaryMaxBytes(value, label) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1 || value > RESULT_SUMMARY_MAX_BYTES_CEILING) {
+    throw new Error(`${label} must be an integer between 1 and ${RESULT_SUMMARY_MAX_BYTES_CEILING}`);
+  }
+  return value;
+}
+function withResultSummaryAllowance(contract, maxSummaryBytes) {
+  if (contract.kind !== "mutation-report") return contract;
+  return { kind: "mutation-report", maxSummaryBytes: parseResultSummaryMaxBytes(maxSummaryBytes, "maxSummaryBytes") };
+}
+function resultContractOutputBytes(contract) {
+  if (contract === null || contract === void 0 || contract.kind !== "mutation-report") return null;
+  return 2 * resultSummaryMaxBytes(contract) + 2 * RESULT_COMMIT_MESSAGE_MAX_BYTES + RESULT_OUTPUT_ENVELOPE_HEADROOM_BYTES;
+}
+var AUTHORSHIP_FIELDS = ["commitMessage", "summary"];
+function hasControlCharacters(value) {
+  for (const character of value) {
+    const code = character.codePointAt(0) ?? 0;
+    if (code === 127) return true;
+    if (code < 32 && character !== "\n" && character !== "\r" && character !== "	") return true;
+  }
+  return false;
+}
+function normalizeAuthored(value) {
+  return value.replace(/\r\n/gu, "\n").replace(/\r/gu, "\n").trim();
+}
+function validateAuthorship(value, summaryMaxBytes) {
+  for (const field of AUTHORSHIP_FIELDS) {
+    const maxBytes = field === "summary" ? summaryMaxBytes : RESULT_COMMIT_MESSAGE_MAX_BYTES;
+    const raw = value[field];
+    if (raw === void 0 || raw === null) continue;
+    if (typeof raw !== "string") return `${field} must be a string when present`;
+    if (raw.trim().length === 0) continue;
+    const bytes = Buffer.byteLength(raw, "utf8");
+    if (bytes > maxBytes) return `${field} must be at most ${maxBytes} UTF-8 bytes (${bytes} given)`;
+    if (hasControlCharacters(raw)) return `${field} must not contain control characters`;
+  }
+  return null;
+}
+function resultContractAuthorship(contract, output) {
+  const empty = { commitMessage: null, summary: null };
+  if (contract.kind !== "mutation-report" && contract.kind !== "architect-plan") return empty;
+  const parsed = parseJson(output);
+  if (!parsed.ok || validateAuthorship(parsed.value, resultSummaryMaxBytes(contract)) !== null) return empty;
+  const read = (field) => {
+    const raw = parsed.value[field];
+    if (typeof raw !== "string") return null;
+    const normalized = normalizeAuthored(raw);
+    return normalized.length === 0 ? null : normalized;
+  };
+  return { commitMessage: read("commitMessage"), summary: read("summary") };
+}
+function validateDebugger(contract, output) {
+  const parsed = parseJson(output);
+  if (!parsed.ok) return failure(contract, "unmeasured", `Debugger result payload failed: ${parsed.reason}`);
+  const value = parsed.value;
+  const unknown = Object.keys(value).filter(
+    (key) => key !== "diagnosis" && key !== "reproduction" && key !== "evidence"
+  );
+  if (unknown.length > 0) {
+    return failure(
+      contract,
+      "unmeasured",
+      `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", `Research result payload failed: ${parsed.reason}`);
+  const value = parsed.value;
+  const unknown = Object.keys(value).filter((key) => key !== "source" && key !== "findings");
+  if (unknown.length > 0) {
+    return failure(
+      contract,
+      "unmeasured",
+      `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",
+      '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 [index, finding] of value.findings.entries()) {
+    if (finding === null || typeof finding !== "object" || Array.isArray(finding)) {
+      return failure(contract, "unmeasured", `Research field "findings[${index}]" must be an object`);
+    }
+    const record = finding;
+    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 validateWorldKnowledge(contract, output, externalSourcesAllowed) {
+  const parsed = parseJson(output);
+  if (!parsed.ok) return failure(contract, "unmeasured", `World-knowledge payload failed: ${parsed.reason}`);
+  const value = parsed.value;
+  const legal = ["discovery", "facts", "synthesis", "uncertainties", "followUpVerification"];
+  const unknown = Object.keys(value).filter((key) => !legal.includes(key));
+  if (unknown.length > 0) {
+    return failure(contract, "unmeasured", `World-knowledge field '${unknown[0]}' is not legal`);
+  }
+  if (value.discovery !== "performed" && value.discovery !== "caller-supplied-only" && value.discovery !== "unavailable") {
+    return failure(
+      contract,
+      "unmeasured",
+      'World-knowledge field "discovery" must be one of: performed | caller-supplied-only | unavailable'
+    );
+  }
+  if (value.discovery === "performed" && !externalSourcesAllowed) {
+    return failure(
+      contract,
+      "unmeasured",
+      'World-knowledge field "discovery" is performed but this run had no external-source posture'
+    );
+  }
+  if (!Array.isArray(value.facts)) {
+    return failure(contract, "unmeasured", 'World-knowledge field "facts" must be an array');
+  }
+  for (const [index, finding] of value.facts.entries()) {
+    if (!finding || typeof finding !== "object" || Array.isArray(finding)) {
+      return failure(contract, "unmeasured", `World-knowledge field "facts[${index}]" must be an object`);
+    }
+    const fact = finding;
+    const factUnknown = Object.keys(fact).filter((key) => !["claim", "evidence", "sources"].includes(key));
+    if (factUnknown.length > 0) {
+      return failure(contract, "unmeasured", `World-knowledge field "facts[${index}].${factUnknown[0]}" is not legal`);
+    }
+    if (!string(fact.claim) || !string(fact.evidence) || !Array.isArray(fact.sources)) {
+      return failure(
+        contract,
+        "unmeasured",
+        `World-knowledge field "facts[${index}]" requires non-empty claim/evidence strings and a sources array`
+      );
+    }
+    if (fact.sources.some((source) => !string(source))) {
+      return failure(contract, "unmeasured", `World-knowledge field "facts[${index}].sources" must contain strings`);
+    }
+  }
+  for (const field of ["synthesis", "uncertainties", "followUpVerification"]) {
+    const entries = value[field];
+    if (!Array.isArray(entries) || entries.some((entry) => !string(entry))) {
+      return failure(contract, "unmeasured", `World-knowledge field "${field}" must be an array of non-empty strings`);
+    }
+  }
+  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 more = effects.mutatedPaths.size - written.length;
+  return `this run wrote ${written.join(", ")}${more > 0 ? ` (+${more} more)` : ""}`;
+}
+var MUTATION_WRITE_SET_REASON_LIMIT = 8;
+function pathIsPresent(filesystem, target) {
+  if (filesystem.pathExists === void 0) return true;
+  return filesystem.pathExists(target);
+}
+var MUTATION_VALIDATION_EXAMPLE = '{"name":"npm test","passed":true,"evidence":"exit 0"}';
+function mutationValidationsReason(value) {
+  const empty = Array.isArray(value) && value.length === 0;
+  if (empty) {
+    return `Mutation result must carry typed validation results: validations was empty. Emit one entry per check this run actually made, each shaped like ${MUTATION_VALIDATION_EXAMPLE}. A run that only read files still names the read and cites what it saw.`;
+  }
+  return `Mutation result must carry typed validation results: every validations entry is shaped like ${MUTATION_VALIDATION_EXAMPLE}, with a string name, a boolean passed, a string evidence, and no other keys.`;
+}
+function validateMutation(contract, input) {
+  if (input.outputTruncated === true && input.output !== null) {
+    const bound = resultContractOutputBytes(contract) ?? Buffer.byteLength(input.output, "utf8");
+    return failure(
+      contract,
+      "unmeasured",
+      `result exceeded the sealed output bound of ${bound} bytes and was truncated; keep summary within ${resultSummaryMaxBytes(contract)} UTF-8 bytes or state the limitation`
+    );
+  }
+  const parsed = parseJson(input.output);
+  if (!parsed.ok) return failure(contract, "unmeasured", parsed.reason);
+  const value = parsed.value;
+  if (!hasOnlyKeys(value, ["mutatedPaths", "validations", "commitMessage", "summary"]) || !Array.isArray(value.mutatedPaths) || value.mutatedPaths.some((entry) => !string(entry))) {
+    return failure(contract, "unmeasured", "Mutation result must carry mutatedPaths and validations");
+  }
+  const authorship = validateAuthorship(value, resultSummaryMaxBytes(contract));
+  if (authorship !== null) return failure(contract, "unmeasured", authorship);
+  const validations = parseChecks(value.validations);
+  if (validations === null) return failure(contract, "unmeasured", mutationValidationsReason(value.validations));
+  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);
+  let unverifiedMutation = false;
+  for (const reported of value.mutatedPaths) {
+    const target = path.resolve(cwd, reported);
+    if (effects.mutatedPaths.has(target)) continue;
+    if (effects.failedMutationPaths.has(target)) {
+      return failure(
+        contract,
+        "unmeasured",
+        `Mutation result names a path whose only write this run attempted was refused: ${reported} (${describeWriteSet(effects, cwd)})`
+      );
+    }
+    if (pathIsPresent(input.filesystem, target)) {
+      unverifiedMutation = true;
+      continue;
+    }
+    return failure(
+      contract,
+      "unmeasured",
+      `Mutation result names a path this run never wrote and that does not exist: ${reported} (${describeWriteSet(effects, cwd)})`
+    );
+  }
+  if (reportedFailure) return success(contract, "fail", value);
+  const measured = !unverifiedMutation && effects.validationCommands.size > 0;
+  return success(contract, measured ? "pass" : "unmeasured", value);
+}
+function validateProvenance(contract, output) {
+  const parsed = parseJson(output);
+  if (!parsed.ok) return failure(contract, "unmeasured", parsed.reason);
+  const value = parsed.value;
+  if (!hasOnlyKeys(value, ["confirmedFacts", "missingEvidence", "nextInspections"]) || ![value.confirmedFacts, value.missingEvidence, value.nextInspections].every(
+    (entry) => Array.isArray(entry) && entry.every((item) => string(item))
+  )) {
+    return failure(
+      contract,
+      "unmeasured",
+      "Provenance result must carry confirmedFacts, missingEvidence, and nextInspections"
+    );
+  }
+  return success(contract, "unmeasured", value);
+}
+function validateArchitect(contract, input) {
+  const artifactPath = path.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: createHash2("sha256").update(content, "utf8").digest("hex")
+  });
+}
+function parseScoutResult(output) {
+  const validation = validateScout({ kind: "scout-report" }, output);
+  if (validation.conformance !== "pass" || validation.scout === void 0) return null;
+  return validation.scout.degradedReason === void 0 ? validation.scout : null;
+}
+function validateResultContract(input) {
+  switch (input.contract.kind) {
+    case "architect-plan":
+      return validateArchitect(input.contract, input);
+    case "scout-report": {
+      const validation = validateScout(input.contract, input.output);
+      if (validation.scout === void 0) return validation;
+      const degradedReason = validation.scout.degradedReason;
+      if (degradedReason !== void 0) {
+        return groundDegradedScout(input.contract, input, validation.scout, degradedReason);
+      }
+      const citations = validateScoutCitations(input, validation.scout.citations);
+      return citations.ok ? success(
+        input.contract,
+        "pass",
+        { scout: validation.scout, evidence: citations.evidence },
+        { scout: validation.scout }
+      ) : failure(input.contract, "fail", citations.reason);
+    }
+    case "verifier-report":
+      return validateVerifier(input.contract, input.output);
+    case "council-report": {
+      const report = parseCouncilReport(input.output);
+      return report === null ? failure(input.contract, "fail", "council-report is malformed") : success(input.contract, "unmeasured", { council: report });
+    }
+    case "council-ballot":
+      return validateCouncilBallot(input.contract, input.output);
+    case "debugger-report":
+      return validateDebugger(input.contract, input.output);
+    case "research-report":
+      return validateResearch(input.contract, input.output, input.networkAllowed);
+    case "world-knowledge-report":
+      return validateWorldKnowledge(input.contract, input.output, input.networkAllowed);
+    case "mutation-report":
+      return validateMutation(input.contract, input);
+    case "provenance-report":
+      return validateProvenance(input.contract, input.output);
+    case "delegation-plan": {
+      const plan = parseDelegationPlanResult(input.output);
+      return plan === null ? failure(
+        input.contract,
+        "fail",
+        "delegation-plan must carry tasks with id, agent, description, depends_on, writes, and optional mode"
+      ) : success(input.contract, "unmeasured", plan, { delegationPlan: plan });
+    }
+    case "oracle-report":
+      return validateOracle(input.contract, input.output);
+    case "external-delegation":
+      return success(input.contract, "unmeasured", { external: true });
+    case "artifact-report": {
+      if (input.contract.path !== void 0) {
+        const content = input.filesystem.readFile(path.resolve(input.cwd, input.contract.path));
+        if (content === null) {
+          return failure(
+            input.contract,
+            "unmeasured",
+            `Required artifact is missing or unreadable: ${JSON.stringify(input.contract.path)}`
+          );
+        }
+        if (content.trim().length === 0) {
+          return failure(input.contract, "unmeasured", `Required artifact is empty: ${JSON.stringify(input.contract.path)}`);
+        }
+      }
+      return success(input.contract, "unmeasured", { artifact: true });
+    }
+    case "context-handbook":
+      return validateContextHandbook(input.contract, input.output);
+    case "code-report":
+      return validateCodeReport(input.contract, input.output);
+  }
+}
+function validateRecipeResult(input) {
+  if (input.contract === null) return null;
+  if (!input.reachedTerminalResult) {
+    return {
+      applicable: false,
+      fact: {
+        sourceId: resultContractSourceId(input.contract),
+        validatorDigest: digest({ contract: input.contract, reached: false }),
+        conformance: "not-reached",
+        quality: "unmeasured"
+      }
+    };
+  }
+  const validation = validateResultContract({
+    contract: input.contract,
+    output: input.output,
+    cwd: input.cwd,
+    networkAllowed: input.networkAllowed,
+    filesystem: input.filesystem,
+    ...input.observedRunEffects !== void 0 ? { observedRunEffects: input.observedRunEffects } : {},
+    ...input.outputTruncated !== void 0 ? { outputTruncated: input.outputTruncated } : {}
+  });
+  return {
+    applicable: true,
+    validation,
+    fact: {
+      sourceId: validation.sourceId,
+      validatorDigest: validation.validatorDigest,
+      conformance: validation.conformance,
+      quality: validation.quality
+    }
+  };
+}
+var RESULT_CONTRACT_REPAIR_LIMIT = 2;
+var RESULT_CONTRACT_ANCHOR_LIMIT = 12;
+function resultContractShape(contract) {
+  switch (contract.kind) {
+    case "architect-plan":
+      return `a plan artifact written to ${contract.path}, then optionally {"commitMessage":"...","summary":"..."} describing it`;
+    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 '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 '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 'one of {"source":"local","findings":[{"claim":"...","evidence":"..."}]} or {"source":"external","findings":[{"claim":"...","evidence":"..."}]}; source legal values are local | external';
+    case "world-knowledge-report":
+      return '{"discovery":"performed|caller-supplied-only|unavailable","facts":[{"claim":"...","evidence":"...","sources":["URL or document id"]}],"synthesis":["comparison or advisory conclusion"],"uncertainties":["..."],"followUpVerification":["..."]}';
+    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":"the requested explanation or deliverable, or a specific limitation; otherwise optional"}. summary allows at most ${resultSummaryMaxBytes(contract)} UTF-8 bytes and commitMessage at most ${RESULT_COMMIT_MESSAGE_MAX_BYTES} UTF-8 bytes. Preserve the requested explanation and citations in summary when repairing the report; if they cannot fit or be grounded, state that specific limitation. Report only actual mutations and checks; a read-only task has mutatedPaths:[] and names the source read in validations, never a command that did not run`;
+    case "provenance-report":
+      return '{"confirmedFacts":["..."],"missingEvidence":["..."],"nextInspections":["..."]}';
+    case "delegation-plan":
+      return '{"tasks":[{"id":"build","agent":"coder","description":"Implement the change","depends_on":[],"writes":["src"],"mode":"parallel"}]}';
+    case "oracle-report":
+      return '{"verdict":"one line","challenge":"the strongest objection you can mount","changesMyMind":"the evidence that would reverse the verdict","citedDecisions":["decision key or task id you relied on"]}';
+    case "external-delegation":
+      return "any final text";
+    case "artifact-report":
+      return contract.path === void 0 ? "any final text; the artifact you wrote at the location the task named is the result" : `any final text; the required artifact at ${JSON.stringify(contract.path)} must be readable and non-empty on disk`;
+    case "context-handbook":
+      return '{"projectName":"string","identity":"one sentence","conventions":[],"invariants":[],"sections":[{"title":"Architecture","body":"markdown that cites `real/path.ts` tokens"}]}';
+    case "code-report":
+      return '{"passed":false,"exitCode":1,"checks":[{"name":"test","passed":false,"evidence":"exit 1"}],"artifactPaths":["/path/command.log"],"outputExcerpt":"..."}';
+  }
+}
+function resultContractRepairMessage(input) {
+  const last = input.attempt >= RESULT_CONTRACT_REPAIR_LIMIT;
+  const boundArtifact = input.contract.kind === "artifact-report" && input.contract.path !== void 0;
+  const lines = [
+    last ? "FINAL RESULT REQUIRED IN THIS RESPONSE. Your previous response still did not satisfy this run's result contract." : "Your previous response did not satisfy this run's result contract.",
+    `Validator reason: ${input.reason}`,
+    input.toolsAvailable === true ? "You may use the admitted tools to repair this validator failure, then emit the required terminal result." : "Tool use is over. Answer from the evidence you already gathered.",
+    ...boundArtifact ? [
+      `Required result: ${resultContractShape(input.contract)}`,
+      input.toolsAvailable === true ? "Repair the required artifact on disk, then give a brief final status. Literal tool-call markup in final text does not write a file." : "State the limitation in a brief final status; the required artifact remains unsatisfied."
+    ] : [
+      `Emit exactly this shape and nothing else: ${resultContractShape(input.contract)}`,
+      "Do not add prose, code fences, or commentary around it. Do not describe work you intend to do next."
+    ]
+  ];
+  if (input.anchors.length > 0) {
+    lines.push(
+      "",
+      "Source ranges you read successfully in this run (path:start-end, inclusive):",
+      ...input.anchors.slice(-RESULT_CONTRACT_ANCHOR_LIMIT).map((anchor) => `- ${anchor}`)
+    );
+  }
+  if (input.contract.kind === "scout-report") {
+    lines.push(
+      "For each finding, use the exact source line that supports its claim inside a listed read range. Range endpoints are not suggested citations.",
+      "If a finding's supporting line cannot be confirmed from the source already returned, remove that finding and keep the confirmed findings. Never shift a rejected citation into range just to pass validation."
+    );
+  }
+  return lines.join("\n");
+}
+var RESULT_CONTRACT_REPAIR_TOOL = "result_contract";
+function resultContractRepairMessages(input, origin) {
+  const id = `clio-result-contract-repair-${input.attempt}`;
+  const timestamp = Date.now();
+  return [
+    {
+      role: "assistant",
+      content: [{ type: "toolCall", id, name: RESULT_CONTRACT_REPAIR_TOOL, arguments: {} }],
+      stopReason: "toolUse",
+      usage: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+      },
+      ...origin,
+      timestamp
+    },
+    {
+      role: "toolResult",
+      toolCallId: id,
+      toolName: RESULT_CONTRACT_REPAIR_TOOL,
+      content: [{ type: "text", text: resultContractRepairMessage(input) }],
+      isError: true,
+      timestamp
+    }
+  ];
+}
+var RECIPE_DECLARABLE_KINDS = [
+  "scout-report",
+  "verifier-report",
+  "council-report",
+  "debugger-report",
+  "research-report",
+  "world-knowledge-report",
+  "mutation-report",
+  "provenance-report",
+  "oracle-report",
+  "external-delegation",
+  "artifact-report",
+  "context-handbook",
+  "delegation-plan"
+];
+var COORDINATOR_AUTHORED_KINDS = ["council-ballot"];
+function parseContract(value, sourcePath, kinds, callerBoundArtifacts = false) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`agent recipe: ${sourcePath}: resultContract must be an object`);
+  }
+  const record = value;
+  if (typeof record.kind !== "string") throw new Error(`agent recipe: ${sourcePath}: resultContract.kind is required`);
+  const keys = Object.keys(record);
+  const only = (...allowed) => keys.every((key) => allowed.includes(key));
+  if (record.kind === "architect-plan") {
+    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("..")) {
+      throw new Error(`agent recipe: ${sourcePath}: architect-plan path must be workspace-relative`);
+    }
+    return { kind: "architect-plan", path: record.path };
+  }
+  if (record.kind === "artifact-report" && callerBoundArtifacts) {
+    if (!only("kind", "path")) {
+      throw new Error(`agent recipe: ${sourcePath}: artifact-report admits only kind and path`);
+    }
+    if (record.path === void 0) return { kind: "artifact-report" };
+    if (!string(record.path) || record.path.includes("\0")) {
+      throw new Error(`agent recipe: ${sourcePath}: artifact-report requires a non-empty path without NUL`);
+    }
+    if (path.posix.isAbsolute(record.path) || path.win32.isAbsolute(record.path) || /^[a-z]:/iu.test(record.path) || record.path.split(/[\\/]/u).includes("..")) {
+      throw new Error(`agent recipe: ${sourcePath}: artifact-report path must be workspace-relative`);
+    }
+    return { kind: "artifact-report", path: record.path };
+  }
+  if (record.kind === "mutation-report") {
+    if (!only("kind", "maxSummaryBytes")) {
+      throw new Error(`agent recipe: ${sourcePath}: mutation-report admits only kind and maxSummaryBytes`);
+    }
+    if (record.maxSummaryBytes === void 0) return { kind: "mutation-report" };
+    try {
+      return {
+        kind: "mutation-report",
+        maxSummaryBytes: parseResultSummaryMaxBytes(record.maxSummaryBytes, "maxSummaryBytes")
+      };
+    } catch (error) {
+      throw new Error(`agent recipe: ${sourcePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  if (!kinds.includes(record.kind) || !only("kind")) {
+    throw new Error(`agent recipe: ${sourcePath}: resultContract.kind is unsupported or has unknown keys`);
+  }
+  return { kind: record.kind };
+}
+function parseResultContract(value, sourcePath) {
+  return parseContract(value, sourcePath, RECIPE_DECLARABLE_KINDS);
+}
+function parseWorkerResultContract(value, sourcePath) {
+  return parseContract(value, sourcePath, [...RECIPE_DECLARABLE_KINDS, ...COORDINATOR_AUTHORED_KINDS], true);
+}
+
+export {
+  parseJsonObjectPayload,
+  AGENT_AUTOMATION_AUTHORITIES,
+  isAgentCategory,
+  isAgentCapabilityClass,
+  isAgentLatencyClass,
+  isAgentAudience,
+  isAgentProjectContextTier,
+  isAgentProduct,
+  resolveAgentToolCompatibility,
+  normalizeAgentSpec,
+  agentSpecFingerprint,
+  isUserVisibleAgent,
+  isShadowAgent,
+  assertAgentSpecPolicy,
+  COUNCIL_BALLOT_VERDICT_MAX_BYTES,
+  COUNCIL_BALLOT_SHAPE,
+  parseCouncilReport,
+  resultContractSourceId,
+  parseVerifierResult,
+  parseOracleResult,
+  RESULT_SUMMARY_MAX_BYTES_CEILING,
+  parseResultSummaryMaxBytes,
+  withResultSummaryAllowance,
+  resultContractOutputBytes,
+  resultContractAuthorship,
+  parseScoutResult,
+  validateResultContract,
+  validateRecipeResult,
+  RESULT_CONTRACT_REPAIR_LIMIT,
+  resultContractShape,
+  resultContractRepairMessages,
+  parseResultContract,
+  parseWorkerResultContract
+};
+//# sourceMappingURL=chunk-ARRUMZ7X.js.map