@iowarp/clio-coder 0.3.7 → 0.3.9

package/dist/{chunk-CEYBNUGC.js → chunk-4H6ULJ3H.js}

@@ -1,33 +1,35 @@
 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-VPTUJU4P.js";
 import {
   deriveExecutionRole,
   isExecutionRole
-} from "./chunk-UND3GU2L.js";
+} from "./chunk-H7IXIC72.js";
+import {
+  typedValidationSummary
+} from "./chunk-7C6RYZGQ.js";
 import {
   expandPath,
   resolveReadPath
 } from "./chunk-OQE5J4C6.js";
-import {
-  DEFAULT_AUTONOMY_LEVEL,
-  autonomyAskRejection,
-  autonomyDenyRejection,
-  isAutonomyLevel,
-  mapAutonomy
-} from "./chunk-HWUFFB6L.js";
 import {
   AGENT_AUTOMATION_AUTHORITIES,
-  agentSpecFingerprint
-} from "./chunk-AOCYTWAV.js";
+  COUNCIL_BALLOT_SHAPE,
+  COUNCIL_BALLOT_VERDICT_MAX_BYTES,
+  PATH_BOUNDARY_MAX_ENTRIES,
+  PathBoundaryError,
+  agentSpecFingerprint,
+  asDirectoryPathBoundary,
+  classify,
+  normalizePathBoundaryEntry,
+  pathBoundaryCovers,
+  resolvePathBoundary
+} from "./chunk-S4COXYBG.js";
 import {
   detectValidationCommand,
   extractCommandDeleteTargets,
@@ -35,6 +37,13 @@ import {
   tokenizeShellLike,
   toolMutationPaths
 } from "./chunk-MV3K5QF2.js";
+import {
+  DEFAULT_AUTONOMY_LEVEL,
+  autonomyAskRejection,
+  autonomyDenyRejection,
+  isAutonomyLevel,
+  mapAutonomy
+} from "./chunk-RAPCMZL4.js";
 import {
   DEFAULT_MAX_LINES,
   OBSERVATION_POLICY_SLACK_BYTES,
@@ -62,26 +71,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-XDOQXGFO.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";
@@ -434,6 +443,12 @@ init_esm_shims();
 init_esm_shims();
 var RESPONSE_SCHEMA_MAX_SERIALIZED_BYTES = 64 * 1024;
 var RESPONSE_SCHEMA_RUNTIME_ID = "llamacpp";
+var OPENAI_SCHEMA_RUNTIME_ID = "lmstudio";
+function responseSchemaDialectFor(runtimeId) {
+  if (runtimeId === RESPONSE_SCHEMA_RUNTIME_ID) return "llamacpp-json-object";
+  if (runtimeId === OPENAI_SCHEMA_RUNTIME_ID) return "openai-json-schema";
+  return null;
+}
 function runtimeSpeaksResponseSchemaDialect(runtime) {
   return runtime.id === RESPONSE_SCHEMA_RUNTIME_ID && runtime.kind === "http" && runtime.apiFamily === "openai-completions";
 }
@@ -1400,6 +1415,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",
@@ -1502,6 +1526,34 @@ function sanitizeForDisplay(value) {
 function oneLine(value) {
   return value.replace(/\s+/g, " ").trim();
 }
+var DISPLAY_TAB_WIDTH = 4;
+var CONTROL_BYTE_PLACEHOLDER = "\xB7";
+function sanitizeMultilineDisplayText(value) {
+  const escapesStripped = value.replace(OSC_PATTERN, "").replace(CSI_PATTERN, "");
+  let neutralized = escapesStripped.length !== value.length;
+  const stripped = escapesStripped.replace(/\r\n/g, "\n");
+  let tabsExpanded = false;
+  let out = "";
+  for (const ch of stripped) {
+    if (ch === "\n") {
+      out += ch;
+      continue;
+    }
+    if (ch === "	") {
+      out += " ".repeat(DISPLAY_TAB_WIDTH);
+      tabsExpanded = true;
+      continue;
+    }
+    const code = ch.codePointAt(0) ?? 0;
+    if (code < 32 || code === 127) {
+      out += CONTROL_BYTE_PLACEHOLDER;
+      neutralized = true;
+      continue;
+    }
+    out += ch;
+  }
+  return { text: out, neutralized, tabsExpanded };
+}
 function sanitizeCallTargetText(value) {
   return oneLine(sanitizeForDisplay(value));
 }
@@ -2716,6 +2768,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 = [];
@@ -2763,23 +2819,28 @@ function validationCommandOf(toolName, args, scope) {
   }
   return typedValidationSummary(toolName, { args: args ?? {} });
 }
-function createRunEffectsRecorder(cwd) {
+function createRunEffectsRecorder(cwd, options = {}) {
   const pending = /* @__PURE__ */ new Map();
   const mutatedPaths = /* @__PURE__ */ new Set();
   const failedMutationPaths = /* @__PURE__ */ new Set();
   const validationCommands = /* @__PURE__ */ new Set();
   const verificationCommands = /* @__PURE__ */ new Set();
+  const writeRecordDowngrades = /* @__PURE__ */ new Map();
   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, {
+        tool: toolName,
+        toolCallId,
         paths: paths.map((target) => path.resolve(base, target)),
         validationCommand,
-        verificationCommand
+        verificationCommand,
+        opaque
       });
     },
     finish(toolCallId, failed) {
@@ -2790,6 +2851,16 @@ function createRunEffectsRecorder(cwd) {
         for (const target of effects.paths) failedMutationPaths.add(target);
         return;
       }
+      if (effects.opaque) {
+        const downgrade = {
+          reason: "opaque_tool_succeeded",
+          tool: effects.tool,
+          toolCallId: effects.toolCallId
+        };
+        const recordWasComplete = writeRecordDowngrades.size === 0;
+        writeRecordDowngrades.set(effects.toolCallId, downgrade);
+        if (recordWasComplete) options.onWriteRecordDowngraded?.({ ...downgrade });
+      }
       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 +2870,9 @@ 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: writeRecordDowngrades.size === 0,
+        writeRecordDowngrades: [...writeRecordDowngrades.values()].map((entry) => ({ ...entry }))
       };
     }
   };
