@iowarp/clio-coder 0.4.3 → 0.4.5

package/dist/{chunk-UXCU4E3T.js → chunk-SE4ZKILO.js}

@@ -1,13 +1,13 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   DEFAULT_WORKING_SET_SETTINGS
-} from "./chunk-LL4KHSZI.js";
+} from "./chunk-U2MSJ57E.js";
 import {
   GUARDRAIL_DEFAULTS
-} from "./chunk-S66XZJOF.js";
+} from "./chunk-C27U2TYG.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/core/defaults.ts
 init_esm_shims();
@@ -37,7 +37,7 @@ var THEME_NAMED_COLORS = [
   "frameStrong"
 ];
 var DEFAULT_DELEGATION_CONNECT_TIMEOUT_MS = 3e4;
-var DEFAULT_DELEGATION_TURN_TIMEOUT_MS = 3e5;
+var DEFAULT_DELEGATION_TURN_TIMEOUT_MS = 0;
 var DEFAULT_DELEGATION_PERMISSION_TIMEOUT_MS = 12e4;
 var ACTIVE_ROUTING_ROLES = ["researcher", "verifier", "reviewer", "judge"];
 var ACTIVE_ROUTING_POSTURES = ["quality", "balanced", "latency", "economy"];
@@ -274,7 +274,7 @@ integrations:
     entries: []
     defaults:
       connectTimeoutMs: 30000
-      turnTimeoutMs: 300000
+      turnTimeoutMs: 0
       permissionTimeoutMs: 120000
       toolGovernance: clio-coder-policy
   runtimePlugins: []
@@ -300,4 +300,4 @@ export {
   DEFAULT_SETTINGS,
   DEFAULT_SETTINGS_YAML
 };
-//# sourceMappingURL=chunk-UXCU4E3T.js.map
+//# sourceMappingURL=chunk-SE4ZKILO.js.map

package/dist/chunk-SL2RDHKO.js

@@ -0,0 +1,19 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/tools/network-policy.ts
+init_esm_shims();
+var NO_NETWORK_TOOLS_ENV = "CLIO_CODER_DISABLE_RETRIEVE_TOOLS";
+function networkToolsDisabled(env = process.env) {
+  return env[NO_NETWORK_TOOLS_ENV] === "1" || env.CLIO_CODER_NO_NETWORK_TOOLS === "1";
+}
+var WEB_FETCH_ALLOW_PRIVATE_NETWORK_ENV = "CLIO_CODER_WEB_FETCH_ALLOW_PRIVATE_NETWORK";
+
+export {
+  NO_NETWORK_TOOLS_ENV,
+  networkToolsDisabled,
+  WEB_FETCH_ALLOW_PRIVATE_NETWORK_ENV
+};
+//# sourceMappingURL=chunk-SL2RDHKO.js.map

package/dist/{chunk-NUGM5KR6.js → chunk-SRCEQKQS.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/providers/registry.ts
 init_esm_shims();
@@ -162,4 +162,4 @@ export {
   createRuntimeRegistry,
   getRuntimeRegistry
 };
-//# sourceMappingURL=chunk-NUGM5KR6.js.map
+//# sourceMappingURL=chunk-SRCEQKQS.js.map

package/dist/{chunk-KKOJXO6R.js → chunk-SRZOW5L2.js}

@@ -2,27 +2,27 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   ensureYaziProfile,
   yaziProfileDir
-} from "./chunk-3M6DQK6S.js";
+} from "./chunk-T334FW2H.js";
 import {
   describeResolution,
   resolveToolBinary,
   toolStatus
-} from "./chunk-QSNYB6ZV.js";
+} from "./chunk-XCUDZQLX.js";
 import {
   findPinnedTool
-} from "./chunk-QDC3K2U3.js";
+} from "./chunk-K2BLQC5E.js";
 import {
   namingCompatibilityEnvironment
-} from "./chunk-D7E7WCDF.js";
+} from "./chunk-DVNAPPXU.js";
 import {
   resolvePackageRoot
-} from "./chunk-IWHMRKLL.js";
+} from "./chunk-E3LEPLQ2.js";
 import {
   clioCacheDir
-} from "./chunk-BYP5D4HI.js";
+} from "./chunk-CTTI7G3T.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/mux/index.ts
 init_esm_shims();
