@iowarp/clio-coder 0.4.3 → 0.4.5

package/dist/{chunk-7E7I3WLS.js → chunk-KYKNBD4Y.js}

@@ -1,22 +1,15 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  createLifecyclePresenter,
-  shortenPath
-} from "./chunk-SKHCAU7K.js";
 import {
   createDelayedManualCodeInput,
   promptOAuthSelection
-} from "./chunk-2STGEDFV.js";
+} from "./chunk-QEQISF75.js";
 import {
-  column,
-  terminalColumns,
-  truncate,
-  twoColumnRow,
-  wrapPlain
-} from "./chunk-2IR2NMPA.js";
+  createLifecyclePresenter,
+  shortenPath
+} from "./chunk-6YA46L5A.js";
 import {
   fingerprintNativeRuntime
-} from "./chunk-NEKRRTYW.js";
+} from "./chunk-MC3JSVR6.js";
 import {
   INHERITED_PROJECT_CONTEXT,
   acceptInteropAgents,
@@ -25,47 +18,55 @@ import {
   interopProposals,
   renderProposalEntry,
   resolveOnPath
-} from "./chunk-INY6HTFL.js";
+} from "./chunk-6SYEGZI3.js";
 import {
   initializeClioHome
-} from "./chunk-I7XBWTYH.js";
+} from "./chunk-T53XI6I7.js";
+import {
+  column,
+  terminalColumns,
+  truncate,
+  twoColumnRow,
+  wrapPlain
+} from "./chunk-ZIDFQJRB.js";
 import {
   credentialWriteFailed,
   printPlaintextCredentialWarning
-} from "./chunk-PUVDKJ2Y.js";
+} from "./chunk-5VTJP36Q.js";
 import {
   printError,
-  printOk
-} from "./chunk-VPKWYKEY.js";
-import {
+  printOk,
   source_default
-} from "./chunk-5TSRNF4G.js";
+} from "./chunk-3T4DXWP6.js";
 import {
   isOrchestratorEligibleRuntime,
   probeCapabilitiesForModel,
   readTargetModelSnapshot,
   recordTargetModelSnapshot
-} from "./chunk-XPWWI35G.js";
+} from "./chunk-TEG3RYVZ.js";
 import {
   credentialsPresent
-} from "./chunk-2JH2WHGE.js";
+} from "./chunk-J2FYEQ5L.js";
 import {
   bindAgentProfileInSettings,
   readSettings,
   removeTargetFromSettings,
   settingsPath,
   updateSettings
-} from "./chunk-GHS5EBTQ.js";
+} from "./chunk-FKIOX6DS.js";
+import {
+  warnLegacyNaming
+} from "./chunk-DVNAPPXU.js";
 import {
   getVersionInfo
-} from "./chunk-XPLRXC72.js";
+} from "./chunk-GD55RTIW.js";
 import {
   greetLmStudio,
   registerBuiltinRuntimes
-} from "./chunk-VW6DOEDG.js";
+} from "./chunk-ICO4TQ2F.js";
 import {
   THINKING_LEVELS
-} from "./chunk-UXCU4E3T.js";
+} from "./chunk-SE4ZKILO.js";
 import {
   buildProviderSupportEntry,
   configuredTargetsForRuntime,
@@ -73,7 +74,7 @@ import {
   listKnownModelsForRuntime,
   listProviderSupportEntries,
   supportGroupLabel
-} from "./chunk-LLDJM5XK.js";
+} from "./chunk-HHVJNVUJ.js";
 import {
   authStoragePath,
   openAuthStorage,
@@ -81,19 +82,19 @@ import {
   resolveAuthTarget,
   resolveRuntimeAuthTarget,
   targetRequiresAuth
-} from "./chunk-ID64D7PE.js";
+} from "./chunk-HXHFDHB6.js";
 import {
   getRuntimeRegistry
-} from "./chunk-NUGM5KR6.js";
+} from "./chunk-SRCEQKQS.js";
 import {
   getCatalogModelForRuntime
-} from "./chunk-5OIVVPHF.js";
+} from "./chunk-TN5FW4XY.js";
 import {
   resolveClioDirs
-} from "./chunk-BYP5D4HI.js";
+} from "./chunk-CTTI7G3T.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/cli/configure.ts
 init_esm_shims();
@@ -3489,7 +3490,7 @@ var SECTIONS = [
         label: "Run doctor",
         hint: "read-only health check",
         run: async () => {
-          const { runDoctorCommand } = await import("./doctor-WNNVO6FY.js");
+          const { runDoctorCommand } = await import("./doctor-N3LCM2LG.js");
           await runDoctorCommand([]);
         }
       },
