@iowarp/clio-coder 0.3.0 → 0.3.2

package/dist/{chunk-XV4ZJ6ZM.js → chunk-STBPMHSX.js}

@@ -1,28 +1,75 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   AGENT_AUTOMATION_AUTHORITIES,
-  canonicalizeExistingPath,
+  artifactDefaultPath,
   classify,
   detectValidationCommand,
   extractCommandDeleteTargets,
   extractCommandWriteTargets,
   inlineShellScript,
-  isVerificationScriptName,
   tokenizeShellLike,
   toolMutationPaths
-} from "./chunk-WD6AJM35.js";
+} from "./chunk-5UUP6MWO.js";
+import {
+  isVerificationScriptName
+} from "./chunk-7MNJORFF.js";
+import {
+  canonicalizeExistingPath
+} from "./chunk-ECH6PKUQ.js";
 import {
   ToolNames
-} from "./chunk-QV47YRF4.js";
+} from "./chunk-CGKSTWHD.js";
+import {
+  foreignAgentDirs
+} from "./chunk-IHXBNWMM.js";
+import {
+  require_dist
+} from "./chunk-APJ265NV.js";
 import {
   clioConfigDir
-} from "./chunk-X3NE4WVW.js";
+} from "./chunk-BNAZZHFG.js";
 import {
   resolvePackageRoot
-} from "./chunk-DXQNI4PC.js";
+} from "./chunk-IWHMRKLL.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
 
 // src/domains/agents/result-contract.ts
+init_esm_shims();
 import { createHash } from "node:crypto";
 import path from "node:path";
+
+// 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/result-contract.ts
 function canonical(value) {
   if (value === null) return "null";
   if (typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
@@ -66,15 +113,12 @@ function success(contract, quality, value, extra = {}) {
 }
 function parseJson(output) {
   if (output === null || output.trim().length === 0) return { ok: false, reason: "missing final result" };
-  try {
-    const value = JSON.parse(output);
-    if (value === null || typeof value !== "object" || Array.isArray(value)) {
-      return { ok: false, reason: "result must be a JSON object" };
-    }
-    return { ok: true, value };
-  } catch {
-    return { ok: false, reason: "result must be valid JSON" };
-  }
+  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);
@@ -427,6 +471,14 @@ 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) {
   const parsed = parseJson(input.output);
   if (!parsed.ok) return failure(contract, "unmeasured", parsed.reason);
@@ -437,8 +489,7 @@ function validateMutation(contract, input) {
   const authorship = validateAuthorship(value);
   if (authorship !== null) return failure(contract, "unmeasured", authorship);
   const validations = parseChecks(value.validations);
-  if (validations === null)
-    return failure(contract, "unmeasured", "Mutation result must carry typed validation results");
+  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);
@@ -616,6 +667,36 @@ function resultContractRepairMessage(input) {
   }
   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
+    }
+  ];
+}
 function parseResultContract(value, sourcePath) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     throw new Error(`agent recipe: ${sourcePath}: resultContract must be an object`);
@@ -650,648 +731,384 @@ function parseResultContract(value, sourcePath) {
   return { kind: record.kind };
 }
 
-// src/domains/agents/fleet-commands.ts
-import { existsSync, readFileSync } from "node:fs";
-import { isAbsolute, join, normalize } from "node:path";
-import { Type } from "typebox";
-import { Value } from "typebox/value";
-import yaml from "yaml";
-var FLEET_COMMAND_MAX_TIMEOUT_MS = 36e5;
-var FLEET_COMMAND_MIN_TIMEOUT_MS = 1e3;
-var FLEET_COMMAND_DEFAULT_TIMEOUT_MS = 6e5;
-var FLEET_COMMAND_BASE_ENV = ["PATH", "HOME", "LANG", "LC_ALL", "TZ", "TMPDIR"];
-var CommandSchema = Type.Object(
-  {
-    argv: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
-    cwd: Type.Optional(Type.String({ minLength: 1 })),
-    timeoutMs: Type.Optional(
-      Type.Integer({ minimum: FLEET_COMMAND_MIN_TIMEOUT_MS, maximum: FLEET_COMMAND_MAX_TIMEOUT_MS })
-    ),
-    env: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
-    description: Type.Optional(Type.String())
-  },
-  { additionalProperties: false }
-);
-var RegistrySchema = Type.Object(
-  {
-    version: Type.Literal(1),
-    commands: Type.Record(Type.String({ minLength: 1 }), CommandSchema, { minProperties: 1 })
-  },
-  { additionalProperties: false }
-);
-var COMMAND_ID_RE = /^[a-z0-9][a-z0-9._-]{0,63}$/u;
-var ENV_NAME_RE = /^[A-Z_][A-Z0-9_]*$/u;
-function fleetCommandsPath(cwd) {
-  return join(cwd, ".clio-coder", "fleets", "commands.yaml");
-}
-function firstSchemaError(value) {
-  if (Value.Check(RegistrySchema, value)) return null;
-  const first = [...Value.Errors(RegistrySchema, value)][0];
-  return first ? `${first.instancePath || "(root)"}: ${first.message}` : "command registry failed validation";
-}
-function checkCwd(id, value, sourcePath) {
-  if (isAbsolute(value)) {
-    throw new Error(`fleet commands ${sourcePath}: command '${id}' cwd must be workspace-relative`);
-  }
-  const normalized = normalize(value);
-  if (normalized === ".." || normalized.startsWith(`..${"/"}`) || normalized.split(/[\\/]/u).includes("..")) {
-    throw new Error(`fleet commands ${sourcePath}: command '${id}' cwd escapes the workspace`);
-  }
-  return normalized === "." ? "" : normalized;
-}
-function parseFleetCommands(raw, sourcePath) {
-  let parsed;
-  try {
-    parsed = yaml.parse(raw);
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err);
-    throw new Error(`fleet commands ${sourcePath}: invalid YAML (${reason})`);
-  }
-  const schemaError = firstSchemaError(parsed);
-  if (schemaError !== null) throw new Error(`fleet commands ${sourcePath}: ${schemaError}`);
-  const registry = parsed;
-  const commands = /* @__PURE__ */ new Map();
-  for (const [id, entry] of Object.entries(registry.commands)) {
-    if (!COMMAND_ID_RE.test(id)) {
-      throw new Error(`fleet commands ${sourcePath}: command id '${id}' must match ${COMMAND_ID_RE.source}`);
-    }
-    const executable = entry.argv[0] ?? "";
-    if (executable.trim().length === 0) {
-      throw new Error(`fleet commands ${sourcePath}: command '${id}' has an empty executable`);
-    }
-    for (const name of entry.env ?? []) {
-      if (!ENV_NAME_RE.test(name)) {
-        throw new Error(`fleet commands ${sourcePath}: command '${id}' env name '${name}' is not a variable name`);
-      }
-    }
-    commands.set(id, {
-      id,
-      argv: [...entry.argv],
-      cwd: entry.cwd === void 0 ? "" : checkCwd(id, entry.cwd, sourcePath),
-      timeoutMs: entry.timeoutMs ?? FLEET_COMMAND_DEFAULT_TIMEOUT_MS,
-      env: [...entry.env ?? []],
-      description: entry.description ?? ""
-    });
+// src/domains/safety/finish-contract.ts
+init_esm_shims();
+var FINISH_CONTRACT_ADVISORY_MESSAGE = "[Clio Coder] finish-contract advisory: you changed files this turn without recording validation evidence or an explicit limitation. Run a verification command or state what could not be verified.";
+var DEFAULT_RECENT_ENTRY_LIMIT = 80;
+var LIMITATION_PATTERNS = [
+  /\b(?:blocked by|blocker|blockers|unable to|not able to|could not|couldn't|cannot|can't)\b/i,
+  /\b(?:did not|didn't|have not|haven't|has not|hasn't|was not able|wasn't able)\b/i,
+  /\b(?:not complete|incomplete)\b/i,
+  /\b(?:not|un)(?:\s|-)?(?:validated|verified|tested)\b/i,
+  /^\s*Tests\s*:\s*(?:not run|not executed|not available|failed|blocked|skipped)\b/im,
+  /^\s*Known gaps?\s*:\s*(?!\s*(?:none|no\b|n\/a|not applicable)\b).+/im,
+  /\bremaining(?:\s+\w+){0,3}\s+(?:work|issue|issues|gap|gaps|blocker|blockers)\b/i
+];
+function assessFinishContract(input) {
+  const assistantText = input.assistantText.trim();
+  const sessionEntries = input.sessionEntries ?? [];
+  const assistantTurnId = input.assistantTurnId ?? null;
+  const window = recentEntries(sessionEntries, assistantTurnId, input.recentEntryLimit ?? DEFAULT_RECENT_ENTRY_LIMIT);
+  const mutatedPaths = mutatingReceipts(window);
+  if (mutatedPaths.length === 0) {
+    return { kind: "ok", reason: "no_mutation", evidence: [], mutatedPaths };
   }
-  return { version: 1, commands, path: sourcePath };
-}
-function loadFleetCommands(cwd) {
-  const path7 = fleetCommandsPath(cwd);
-  if (!existsSync(path7)) return null;
-  return parseFleetCommands(readFileSync(path7, "utf8"), path7);
-}
-
-// src/domains/agents/fleet-contract.ts
-import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2 } from "node:fs";
-import { basename, join as join2 } from "node:path";
-import { Type as Type2 } from "typebox";
-import { Value as Value2 } from "typebox/value";
-
-// src/domains/agents/frontmatter.ts
-import yaml2 from "yaml";
-function parseFrontmatter(raw, sourcePath) {
-  const opening = raw.match(/^---\r?\n/);
-  if (!opening) {
-    throw new Error(`frontmatter: ${sourcePath}: missing YAML frontmatter opening delimiter`);
-  }
-  const closeRegex = /\r?\n---(?:\r?\n|$)/g;
-  closeRegex.lastIndex = opening[0].length;
-  const closing = closeRegex.exec(raw);
-  if (!closing) {
-    throw new Error(`frontmatter: ${sourcePath}: missing YAML frontmatter closing delimiter`);
-  }
-  const frontmatterText = raw.slice(opening[0].length, closing.index);
-  const body = raw.slice(closing.index + closing[0].length);
-  let parsed;
-  try {
-    parsed = yaml2.parse(frontmatterText);
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err);
-    throw new Error(`frontmatter: ${sourcePath}: invalid YAML frontmatter (${reason})`);
+  const evidence = collectValidationEvidence(window);
+  if (evidence.length > 0) {
+    return { kind: "ok", reason: "validation_evidence", evidence, mutatedPaths };
   }
-  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error(`frontmatter: ${sourcePath}: frontmatter must be a YAML object`);
+  if (hasExplicitLimitation(assistantText)) {
+    return { kind: "ok", reason: "explicit_limitation", evidence: [], mutatedPaths };
   }
   return {
-    frontmatter: parsed,
-    body
+    kind: "engage",
+    reason: "unvalidated_mutation",
+    message: FINISH_CONTRACT_ADVISORY_MESSAGE,
+    evidence: [],
+    mutatedPaths
   };
 }