@@ -3031,10 +3104,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 +3334,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 +3345,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 +3383,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 +3391,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 +3428,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 +3468,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 +3755,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 +3850,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;
@@ -4103,12 +4439,14 @@ function agentRoleReadinessReport(entries) {
 
 export {
   RESPONSE_SCHEMA_RUNTIME_ID,
+  responseSchemaDialectFor,
   runtimeSpeaksResponseSchemaDialect,
   responseSchemaConflictsWithTools,
   UnsupportedResponseSchemaError,
   isResponseSchemaRejection,
   redactSecretString,
   redactToolArgs,
+  sanitizeMultilineDisplayText,
   sanitizeCallTargetText,
   describeCallAction,
   describeCallTarget,
@@ -4167,9 +4505,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 +4522,4 @@ export {
   DISPATCH_BRIEFING_MAX_BYTES,
   validateJobSpec
 };
-//# sourceMappingURL=chunk-CEYBNUGC.js.map
+//# sourceMappingURL=chunk-4H6ULJ3H.js.map

package/dist/{chunk-YTYFXUI3.js → chunk-4LJX2PUC.js}

@@ -1,29 +1,29 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  parseTomlDocument,
-  tomlTableAt
-} from "./chunk-LCGCVYZ4.js";
 import {
   verifyTool
-} from "./chunk-UFQ3F4FW.js";
+} from "./chunk-NQ6UCCOD.js";
 import {
   discoverDeclaredChecksAtRoot,
   discoverDeclaredProjectEntriesAtRoot
-} from "./chunk-PD3MESLB.js";
+} from "./chunk-P3JGPQFL.js";
+import {
+  parseTomlDocument,
+  tomlTableAt
+} from "./chunk-LCGCVYZ4.js";
 import {
   PROJECT_VERIFIER_CATALOG_CAPS,
   PROJECT_VERIFIER_CATALOG_RELATIVE_PATH,
   PROJECT_VERIFIER_CATALOG_VERSION,
   compareCodepoints,
   parseProjectVerifierCatalogText
-} from "./chunk-GH5622CP.js";
+} from "./chunk-A2NJGIB3.js";
 import {
   isVerificationScriptName
 } from "./chunk-UL3WSD3F.js";
 import {
   SAFE_EXEC_DEFAULT_TIMEOUT_MS,
   resolveSafeCwd
-} from "./chunk-D4MDIG46.js";
+} from "./chunk-B5CSFE7B.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -960,4 +960,4 @@ export {
   previewVerifierDraft,
   runVerifierAuthoringWorkflow
 };
-//# sourceMappingURL=chunk-YTYFXUI3.js.map
+//# sourceMappingURL=chunk-4LJX2PUC.js.map

package/dist/{chunk-DOOEX22V.js → chunk-56KB5IJP.js}

@@ -1,7 +1,10 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  readClioVersion
+} from "./chunk-IWHMRKLL.js";
 import {
   DEFAULT_SETTINGS_YAML
-} from "./chunk-4DGYLA73.js";
+} from "./chunk-XDOQXGFO.js";
 import {
   clioCacheDir,
   clioConfigDir,
@@ -9,9 +12,6 @@ import {
   clioStateDir,
   resolveClioDirs
 } from "./chunk-BNAZZHFG.js";
-import {
-  readClioVersion
-} from "./chunk-IWHMRKLL.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -143,4 +143,4 @@ function enforceHomePrefixGuard() {
 export {
   initializeClioHome
 };
-//# sourceMappingURL=chunk-DOOEX22V.js.map
+//# sourceMappingURL=chunk-56KB5IJP.js.map