@@ -3731,7 +3732,7 @@ async function runConfigureCommand(argv, inStream = input, outStream = output2)
       return 2;
     }
     if (runtimeId === "lmstudio-native" && runtime.id === "lmstudio") {
-      process.stderr.write("warning: runtime 'lmstudio-native' is deprecated; using 'lmstudio'\n");
+      warnLegacyNaming(runtimeId, runtime.id);
     }
   }
   const hasTargetSetupFlag = args.id !== void 0 || args.url !== void 0 || args.model !== void 0 || args.workerProfile !== void 0 || args.workerProfileModel !== void 0 || args.apiKey !== void 0 || args.apiKeyEnv !== void 0 || args.gateway || args.lifecycle !== void 0 || args.setOrchestrator || args.setWorkerDefault || args.contextWindow !== void 0 || args.maxTokens !== void 0 || args.reasoning !== void 0;
@@ -3755,8 +3756,9 @@ async function runConfigureCommand(argv, inStream = input, outStream = output2)
 }
 
 export {
+  resolveSupportedWireModels,
   runTargetRemove,
   runTargetRename,
   runConfigureCommand
 };
-//# sourceMappingURL=chunk-7E7I3WLS.js.map
+//# sourceMappingURL=chunk-KYKNBD4Y.js.map

package/dist/chunk-L4N3DWNW.js