-
-// src/domains/agents/write-boundary.ts
-var WRITE_BOUNDARY_MAX_ENTRIES = 32;
-var GLOB_CHARACTERS = /[*?[\]{}]/u;
-function normalizeWriteBoundaryEntry(entry) {
-  const raw = entry.trim();
-  if (raw.length === 0) throw new Error("write boundary: entry must be a non-empty path");
-  if (raw.includes("\\")) {
-    throw new Error(`write boundary: entry '${entry}' must use '/' separators`);
-  }
-  if (GLOB_CHARACTERS.test(raw)) {
-    throw new Error(`write boundary: entry '${entry}' looks like a glob, which v1 does not support`);
-  }
-  if (raw.startsWith("/") || /^[A-Za-z]:/u.test(raw)) {
-    throw new Error(`write boundary: entry '${entry}' must be repository-relative, not absolute`);
-  }
-  const subtree = raw.endsWith("/");
-  const segments = raw.split("/").filter((segment) => segment.length > 0);
-  if (segments.length === 0) {
-    throw new Error(`write boundary: entry '${entry}' must name a path inside the repository`);
-  }
-  for (const segment of segments) {
-    if (segment === "..") throw new Error(`write boundary: entry '${entry}' must not contain '..'`);
-    if (segment === ".") throw new Error(`write boundary: entry '${entry}' must not contain '.' segments`);
-  }
-  const joined = segments.join("/");
-  return subtree ? `${joined}/` : joined;
+function hasExplicitLimitation(text) {
+  const normalized = text.trim();
+  if (normalized.length === 0) return false;
+  return LIMITATION_PATTERNS.some((pattern) => pattern.test(normalized));
 }
-function normalizeWriteBoundary(entries) {
-  if (entries.length > WRITE_BOUNDARY_MAX_ENTRIES) {
-    throw new Error(`write boundary: at most ${WRITE_BOUNDARY_MAX_ENTRIES} entries may be declared`);
+function mutatingReceipts(recent) {
+  const mutationCalls = /* @__PURE__ */ new Map();
+  const paths = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of recent) {
+    const bashMutation = bashExecutionMutationPaths(entry);
+    if (bashMutation !== null) {
+      for (const path5 of bashMutation) pushPath(paths, seen, path5);
+      continue;
+    }
+    const call = mutatingToolCall(entry);
+    if (call !== null) {
+      mutationCalls.set(call.toolCallId, call);
+      continue;
+    }
+    const resultId = successfulToolResultId(entry);
+    if (resultId !== null) {
+      const candidate = mutationCalls.get(resultId);
+      if (candidate !== void 0) {
+        for (const path5 of candidate.paths) pushPath(paths, seen, path5);
+      }
+    }
   }
-  const normalized = new Set(entries.map(normalizeWriteBoundaryEntry));
-  return [...normalized].sort();
-}
-function toRepoRelativePosix(path7) {
-  return path7.split("\\").join("/");
-}
-function writeBoundaryCovers(boundary, path7) {
-  const candidate = toRepoRelativePosix(path7);
-  return boundary.some((entry) => entry.endsWith("/") ? candidate.startsWith(entry) : candidate === entry);
-}
-function describeWriteBoundary(boundary) {
-  return boundary.length === 0 ? "(nothing: readonly)" : boundary.join(", ");
-}
-
-// src/domains/agents/fleet-contract.ts
-var FLEET_WRITE_BOUNDARY_VERSION = 4;
-var FLEET_LOOP_MAX_ATTEMPTS = 5;
-var FleetScopeSchema = Type2.Union([Type2.Literal("readonly"), Type2.Literal("workspace")]);
-function writesSchema(version) {
-  return version >= FLEET_WRITE_BOUNDARY_VERSION ? { writes: Type2.Optional(Type2.Array(Type2.String({ minLength: 1 }), { maxItems: WRITE_BOUNDARY_MAX_ENTRIES })) } : {};
-}
-function agentStepSchema(version) {
-  return Type2.Object(
-    {
-      kind: Type2.Optional(Type2.Literal("agent")),
-      id: Type2.String({ minLength: 1 }),
-      agent: Type2.String({ minLength: 1 }),
-      scope: FleetScopeSchema,
-      dependencies: Type2.Array(Type2.String({ minLength: 1 })),
-      ...writesSchema(version)
-    },
-    { additionalProperties: false }
-  );
-}
-function codeStepSchema(version) {
-  return Type2.Object(
-    {
-      kind: Type2.Literal("code"),
-      id: Type2.String({ minLength: 1 }),
-      command: Type2.String({ minLength: 1 }),
-      scope: FleetScopeSchema,
-      dependencies: Type2.Array(Type2.String({ minLength: 1 })),
-      ...version >= 3 ? { commitFrom: Type2.Optional(Type2.Array(Type2.String({ minLength: 1 }), { minItems: 1 })) } : {},
-      ...writesSchema(version)
-    },
-    { additionalProperties: false }
-  );
-}
-function loopStepSchema(version) {
-  return Type2.Object(
-    {
-      kind: Type2.Literal("loop"),
-      id: Type2.String({ minLength: 1 }),
-      // Required and finite: this is the whole point of the construct.
-      maxAttempts: Type2.Integer({ minimum: 1, maximum: FLEET_LOOP_MAX_ATTEMPTS }),
-      dependencies: Type2.Array(Type2.String({ minLength: 1 })),
-      check: Type2.Union([
-        Type2.Object(
-          {
-            kind: Type2.Literal("code"),
-            command: Type2.String({ minLength: 1 }),
-            scope: FleetScopeSchema,
-            ...writesSchema(version)
-          },
-          { additionalProperties: false }
-        ),
-        Type2.Object(
-          {
-            kind: Type2.Literal("agent"),
-            agent: Type2.String({ minLength: 1 }),
-            scope: FleetScopeSchema,
-            ...writesSchema(version)
-          },
-          { additionalProperties: false }
-        )
-      ]),
-      repair: Type2.Object(
-        {
-          kind: Type2.Optional(Type2.Literal("agent")),
-          agent: Type2.String({ minLength: 1 }),
-          scope: FleetScopeSchema,
-          ...writesSchema(version)
-        },
-        { additionalProperties: false }
-      )
-    },
-    { additionalProperties: false }
-  );
-}
-function stepSchema(version) {
-  if (version === 1) return agentStepSchema(1);
-  if (version === 2) return Type2.Union([agentStepSchema(2), codeStepSchema(2)]);
-  return Type2.Union([agentStepSchema(version), codeStepSchema(version), loopStepSchema(version)]);
-}
-function frontmatterSchema(version) {
-  return Type2.Object(
-    {
-      version: Type2.Literal(version),
-      name: Type2.String({ minLength: 1 }),
-      description: Type2.Optional(Type2.String()),
-      steps: Type2.Array(stepSchema(version), { minItems: 1 }),
-      maxWorkers: Type2.Integer({ minimum: 1 }),
-      budgetUsd: Type2.Optional(Type2.Number()),
-      onFailure: Type2.Union([Type2.Literal("stop"), Type2.Literal("continue")])
-    },
-    { additionalProperties: false }
-  );
+  return paths;
 }
-var SCHEMAS = {
-  1: frontmatterSchema(1),
-  2: frontmatterSchema(2),
-  3: frontmatterSchema(3),
-  4: frontmatterSchema(4)
-};
-function contractVersion(frontmatter) {
-  const value = frontmatter.version;
-  return value === 1 || value === 2 || value === 3 || value === 4 ? value : null;
-}
-function firstSchemaError2(frontmatter, version) {
-  const schema = SCHEMAS[version];
-  if (Value2.Check(schema, frontmatter)) return null;
-  const first = [...Value2.Errors(schema, frontmatter)][0];
-  return first ? `${first.instancePath || "(root)"}: ${first.message}` : "front matter failed validation";
-}
-function fleetsDir(cwd) {
-  return join2(cwd, ".clio-coder", "fleets");
-}
-function normalizedWrites(writes) {
-  return writes === void 0 ? {} : { writes: normalizeWriteBoundary(writes) };
-}
-function normalizeStep(step) {
-  if (step.kind === "loop") {
-    const check = step.check;
-    const repair = step.repair;
-    return {
-      kind: "loop",
-      id: step.id,
-      maxAttempts: step.maxAttempts ?? 0,
-      dependencies: [...step.dependencies],
-      check: check.kind === "code" ? { kind: "code", command: check.command ?? "", scope: check.scope, ...normalizedWrites(check.writes) } : { kind: "agent", agent: check.agent ?? "", scope: check.scope, ...normalizedWrites(check.writes) },
-      repair: { kind: "agent", agent: repair.agent, scope: repair.scope, ...normalizedWrites(repair.writes) }
-    };
-  }
-  if (step.kind === "code") {
-    return {
-      kind: "code",
-      id: step.id,
-      command: step.command ?? "",
-      scope: step.scope,
-      dependencies: [...step.dependencies],
-      ...step.commitFrom !== void 0 ? { commitFrom: [...step.commitFrom] } : {},
-      ...normalizedWrites(step.writes)
-    };
+function mutationPathsForTool(toolName, args) {
+  if (toolName === ToolNames.Bash) {
+    const command = typeof args?.command === "string" ? args.command : null;
+    if (command === null) return [];
+    return [...extractCommandWriteTargets(command), ...extractCommandDeleteTargets(command)];
   }
-  return {
-    kind: "agent",
-    id: step.id,
-    agent: step.agent ?? "",
-    scope: step.scope,
-    dependencies: [...step.dependencies],
-    ...normalizedWrites(step.writes)
-  };
+  return toolMutationPaths(toolName, args);
 }
-function fleetLoopCheckStepId(loopId, attempt) {
-  return `${loopId}.check.${attempt}`;
+function mutatingToolCall(entry) {
+  const record = asRecord(entry);
+  if (record?.kind !== "message" || record.role !== "tool_call") return null;
+  const payload = asRecord(record.payload);
+  if (payload === null) return null;
+  const toolName = stringFromFirst(payload, ["name", "toolName", "tool"]);
+  if (toolName === null) return null;
+  const args = asRecord(payload.args ?? payload.arguments ?? payload.input) ?? void 0;
+  const paths = mutationPathsForTool(toolName, args);
+  if (paths.length === 0) return null;
+  const toolCallId = stringFromFirst(payload, ["toolCallId", "tool_call_id", "id"]) ?? turnIdOf(entry);
+  if (toolCallId === null) return null;
+  return { toolCallId, paths };
 }
-function fleetLoopRepairStepId(loopId, attempt) {
-  return `${loopId}.repair.${attempt}`;
+function bashExecutionMutationPaths(entry) {
+  const record = asRecord(entry);
+  if (record?.kind !== "bashExecution") return null;
+  if (typeof record.command !== "string") return null;
+  if (record.cancelled === true || record.exitCode !== 0) return null;
+  return [...extractCommandWriteTargets(record.command), ...extractCommandDeleteTargets(record.command)];
 }
-function occupiedIds(contract) {
-  const owners = /* @__PURE__ */ new Map();
-  for (const step of contract.steps) {
-    owners.set(step.id, step.id);
-    if (step.kind !== "loop") continue;
-    for (let attempt = 1; attempt <= step.maxAttempts; attempt++) {
-      owners.set(fleetLoopCheckStepId(step.id, attempt), step.id);
-      if (attempt < step.maxAttempts) owners.set(fleetLoopRepairStepId(step.id, attempt), step.id);
-    }
-  }
-  return owners;
-}
-function validateFleetGraph(contract) {
-  const declared = /* @__PURE__ */ new Set();
-  for (const step of contract.steps) {
-    if (declared.has(step.id)) throw new Error(`fleet contract ${contract.path}: duplicate step id '${step.id}'`);
-    declared.add(step.id);
-  }
-  const owners = /* @__PURE__ */ new Map();
-  for (const step of contract.steps) {
-    if (step.kind !== "loop") continue;
-    for (const [generated, owner] of occupiedIds({ steps: [step] })) {
-      if (generated === step.id) continue;
-      if (declared.has(generated)) {
-        throw new Error(
-          `fleet contract ${contract.path}: step id '${generated}' collides with an id loop '${owner}' generates`
-        );
-      }
-      owners.set(generated, owner);
+function pushPath(paths, seen, path5) {
+  if (path5.length === 0 || seen.has(path5)) return;
+  seen.add(path5);
+  paths.push(path5);
+}
+function collectValidationEvidence(recent) {
+  const evidence = [];
+  const toolCalls = /* @__PURE__ */ new Map();
+  const dispatchCalls = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of recent) {
+    const protectedArtifact = protectedArtifactEvidence(entry);
+    if (protectedArtifact !== null) {
+      pushEvidence(evidence, seen, protectedArtifact);
+      continue;
     }
-  }
-  for (const step of contract.steps) {
-    for (const dependency of step.dependencies) {
-      if (dependency === step.id) throw new Error(`fleet contract ${contract.path}: step '${step.id}' depends on itself`);
-      if (!declared.has(dependency)) {
-        throw new Error(`fleet contract ${contract.path}: step '${step.id}' has unknown dependency '${dependency}'`);
-      }
+    const call = bashValidationCall(entry);
+    if (call !== null) {
+      toolCalls.set(call.toolCallId, call);
+      continue;
     }
-  }
-  const remaining = new Set(declared);
-  const settled = /* @__PURE__ */ new Set();
-  while (remaining.size > 0) {
-    const ready = contract.steps.filter(
-      (step) => remaining.has(step.id) && step.dependencies.every((dependency) => settled.has(dependency))
-    );
-    if (ready.length === 0) {
-      throw new Error(`fleet contract ${contract.path}: dependency cycle among steps ${[...remaining].sort().join(", ")}`);
+    const typedValidationCall = validationToolCall(entry);
+    if (typedValidationCall !== null) {
+      toolCalls.set(typedValidationCall.toolCallId, typedValidationCall);
+      continue;
     }
-    for (const step of ready) {
-      remaining.delete(step.id);
-      settled.add(step.id);
+    const dispatchCall = dispatchEvidenceCall(entry);
+    if (dispatchCall !== null) {
+      dispatchCalls.set(dispatchCall.toolCallId, dispatchCall);
+      continue;
     }
-  }
-  const ancestors = fleetStepAncestors(contract.steps);
-  for (const step of contract.steps) {
-    if (step.kind !== "code" || step.commitFrom === void 0) continue;
-    for (const source of step.commitFrom) {
-      const target = contract.steps.find((candidate) => candidate.id === source);
-      if (target === void 0) {
-        throw new Error(`fleet contract ${contract.path}: commit step '${step.id}' names unknown source '${source}'`);
-      }
-      if (target.kind === "code") {
-        throw new Error(
-          `fleet contract ${contract.path}: commit step '${step.id}' source '${source}' is a code step and authors no commit message`
-        );
+    const resultId = successfulToolResultId(entry);
+    if (resultId !== null) {
+      const dispatchCandidate = dispatchCalls.get(resultId);
+      const dispatchReceipt = dispatchReceiptEvidence(entry, dispatchCandidate);
+      if (dispatchReceipt !== null) {
+        pushEvidence(evidence, seen, dispatchReceipt);
+        continue;
       }
-      if (!(ancestors.get(step.id)?.has(source) ?? false)) {
-        throw new Error(
-          `fleet contract ${contract.path}: commit step '${step.id}' must depend on its message source '${source}'`
-        );
+      const candidate = toolCalls.get(resultId);
+      if (candidate !== void 0) {
+        pushEvidence(evidence, seen, validationEvidence(candidate));
       }
-    }
-  }
-}
-function fleetStepWriteBoundary(version, scope, writes) {
-  if (version < FLEET_WRITE_BOUNDARY_VERSION) return void 0;
-  return scope === "readonly" ? [] : [...writes ?? []];
-}
-function fleetStepBoundaries(contract) {
-  const boundaries = [];
-  const add = (id, scope, writes) => {
-    boundaries.push({ id, scope, writes: fleetStepWriteBoundary(contract.version, scope, writes) });
-  };
-  for (const step of contract.steps) {
-    if (step.kind === "loop") {
-      add(`${step.id}.check`, step.check.scope, step.check.writes);
-      add(`${step.id}.repair`, step.repair.scope, step.repair.writes);
       continue;
     }
-    add(step.id, step.scope, step.writes);
+    const bashExecution = bashExecutionEvidence(entry);
+    if (bashExecution !== null) pushEvidence(evidence, seen, bashExecution);
   }
-  return boundaries;
+  return evidence;
 }
-function validateWriteBoundaries(contract) {
-  if (contract.version < FLEET_WRITE_BOUNDARY_VERSION) return;
-  for (const position of fleetStepBoundaries(contract)) {
-    if (position.scope === "workspace" && (position.writes?.length ?? 0) === 0) {
-      throw new Error(
-        `fleet contract ${contract.path}: step '${position.id}' has scope 'workspace' and must declare a non-empty 'writes' allowlist at version ${FLEET_WRITE_BOUNDARY_VERSION}`
-      );
-    }
-  }
-  for (const step of contract.steps) {
-    const declared = step.kind === "loop" ? [
-      { id: `${step.id}.check`, scope: step.check.scope, writes: step.check.writes },
-      { id: `${step.id}.repair`, scope: step.repair.scope, writes: step.repair.writes }
-    ] : [{ id: step.id, scope: step.scope, writes: step.writes }];
-    for (const position of declared) {
-      if (position.scope === "readonly" && position.writes !== void 0) {
-        throw new Error(
-          `fleet contract ${contract.path}: step '${position.id}' is 'readonly', which is the empty allowlist; remove its 'writes' or give it scope 'workspace'`
-        );
-      }
+function recentEntries(entries, assistantTurnId, recentEntryLimit) {
+  const boundedLimit = Number.isFinite(recentEntryLimit) && recentEntryLimit > 0 ? Math.floor(recentEntryLimit) : DEFAULT_RECENT_ENTRY_LIMIT;
+  const assistantIndex = assistantTurnId === null ? -1 : entries.findIndex((entry) => turnIdOf(entry) === assistantTurnId);
+  const endExclusive = assistantIndex >= 0 ? assistantIndex : entries.length;
+  let startInclusive = Math.max(0, endExclusive - boundedLimit);
+  for (let index = endExclusive - 1; index >= startInclusive; index -= 1) {
+    if (isUserMessageEntry(entries[index])) {
+      startInclusive = index + 1;
+      break;
     }
   }
+  return entries.slice(startInclusive, endExclusive);
 }
-function fleetStepAncestors(steps) {
-  const direct = new Map(steps.map((step) => [step.id, step.dependencies]));
-  const closure = /* @__PURE__ */ new Map();
-  const resolve = (id, seen) => {
-    const cached = closure.get(id);
-    if (cached !== void 0) return cached;
-    const result = /* @__PURE__ */ new Set();
-    if (seen.has(id)) return result;
-    seen.add(id);
-    for (const dependency of direct.get(id) ?? []) {
-      result.add(dependency);
-      for (const inherited of resolve(dependency, seen)) result.add(inherited);
-    }
-    closure.set(id, result);
-    return result;
-  };
-  for (const step of steps) resolve(step.id, /* @__PURE__ */ new Set());
-  return closure;
-}
-function parseFleetContract(raw, sourcePath) {
-  const { frontmatter, body } = parseFrontmatter(raw, sourcePath);
-  const version = contractVersion(frontmatter);
-  if (version === null) {
-    throw new Error(
-      `fleet contract ${sourcePath}: version must be 1 (agent steps), 2 (agent and code steps), 3 (adds bounded loops and commit steps), or 4 (adds enforced write boundaries)`
-    );
-  }
-  if (version < FLEET_WRITE_BOUNDARY_VERSION) assertNoWritesBefore(frontmatter, sourcePath, version);
-  const schemaError = firstSchemaError2(frontmatter, version);
-  if (schemaError !== null) {
-    throw new Error(`fleet contract ${sourcePath}: ${schemaError}`);
-  }
-  const fm = frontmatter;
-  if (fm.budgetUsd !== void 0 && !(fm.budgetUsd > 0)) {
-    throw new Error(`fleet contract ${sourcePath}: budgetUsd must be a positive number`);
-  }
-  const trimmedBody = body.trim();
-  if (trimmedBody.length === 0) {
-    throw new Error(`fleet contract ${sourcePath}: prompt body is empty`);
-  }
-  const contract = {
-    version,
-    name: fm.name,
-    description: fm.description ?? "",
-    steps: fm.steps.map(normalizeStep),
-    maxWorkers: fm.maxWorkers,
-    budgetUsd: fm.budgetUsd ?? null,
-    onFailure: fm.onFailure,
-    body: trimmedBody,
-    path: sourcePath
+function bashValidationCall(entry) {
+  const record = asRecord(entry);
+  if (record?.kind !== "message" || record.role !== "tool_call") return null;
+  const payload = asRecord(record.payload);
+  if (payload === null) return null;
+  const toolName = stringFromFirst(payload, ["name", "toolName", "tool"]);
+  if (toolName !== "bash") return null;
+  const args = asRecord(payload.args ?? payload.arguments ?? payload.input);
+  const command = typeof args?.command === "string" ? args.command : null;
+  if (command === null) return null;
+  const detected = detectValidationCommand(command);
+  if (detected.kind !== "validation") return null;
+  const toolCallId = stringFromFirst(payload, ["toolCallId", "tool_call_id", "id"]) ?? turnIdOf(entry);
+  if (toolCallId === null) return null;
+  const candidate = {
+    toolCallId,
+    command: detected.matched
   };
-  validateFleetGraph(contract);
-  validateWriteBoundaries(contract);
-  return contract;
-}
-function assertNoWritesBefore(frontmatter, sourcePath, version) {
-  const steps = Array.isArray(frontmatter.steps) ? frontmatter.steps : [];
-  const declaresWrites = (value) => typeof value === "object" && value !== null && "writes" in value;
-  for (const step of steps) {
-    const raw = step;
-    if (declaresWrites(raw) || declaresWrites(raw.check) || declaresWrites(raw.repair)) {
-      throw new Error(
-        `fleet contract ${sourcePath}: 'writes' requires contract version ${FLEET_WRITE_BOUNDARY_VERSION}; this contract declares version ${version}, where the declaration would not be enforced`
-      );
-    }
-  }
-}
-function fleetCodeSteps(contract) {
-  const steps = [];
-  for (const step of contract.steps) {
-    if (step.kind === "code") steps.push({ id: step.id, command: step.command });
-    else if (step.kind === "loop" && step.check.kind === "code") {
-      steps.push({ id: fleetLoopCheckStepId(step.id, 1), command: step.check.command });
-    }
-  }
-  return steps;
+  const turnId = turnIdOf(entry);
+  if (turnId !== null) candidate.turnId = turnId;
+  return candidate;
 }
-var FLEET_COMMANDS_REPO_PATH = ".clio-coder/fleets/commands.yaml";
-var FLEET_COMMANDS_REMEDY = "declare each id there under `commands:` with an `argv` list; `clio-coder docs fleet_dispatch` has the schema";
-var FleetCommandRegistryMissingError = class extends Error {
-  constructor(contractPath, commands) {
-    super(
-      `fleet contract ${contractPath}: code steps require a command registry at ${FLEET_COMMANDS_REPO_PATH} declaring ${commands.join(", ")}`
-    );
-    this.contractPath = contractPath;
-    this.commands = commands;
-    this.name = "FleetCommandRegistryMissingError";
-  }
-  contractPath;
-  commands;
-};
-function validateFleetCommands(contract, registry) {
-  const codeSteps = fleetCodeSteps(contract);
-  if (codeSteps.length === 0) return;
-  if (registry === null) {
-    throw new FleetCommandRegistryMissingError(contract.path, [...new Set(codeSteps.map((step) => step.command))].sort());
-  }
-  for (const step of codeSteps) {
-    if (!registry.commands.has(step.command)) {
-      const known = [...registry.commands.keys()].sort().join(", ");
-      throw new Error(
-        `fleet contract ${contract.path}: step '${step.id}' names unknown command '${step.command}' (registered: ${known || "none"})`
-      );
+function dispatchEvidenceCall(entry) {
+  const record = asRecord(entry);
+  if (record?.kind !== "message" || record.role !== "tool_call") return null;
+  const payload = asRecord(record.payload);
+  if (payload === null) return null;
+  const toolName = stringFromFirst(payload, ["name", "toolName", "tool"]);
+  if (toolName !== "dispatch") return null;
+  const args = asRecord(payload.args ?? payload.arguments ?? payload.input);
+  const { agentId, task } = dispatchCallDescriptor(args);
+  const toolCallId = stringFromFirst(payload, ["toolCallId", "tool_call_id", "id"]) ?? turnIdOf(entry);
+  if (toolCallId === null) return null;
+  const candidate = {
+    toolCallId,
+    command: `agent=${agentId}${task.length > 0 ? ` task=${task}` : ""}`
+  };
+  const turnId = turnIdOf(entry);
+  if (turnId !== null) candidate.turnId = turnId;
+  return candidate;
+}
+function dispatchCallDescriptor(args) {
+  const defaultAgent = stringFromFirst(args ?? {}, ["agent", "agent_id", "agentId"]);
+  const tasks = Array.isArray(args?.tasks) ? args.tasks : null;
+  if (tasks !== null && tasks.length > 0) {
+    const first = tasks[0];
+    if (typeof first === "string") {
+      return { agentId: defaultAgent ?? "coder", task: first.trim() };
     }
+    const firstRecord = asRecord(first);
+    const itemAgent = firstRecord === null ? null : stringFromFirst(firstRecord, ["agent", "agent_id", "agentId"]);
+    const itemTask = typeof firstRecord?.task === "string" ? firstRecord.task.trim() : "";
+    return { agentId: itemAgent ?? defaultAgent ?? "coder", task: itemTask };
   }
+  const singleTask = typeof args?.task === "string" ? args.task.trim() : "";
+  return { agentId: defaultAgent ?? "coder", task: singleTask };
 }
-function builtinFleetsDir() {
-  return join2(resolvePackageRoot(), "src", "domains", "agents", "fleets");
+function validationToolCall(entry) {
+  const record = asRecord(entry);
+  if (record?.kind !== "message" || record.role !== "tool_call") return null;
+  const payload = asRecord(record.payload);
+  if (payload === null) return null;
+  const toolName = stringFromFirst(payload, ["name", "toolName", "tool"]);
+  if (toolName === null) return null;
+  const summary = typedValidationSummary(toolName, payload);
+  if (summary === null) return null;
+  const toolCallId = stringFromFirst(payload, ["toolCallId", "tool_call_id", "id"]) ?? turnIdOf(entry);
+  if (toolCallId === null) return null;
+  const candidate = {
+    toolCallId,
+    command: summary
+  };
+  const turnId = turnIdOf(entry);
+  if (turnId !== null) candidate.turnId = turnId;
+  return candidate;
 }
-function fleetContractPath(cwd, name) {
-  const projectPath = join2(fleetsDir(cwd), `${name}.md`);
-  if (existsSync2(projectPath)) return { path: projectPath, source: "project" };
-  const builtinPath = join2(builtinFleetsDir(), `${name}.md`);
-  if (existsSync2(builtinPath)) return { path: builtinPath, source: "builtin" };
+function typedValidationSummary(toolName, payload) {
+  const args = asRecord(payload.args ?? payload.arguments ?? payload.input);
+  if (toolName === "verify") {
+    const check = typeof args?.check === "string" ? args.check.trim() : "";
+    if (check === "frontend") {
+      const path5 = typeof args?.path === "string" && args.path.trim().length > 0 ? args.path.trim() : "artifact";
+      return `verify frontend ${path5}`;
+    }
+    if (!isVerificationScriptName(check)) return null;
+    return `npm run ${check}`;
+  }
   return null;
 }
-function loadFleetContract(cwd, name) {
-  const located = fleetContractPath(cwd, name);
-  if (located === null) {
-    throw new Error(`fleet contract not found: ${join2(fleetsDir(cwd), `${name}.md`)} (and no builtin named '${name}')`);
-  }
-  const contract = parseFleetContract(readFileSync2(located.path, "utf8"), located.path);
-  validateFleetCommands(contract, loadFleetCommands(cwd));
-  return contract;
+function successfulToolResultId(entry) {
+  const record = asRecord(entry);
+  if (record?.kind !== "message" || record.role !== "tool_result") return null;
+  const payload = asRecord(record.payload);
+  if (payload === null) return null;
+  if (payload.isError === true || payload.error === true) return null;
+  const result = asRecord(payload.result);
+  const details = asRecord(result?.details);
+  if (details?.kind === "error") return null;
+  return stringFromFirst(payload, ["toolCallId", "tool_call_id", "id"]);
 }
-function listDirectory(dir) {
-  if (!existsSync2(dir)) return [];
-  try {
-    return readdirSync(dir).filter((name) => name.endsWith(".md")).sort();
-  } catch {
-    return [];
-  }
+function dispatchReceiptEvidence(entry, candidate) {
+  const record = asRecord(entry);
+  if (record?.kind !== "message" || record.role !== "tool_result") return null;
+  const payload = asRecord(record.payload);
+  if (payload === null) return null;
+  const toolName = stringFromFirst(payload, ["toolName", "name", "tool"]);
+  if (toolName !== null && toolName !== "dispatch") return null;
+  const result = asRecord(payload.result);
+  const details = asRecord(result?.details);
+  if (details === null) return null;
+  const summary = passedDispatchReceiptSummary(details, candidate);
+  if (summary === null) return null;
+  const evidence = {
+    kind: "dispatch_receipt",
+    summary
+  };
+  const turnId = candidate?.turnId ?? turnIdOf(entry);
+  if (turnId !== null && turnId !== void 0) evidence.turnId = turnId;
+  return evidence;
 }
-function listFleetContracts(cwd) {
-  let registry = null;
-  let registryError = null;
-  try {
-    registry = loadFleetCommands(cwd);
-  } catch (err) {
-    registryError = err instanceof Error ? err.message : String(err);
+function passedDispatchReceiptSummary(details, candidate) {
+  if (Array.isArray(details.runs)) {
+    const runs = details.runs.map(asRecord);
+    if (runs.length === 0 || runs.some((run) => run === null || run.exitCode !== 0)) return null;
+    if (typeof details.failedCount === "number" && details.failedCount !== 0) return null;
+    const first = runs[0];
+    const runId = typeof first?.runId === "string" && first.runId.length > 0 ? first.runId : "unknown";
+    const agentId = dispatchReceiptAgentId(typeof first?.agentId === "string" ? first.agentId : void 0, candidate);
+    const extra = runs.length > 1 ? ` (+${runs.length - 1} more)` : "";
+    return `dispatch receipt passed: run ${runId} agent ${agentId}${extra}`;
   }
-  const listings = /* @__PURE__ */ new Map();
-  const sources = [
-    { dir: builtinFleetsDir(), source: "builtin" },
-    { dir: fleetsDir(cwd), source: "project" }
-  ];
-  for (const { dir, source } of sources) {
-    for (const file of listDirectory(dir)) {
-      const path7 = join2(dir, file);
-      const name = basename(file, ".md");
-      try {
-        const contract = parseFleetContract(readFileSync2(path7, "utf8"), path7);
-        if (registryError !== null && fleetCodeSteps(contract).length > 0) throw new Error(registryError);
-        validateFleetCommands(contract, registry);
-        listings.set(name, { name, path: path7, source, contract, error: null, needsCommands: null });
-      } catch (err) {
-        listings.set(name, {
-          name,
-          path: path7,
-          source,
-          contract: null,
-          error: err instanceof Error ? err.message : String(err),
-          // A registry this repo never wrote is unfinished setup. A registry
-          // that exists and does not parse, or one missing an id the contract
-          // names, is a real error and stays one.
-          needsCommands: err instanceof FleetCommandRegistryMissingError ? err.commands : null
-        });
-      }
-    }
+  if (details.exitCode === 0) {
+    const runId = typeof details.runId === "string" && details.runId.length > 0 ? details.runId : "unknown";
+    const agentId = dispatchReceiptAgentId(typeof details.agentId === "string" ? details.agentId : void 0, candidate);
+    return `dispatch receipt passed: run ${runId} agent ${agentId}`;
   }
-  return [...listings.values()].sort((left, right) => left.name.localeCompare(right.name));
+  return null;
 }
-var PLACEHOLDER_RE = /\{\{\s*([A-Za-z_][A-Za-z0-9_-]*)\s*\}\}/g;
-function renderFleetPrompt(body, vars) {
-  const missing = /* @__PURE__ */ new Set();
-  const rendered = body.replace(PLACEHOLDER_RE, (_match, name) => {
-    const value = vars[name];
-    if (value === void 0) {
-      missing.add(name);
-      return "";
-    }
-    return value;
-  });
-  if (missing.size > 0) {
-    throw new Error(`fleet prompt: unresolved template variables: ${[...missing].join(", ")} (pass --var name=value)`);
+function dispatchReceiptAgentId(receiptAgentId, candidate) {
+  if (receiptAgentId !== void 0 && receiptAgentId.length > 0) return receiptAgentId;
+  return candidate?.command.match(/^agent=([^\s]+)/)?.[1] ?? "unknown";
+}
+function bashExecutionEvidence(entry) {
+  const record = asRecord(entry);
+  if (record?.kind !== "bashExecution") return null;
+  if (typeof record.command !== "string") return null;
+  if (record.cancelled === true) return null;
+  if (record.exitCode !== 0) return null;
+  const detected = detectValidationCommand(record.command);
+  if (detected.kind !== "validation") return null;
+  const evidence = {
+    kind: "validation_command",
+    summary: `validation command passed: ${detected.matched}`
+  };
+  const turnId = turnIdOf(entry);
+  if (turnId !== null) evidence.turnId = turnId;
+  return evidence;
+}
+function protectedArtifactEvidence(entry) {
+  const record = asRecord(entry);
+  if (record?.kind !== "protectedArtifact" || record.action !== "protect") return null;
+  const artifact = asRecord(record.artifact);
+  const path5 = typeof artifact?.path === "string" && artifact.path.trim().length > 0 ? artifact.path.trim() : null;
+  if (path5 === null) return null;
+  const evidence = {
+    kind: "protected_artifact",
+    summary: `protected artifact recorded: ${path5}`
+  };
+  const turnId = turnIdOf(entry);
+  if (turnId !== null) evidence.turnId = turnId;
+  return evidence;
+}
+function validationEvidence(candidate) {
+  const evidence = {
+    kind: "validation_command",
+    summary: `validation command passed: ${candidate.command}`
+  };
+  if (candidate.turnId !== void 0) evidence.turnId = candidate.turnId;
+  return evidence;
+}
+function pushEvidence(evidence, seen, item) {
+  const key = `${item.kind}\0${item.summary}\0${item.turnId ?? ""}`;
+  if (seen.has(key)) return;
+  seen.add(key);
+  evidence.push(item);
+}
+function isUserMessageEntry(entry) {
+  const record = asRecord(entry);
+  if (record?.kind !== "message" || record.role !== "user") return false;
+  const payload = asRecord(record.payload);
+  return payload?.synthetic !== true;
+}
+function turnIdOf(entry) {
+  const record = asRecord(entry);
+  return typeof record?.turnId === "string" ? record.turnId : null;
+}
+function stringFromFirst(record, keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.length > 0) return value;
   }
-  return rendered;
+  return null;
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" ? value : null;
 }
 
 // src/domains/safety/autonomy.ts
+init_esm_shims();
 var AUTONOMY_LEVELS = ["read-only", "suggest", "auto-edit", "full-auto"];
 var DEFAULT_AUTONOMY_LEVEL = "auto-edit";
 function isAutonomyLevel(value) {
   return typeof value === "string" && AUTONOMY_LEVELS.includes(value);
 }
+var DEFAULT_AUTONOMY_EXPOSURE = "local";
 function mapAutonomy(level, actionClass, options = {}) {
-  if (actionClass === "read") return "allow";
   if (actionClass === "git_destructive") return "deny";
+  if ((level === "auto-edit" || level === "suggest") && options.exposure === "outward") return "ask";
+  if (actionClass === "read") return "allow";
   if (level === "read-only") return "deny";
   if (level === "suggest") return "ask";
   switch (actionClass) {
@@ -1317,7 +1134,17 @@ function autonomyDenyRejection(level, tool, actionClass) {
     hints: ["Propose the exact edit or command as text.", "The operator can change the level in /settings."]
   };
 }
-function autonomyAskRejection(level, tool, actionClass) {
+function autonomyAskRejection(level, tool, actionClass, exposure = DEFAULT_AUTONOMY_EXPOSURE) {
+  if (exposure === "outward") {
+    return {
+      short: `${tool} needs approval: outward-facing gate at autonomy ${level}`,
+      detail: `The call declared exposure=outward, so answering it publishes or sends something outside the workspace. Autonomy ${level} auto-answers local gates and parks outward-facing ones for the operator.`,
+      hints: [
+        "Approving resumes only this call.",
+        "Autonomy full-auto answers outward gates too; the safety net still applies there."
+      ]
+    };
+  }
   return {
     short: `${tool} needs approval (${actionClass}) at autonomy ${level}`,
     detail: `Autonomy ${level} routes ${actionClass} actions through operator approval. The call is parked until the operator approves it once or cancels it.`,
@@ -1336,105 +1163,11 @@ function autonomyAskRejection(level, tool, actionClass) {
   };
 }
 
-// src/domains/safety/loop-detector.ts
-var DEFAULT_WINDOW_MS = 3e4;
-var DEFAULT_MAX_REPEATS = 3;
-var DEFAULT_KEEP_LAST_ATTEMPTS = 4;
-function createLoopState(opts) {
-  const windowMs = opts?.windowMs ?? DEFAULT_WINDOW_MS;
-  const maxRepeats = opts?.maxRepeats ?? DEFAULT_MAX_REPEATS;
-  const keepLastAttempts = opts?.keepLastAttempts ?? DEFAULT_KEEP_LAST_ATTEMPTS;
-  return { recent: [], windowMs, maxRepeats, keepLastAttempts };
-}
-function hashToolCall(tool, args) {
-  let argPart;
-  try {
-    argPart = canonicalSerialize(args ?? {}, /* @__PURE__ */ new WeakSet());
-  } catch {
-    argPart = "<unrepresentable>";
-  }
-  return `${tool}${argPart}`;
-}
-function canonicalSerialize(value, seen) {
-  if (value === null) return "null";
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) {
-      throw new Error(`canonicalSerialize: non-finite number ${String(value)} is not representable`);
-    }
-    return JSON.stringify(value);
-  }
-  if (typeof value === "string" || typeof value === "boolean") {
-    return JSON.stringify(value);
-  }
-  if (typeof value === "bigint") {
-    throw new Error("canonicalSerialize: bigint is not representable");
-  }
-  if (typeof value === "symbol" || typeof value === "function" || value === void 0) {
-    throw new Error(`canonicalSerialize: ${typeof value} is not representable`);
-  }
-  if (Array.isArray(value)) {
-    if (seen.has(value)) throw new Error("canonicalSerialize: circular reference is not representable");
-    seen.add(value);
-    try {
-      const parts = [];
-      for (let i = 0; i < value.length; i++) {
-        if (!(i in value) || value[i] === void 0) {
-          parts.push("null");
-          continue;
-        }
-        parts.push(canonicalSerialize(value[i], seen));
-      }
-      return `[${parts.join(",")}]`;
-    } finally {
-      seen.delete(value);
-    }
-  }
-  if (typeof value === "object") {
-    if (value instanceof Date) {
-      const jsonValue = value.toJSON();
-      return jsonValue === null ? "null" : JSON.stringify(jsonValue);
-    }
-    if (seen.has(value)) throw new Error("canonicalSerialize: circular reference is not representable");
-    seen.add(value);
-    const obj = value;
-    try {
-      const keys = Object.keys(obj).sort();
-      const parts = [];
-      for (const key of keys) {
-        const child = obj[key];
-        if (child === void 0) continue;
-        parts.push(`${JSON.stringify(key)}:${canonicalSerialize(child, seen)}`);
-      }
-      return `{${parts.join(",")}}`;
-    } finally {
-      seen.delete(value);
-    }
-  }
-  throw new Error(`canonicalSerialize: unsupported value of type ${typeof value}`);
-}
-function observe(state, key, now) {
-  const cutoff = now - state.windowMs;
-  const keepLast = state.keepLastAttempts ?? DEFAULT_KEEP_LAST_ATTEMPTS;
-  const appended = [...state.recent, { key, at: now }];
-  const floorStart = Math.max(0, appended.length - keepLast);
-  const next = appended.filter((entry, index) => index >= floorStart || entry.at >= cutoff);
-  let count = 0;
-  for (const entry of next) {
-    if (entry.key === key) count += 1;
-  }
-  const looping = count >= state.maxRepeats;
-  const newState = {
-    recent: next,
-    windowMs: state.windowMs,
-    maxRepeats: state.maxRepeats
-  };
-  return [newState, { looping, key, count }];
-}
-
 // src/domains/safety/path-policy.ts
+init_esm_shims();
 import { homedir } from "node:os";
 import path2 from "node:path";
-var ORDERED_KINDS = ["zeroAccessPaths", "readOnlyPaths", "noDeletePaths"];
+var ORDERED_KINDS = ["zeroAccessPaths", "readOnlyPaths", "noWritePaths", "noDeletePaths"];
 function isSameOrDescendant(candidatePath, policyPath) {
   const candidate = path2.resolve(candidatePath);
   const policy = path2.resolve(policyPath);
@@ -1453,7 +1186,7 @@ function normalizePolicyEntry(rawPath, root) {
 }
 function blocksOperation(kind, operation) {
   if (kind === "zeroAccessPaths") return true;
-  if (kind === "readOnlyPaths") return operation === "write" || operation === "delete";
+  if (kind === "readOnlyPaths" || kind === "noWritePaths") return operation === "write" || operation === "delete";
   return operation === "delete";
 }
 function compilePathPolicy(input, root = process.cwd()) {
@@ -1534,10 +1267,12 @@ function normalizeSeparators(value) {
 }
 
 // src/domains/safety/policy-engine.ts
+init_esm_shims();
 import { createHash as createHash3 } from "node:crypto";
 import path4 from "node:path";
 
 // src/domains/safety/default-path-policy.ts
+init_esm_shims();
 var DEFAULT_DAMAGE_CONTROL_PATH_POLICY = {
   zeroAccessPaths: [
     ".env",
@@ -1619,6 +1354,10 @@ var DEFAULT_DAMAGE_CONTROL_PATH_POLICY = {
     "venv/",
     "target/"
   ],
+  // Another agent's own configuration. Clio reads these roots for skills,
+  // prompts, and rule prose and has no reason to author them, so the guard is
+  // on writes and not only on deletes.
+  noWritePaths: [...foreignAgentDirs()],
   noDeletePaths: [
     "~/.claude/",
     "CLAUDE.md",
@@ -1636,15 +1375,17 @@ function mergePathPolicyInputs(base, override) {
   return {
     zeroAccessPaths: [...base.zeroAccessPaths ?? [], ...override.zeroAccessPaths ?? []],
     readOnlyPaths: [...base.readOnlyPaths ?? [], ...override.readOnlyPaths ?? []],
+    noWritePaths: [...base.noWritePaths ?? [], ...override.noWritePaths ?? []],
     noDeletePaths: [...base.noDeletePaths ?? [], ...override.noDeletePaths ?? []]
   };
 }
 
 // src/domains/safety/project-policy.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import path3 from "node:path";
-import { parse as parseYaml } from "yaml";
 var POLICY_RELATIVE_PATH = path3.join(".clio-coder", "safety.yaml");
 var ACTION_CLASSES = /* @__PURE__ */ new Set([
   "read",
@@ -1655,7 +1396,7 @@ var ACTION_CLASSES = /* @__PURE__ */ new Set([
   "git_destructive",
   "unknown"
 ]);
-var PATH_POLICY_KEYS = ["zeroAccessPaths", "readOnlyPaths", "noDeletePaths"];
+var PATH_POLICY_KEYS = ["zeroAccessPaths", "readOnlyPaths", "noWritePaths", "noDeletePaths"];
 var ROOT_KEYS = /* @__PURE__ */ new Set(["version", "commands", "tasks", "disableDefaultPathPolicy", ...PATH_POLICY_KEYS]);
 var COMMAND_KEYS = /* @__PURE__ */ new Set([
   "id",
@@ -1677,7 +1418,7 @@ function projectSafetyPolicyPath(cwd = process.cwd()) {
   let cursor = path3.resolve(cwd);
   while (true) {
     const candidate = path3.join(cursor, POLICY_RELATIVE_PATH);
-    if (existsSync3(candidate)) return candidate;
+    if (existsSync(candidate)) return candidate;
     const parent = path3.dirname(cursor);
     if (parent === cursor) return null;
     cursor = parent;
@@ -1698,7 +1439,7 @@ function loadProjectSafetyPolicy(cwd = process.cwd()) {
   }
   let raw;
   try {
-    raw = readFileSync3(policyPath, "utf8");
+    raw = readFileSync(policyPath, "utf8");
   } catch (err) {
     return {
       path: policyPath,
@@ -1712,7 +1453,7 @@ function loadProjectSafetyPolicy(cwd = process.cwd()) {
   }
   const hash = sha256(raw);
   try {
-    const parsed = parseYaml(raw);
+    const parsed = (0, import_yaml.parse)(raw);
     return validateProjectSafetyPolicy(parsed, policyPath, hash);
   } catch (err) {
     return {
@@ -1948,6 +1689,7 @@ function sha256(raw) {
 }
 
 // src/domains/safety/rejection-feedback.ts
+init_esm_shims();
 var HARD_BLOCK_CLASSES = ["git_destructive"];
 function buildShort(ctx) {
   const postureSuffix = ctx.posture ? ` in ${ctx.posture}` : "";
@@ -2008,11 +1750,13 @@ function formatModelRejection(reason, rejection) {
 }
 
 // src/domains/safety/rule-pack-loader.ts
-import { readFileSync as readFileSync4 } from "node:fs";
-import { join as join3 } from "node:path";
-import { parse as parseYaml2 } from "yaml";
+init_esm_shims();
+var import_yaml2 = __toESM(require_dist(), 1);
+import { readFileSync as readFileSync2 } from "node:fs";
+import { join } from "node:path";
 
 // src/domains/safety/rule-compiler.ts
+init_esm_shims();
 function asString(value, ruleId, field) {
   if (typeof value !== "string" || value.length === 0) {
     throw new Error(`damage-control rule '${ruleId}': expected string for ${field}`);
@@ -2062,8 +1806,8 @@ function emptyRuleset(version) {
   return { version, rules: [] };
 }
 function loadRulePacks(yamlPath) {
-  const raw = readFileSync4(yamlPath, "utf8");
-  const parsed = parseYaml2(raw);
+  const raw = readFileSync2(yamlPath, "utf8");
+  const parsed = (0, import_yaml2.parse)(raw);
   if (!parsed || typeof parsed !== "object") {
     throw new Error(`damage-control rules at ${yamlPath}: expected mapping at document root`);
   }
@@ -2094,7 +1838,7 @@ function loadRulePacks(yamlPath) {
   return out;
 }
 function loadDefaultRulePacks() {
-  return loadRulePacks(join3(resolvePackageRoot(), "damage-control-rules.yaml"));
+  return loadRulePacks(join(resolvePackageRoot(), "damage-control-rules.yaml"));
 }
 var cachedPacks = null;
 function getCachedDefaultRulePacks() {
@@ -2132,10 +1876,7 @@ function writeRootTargetPath(call) {
   if (!WRITE_ROOT_TOOLS.has(call.tool)) return null;
   const target = pathArg(call.args);
   if (target !== null) return target;
-  if (call.tool === ToolNames.Artifact) {
-    const kind = call.args?.kind;
-    return kind === "review" ? "REVIEW.md" : kind === "report" ? "REPORT.md" : "PLAN.md";
-  }
+  if (call.tool === ToolNames.Artifact) return artifactDefaultPath(call.args?.kind);
   return null;
 }
 function isWriteConfinementEscape(call, actionClass) {
@@ -2374,10 +2115,8 @@ function pathPolicyTargets(call) {
       const target = pathArg(args);
       return target === null ? [] : [{ operation: "write", path: target }];
     }
-    case ToolNames.Artifact: {
-      const fallback = args?.kind === "review" ? "REVIEW.md" : args?.kind === "report" ? "REPORT.md" : "PLAN.md";
-      return [{ operation: "write", path: pathArg(args) ?? fallback }];
-    }
+    case ToolNames.Artifact:
+      return [{ operation: "write", path: pathArg(args) ?? artifactDefaultPath(args?.kind) }];
     case ToolNames.CredentialPresent:
       return [];
     case ToolNames.Bash: {
@@ -2689,446 +2428,8 @@ function packPayload(rules) {
   }));
 }
 
-// src/domains/safety/scope.ts
-import path5 from "node:path";
-function normalizeRoot(root) {
-  return path5.resolve(root);
-}
-function isUnder(child, parent) {
-  const c = normalizeRoot(child);
-  const p = normalizeRoot(parent);
-  if (c === p) return true;
-  const rel = path5.relative(p, c);
-  return rel !== "" && !rel.startsWith("..") && !path5.isAbsolute(rel);
-}
-function isSubset(worker, orchestrator) {
-  for (const action of worker.allowedActions) {
-    if (!orchestrator.allowedActions.has(action)) return false;
-  }
-  for (const root of worker.allowedWriteRoots) {
-    const covered = orchestrator.allowedWriteRoots.some((outer) => isUnder(root, outer));
-    if (!covered) return false;
-  }
-  if (worker.allowNetwork && !orchestrator.allowNetwork) return false;
-  if (worker.allowDispatch && !orchestrator.allowDispatch) return false;
-  return true;
-}
-var READONLY_SCOPE = {
-  allowedActions: /* @__PURE__ */ new Set(["read"]),
-  allowedWriteRoots: [],
-  allowNetwork: true,
-  allowDispatch: false
-};
-var WORKSPACE_SCOPE = {
-  allowedActions: /* @__PURE__ */ new Set(["read", "write", "execute", "dispatch"]),
-  allowedWriteRoots: [process.cwd()],
-  allowNetwork: true,
-  allowDispatch: true
-};
-var CONFIRMED_SCOPE = {
-  allowedActions: /* @__PURE__ */ new Set(["read", "write", "execute", "dispatch", "system_modify"]),
-  allowedWriteRoots: [process.cwd()],
-  allowNetwork: true,
-  allowDispatch: true
-};
-
-// src/domains/safety/finish-contract.ts
-var FINISH_CONTRACT_ADVISORY_MESSAGE = "[Clio Coder] finish-contract advisory: you changed files this turn without recording validation evidence or an explicit limitation. Run a verification command or state what could not be verified.";
-var DEFAULT_RECENT_ENTRY_LIMIT = 80;
-var LIMITATION_PATTERNS = [
-  /\b(?:blocked by|blocker|blockers|unable to|not able to|could not|couldn't|cannot|can't)\b/i,
-  /\b(?:did not|didn't|have not|haven't|has not|hasn't|was not able|wasn't able)\b/i,
-  /\b(?:not complete|incomplete)\b/i,
-  /\b(?:not|un)(?:\s|-)?(?:validated|verified|tested)\b/i,
-  /^\s*Tests\s*:\s*(?:not run|not executed|not available|failed|blocked|skipped)\b/im,
-  /^\s*Known gaps?\s*:\s*(?!\s*(?:none|no\b|n\/a|not applicable)\b).+/im,
-  /\bremaining(?:\s+\w+){0,3}\s+(?:work|issue|issues|gap|gaps|blocker|blockers)\b/i
-];
-function assessFinishContract(input) {
-  const assistantText = input.assistantText.trim();
-  const sessionEntries = input.sessionEntries ?? [];
-  const assistantTurnId = input.assistantTurnId ?? null;
-  const window = recentEntries(sessionEntries, assistantTurnId, input.recentEntryLimit ?? DEFAULT_RECENT_ENTRY_LIMIT);
-  const mutatedPaths = mutatingReceipts(window);
-  if (mutatedPaths.length === 0) {
-    return { kind: "ok", reason: "no_mutation", evidence: [], mutatedPaths };
-  }
-  const evidence = collectValidationEvidence(window);
-  if (evidence.length > 0) {
-    return { kind: "ok", reason: "validation_evidence", evidence, mutatedPaths };
-  }
-  if (hasExplicitLimitation(assistantText)) {
-    return { kind: "ok", reason: "explicit_limitation", evidence: [], mutatedPaths };
-  }
-  return {
-    kind: "engage",
-    reason: "unvalidated_mutation",
-    message: FINISH_CONTRACT_ADVISORY_MESSAGE,
-    evidence: [],
-    mutatedPaths
-  };
-}
-function hasExplicitLimitation(text) {
-  const normalized = text.trim();
-  if (normalized.length === 0) return false;
-  return LIMITATION_PATTERNS.some((pattern) => pattern.test(normalized));
-}
-function mutatingReceipts(recent) {
-  const mutationCalls = /* @__PURE__ */ new Map();
-  const paths = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const entry of recent) {
-    const bashMutation = bashExecutionMutationPaths(entry);
-    if (bashMutation !== null) {
-      for (const path7 of bashMutation) pushPath(paths, seen, path7);
-      continue;
-    }
-    const call = mutatingToolCall(entry);
-    if (call !== null) {
-      mutationCalls.set(call.toolCallId, call);
-      continue;
-    }
-    const resultId = successfulToolResultId(entry);
-    if (resultId !== null) {
-      const candidate = mutationCalls.get(resultId);
-      if (candidate !== void 0) {
-        for (const path7 of candidate.paths) pushPath(paths, seen, path7);
-      }
-    }
-  }
-  return paths;
-}
-function mutationPathsForTool(toolName, args) {
-  if (toolName === ToolNames.Bash) {
-    const command = typeof args?.command === "string" ? args.command : null;
-    if (command === null) return [];
-    return [...extractCommandWriteTargets(command), ...extractCommandDeleteTargets(command)];
-  }
-  return toolMutationPaths(toolName, args);
-}
-function mutatingToolCall(entry) {
-  const record = asRecord(entry);
-  if (record?.kind !== "message" || record.role !== "tool_call") return null;
-  const payload = asRecord(record.payload);
-  if (payload === null) return null;
-  const toolName = stringFromFirst(payload, ["name", "toolName", "tool"]);
-  if (toolName === null) return null;
-  const args = asRecord(payload.args ?? payload.arguments ?? payload.input) ?? void 0;
-  const paths = mutationPathsForTool(toolName, args);
-  if (paths.length === 0) return null;
-  const toolCallId = stringFromFirst(payload, ["toolCallId", "tool_call_id", "id"]) ?? turnIdOf(entry);
-  if (toolCallId === null) return null;
-  return { toolCallId, paths };
-}
-function bashExecutionMutationPaths(entry) {
-  const record = asRecord(entry);
-  if (record?.kind !== "bashExecution") return null;
-  if (typeof record.command !== "string") return null;
-  if (record.cancelled === true || record.exitCode !== 0) return null;
-  return [...extractCommandWriteTargets(record.command), ...extractCommandDeleteTargets(record.command)];
-}
-function pushPath(paths, seen, path7) {
-  if (path7.length === 0 || seen.has(path7)) return;
-  seen.add(path7);
-  paths.push(path7);
-}
-function collectValidationEvidence(recent) {
-  const evidence = [];
-  const toolCalls = /* @__PURE__ */ new Map();
-  const dispatchCalls = /* @__PURE__ */ new Map();
-  const seen = /* @__PURE__ */ new Set();
-  for (const entry of recent) {
-    const protectedArtifact = protectedArtifactEvidence(entry);
-    if (protectedArtifact !== null) {
-      pushEvidence(evidence, seen, protectedArtifact);
-      continue;
-    }
-    const call = bashValidationCall(entry);
-    if (call !== null) {
-      toolCalls.set(call.toolCallId, call);
-      continue;
-    }
-    const typedValidationCall = validationToolCall(entry);
-    if (typedValidationCall !== null) {
-      toolCalls.set(typedValidationCall.toolCallId, typedValidationCall);
-      continue;
-    }
-    const dispatchCall = dispatchEvidenceCall(entry);
-    if (dispatchCall !== null) {
-      dispatchCalls.set(dispatchCall.toolCallId, dispatchCall);
-      continue;
-    }
-    const resultId = successfulToolResultId(entry);
-    if (resultId !== null) {
-      const dispatchCandidate = dispatchCalls.get(resultId);
-      const dispatchReceipt = dispatchReceiptEvidence(entry, dispatchCandidate);
-      if (dispatchReceipt !== null) {
-        pushEvidence(evidence, seen, dispatchReceipt);
-        continue;
-      }
-      const candidate = toolCalls.get(resultId);
-      if (candidate !== void 0) {
-        pushEvidence(evidence, seen, validationEvidence(candidate));
-      }
-      continue;
-    }
-    const bashExecution = bashExecutionEvidence(entry);
-    if (bashExecution !== null) pushEvidence(evidence, seen, bashExecution);
-  }
-  return evidence;
-}
-function recentEntries(entries, assistantTurnId, recentEntryLimit) {
-  const boundedLimit = Number.isFinite(recentEntryLimit) && recentEntryLimit > 0 ? Math.floor(recentEntryLimit) : DEFAULT_RECENT_ENTRY_LIMIT;
-  const assistantIndex = assistantTurnId === null ? -1 : entries.findIndex((entry) => turnIdOf(entry) === assistantTurnId);
-  const endExclusive = assistantIndex >= 0 ? assistantIndex : entries.length;
-  let startInclusive = Math.max(0, endExclusive - boundedLimit);
-  for (let index = endExclusive - 1; index >= startInclusive; index -= 1) {
-    if (isUserMessageEntry(entries[index])) {
-      startInclusive = index + 1;
-      break;
-    }
-  }
-  return entries.slice(startInclusive, endExclusive);
-}
-function bashValidationCall(entry) {
-  const record = asRecord(entry);
-  if (record?.kind !== "message" || record.role !== "tool_call") return null;
-  const payload = asRecord(record.payload);
-  if (payload === null) return null;
-  const toolName = stringFromFirst(payload, ["name", "toolName", "tool"]);
-  if (toolName !== "bash") return null;
-  const args = asRecord(payload.args ?? payload.arguments ?? payload.input);
-  const command = typeof args?.command === "string" ? args.command : null;
-  if (command === null) return null;
-  const detected = detectValidationCommand(command);
-  if (detected.kind !== "validation") return null;
-  const toolCallId = stringFromFirst(payload, ["toolCallId", "tool_call_id", "id"]) ?? turnIdOf(entry);
-  if (toolCallId === null) return null;
-  const candidate = {
-    toolCallId,
-    command: detected.matched
-  };
-  const turnId = turnIdOf(entry);
-  if (turnId !== null) candidate.turnId = turnId;
-  return candidate;
-}
-function dispatchEvidenceCall(entry) {
-  const record = asRecord(entry);
-  if (record?.kind !== "message" || record.role !== "tool_call") return null;
-  const payload = asRecord(record.payload);
-  if (payload === null) return null;
-  const toolName = stringFromFirst(payload, ["name", "toolName", "tool"]);
-  if (toolName !== "dispatch") return null;
-  const args = asRecord(payload.args ?? payload.arguments ?? payload.input);
-  const { agentId, task } = dispatchCallDescriptor(args);
-  const toolCallId = stringFromFirst(payload, ["toolCallId", "tool_call_id", "id"]) ?? turnIdOf(entry);
-  if (toolCallId === null) return null;
-  const candidate = {
-    toolCallId,
-    command: `agent=${agentId}${task.length > 0 ? ` task=${task}` : ""}`
-  };
-  const turnId = turnIdOf(entry);
-  if (turnId !== null) candidate.turnId = turnId;
-  return candidate;
-}
-function dispatchCallDescriptor(args) {
-  const defaultAgent = stringFromFirst(args ?? {}, ["agent", "agent_id", "agentId"]);
-  const tasks = Array.isArray(args?.tasks) ? args.tasks : null;
-  if (tasks !== null && tasks.length > 0) {
-    const first = tasks[0];
-    if (typeof first === "string") {
-      return { agentId: defaultAgent ?? "coder", task: first.trim() };
-    }
-    const firstRecord = asRecord(first);
-    const itemAgent = firstRecord === null ? null : stringFromFirst(firstRecord, ["agent", "agent_id", "agentId"]);
-    const itemTask = typeof firstRecord?.task === "string" ? firstRecord.task.trim() : "";
-    return { agentId: itemAgent ?? defaultAgent ?? "coder", task: itemTask };
-  }
-  const singleTask = typeof args?.task === "string" ? args.task.trim() : "";
-  return { agentId: defaultAgent ?? "coder", task: singleTask };
-}
-function validationToolCall(entry) {
-  const record = asRecord(entry);
-  if (record?.kind !== "message" || record.role !== "tool_call") return null;
-  const payload = asRecord(record.payload);
-  if (payload === null) return null;
-  const toolName = stringFromFirst(payload, ["name", "toolName", "tool"]);
-  if (toolName === null) return null;
-  const summary = typedValidationSummary(toolName, payload);
-  if (summary === null) return null;
-  const toolCallId = stringFromFirst(payload, ["toolCallId", "tool_call_id", "id"]) ?? turnIdOf(entry);
-  if (toolCallId === null) return null;
-  const candidate = {
-    toolCallId,
-    command: summary
-  };
-  const turnId = turnIdOf(entry);
-  if (turnId !== null) candidate.turnId = turnId;
-  return candidate;
-}
-function typedValidationSummary(toolName, payload) {
-  const args = asRecord(payload.args ?? payload.arguments ?? payload.input);
-  if (toolName === "verify") {
-    const check = typeof args?.check === "string" ? args.check.trim() : "";
-    if (check === "frontend") {
-      const path7 = typeof args?.path === "string" && args.path.trim().length > 0 ? args.path.trim() : "artifact";
-      return `verify frontend ${path7}`;
-    }
-    if (!isVerificationScriptName(check)) return null;
-    return `npm run ${check}`;
-  }
-  return null;
-}
-function successfulToolResultId(entry) {
-  const record = asRecord(entry);
-  if (record?.kind !== "message" || record.role !== "tool_result") return null;
-  const payload = asRecord(record.payload);
-  if (payload === null) return null;
-  if (payload.isError === true || payload.error === true) return null;
-  const result = asRecord(payload.result);
-  const details = asRecord(result?.details);
-  if (details?.kind === "error") return null;
-  return stringFromFirst(payload, ["toolCallId", "tool_call_id", "id"]);
-}
-function dispatchReceiptEvidence(entry, candidate) {
-  const record = asRecord(entry);
-  if (record?.kind !== "message" || record.role !== "tool_result") return null;
-  const payload = asRecord(record.payload);
-  if (payload === null) return null;
-  const toolName = stringFromFirst(payload, ["toolName", "name", "tool"]);
-  if (toolName !== null && toolName !== "dispatch") return null;
-  const result = asRecord(payload.result);
-  const details = asRecord(result?.details);
-  if (details === null) return null;
-  const summary = passedDispatchReceiptSummary(details, candidate);
-  if (summary === null) return null;
-  const evidence = {
-    kind: "dispatch_receipt",
-    summary
-  };
-  const turnId = candidate?.turnId ?? turnIdOf(entry);
-  if (turnId !== null && turnId !== void 0) evidence.turnId = turnId;
-  return evidence;
-}
-function passedDispatchReceiptSummary(details, candidate) {
-  if (Array.isArray(details.runs)) {
-    const runs = details.runs.map(asRecord);
-    if (runs.length === 0 || runs.some((run) => run === null || run.exitCode !== 0)) return null;
-    if (typeof details.failedCount === "number" && details.failedCount !== 0) return null;
-    const first = runs[0];
-    const runId = typeof first?.runId === "string" && first.runId.length > 0 ? first.runId : "unknown";
-    const agentId = dispatchReceiptAgentId(typeof first?.agentId === "string" ? first.agentId : void 0, candidate);
-    const extra = runs.length > 1 ? ` (+${runs.length - 1} more)` : "";
-    return `dispatch receipt passed: run ${runId} agent ${agentId}${extra}`;
-  }
-  if (details.exitCode === 0) {
-    const runId = typeof details.runId === "string" && details.runId.length > 0 ? details.runId : "unknown";
-    const agentId = dispatchReceiptAgentId(typeof details.agentId === "string" ? details.agentId : void 0, candidate);
-    return `dispatch receipt passed: run ${runId} agent ${agentId}`;
-  }
-  return null;
-}
-function dispatchReceiptAgentId(receiptAgentId, candidate) {
-  if (receiptAgentId !== void 0 && receiptAgentId.length > 0) return receiptAgentId;
-  return candidate?.command.match(/^agent=([^\s]+)/)?.[1] ?? "unknown";
-}
-function bashExecutionEvidence(entry) {
-  const record = asRecord(entry);
-  if (record?.kind !== "bashExecution") return null;
-  if (typeof record.command !== "string") return null;
-  if (record.cancelled === true) return null;
-  if (record.exitCode !== 0) return null;
-  const detected = detectValidationCommand(record.command);
-  if (detected.kind !== "validation") return null;
-  const evidence = {
-    kind: "validation_command",
-    summary: `validation command passed: ${detected.matched}`
-  };
-  const turnId = turnIdOf(entry);
-  if (turnId !== null) evidence.turnId = turnId;
-  return evidence;
-}
-function protectedArtifactEvidence(entry) {
-  const record = asRecord(entry);
-  if (record?.kind !== "protectedArtifact" || record.action !== "protect") return null;
-  const artifact = asRecord(record.artifact);
-  const path7 = typeof artifact?.path === "string" && artifact.path.trim().length > 0 ? artifact.path.trim() : null;
-  if (path7 === null) return null;
-  const evidence = {
-    kind: "protected_artifact",
-    summary: `protected artifact recorded: ${path7}`
-  };
-  const turnId = turnIdOf(entry);
-  if (turnId !== null) evidence.turnId = turnId;
-  return evidence;
-}
-function validationEvidence(candidate) {
-  const evidence = {
-    kind: "validation_command",
-    summary: `validation command passed: ${candidate.command}`
-  };
-  if (candidate.turnId !== void 0) evidence.turnId = candidate.turnId;
-  return evidence;
-}
-function pushEvidence(evidence, seen, item) {
-  const key = `${item.kind}\0${item.summary}\0${item.turnId ?? ""}`;
-  if (seen.has(key)) return;
-  seen.add(key);
-  evidence.push(item);
-}
-function isUserMessageEntry(entry) {
-  const record = asRecord(entry);
-  if (record?.kind !== "message" || record.role !== "user") return false;
-  const payload = asRecord(record.payload);
-  return payload?.synthetic !== true;
-}
-function turnIdOf(entry) {
-  const record = asRecord(entry);
-  return typeof record?.turnId === "string" ? record.turnId : null;
-}
-function stringFromFirst(record, keys) {
-  for (const key of keys) {
-    const value = record[key];
-    if (typeof value === "string" && value.length > 0) return value;
-  }
-  return null;
-}
-function asRecord(value) {
-  return value !== null && typeof value === "object" ? value : null;
-}
-
-// src/domains/safety/rigor.ts
-import { existsSync as existsSync4 } from "node:fs";
-import path6 from "node:path";
-var VALIDATION_CONTRACT_FILES = [
-  path6.join(".clio-coder", "validation.yaml"),
-  path6.join(".clio-coder", "validation.yml"),
-  "validation.yaml",
-  "validation.yml",
-  "VALIDATION.md"
-];
-function resolveRigor(options) {
-  if (options.override === "high" || options.override === "normal") return options.override;
-  const cwd = options.cwd ?? process.cwd();
-  return hasValidationContract(cwd) ? "high" : "normal";
-}
-function parseRigorOverride(value) {
-  if (typeof value !== "string") return null;
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "high") return "high";
-  if (normalized === "normal") return "normal";
-  return null;
-}
-function hasValidationContract(cwd) {
-  try {
-    return VALIDATION_CONTRACT_FILES.some((relative) => existsSync4(path6.join(cwd, relative)));
-  } catch {
-    return false;
-  }
-}
-
 export {
-  parseFrontmatter,
+  parseJsonObjectPayload,
   resultContractSourceId,
   parseVerifierResult,
   resultContractAuthorship,
@@ -3136,42 +2437,20 @@ export {
   validateResultContract,
   validateRecipeResult,
   RESULT_CONTRACT_REPAIR_LIMIT,
-  resultContractRepairMessage,
+  resultContractRepairMessages,
   parseResultContract,
-  FLEET_COMMAND_BASE_ENV,
-  loadFleetCommands,
-  normalizeWriteBoundary,
-  writeBoundaryCovers,
-  describeWriteBoundary,
-  fleetLoopCheckStepId,
-  fleetLoopRepairStepId,
-  fleetStepWriteBoundary,
-  FLEET_COMMANDS_REPO_PATH,
-  FLEET_COMMANDS_REMEDY,
-  FleetCommandRegistryMissingError,
-  loadFleetContract,
-  listFleetContracts,
-  renderFleetPrompt,
   AUTONOMY_LEVELS,
   DEFAULT_AUTONOMY_LEVEL,
   isAutonomyLevel,
+  DEFAULT_AUTONOMY_EXPOSURE,
   mapAutonomy,
   autonomyDenyRejection,
   autonomyAskRejection,
-  createLoopState,
-  hashToolCall,
-  observe,
-  formatModelRejection,
-  WRITE_ROOT_REFUSED_TOOLS,
-  createSafetyPolicyEngine,
-  isSubset,
-  READONLY_SCOPE,
-  WORKSPACE_SCOPE,
-  CONFIRMED_SCOPE,
   DEFAULT_RECENT_ENTRY_LIMIT,
   assessFinishContract,
   typedValidationSummary,
-  resolveRigor,
-  parseRigorOverride
+  formatModelRejection,
+  WRITE_ROOT_REFUSED_TOOLS,
+  createSafetyPolicyEngine
 };
-//# sourceMappingURL=chunk-XV4ZJ6ZM.js.map
+//# sourceMappingURL=chunk-STBPMHSX.js.map