@@ -136,11 +136,13 @@ function createDockController(options) {
       const geometry = await client.paneLayout(anchorPaneId);
       const anchorRect = geometry.panes.find((pane2) => pane2.paneId === anchorPaneId)?.rect;
       if (!anchorRect) {
+        openOptions.onRefused?.(`no anchor geometry for ${anchorPaneId}; check the pane host layout before trying again`);
         log("debug", `mux ${slot} dock open found no anchor rect for ${anchorPaneId}`);
         return null;
       }
       const plan = planDockOpen(anchorRect, spec, openOptions.share);
       if ("refused" in plan) {
+        openOptions.onRefused?.(`${plan.refused}; enlarge the anchor pane before trying again`);
         log("info", `mux ${slot} dock refused: ${plan.refused}`);
         return null;
       }
@@ -379,7 +381,7 @@ function createMuxRuntime(options) {
     if (stopped || client === null || detection.mode === "none") return false;
     return healthy || now() >= probeHealthAt;
   };
-  const attempt = async (what, run, fallback) => {
+  const attempt = async (what, run, fallback, onError) => {
     if (!usable() || client === null) return fallback;
     try {
       const value = await run(client);
@@ -387,6 +389,7 @@ function createMuxRuntime(options) {
       return value;
     } catch (error) {
       degrade(what, error);
+      onError?.(error);
       return fallback;
     }
   };
@@ -437,6 +440,12 @@ function createMuxRuntime(options) {
       return detection;
     },
     async openUtilityPane(request) {
+      const report = (failure) => {
+        try {
+          request.onFailure?.(failure);
+        } catch {
+        }
+      };
       const dockSlot = request.dock?.slot;
       if (dockSlot && docks) {
         const existing = docks.stateFor(dockSlot);
@@ -449,6 +458,7 @@ function createMuxRuntime(options) {
           let ref;
           if (request.dock && docks) {
             const placed = await docks.open(request.dock.slot, {
+              onRefused: (message) => report({ source: "local", message }),
               ...request.dock.share === void 0 ? {} : { share: request.dock.share },
               cwd: request.cwd,
               ...request.env ? { env: request.env } : {}
@@ -484,7 +494,20 @@ function createMuxRuntime(options) {
           }
           return ref;
         },
-        null
+        null,
+        (error) => {
+          if (error instanceof MuxError) {
+            report({
+              source: "mux",
+              kind: error.kind,
+              wireCode: error.wireCode,
+              method: error.method,
+              message: error.message
+            });
+          } else {
+            report({ source: "local", message: error instanceof Error ? error.message : String(error) });
+          }
+        }
       );
     },
     async closePane(paneId) {
@@ -1040,9 +1063,16 @@ function createMuxClient(options) {
             const error = asRecord(line.error);
             if (responseId !== id && !(responseId === "" && error)) return;
             if (error) {
-              const code = typeof error.code === "string" ? error.code : "unknown";
-              const message = typeof error.message === "string" ? error.message : code;
-              finish(() => reject(new MuxError(muxErrorKind(code), message, { wireCode: code, method })));
+              const code = typeof error.code === "string" ? error.code : void 0;
+              const message = typeof error.message === "string" ? error.message : "no failure message was supplied by the pane host";
+              finish(
+                () => reject(
+                  new MuxError(muxErrorKind(code ?? "unknown"), message, {
+                    ...code === void 0 ? {} : { wireCode: code },
+                    method
+                  })
+                )
+              );
               return;
             }
             finish(() => resolve(line.result));
@@ -1390,7 +1420,9 @@ async function detectMux(options = {}) {
     return { detection: none("panes are turned off"), client: null };
   }
   if (enabled === "embedded") {
-    log("info", "interface.panes.enabled=embedded is not implemented yet; detecting a guest pane host instead");
+    const reason = "embedded pane hosting is not implemented; use auto or guest";
+    log("warning", reason);
+    return { detection: none(reason, [], true), client: null };
   }
   if (env.HERDR_ENV !== "1") {
     return { detection: none("HERDR_ENV is not 1, so Clio is not running inside a pane host"), client: null };
@@ -1830,4 +1862,4 @@ export {
   createYaziSession,
   createMuxDomainModule
 };
-//# sourceMappingURL=chunk-KKOJXO6R.js.map
+//# sourceMappingURL=chunk-SRZOW5L2.js.map

package/dist/{chunk-3M6DQK6S.js → chunk-T334FW2H.js}

@@ -1,24 +1,24 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   parseTomlDocument
-} from "./chunk-LCGCVYZ4.js";
+} from "./chunk-LQTKDAUO.js";
 import {
   resolveToolBinary
-} from "./chunk-QSNYB6ZV.js";
+} from "./chunk-XCUDZQLX.js";
 import {
   findPinnedTool
-} from "./chunk-QDC3K2U3.js";
+} from "./chunk-K2BLQC5E.js";
 import {
   readClioVersion,
   resolvePackageRoot
-} from "./chunk-IWHMRKLL.js";
+} from "./chunk-E3LEPLQ2.js";
 import {
   clioCacheDir,
   resolveClioDirs
-} from "./chunk-BYP5D4HI.js";
+} from "./chunk-CTTI7G3T.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/mux/yazi/theme.ts
 init_esm_shims();
@@ -359,4 +359,4 @@ export {
   describeYaziProfile,
   ensureYaziProfile
 };
-//# sourceMappingURL=chunk-3M6DQK6S.js.map
+//# sourceMappingURL=chunk-T334FW2H.js.map

package/dist/chunk-T52TPHYC.js

@@ -0,0 +1,318 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  compareCodepoints
+} from "./chunk-B6UM3OZC.js";
+import {
+  byteLength
+} from "./chunk-MYI32N4R.js";
+import {
+  resolveSafeCwd
+} from "./chunk-GJ24ODAX.js";
+import {
+  require_dist
+} from "./chunk-B5GGDIHT.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/safety/validation-contract.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import path from "node:path";
+var VALIDATION_CONTRACT_VERSION = 1;
+var VALIDATION_CONTRACT_YAML_PATHS = [
+  ".clio-coder/validation.yaml",
+  ".clio-coder/validation.yml",
+  "validation.yaml",
+  "validation.yml"
+];
+var VALIDATION_CONTRACT_MARKDOWN_PATH = "VALIDATION.md";
+var VALIDATION_CONTRACT_CAPS = Object.freeze({
+  fileBytes: 256 * 1024,
+  textBytes: 4096,
+  notesBytes: 16 * 1024,
+  artifacts: 256,
+  validators: 128,
+  modules: 64,
+  mapEntries: 256,
+  mapKeyBytes: 256
+});
+var RUNTIME_KINDS = ["local", "slurm", "mpi", "other"];
+var ROOT_FIELDS = /* @__PURE__ */ new Set(["version", "task", "runtime", "artifacts", "validators", "notes"]);
+var RUNTIME_FIELDS = /* @__PURE__ */ new Set(["kind", "nodes", "ranks", "walltime", "modules"]);
+var ARTIFACT_FIELDS = /* @__PURE__ */ new Set([
+  "path",
+  "format",
+  "expected_dimensions",
+  "expected_attributes",
+  "numerical_tolerances",
+  "preserve"
+]);
+var TOLERANCE_FIELDS = /* @__PURE__ */ new Set(["relative", "absolute", "ulp"]);
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function unknownFields(record, allowed) {
+  return Object.keys(record).filter((key) => !allowed.has(key)).sort(compareCodepoints);
+}
+function boundedText(value, location, cap) {
+  if (typeof value !== "string" || value.length === 0) return new Error(`${location} must be a non-empty string`);
+  if (value.includes("\0")) return new Error(`${location} must not contain a NUL byte`);
+  if (byteLength(value) > cap) return new Error(`${location} exceeds the ${cap}-byte cap`);
+  return value;
+}
+function positiveInteger(value, location) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    return new Error(`${location} must be a positive integer`);
+  }
+  return value;
+}
+function nonNegativeNumber(value, location) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return new Error(`${location} must be a finite non-negative number`);
+  }
+  return value;
+}
+function boundedStringList(value, location, cap) {
+  if (!Array.isArray(value)) return new Error(`${location} must be an array of strings`);
+  if (value.length > cap) return new Error(`${location} exceeds the ${cap}-entry cap`);
+  const items = [];
+  for (const [index, entry] of value.entries()) {
+    const text = boundedText(entry, `${location}[${index}]`, VALIDATION_CONTRACT_CAPS.textBytes);
+    if (text instanceof Error) return text;
+    items.push(text);
+  }
+  return items;
+}
+function boundedMap(value, location, validateEntry) {
+  if (!isRecord(value)) return new Error(`${location} must be a map`);
+  const keys = Object.keys(value);
+  if (keys.length > VALIDATION_CONTRACT_CAPS.mapEntries) {
+    return new Error(`${location} exceeds the ${VALIDATION_CONTRACT_CAPS.mapEntries}-entry cap`);
+  }
+  const out = {};
+  for (const key of keys.sort(compareCodepoints)) {
+    const entryLocation = `${location}.${key}`;
+    if (key.length === 0) return new Error(`${location} has an empty key`);
+    if (byteLength(key) > VALIDATION_CONTRACT_CAPS.mapKeyBytes) {
+      return new Error(`${entryLocation} key exceeds the ${VALIDATION_CONTRACT_CAPS.mapKeyBytes}-byte cap`);
+    }
+    const entry = validateEntry(value[key], entryLocation);
+    if (entry instanceof Error) return entry;
+    out[key] = entry;
+  }
+  return out;
+}
+function validateRuntime(value, location) {
+  if (!isRecord(value)) return new Error(`${location} must be an object with a kind field`);
+  const unknown = unknownFields(value, RUNTIME_FIELDS);
+  if (unknown.length > 0) return new Error(`${location} has unknown field(s): ${unknown.join(", ")}`);
+  if (!Object.hasOwn(value, "kind")) return new Error(`${location}.kind is required`);
+  const kind = value.kind;
+  if (typeof kind !== "string" || !RUNTIME_KINDS.includes(kind)) {
+    return new Error(`${location}.kind must be one of ${RUNTIME_KINDS.join(", ")}`);
+  }
+  const runtime = { kind };
+  if (Object.hasOwn(value, "nodes")) {
+    const nodes = positiveInteger(value.nodes, `${location}.nodes`);
+    if (nodes instanceof Error) return nodes;
+    runtime.nodes = nodes;
+  }
+  if (Object.hasOwn(value, "ranks")) {
+    const ranks = positiveInteger(value.ranks, `${location}.ranks`);
+    if (ranks instanceof Error) return ranks;
+    runtime.ranks = ranks;
+  }
+  if (Object.hasOwn(value, "walltime")) {
+    const walltime = boundedText(value.walltime, `${location}.walltime`, VALIDATION_CONTRACT_CAPS.textBytes);
+    if (walltime instanceof Error) return walltime;
+    runtime.walltime = walltime;
+  }
+  if (Object.hasOwn(value, "modules")) {
+    const modules = boundedStringList(value.modules, `${location}.modules`, VALIDATION_CONTRACT_CAPS.modules);
+    if (modules instanceof Error) return modules;
+    runtime.modules = modules;
+  }
+  return runtime;
+}
+function validateTolerances(value, location) {
+  if (!isRecord(value)) return new Error(`${location} must be an object`);
+  const unknown = unknownFields(value, TOLERANCE_FIELDS);
+  if (unknown.length > 0) return new Error(`${location} has unknown field(s): ${unknown.join(", ")}`);
+  const tolerances = {};
+  if (Object.hasOwn(value, "relative")) {
+    const relative = nonNegativeNumber(value.relative, `${location}.relative`);
+    if (relative instanceof Error) return relative;
+    tolerances.relative = relative;
+  }
+  if (Object.hasOwn(value, "absolute")) {
+    const absolute = nonNegativeNumber(value.absolute, `${location}.absolute`);
+    if (absolute instanceof Error) return absolute;
+    tolerances.absolute = absolute;
+  }
+  if (Object.hasOwn(value, "ulp")) {
+    const ulp = value.ulp;
+    if (typeof ulp !== "number" || !Number.isInteger(ulp) || ulp < 0) {
+      return new Error(`${location}.ulp must be a non-negative integer`);
+    }
+    tolerances.ulp = ulp;
+  }
+  return tolerances;
+}
+function validateArtifact(value, location) {
+  if (!isRecord(value)) return new Error(`${location} must be an object with a path field`);
+  const unknown = unknownFields(value, ARTIFACT_FIELDS);
+  if (unknown.length > 0) return new Error(`${location} has unknown field(s): ${unknown.join(", ")}`);
+  if (!Object.hasOwn(value, "path")) return new Error(`${location}.path is required`);
+  const artifactPath = boundedText(value.path, `${location}.path`, VALIDATION_CONTRACT_CAPS.textBytes);
+  if (artifactPath instanceof Error) return artifactPath;
+  const artifact = { path: artifactPath };
+  if (Object.hasOwn(value, "format")) {
+    const format = boundedText(value.format, `${location}.format`, VALIDATION_CONTRACT_CAPS.textBytes);
+    if (format instanceof Error) return format;
+    artifact.format = format;
+  }
+  if (Object.hasOwn(value, "expected_dimensions")) {
+    const dimensions = boundedMap(
+      value.expected_dimensions,
+      `${location}.expected_dimensions`,
+      (entry, entryLocation) => typeof entry === "number" && Number.isInteger(entry) && entry >= 0 ? entry : new Error(`${entryLocation} must be a non-negative integer`)
+    );
+    if (dimensions instanceof Error) return dimensions;
+    artifact.expected_dimensions = dimensions;
+  }
+  if (Object.hasOwn(value, "expected_attributes")) {
+    const attributes = boundedMap(
+      value.expected_attributes,
+      `${location}.expected_attributes`,
+      (entry, entryLocation) => typeof entry === "string" ? boundedText(entry, entryLocation, VALIDATION_CONTRACT_CAPS.textBytes) : new Error(`${entryLocation} must be a string`)
+    );
+    if (attributes instanceof Error) return attributes;
+    artifact.expected_attributes = attributes;
+  }
+  if (Object.hasOwn(value, "numerical_tolerances")) {
+    const tolerances = validateTolerances(value.numerical_tolerances, `${location}.numerical_tolerances`);
+    if (tolerances instanceof Error) return tolerances;
+    artifact.numerical_tolerances = tolerances;
+  }
+  if (Object.hasOwn(value, "preserve")) {
+    if (typeof value.preserve !== "boolean") return new Error(`${location}.preserve must be a boolean`);
+    artifact.preserve = value.preserve;
+  }
+  return artifact;
+}
+function parseValidationContractText(text, contractPath) {
+  const invalid = (reason) => ({ ok: false, path: contractPath, reason });
+  const document = (0, import_yaml.parseDocument)(text, { prettyErrors: false, strict: true, uniqueKeys: true });
+  if (document.errors.length > 0) {
+    return invalid(`invalid YAML: ${document.errors.map((error) => error.message).join("; ")}`);
+  }
+  let parsed;
+  try {
+    parsed = document.toJS({ maxAliasCount: 0 });
+  } catch (error) {
+    return invalid(`invalid YAML: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!isRecord(parsed)) return invalid("root must be an object with a version field");
+  const rootUnknown = unknownFields(parsed, ROOT_FIELDS);
+  if (rootUnknown.length > 0) return invalid(`root has unknown field(s): ${rootUnknown.join(", ")}`);
+  if (!Object.hasOwn(parsed, "version")) return invalid("root.version is required");
+  if (parsed.version !== VALIDATION_CONTRACT_VERSION) {
+    return invalid(
+      `unsupported version ${JSON.stringify(parsed.version)}; supported version is ${VALIDATION_CONTRACT_VERSION}`
+    );
+  }
+  const contract = { version: VALIDATION_CONTRACT_VERSION };
+  if (Object.hasOwn(parsed, "task")) {
+    const task = boundedText(parsed.task, "root.task", VALIDATION_CONTRACT_CAPS.textBytes);
+    if (task instanceof Error) return invalid(task.message);
+    contract.task = task;
+  }
+  if (Object.hasOwn(parsed, "runtime")) {
+    const runtime = validateRuntime(parsed.runtime, "root.runtime");
+    if (runtime instanceof Error) return invalid(runtime.message);
+    contract.runtime = runtime;
+  }
+  if (Object.hasOwn(parsed, "artifacts")) {
+    if (!Array.isArray(parsed.artifacts)) return invalid("root.artifacts must be an array");
+    if (parsed.artifacts.length > VALIDATION_CONTRACT_CAPS.artifacts) {
+      return invalid(`root.artifacts exceeds the ${VALIDATION_CONTRACT_CAPS.artifacts}-entry cap`);
+    }
+    const artifacts = [];
+    for (const [index, value] of parsed.artifacts.entries()) {
+      const artifact = validateArtifact(value, `artifacts[${index}]`);
+      if (artifact instanceof Error) return invalid(artifact.message);
+      artifacts.push(artifact);
+    }
+    contract.artifacts = artifacts;
+  }
+  if (Object.hasOwn(parsed, "validators")) {
+    const validators = boundedStringList(parsed.validators, "root.validators", VALIDATION_CONTRACT_CAPS.validators);
+    if (validators instanceof Error) return invalid(validators.message);
+    contract.validators = validators;
+  }
+  if (Object.hasOwn(parsed, "notes")) {
+    const notes = boundedText(parsed.notes, "root.notes", VALIDATION_CONTRACT_CAPS.notesBytes);
+    if (notes instanceof Error) return invalid(notes.message);
+    contract.notes = notes;
+  }
+  return { ok: true, contract, path: contractPath };
+}
+function readContractText(absolutePath, workspaceRoot) {
+  let realPath;
+  try {
+    const realRoot = realpathSync(workspaceRoot);
+    realPath = realpathSync(absolutePath);
+    resolveSafeCwd(realPath, realRoot);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return new Error(`contract file must resolve inside the workspace root (${message})`);
+  }
+  try {
+    const stats = statSync(realPath);
+    if (!stats.isFile()) return new Error("contract path must be a regular file");
+    if (stats.size > VALIDATION_CONTRACT_CAPS.fileBytes) {
+      return new Error(`file exceeds the ${VALIDATION_CONTRACT_CAPS.fileBytes}-byte cap`);
+    }
+    return readFileSync(realPath, "utf8");
+  } catch (error) {
+    return new Error(`cannot read contract (${error instanceof Error ? error.message : String(error)})`);
+  }
+}
+function loadValidationContract(workspaceRoot) {
+  let contractPath = null;
+  try {
+    contractPath = VALIDATION_CONTRACT_YAML_PATHS.find((relative) => existsSync(path.join(workspaceRoot, relative))) ?? null;
+    if (contractPath === null) {
+      if (existsSync(path.join(workspaceRoot, VALIDATION_CONTRACT_MARKDOWN_PATH))) {
+        return { ok: true, contract: null, path: VALIDATION_CONTRACT_MARKDOWN_PATH, advisory: true };
+      }
+      return { ok: true, contract: null };
+    }
+  } catch (error) {
+    return {
+      ok: false,
+      path: contractPath ?? VALIDATION_CONTRACT_YAML_PATHS[0] ?? "validation.yaml",
+      reason: `cannot inspect workspace root (${error instanceof Error ? error.message : String(error)})`
+    };
+  }
+  const text = readContractText(path.join(workspaceRoot, contractPath), workspaceRoot);
+  if (text instanceof Error) return { ok: false, path: contractPath, reason: text.message };
+  return parseValidationContractText(text, contractPath);
+}
+function describeValidationContract(result) {
+  if (!result.ok) return `${result.path}: ${result.reason}`;
+  if (result.contract === null) {
+    return "advisory" in result ? `${result.path} is advisory prose and does not raise rigor; add a version-1 validation.yaml to raise the default to high` : null;
+  }
+  return null;
+}
+
+export {
+  VALIDATION_CONTRACT_MARKDOWN_PATH,
+  loadValidationContract,
+  describeValidationContract
+};
+//# sourceMappingURL=chunk-T52TPHYC.js.map

package/dist/{chunk-I7XBWTYH.js → chunk-T53XI6I7.js}

@@ -1,20 +1,20 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   readClioVersion
-} from "./chunk-IWHMRKLL.js";
+} from "./chunk-E3LEPLQ2.js";
 import {
   DEFAULT_SETTINGS_YAML
-} from "./chunk-UXCU4E3T.js";
+} from "./chunk-SE4ZKILO.js";
 import {
   clioCacheDir,
   clioConfigDir,
   clioDataDir,
   clioStateDir,
   resolveClioDirs
-} from "./chunk-BYP5D4HI.js";
+} from "./chunk-CTTI7G3T.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/core/init.ts
 init_esm_shims();
@@ -143,4 +143,4 @@ function enforceHomePrefixGuard() {
 export {
   initializeClioHome
 };
-//# sourceMappingURL=chunk-I7XBWTYH.js.map
+//# sourceMappingURL=chunk-T53XI6I7.js.map

package/dist/{chunk-LDJG7DW3.js → chunk-T7FDXNRU.js}

@@ -3,37 +3,37 @@ import {
   frontmatterRegion,
   normalizedSkillHash,
   stripProvenanceLines
-} from "./chunk-NDDGJUXD.js";
+} from "./chunk-DNCE23JJ.js";
 import {
   readRootEntries,
   splitYamlFrontmatter,
   stringField
-} from "./chunk-CE5AX47J.js";
+} from "./chunk-U7H5WRG5.js";
 import {
   enabledExtensionResourceRoots
-} from "./chunk-7DRAWPTZ.js";
+} from "./chunk-22PQ4TX4.js";
 import {
   ToolNames
-} from "./chunk-K6BSR66V.js";
+} from "./chunk-EHOSNVVM.js";
+import {
+  warnLegacyNaming
+} from "./chunk-DVNAPPXU.js";
 import {
   INTEROP_AGENT_KINDS,
   interopSourceRank
-} from "./chunk-KXDSS5WJ.js";
-import {
-  warnLegacyNaming
-} from "./chunk-D7E7WCDF.js";
+} from "./chunk-5CY4Q6QI.js";
 import {
   resolvePackageRoot
-} from "./chunk-IWHMRKLL.js";
+} from "./chunk-E3LEPLQ2.js";
 import {
   fsyncDirectory
-} from "./chunk-WEPFGWHJ.js";
+} from "./chunk-ZZFWWYLX.js";
 import {
   clioConfigDir
-} from "./chunk-BYP5D4HI.js";
+} from "./chunk-CTTI7G3T.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/resources/skills/install.ts
 init_esm_shims();
@@ -1254,4 +1254,4 @@ export {
   expandSkillInvocationInput,
   parsePendingSkillRequests
 };
-//# sourceMappingURL=chunk-LDJG7DW3.js.map
+//# sourceMappingURL=chunk-T7FDXNRU.js.map