@@ -0,0 +1,539 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  PATH_BOUNDARY_MAX_ENTRIES,
+  PathBoundaryError,
+  asDirectoryPathBoundary,
+  normalizePathBoundaryEntry,
+  pathBoundaryCovers,
+  resolvePathBoundary
+} from "./chunk-R2P2U3ZS.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/dispatch/intent.ts
+init_esm_shims();
+import path from "node:path";
+
+// src/domains/dispatch/path-scope.ts
+init_esm_shims();
+import { existsSync } from "node:fs";
+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 PARENT_PREFIX_RE = /^(?:\.\.\/)+/u;
+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, path2, evidence) {
+  const current = entries.get(path2);
+  if (current === void 0) {
+    entries.set(path2, { path: path2, 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 path2 of input.readRoots) addProvenance(entries, path2, DECLARED_EVIDENCE.readRoots);
+  for (const path2 of input.writeRoots) addProvenance(entries, path2, DECLARED_EVIDENCE.writeRoots);
+  for (const path2 of input.relevantPaths) addProvenance(entries, path2, DECLARED_EVIDENCE.relevantPaths);
+  return sortedEntries(entries);
+}
+function inferredPaths(req, root) {
+  const paths = /* @__PURE__ */ new Set();
+  const droppedTokens = /* @__PURE__ */ new Set();
+  const text = `${req.task}
+${req.briefing ?? ""}`;
+  for (const match of text.matchAll(DISPATCH_PATH_TOKEN_RE)) {
+    const inferred = inferredPathToken(match[0], root);
+    if (inferred.kind === "dropped") {
+      droppedTokens.add(inferred.token);
+      continue;
+    }
+    const token = inferred.kind === "anchored" ? inferred.resolved : inferred.token;
+    if (token.startsWith("http://") || token.startsWith("https://")) continue;
+    paths.add(token);
+  }
+  return { paths: [...paths], droppedTokens: [...droppedTokens] };
+}
+function inferredPathToken(raw, root) {
+  const token = raw.replace(/^\.\//u, "").replace(/\.+$/u, "");
+  const parents = PARENT_PREFIX_RE.exec(token)?.[0];
+  if (parents === void 0) return { kind: "token", token };
+  const rest = token.slice(parents.length);
+  const segments = rest.split("/");
+  if (rest.length === 0 || segments.includes("..") || segments.includes(".")) return { kind: "token", token };
+  return existsSync(resolvePathBoundary(root, rest)) ? { kind: "anchored", token, resolved: rest } : { kind: "dropped", token };
+}
+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, root) {
+  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 paths = [];
+  const parentTokens = [];
+  for (const match of withoutUrls.matchAll(DISPATCH_PATH_TOKEN_RE)) {
+    const inferred = inferredPathToken(match[0], root);
+    if (inferred.kind === "dropped") {
+      parentTokens.push({ token: inferred.token, resolved: null, source });
+      continue;
+    }
+    if (inferred.kind === "anchored") {
+      parentTokens.push({ token: inferred.token, resolved: inferred.resolved, source });
+    }
+    const token = inferred.kind === "anchored" ? inferred.resolved : inferred.token;
+    try {
+      paths.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 { paths, parentTokens };
+}
+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);
+  }
+  const parentTokens = /* @__PURE__ */ new Map();
+  const recordParentTokens = (entries) => {
+    for (const entry of entries) if (!parentTokens.has(entry.token)) parentTokens.set(entry.token, entry);
+  };
+  const taskScope = strictInferredPaths(req.task, "task", cwd);
+  for (const candidate of taskScope.paths) addProvenance(workingEntries, candidate.path, candidate.evidence);
+  recordParentTokens(taskScope.parentTokens);
+  if (req.briefing !== void 0) {
+    const briefingScope = strictInferredPaths(req.briefing, "briefing", cwd);
+    for (const candidate of briefingScope.paths) addProvenance(workingEntries, candidate.path, candidate.evidence);
+    recordParentTokens(briefingScope.parentTokens);
+  }
+  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: [],
+    parentTokens: [...parentTokens.values()],
+    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 inferred = inferredPaths(req, cwd);
+  const inferredOnlyPaths = [
+    ...inferred.paths.filter((candidate) => !pathBoundaryCovers(declaredPaths, candidate)),
+    ...inferred.droppedTokens
+  ];
+  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,
+    // Empty on purpose: the declaration is the scope here, so no "../" token
+    // changed what the worker sees and there is nothing for the legacy notice
+    // to report. A dropped one still reaches the operator through
+    // inferredOnlyPaths above.
+    parentTokens: [],
+    provenance: {
+      version: 1,
+      mode: "declared",
+      workingContextPaths: declaredProvenance,
+      writeBoundaries
+    }
+  };
+}
+var REPORTABLE_OMITTED_PATH_RE = /\.(?:[cm]?[jt]sx?|json|ya?ml|md|txt|py|go|rs|c|h|cc|cpp|hpp|java|rb|sh|toml|css|html|sql|lock)(?:\/|$)|\/$/u;
+var OMITTED_PATH_REPORT_CAP = 12;
+function reportableOmittedPaths(scope) {
+  return scope.inferredOnlyPaths.filter((path2) => REPORTABLE_OMITTED_PATH_RE.test(path2));
+}
+function renderOmittedPaths(paths) {
+  if (paths.length <= OMITTED_PATH_REPORT_CAP) return paths.join(", ");
+  return `${paths.slice(0, OMITTED_PATH_REPORT_CAP).join(", ")} and ${paths.length - OMITTED_PATH_REPORT_CAP} more`;
+}
+function declaredScopeReplacementDiagnostic(scope) {
+  if (scope.source !== "declared") return null;
+  const omitted = reportableOmittedPaths(scope);
+  if (omitted.length === 0) return null;
+  return `typed_scope_replaced_inferred_paths: typed intent omitted prose-inferred paths ${renderOmittedPaths(
+    omitted
+  )}; those paths did not select project rules or expand worker authority`;
+}
+function declaredScopeReplacementNotice(scope) {
+  if (scope.source !== "declared") return null;
+  const omittedPaths = reportableOmittedPaths(scope);
+  if (omittedPaths.length === 0) return null;
+  return {
+    code: "typed_scope_replaced_inferred_paths",
+    level: "warning",
+    omittedPaths,
+    message: `[dispatch scope] typed intent replaced prose path inference; omitted paths: ${renderOmittedPaths(
+      omittedPaths
+    )}. Those paths did not select project rules or expand worker authority.`
+  };
+}
+function renderParentTokens(tokens) {
+  return renderOmittedPaths(tokens.map((entry) => `${entry.token} -> ${entry.resolved ?? "dropped"}`));
+}
+function inferredScopeParentTokenDiagnostic(scope) {
+  const tokens = scope.parentTokens;
+  if (tokens.length === 0) return null;
+  return `legacy_scope_inferred: prose inference resolved path tokens carrying a leading '../' run against the dispatch root ${renderParentTokens(
+    tokens
+  )}; an anchored token selects project rules without expanding worker authority and a dropped one took no part in scope`;
+}
+function inferredScopeParentTokenNotice(scope) {
+  const tokens = scope.parentTokens;
+  if (tokens.length === 0) return null;
+  return {
+    code: "legacy_scope_inferred",
+    level: "warning",
+    // Every entry names the raw prose token, the one spelling both outcomes
+    // share; the message carries what each one resolved to.
+    paths: tokens.map((entry) => ({
+      path: entry.token,
+      policy: "working-context",
+      provenance: "inferred",
+      source: entry.source,
+      confidence: "low"
+    })),
+    message: `[dispatch scope] prose inference resolved path tokens carrying a leading '../' run against the dispatch root: ${renderParentTokens(
+      tokens
+    )}. An anchored token selects project rules without expanding worker authority; a dropped one took no part in scope.`
+  };
+}
+
+// src/domains/dispatch/intent.ts
+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;
+var RAW_FIELDS = /* @__PURE__ */ new Set([
+  "version",
+  "read_roots",
+  "write_roots",
+  "relevant_paths",
+  "expected_outputs",
+  "verification"
+]);
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function compareCodepoints(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function fail(reason, message) {
+  return { ok: false, reason, message };
+}
+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`);
+  }
+  const trimmed = value.trim();
+  if (Buffer.byteLength(trimmed, "utf8") > DISPATCH_INTENT_PATH_ENTRY_BYTES_CAP) {
+    return fail(
+      "intent_path_over_cap",
+      `${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("\\") || path.posix.isAbsolute(trimmed) || path.win32.isAbsolute(trimmed)) {
+    return fail("intent_path_absolute", `${field}[${index}] must be a repository-relative POSIX path`);
+  }
+  const normalized = path.posix.normalize(trimmed.replace(/^\.\//u, "").replace(/\/{2,}/gu, "/"));
+  if (normalized === "." || normalized.length === 0) {
+    return fail("intent_path_malformed", `${field}[${index}] must not normalize to an empty path`);
+  }
+  if (normalized === ".." || normalized.startsWith("../") || normalized.split("/").includes("..")) {
+    return fail("intent_path_escapes_root", `${field}[${index}] escapes the repository root`);
+  }
+  return normalized;
+}
+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) {
+    return fail("intent_path_over_cap", `${field} exceeds the ${DISPATCH_INTENT_PATH_LIST_CAP}-entry cap`);
+  }
+  const normalized = [];
+  for (const [index, entry] of value.entries()) {
+    if (normalizeEntry === normalizeScopePathEntry && typeof entry === "string" && /^\.\/?$/u.test(entry.trim())) {
+      continue;
+    }
+    const result = normalizeEntry(entry, field, index);
+    if (typeof result !== "string") return result;
+    normalized.push(result);
+  }
+  return [...new Set(normalized)].sort(compareCodepoints);
+}
+function declaredScopeIntent(input) {
+  const readRoots = normalizePathList(input.readRoots, "intent.read_roots");
+  if (!Array.isArray(readRoots)) return readRoots;
+  const writeRoots = normalizePathList(input.writeRoots, "intent.write_roots");
+  if (!Array.isArray(writeRoots)) return writeRoots;
+  const relevantPaths = normalizePathList(input.relevantPaths, "intent.relevant_paths");
+  if (!Array.isArray(relevantPaths)) return relevantPaths;
+  return {
+    ok: true,
+    intent: {
+      version: 2,
+      readRoots,
+      writeRoots,
+      relevantPaths,
+      pathProvenance: declaredIntentPathProvenance({ readRoots, writeRoots, relevantPaths }),
+      expectedOutputs: [],
+      verification: []
+    }
+  };
+}
+function isDispatchIntent(value) {
+  if (!isRecord(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) => isRecord(entry) && typeof entry.check === "string" && entry.check.length > 0 && typeof entry.timeoutMs === "number" && Number.isInteger(entry.timeoutMs) && entry.timeoutMs >= DISPATCH_INTENT_TIMEOUT_MIN_MS
+  );
+}
+function narrowDispatchIntentToReadOnly(intent) {
+  if (intent.writeRoots.length === 0) return intent;
+  const readRoots = [.../* @__PURE__ */ new Set([...intent.readRoots, ...intent.writeRoots])].sort(compareCodepoints);
+  return {
+    version: 2,
+    readRoots,
+    writeRoots: [],
+    relevantPaths: [...intent.relevantPaths],
+    pathProvenance: declaredIntentPathProvenance({ readRoots, writeRoots: [], relevantPaths: intent.relevantPaths }),
+    expectedOutputs: [...intent.expectedOutputs],
+    verification: intent.verification.map((entry) => ({ ...entry }))
+  };
+}
+function normalizeDispatchIntent(raw, checks) {
+  if (!isRecord(raw)) return fail("intent_malformed", "intent must be an object");
+  const unknown = Object.keys(raw).filter((key) => !RAW_FIELDS.has(key)).sort(compareCodepoints);
+  if (unknown.length > 0) return fail("intent_malformed", `intent contains unknown field '${unknown[0]}'`);
+  if (raw.version !== void 0 && raw.version !== 2) {
+    return fail(
+      "intent_version_unsupported",
+      `intent declares version ${JSON.stringify(raw.version)}; this build speaks dispatch intent version 2. A declaration at another version is refused rather than migrated: restate read_roots, write_roots, relevant_paths, expected_outputs, and verification under version 2`
+    );
+  }
+  const readRoots = normalizePathList(raw.read_roots, "intent.read_roots");
+  if (!Array.isArray(readRoots)) return readRoots;
+  const writeRoots = normalizePathList(raw.write_roots, "intent.write_roots");
+  if (!Array.isArray(writeRoots)) return writeRoots;
+  const relevantPaths = normalizePathList(raw.relevant_paths, "intent.relevant_paths");
+  if (!Array.isArray(relevantPaths)) return relevantPaths;
+  const expectedOutputs = normalizeIntentExpectedOutputs(raw.expected_outputs);
+  if (!Array.isArray(expectedOutputs)) return expectedOutputs;
+  const verification = normalizeIntentVerification(raw.verification, checks);
+  if (!Array.isArray(verification)) return verification;
+  return {
+    ok: true,
+    intent: {
+      version: 2,
+      readRoots,
+      writeRoots,
+      relevantPaths,
+      pathProvenance: declaredIntentPathProvenance({ readRoots, writeRoots, relevantPaths }),
+      expectedOutputs,
+      verification
+    }
+  };
+}
+function normalizeIntentExpectedOutputs(raw) {
+  return normalizePathList(raw, "intent.expected_outputs", normalizeExpectedOutputEntry);
+}
+function normalizeIntentVerification(raw, checks) {
+  const rawVerification = raw ?? [];
+  if (!Array.isArray(rawVerification)) {
+    return fail("verification_malformed", "intent.verification must be an array");
+  }
+  if (rawVerification.length > DISPATCH_INTENT_VERIFICATION_CAP) {
+    return fail("verification_over_cap", `intent.verification exceeds the ${DISPATCH_INTENT_VERIFICATION_CAP}-entry cap`);
+  }
+  const verification = [];
+  for (const [index, entry] of rawVerification.entries()) {
+    if (!isRecord(entry) || Object.keys(entry).some((key) => key !== "check" && key !== "timeout_ms")) {
+      return fail("verification_malformed", `intent.verification[${index}] must contain check and optional timeout_ms`);
+    }
+    if (typeof entry.check !== "string" || entry.check.trim().length === 0) {
+      return fail("verification_malformed", `intent.verification[${index}].check must be a non-empty declared id`);
+    }
+    const check = entry.check.trim();
+    const declared = checks.get(check);
+    if (declared === void 0 && check.toLowerCase() === "none") continue;
+    if (declared === void 0) {
+      return fail(
+        "verification_check_undeclared",
+        `verification check '${check}' is undeclared: intent.verification takes only check ids that verify() lists (package.json verification scripts or .clio-coder/verifiers.yaml entries), never a shell command; omit verification and run the check yourself after the receipt, or declare the check first`
+      );
+    }
+    if (entry.timeout_ms !== void 0 && (typeof entry.timeout_ms !== "number" || !Number.isInteger(entry.timeout_ms) || entry.timeout_ms <= 0)) {
+      return fail("verification_malformed", `intent.verification[${index}].timeout_ms must be a positive integer`);
+    }
+    const requested = typeof entry.timeout_ms === "number" ? entry.timeout_ms : declared.timeoutMs;
+    verification.push({
+      check,
+      timeoutMs: Math.min(declared.timeoutMs, Math.max(DISPATCH_INTENT_TIMEOUT_MIN_MS, requested))
+    });
+  }
+  return verification;
+}
+
+export {
+  resolveDispatchPathScope,
+  declaredScopeReplacementDiagnostic,
+  declaredScopeReplacementNotice,
+  inferredScopeParentTokenDiagnostic,
+  inferredScopeParentTokenNotice,
+  DISPATCH_INTENT_TIMEOUT_MIN_MS,
+  declaredScopeIntent,
+  isDispatchIntent,
+  narrowDispatchIntentToReadOnly,
+  normalizeDispatchIntent,
+  normalizeIntentExpectedOutputs,
+  normalizeIntentVerification
+};
+//# sourceMappingURL=chunk-L4N3DWNW.js.map