@iowarp/clio-coder 0.4.3 → 0.4.4

package/dist/chunk-IRXAATOX.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-HHV2GANA.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.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-IRXAATOX.js.map

package/dist/chunk-IXIY2H4R.js

@@ -0,0 +1,44 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  inspectEvidence
+} from "./chunk-NRO2BJRH.js";
+import {
+  TRUST_STATUS_AXES,
+  trustVerdict
+} from "./chunk-CUSRQKPU.js";
+import {
+  clioDataDir
+} from "./chunk-BYP5D4HI.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/evidence/detail.ts
+init_esm_shims();
+var EVIDENCE_DETAIL_MAX_RUNS = 16;
+async function evidenceDetailSnapshot(evidenceId, now = Date.now, dataDir = clioDataDir()) {
+  const inspected = await inspectEvidence(dataDir, evidenceId);
+  const all = inspected.trustStatus.runs;
+  const window = all.slice(0, EVIDENCE_DETAIL_MAX_RUNS);
+  return {
+    version: 1,
+    generatedAt: new Date(now()).toISOString(),
+    evidenceId: inspected.overview.evidenceId,
+    sourceKind: inspected.overview.source.kind,
+    canonical: inspected.trustStatus.projection === "canonical",
+    runs: window.map(
+      (run) => ({
+        runId: run.runId,
+        verdict: trustVerdict(run.status),
+        axes: Object.fromEntries(TRUST_STATUS_AXES.map((axis) => [axis, run.status[axis].state]))
+      })
+    ),
+    runsTruncated: all.length > window.length
+  };
+}
+
+export {
+  EVIDENCE_DETAIL_MAX_RUNS,
+  evidenceDetailSnapshot
+};
+//# sourceMappingURL=chunk-IXIY2H4R.js.map