@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-I47EJPYL.js

@@ -1,1377 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  classify
-} from "./chunk-H2WSCZZT.js";
-import {
-  ToolNames,
-  isBuiltinToolName
-} from "./chunk-V4XJWDHR.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-I47EJPYL.js.map