@iowarp/clio-coder 0.3.7 → 0.3.8

package/dist/{chunk-XEGB6BCN.js → chunk-7RGZWPB6.js}

@@ -7,10 +7,10 @@ import {
   TASK_MEMORY_POLICY_DEFAULT_TIMEOUT_MS,
   runTaskMemoryPolicy,
   taskMemoryBankDelta
-} from "./chunk-WHGPSPT5.js";
+} from "./chunk-ZVJ5BLO2.js";
 import {
   isTerminalRunEnvelope
-} from "./chunk-CEYBNUGC.js";
+} from "./chunk-A3WNZD3P.js";
 import {
   taskBoardCounts
 } from "./chunk-5FR74PWO.js";
@@ -27,11 +27,11 @@ import {
 } from "./chunk-CGKSTWHD.js";
 import {
   ceilChars
-} from "./chunk-GEYXPTRF.js";
+} from "./chunk-RWSI4YD7.js";
 import {
   reportCommitAttributionDiagnostic,
   withManagedGitCommitAttributionEnvironment
-} from "./chunk-D4MDIG46.js";
+} from "./chunk-B5CSFE7B.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -2404,4 +2404,4 @@ export {
   createWatchdogRegistration,
   MiddlewareDomainModule
 };
-//# sourceMappingURL=chunk-XEGB6BCN.js.map
+//# sourceMappingURL=chunk-7RGZWPB6.js.map

package/dist/{chunk-GH5622CP.js → chunk-A2NJGIB3.js}

@@ -5,7 +5,7 @@ import {
 import {
   SAFE_EXEC_DEFAULT_TIMEOUT_MS,
   resolveSafeCwd
-} from "./chunk-D4MDIG46.js";
+} from "./chunk-B5CSFE7B.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -310,4 +310,4 @@ export {
   parseProjectVerifierCatalogText,
   packageDeclaredCheck
 };
-//# sourceMappingURL=chunk-GH5622CP.js.map
+//# sourceMappingURL=chunk-A2NJGIB3.js.map

package/dist/{chunk-CEYBNUGC.js → chunk-A3WNZD3P.js}

@@ -1,18 +1,18 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  typedValidationSummary
-} from "./chunk-OBMAI2DP.js";
 import {
   ROUTE_POLICY_VERSION,
   isRouteDecisionAgentSelection,
   isRoutingIntent,
   routePriorForLatencyClass,
   sameRouteIdentity
-} from "./chunk-5C77SEEY.js";
+} from "./chunk-P43ETTHK.js";
 import {
   deriveExecutionRole,
   isExecutionRole
-} from "./chunk-UND3GU2L.js";
+} from "./chunk-H7IXIC72.js";
+import {
+  typedValidationSummary
+} from "./chunk-5H3GB5BO.js";
 import {
   expandPath,
   resolveReadPath
@@ -24,9 +24,20 @@ import {
   isAutonomyLevel,
   mapAutonomy
 } from "./chunk-HWUFFB6L.js";
+import {
+  COUNCIL_BALLOT_SHAPE,
+  COUNCIL_BALLOT_VERDICT_MAX_BYTES,
+  PATH_BOUNDARY_MAX_ENTRIES,
+  PathBoundaryError,
+  asDirectoryPathBoundary,
+  normalizePathBoundaryEntry,
+  pathBoundaryCovers,
+  resolvePathBoundary
+} from "./chunk-TTHACPOM.js";
 import {
   AGENT_AUTOMATION_AUTHORITIES,
-  agentSpecFingerprint
+  agentSpecFingerprint,
+  classify
 } from "./chunk-AOCYTWAV.js";
 import {
   detectValidationCommand,
@@ -62,26 +73,26 @@ import {
   ToolNames,
   isBuiltinToolName
 } from "./chunk-CGKSTWHD.js";
-import {
-  THINKING_LEVELS
-} from "./chunk-4DGYLA73.js";
 import {
   gitCommitAttributionEnabled,
   reportCommitAttributionDiagnostic,
   resolveSafeCwd,
   withManagedGitCommitAttributionEnvironment
-} from "./chunk-D4MDIG46.js";
+} from "./chunk-B5CSFE7B.js";
 import {
   clampTimerDelayMs
 } from "./chunk-FQ4SKYE4.js";
+import {
+  AI_AGENT_NAME
+} from "./chunk-6EJMN2Y3.js";
+import {
+  THINKING_LEVELS
+} from "./chunk-4DGYLA73.js";
 import {
   GUARDRAIL_DEFAULTS,
   GUARDRAIL_ENV_VARS,
   resolveGuardrail
 } from "./chunk-4ZG3XFUR.js";
-import {
-  AI_AGENT_NAME
-} from "./chunk-6EJMN2Y3.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -1400,6 +1411,15 @@ var COUNCIL_JUDGE_PROMPT = [
   "You cannot modify anything.",
   'End with a JSON object only: {"verdict":"...","text":"the supported synthesis"}.'
 ].join("\n");
+var COUNCIL_VOTE_MEMBER_DIRECTIVE = [
+  "This council round is a vote. Do the work the task asks for, then cast one ballot on it.",
+  `The verdict is a short comparable token the other members can match exactly, such as "yes", "no", "keep", or the name of an option you were given. It must be a single line of at most ${COUNCIL_BALLOT_VERDICT_MAX_BYTES} bytes and is lower-cased before the tally. Anything longer is reasoning: put that in text, along with the evidence behind it.`,
+  "Your recipe's own result shape does not apply to this run. The council reads the ballot and nothing else.",
+  `End with a JSON object only: ${COUNCIL_BALLOT_SHAPE}`
+].join("\n");
+function renderCouncilVoteMemberTask(originalTask) {
+  return [originalTask, COUNCIL_VOTE_MEMBER_DIRECTIVE].join("\n\n");
+}
 var COMPETE_STANCES = [
   "minimal-diff",
   "test-first",
@@ -2716,6 +2736,10 @@ function builtin(spec, sourceInfo) {
 // src/domains/safety/run-effects.ts
 init_esm_shims();
 import path from "node:path";
+var ENUMERABLE_ACTION_CLASSES = /* @__PURE__ */ new Set(["read", "write"]);
+function toolWritesOpaquely(toolName) {
+  return !ENUMERABLE_ACTION_CLASSES.has(classify({ tool: toolName }).actionClass);
+}
 var GIT_PATH_MUTATIONS = /* @__PURE__ */ new Set(["mv", "rm"]);
 function gitPathOperands(command) {
   const targets = [];
@@ -2769,17 +2793,20 @@ function createRunEffectsRecorder(cwd) {
   const failedMutationPaths = /* @__PURE__ */ new Set();
   const validationCommands = /* @__PURE__ */ new Set();
   const verificationCommands = /* @__PURE__ */ new Set();
+  let opaqueWriteObserved = false;
   return {
     start(toolCallId, toolName, args) {
       const paths = mutationTargets(toolName, args);
       const validationCommand = validationCommandOf(toolName, args, "finish-contract");
       const verificationCommand = validationCommandOf(toolName, args, "grounding");
-      if (paths.length === 0 && validationCommand === null && verificationCommand === null) return;
+      const opaque = toolWritesOpaquely(toolName);
+      if (!opaque && paths.length === 0 && validationCommand === null && verificationCommand === null) return;
       const base = typeof args?.cwd === "string" && args.cwd.length > 0 ? path.resolve(cwd, args.cwd) : cwd;
       pending.set(toolCallId, {
         paths: paths.map((target) => path.resolve(base, target)),
         validationCommand,
-        verificationCommand
+        verificationCommand,
+        opaque
       });
     },
     finish(toolCallId, failed) {
@@ -2790,6 +2817,7 @@ function createRunEffectsRecorder(cwd) {
         for (const target of effects.paths) failedMutationPaths.add(target);
         return;
       }
+      if (effects.opaque) opaqueWriteObserved = true;
       for (const target of effects.paths) mutatedPaths.add(target);
       if (effects.validationCommand !== null) validationCommands.add(effects.validationCommand);
       if (effects.verificationCommand !== null) verificationCommands.add(effects.verificationCommand);
@@ -2799,7 +2827,8 @@ function createRunEffectsRecorder(cwd) {
         mutatedPaths: new Set(mutatedPaths),
         failedMutationPaths: new Set([...failedMutationPaths].filter((target) => !mutatedPaths.has(target))),
         validationCommands: new Set(validationCommands),
-        verificationCommands: new Set(verificationCommands)
+        verificationCommands: new Set(verificationCommands),
+        writeRecordComplete: !opaqueWriteObserved
       };
     }
   };
@@ -3031,10 +3060,223 @@ function renderAll(entries) {
   return lines.join("\n");
 }
 
+// src/domains/dispatch/path-scope.ts
+init_esm_shims();
+var DISPATCH_PATH_TOKEN_RE = /(?:[\w.-]+\/)+[\w.-]+|\b[\w-]+\.[A-Za-z0-9]{1,8}\b/g;
+var HTTP_URL_RE = /\bhttps?:\/\/\S+/gu;
+var POSIX_ABSOLUTE_TOKEN_RE = /(?:^|[\s("'])((?:\/[\w.~+-]+)+)/gu;
+var WINDOWS_ABSOLUTE_TOKEN_RE = /(?:^|[\s("'])([A-Za-z]:[\\/][^\s"']+)/gu;
+var BACKSLASH_PATH_RE = /\b[A-Za-z_.-][\w.-]*\\(?:(?:[\w.-]+\\)+[\w.-]+|[\w-]+\.[A-Za-z0-9]{1,8})\b/gu;
+var DOUBLE_SEPARATOR_PATH_RE = /\b[\w.-]+\/\/[\w./-]+/gu;
+var DispatchPathScopeInferenceError = class extends Error {
+  code;
+  source;
+  token;
+  constructor(code, source, token, detail) {
+    super(`${code}: ${source} contains ${detail} '${token}'; declare intent explicitly`);
+    this.name = "DispatchPathScopeInferenceError";
+    this.code = code;
+    this.source = source;
+    this.token = token;
+  }
+};
+var DECLARED_EVIDENCE = {
+  readRoots: {
+    provenance: "declared",
+    source: "intent.read_roots",
+    confidence: "certain",
+    reason: "explicit_intent"
+  },
+  writeRoots: {
+    provenance: "declared",
+    source: "intent.write_roots",
+    confidence: "certain",
+    reason: "explicit_intent"
+  },
+  relevantPaths: {
+    provenance: "declared",
+    source: "intent.relevant_paths",
+    confidence: "certain",
+    reason: "explicit_intent"
+  }
+};
+function cloneEvidence(evidence) {
+  return { ...evidence };
+}
+function addProvenance(entries, path4, evidence) {
+  const current = entries.get(path4);
+  if (current === void 0) {
+    entries.set(path4, { path: path4, evidence: [cloneEvidence(evidence)] });
+    return;
+  }
+  if (!current.evidence.some((entry) => entry.source === evidence.source)) {
+    current.evidence.push(cloneEvidence(evidence));
+  }
+}
+function sortedEntries(entries) {
+  return [...entries.values()].sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0).map((entry) => ({ path: entry.path, evidence: entry.evidence.map(cloneEvidence) }));
+}
+function declaredIntentPathProvenance(input) {
+  const entries = /* @__PURE__ */ new Map();
+  for (const path4 of input.readRoots) addProvenance(entries, path4, DECLARED_EVIDENCE.readRoots);
+  for (const path4 of input.writeRoots) addProvenance(entries, path4, DECLARED_EVIDENCE.writeRoots);
+  for (const path4 of input.relevantPaths) addProvenance(entries, path4, DECLARED_EVIDENCE.relevantPaths);
+  return sortedEntries(entries);
+}
+function inferredPaths(req) {
+  const paths = /* @__PURE__ */ new Set();
+  const text = `${req.task}
+${req.briefing ?? ""}`;
+  for (const match of text.matchAll(DISPATCH_PATH_TOKEN_RE)) {
+    const token = inferredPathToken(match[0]);
+    if (token.startsWith("http://") || token.startsWith("https://")) continue;
+    paths.add(token);
+  }
+  return [...paths];
+}
+function inferredPathToken(token) {
+  return token.replace(/\.+$/u, "");
+}
+function failMalformedText(text, source) {
+  const withoutUrls = text.replace(HTTP_URL_RE, (url) => " ".repeat(url.length));
+  const absolute = POSIX_ABSOLUTE_TOKEN_RE.exec(withoutUrls)?.[1];
+  POSIX_ABSOLUTE_TOKEN_RE.lastIndex = 0;
+  if (absolute !== void 0) {
+    throw new DispatchPathScopeInferenceError("legacy_scope_path_absolute", source, absolute, "an absolute path token");
+  }
+  const windowsAbsolute = WINDOWS_ABSOLUTE_TOKEN_RE.exec(withoutUrls)?.[1];
+  WINDOWS_ABSOLUTE_TOKEN_RE.lastIndex = 0;
+  if (windowsAbsolute !== void 0) {
+    throw new DispatchPathScopeInferenceError(
+      "legacy_scope_path_absolute",
+      source,
+      windowsAbsolute,
+      "an absolute path token"
+    );
+  }
+  for (const pattern of [BACKSLASH_PATH_RE, DOUBLE_SEPARATOR_PATH_RE]) {
+    const malformed = pattern.exec(withoutUrls)?.[0];
+    pattern.lastIndex = 0;
+    if (malformed !== void 0) {
+      throw new DispatchPathScopeInferenceError(
+        "legacy_scope_path_malformed",
+        source,
+        malformed,
+        "a malformed path token"
+      );
+    }
+  }
+}
+function strictInferredPaths(text, source) {
+  failMalformedText(text, source);
+  const withoutUrls = text.replace(HTTP_URL_RE, (url) => " ".repeat(url.length));
+  const evidence = source === "task" ? { provenance: "inferred", source, confidence: "medium", reason: "task_path_token" } : { provenance: "inferred", source, confidence: "low", reason: "briefing_path_token" };
+  const result = [];
+  for (const match of withoutUrls.matchAll(DISPATCH_PATH_TOKEN_RE)) {
+    const token = inferredPathToken(match[0]);
+    try {
+      result.push({ path: normalizePathBoundaryEntry(token), evidence });
+    } catch (error) {
+      const code = error instanceof PathBoundaryError && error.code === "absolute" ? "legacy_scope_path_absolute" : "legacy_scope_path_malformed";
+      throw new DispatchPathScopeInferenceError(
+        code,
+        source,
+        token,
+        code === "legacy_scope_path_absolute" ? "an absolute path token" : "a malformed path token"
+      );
+    }
+  }
+  return result;
+}
+function legacyPathScope(req, cwd) {
+  const workingEntries = /* @__PURE__ */ new Map();
+  const writeEntries = /* @__PURE__ */ new Map();
+  const writeEvidence = {
+    provenance: "derived",
+    source: "writeRoots",
+    confidence: "high",
+    reason: "legacy_write_roots"
+  };
+  for (const root of req.writeRoots ?? []) {
+    addProvenance(workingEntries, root, writeEvidence);
+    addProvenance(writeEntries, asDirectoryPathBoundary(resolvePathBoundary(cwd, root)), writeEvidence);
+  }
+  for (const candidate of strictInferredPaths(req.task, "task")) {
+    addProvenance(workingEntries, candidate.path, candidate.evidence);
+  }
+  if (req.briefing !== void 0) {
+    for (const candidate of strictInferredPaths(req.briefing, "briefing")) {
+      addProvenance(workingEntries, candidate.path, candidate.evidence);
+    }
+  }
+  const workingContext = [...workingEntries.values()].map((entry) => ({
+    path: entry.path,
+    evidence: entry.evidence.map(cloneEvidence)
+  }));
+  const writeBoundaries = [...writeEntries.values()].map((entry) => ({
+    path: entry.path,
+    evidence: entry.evidence.map(cloneEvidence)
+  }));
+  return {
+    source: "inferred",
+    workingContextPaths: workingContext.map((entry) => entry.path),
+    writeBoundaries: writeBoundaries.map((entry) => entry.path),
+    inferredOnlyPaths: [],
+    provenance: {
+      version: 1,
+      mode: "legacy-inferred",
+      workingContextPaths: workingContext,
+      writeBoundaries
+    }
+  };
+}
+function resolveDispatchPathScope(req) {
+  const cwd = req.cwd ?? process.cwd();
+  if (req.intent === void 0) return legacyPathScope(req, cwd);
+  const declaredProvenance = declaredIntentPathProvenance(req.intent);
+  const declaredPaths = declaredProvenance.map((entry) => entry.path);
+  const inferredOnlyPaths = inferredPaths(req).filter((candidate) => !pathBoundaryCovers(declaredPaths, candidate));
+  const writeEvidence = DECLARED_EVIDENCE.writeRoots;
+  const writeBoundaries = req.intent.writeRoots.map((root) => ({
+    path: resolvePathBoundary(cwd, root),
+    evidence: [cloneEvidence(writeEvidence)]
+  }));
+  return {
+    source: "declared",
+    workingContextPaths: declaredPaths,
+    writeBoundaries: writeBoundaries.map((entry) => entry.path),
+    inferredOnlyPaths,
+    provenance: {
+      version: 1,
+      mode: "declared",
+      workingContextPaths: declaredProvenance,
+      writeBoundaries
+    }
+  };
+}
+function declaredScopeReplacementDiagnostic(scope) {
+  if (scope.source !== "declared" || scope.inferredOnlyPaths.length === 0) return null;
+  return `typed_scope_replaced_inferred_paths: typed intent omitted prose-inferred paths ${scope.inferredOnlyPaths.join(
+    ", "
+  )}; those paths did not select project rules or expand worker authority`;
+}
+function declaredScopeReplacementNotice(scope) {
+  if (scope.source !== "declared" || scope.inferredOnlyPaths.length === 0) return null;
+  const omittedPaths = [...scope.inferredOnlyPaths];
+  return {
+    code: "typed_scope_replaced_inferred_paths",
+    level: "warning",
+    omittedPaths,
+    message: `[dispatch scope] typed intent replaced prose path inference; omitted paths: ${omittedPaths.join(
+      ", "
+    )}. Those paths did not select project rules or expand worker authority.`
+  };
+}
+
 // src/domains/dispatch/intent.ts
 init_esm_shims();
 import path2 from "node:path";
-var DISPATCH_INTENT_PATH_LIST_CAP = 32;
+var DISPATCH_INTENT_PATH_LIST_CAP = PATH_BOUNDARY_MAX_ENTRIES;
 var DISPATCH_INTENT_PATH_ENTRY_BYTES_CAP = 512;
 var DISPATCH_INTENT_VERIFICATION_CAP = 8;
 var DISPATCH_INTENT_TIMEOUT_MIN_MS = 1e3;
@@ -3048,7 +3290,7 @@ function compareCodepoints(left, right) {
 function fail(reason, message) {
   return { ok: false, reason, message };
 }
-function normalizePathEntry(value, field, index) {
+function checkedPathText(value, field, index) {
   if (typeof value !== "string" || value.trim().length === 0) {
     return fail("intent_path_malformed", `${field}[${index}] must be a non-empty repository-relative POSIX path`);
   }
@@ -3059,6 +3301,32 @@ function normalizePathEntry(value, field, index) {
       `${field}[${index}] exceeds the ${DISPATCH_INTENT_PATH_ENTRY_BYTES_CAP}-byte cap`
     );
   }
+  return trimmed;
+}
+function normalizeScopePathEntry(value, field, index) {
+  const checked = checkedPathText(value, field, index);
+  if (typeof checked !== "string") return checked;
+  try {
+    return normalizePathBoundaryEntry(checked);
+  } catch (error) {
+    if (error instanceof PathBoundaryError) {
+      if (error.code === "absolute") {
+        return fail("intent_path_absolute", `${field}[${index}] must be a repository-relative POSIX path`);
+      }
+      if (error.code === "parent") {
+        return fail("intent_path_escapes_root", `${field}[${index}] escapes the repository root`);
+      }
+    }
+    return fail(
+      "intent_path_malformed",
+      `${field}[${index}] does not follow the repository path boundary grammar: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function normalizeExpectedOutputEntry(value, field, index) {
+  const checked = checkedPathText(value, field, index);
+  if (typeof checked !== "string") return checked;
+  const trimmed = checked;
   if (trimmed.includes("\\") || path2.posix.isAbsolute(trimmed) || path2.win32.isAbsolute(trimmed)) {
     return fail("intent_path_absolute", `${field}[${index}] must be a repository-relative POSIX path`);
   }
@@ -3071,7 +3339,7 @@ function normalizePathEntry(value, field, index) {
   }
   return normalized;
 }
-function normalizePathList(value, field) {
+function normalizePathList(value, field, normalizeEntry = normalizeScopePathEntry) {
   if (value === void 0) return [];
   if (!Array.isArray(value)) return fail("intent_path_malformed", `${field} must be an array`);
   if (value.length > DISPATCH_INTENT_PATH_LIST_CAP) {
@@ -3079,17 +3347,29 @@ function normalizePathList(value, field) {
   }
   const normalized = [];
   for (const [index, entry] of value.entries()) {
-    const result = normalizePathEntry(entry, field, index);
+    const result = normalizeEntry(entry, field, index);
     if (typeof result !== "string") return result;
     normalized.push(result);
   }
   return [...new Set(normalized)].sort(compareCodepoints);
 }
 function isDispatchIntent(value) {
-  if (!isRecord2(value) || value.version !== 1) return false;
+  if (!isRecord2(value) || value.version !== 2) return false;
   for (const field of ["readRoots", "writeRoots", "relevantPaths", "expectedOutputs"]) {
     if (!Array.isArray(value[field]) || !value[field].every((entry) => typeof entry === "string")) return false;
   }
+  const readRoots = value.readRoots;
+  const writeRoots = value.writeRoots;
+  const relevantPaths = value.relevantPaths;
+  if (!Array.isArray(value.pathProvenance) || JSON.stringify(value.pathProvenance) !== JSON.stringify(
+    declaredIntentPathProvenance({
+      readRoots,
+      writeRoots,
+      relevantPaths
+    })
+  )) {
+    return false;
+  }
   return Array.isArray(value.verification) && value.verification.every(
     (entry) => isRecord2(entry) && typeof entry.check === "string" && entry.check.length > 0 && typeof entry.timeoutMs === "number" && Number.isInteger(entry.timeoutMs) && entry.timeoutMs >= DISPATCH_INTENT_TIMEOUT_MIN_MS
   );
@@ -3104,7 +3384,11 @@ function normalizeDispatchIntent(raw, checks) {
   if (!Array.isArray(writeRoots)) return writeRoots;
   const relevantPaths = normalizePathList(raw.relevant_paths, "intent.relevant_paths");
   if (!Array.isArray(relevantPaths)) return relevantPaths;
-  const expectedOutputs = normalizePathList(raw.expected_outputs, "intent.expected_outputs");
+  const expectedOutputs = normalizePathList(
+    raw.expected_outputs,
+    "intent.expected_outputs",
+    normalizeExpectedOutputEntry
+  );
   if (!Array.isArray(expectedOutputs)) return expectedOutputs;
   const rawVerification = raw.verification ?? [];
   if (!Array.isArray(rawVerification)) {
@@ -3140,7 +3424,15 @@ function normalizeDispatchIntent(raw, checks) {
   }
   return {
     ok: true,
-    intent: { version: 1, readRoots, writeRoots, relevantPaths, expectedOutputs, verification }
+    intent: {
+      version: 2,
+      readRoots,
+      writeRoots,
+      relevantPaths,
+      pathProvenance: declaredIntentPathProvenance({ readRoots, writeRoots, relevantPaths }),
+      expectedOutputs,
+      verification
+    }
   };
 }
 
@@ -3419,8 +3711,8 @@ function validateJobSpec(spec) {
   }
   if (isDispatchIntent(spec.intent) && spec.intent.writeRoots.length > 0 && Array.isArray(spec.writeRoots)) {
     const jobCwd = typeof spec.cwd === "string" && spec.cwd.length > 0 ? spec.cwd : process.cwd();
-    const legacy = [...new Set(spec.writeRoots.map((root) => path3.resolve(jobCwd, String(root))))].sort();
-    const declared = [...new Set(spec.intent.writeRoots.map((root) => path3.resolve(jobCwd, root)))].sort();
+    const legacy = [...new Set(spec.writeRoots.map((root) => resolvePathBoundary(jobCwd, String(root))))].sort();
+    const declared = [...new Set(spec.intent.writeRoots.map((root) => resolvePathBoundary(jobCwd, root)))].sort();
     if (JSON.stringify(legacy) !== JSON.stringify(declared)) errors.push("intent_write_roots_contradiction");
   }
   if ("requestOrigin" in spec && spec.requestOrigin !== void 0) {
@@ -3514,7 +3806,7 @@ function validateJobSpec(spec) {
   const effectiveWriteRoots = Array.isArray(spec.writeRoots) && spec.writeRoots.length > 0 && spec.writeRoots.every((root) => typeof root === "string" && root.length > 0) ? spec.writeRoots : isDispatchIntent(spec.intent) && spec.intent.writeRoots.length > 0 ? spec.intent.writeRoots : void 0;
   if (effectiveWriteRoots !== void 0) {
     const jobCwd = typeof spec.cwd === "string" && spec.cwd.length > 0 ? spec.cwd : process.cwd();
-    out.writeRoots = effectiveWriteRoots.map((root) => path3.resolve(jobCwd, String(root)));
+    out.writeRoots = isDispatchIntent(spec.intent) ? effectiveWriteRoots.map((root) => resolvePathBoundary(jobCwd, String(root))) : effectiveWriteRoots.map((root) => asDirectoryPathBoundary(path3.resolve(jobCwd, String(root))));
   }
   if (typeof spec.requestOrigin === "string" && VALID_REQUEST_ORIGINS.has(spec.requestOrigin)) {
     out.requestOrigin = spec.requestOrigin;
@@ -4167,9 +4459,13 @@ export {
   REVIEWER_GATE_PROMPT,
   JUDGE_GATE_PROMPT,
   COUNCIL_JUDGE_PROMPT,
+  renderCouncilVoteMemberTask,
   COMPETE_STANCES,
   competeStanceLiner,
   isBoundedGateRolePrompt,
+  resolveDispatchPathScope,
+  declaredScopeReplacementDiagnostic,
+  declaredScopeReplacementNotice,
   isRunOutcomeCode,
   RETRYABLE_OUTCOMES,
   isTerminalRunEnvelope,
@@ -4180,4 +4476,4 @@ export {
   DISPATCH_BRIEFING_MAX_BYTES,
   validateJobSpec
 };
-//# sourceMappingURL=chunk-CEYBNUGC.js.map
+//# sourceMappingURL=chunk-A3WNZD3P.js.map

package/dist/{chunk-D4MDIG46.js → chunk-B5CSFE7B.js}

@@ -2,12 +2,12 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   clampTimerDelayMs
 } from "./chunk-FQ4SKYE4.js";
-import {
-  clioStateDir
-} from "./chunk-BNAZZHFG.js";
 import {
   AI_AGENT_NAME
 } from "./chunk-6EJMN2Y3.js";
+import {
+  clioStateDir
+} from "./chunk-BNAZZHFG.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -48,7 +48,7 @@ var KNOWN_CLIO_TRAILERS = new Set(
   Object.values(CLIO_COMMIT_TRAILERS).map((line) => normalizedTrailer(line)).filter((line) => line !== null)
 );
 function isClioTrailer(key) {
-  return KNOWN_CLIO_TRAILERS.has(key) || key.startsWith("clio-evidence:receipt-v19/sha256:");
+  return KNOWN_CLIO_TRAILERS.has(key) || key.startsWith("clio-evidence:receipt-v20/sha256:");
 }
 function trailerBlockStart(lines) {
   if (lines.length < 2) return null;
@@ -67,10 +67,10 @@ function trailerBlockStart(lines) {
   return sawTrailer ? first : null;
 }
 function receiptTrailer(receipt) {
-  if (receipt?.version !== 19 || receipt.algorithm !== "sha256" || receipt.integrityValid !== true || receipt.directlyRelevant !== true || !SHA256.test(receipt.digest)) {
+  if (receipt?.version !== 20 || receipt.algorithm !== "sha256" || receipt.integrityValid !== true || receipt.directlyRelevant !== true || !SHA256.test(receipt.digest)) {
     return null;
   }
-  return `Clio-Evidence: receipt-v19/sha256:${receipt.digest}`;
+  return `Clio-Evidence: receipt-v20/sha256:${receipt.digest}`;
 }
 function attributeCommitMessage(originalMessage, evidence, enabled = true) {
   if (!enabled) return originalMessage;
@@ -567,4 +567,4 @@ export {
   runCommandVector,
   combineSafeOutput
 };
-//# sourceMappingURL=chunk-D4MDIG46.js.map
+//# sourceMappingURL=chunk-B5CSFE7B.js.map

package/dist/{chunk-2SFS6XQE.js → chunk-DGSYXYMX.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   enabledExtensionResourceRoots
-} from "./chunk-ZWLZP4ZT.js";
+} from "./chunk-DYIM5TJT.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -29,6 +29,7 @@ function defaultScopedResourceRoots(kind, cwd) {
   return [
     ...enabledExtensionResourceRoots(kind, cwd).map((root) => ({
       path: root.path,
+      rootPath: root.rootPath,
       scope: "package",
       source: root.source,
       precedence: COMPAT_RESOURCE_PRECEDENCE.extension
@@ -119,4 +120,4 @@ export {
   splitYamlFrontmatter,
   stringField
 };
-//# sourceMappingURL=chunk-2SFS6XQE.js.map
+//# sourceMappingURL=chunk-DGSYXYMX.js.map