@iowarp/clio-coder 0.4.3 → 0.4.4

package/dist/{chunk-JSC3U7TI.js → chunk-TOIVGRUX.js}

@@ -3,7 +3,7 @@ import {
   gitCommitAttributionEnabled,
   reportCommitAttributionDiagnostic,
   withManagedGitCommitAttributionEnvironment
-} from "./chunk-JIEGK6UF.js";
+} from "./chunk-U6TMQNSI.js";
 import {
   clampTimerDelayMs
 } from "./chunk-EBY63B7G.js";
@@ -193,4 +193,4 @@ export {
   runCommandVector,
   combineSafeOutput
 };
-//# sourceMappingURL=chunk-JSC3U7TI.js.map
+//# sourceMappingURL=chunk-TOIVGRUX.js.map

package/dist/{chunk-7DRAWPTZ.js → chunk-TQAHXW6Y.js}

@@ -357,4 +357,4 @@ export {
   enabledExtensionResourceRoots,
   ExtensionsDomainModule
 };
-//# sourceMappingURL=chunk-7DRAWPTZ.js.map
+//# sourceMappingURL=chunk-TQAHXW6Y.js.map

package/dist/{chunk-JIEGK6UF.js → chunk-U6TMQNSI.js}

@@ -34,6 +34,9 @@ var CLIO_COMMIT_TRAILERS = {
   reviewed: `Reviewed-by: ${CLIO_COMMIT_IDENTITY}`,
   coAuthored: `Co-authored-by: ${CLIO_COMMIT_IDENTITY}`
 };
+var CLIO_DECISION_TRAILER_KEY = "Clio-Decision";
+var CLIO_DECISION_TRAILER_CAP = 32;
+var DECISION_REF_PATTERN = /^[A-Za-z0-9][A-Za-z0-9:._-]{0,127}\/[a-z0-9]+(?:[_-][a-z0-9]+)*$/u;
 var TRAILER_LINE = /^([A-Za-z0-9][A-Za-z0-9-]*):[ \t]+(.+)$/u;
 var SHA256 = /^[0-9a-f]{64}$/u;
 function normalizedTrailer(line) {
@@ -45,7 +48,18 @@ var KNOWN_CLIO_TRAILERS = new Set(
   Object.values(CLIO_COMMIT_TRAILERS).map((line) => normalizedTrailer(line)).filter((line) => line !== null)
 );
 function isClioTrailer(key) {
-  return KNOWN_CLIO_TRAILERS.has(key) || key.startsWith("clio-evidence:receipt-v20/sha256:");
+  return KNOWN_CLIO_TRAILERS.has(key) || key.startsWith("clio-evidence:receipt-v20/sha256:") || key.startsWith(`${CLIO_DECISION_TRAILER_KEY.toLowerCase()}:`);
+}
+function decisionTrailerRefs(decisions) {
+  if (decisions === void 0) return [];
+  const refs = /* @__PURE__ */ new Set();
+  for (const ref of decisions) {
+    if (typeof ref === "string" && DECISION_REF_PATTERN.test(ref)) refs.add(ref);
+  }
+  return [...refs].sort().slice(0, CLIO_DECISION_TRAILER_CAP);
+}
+function decisionTrailer(ref) {
+  return `${CLIO_DECISION_TRAILER_KEY}: ${ref}`;
 }
 function trailerBlockStart(lines) {
   if (lines.length < 2) return null;
@@ -92,6 +106,7 @@ function attributeCommitMessage(originalMessage, evidence, enabled = true) {
   if (evidence.materiallyAuthored === true) desired.push(CLIO_COMMIT_TRAILERS.coAuthored);
   const receipt = receiptTrailer(evidence.receipt);
   if (receipt !== null) desired.push(receipt);
+  for (const ref of decisionTrailerRefs(evidence.decisions)) desired.push(decisionTrailer(ref));
   const existing = new Set(
     (blockStart === null ? [] : retained.slice(blockStart)).map((line) => normalizedTrailer(line)).filter((line) => line !== null)
   );
@@ -112,9 +127,10 @@ function attributeCommitMessage(originalMessage, evidence, enabled = true) {
 var CLIO_GIT_COMMITS_ENABLED_ENV = "CLIO_CODER_GIT_COMMITS_ENABLED";
 var ASSISTED_ENV = "CLIO_CODER_COMMIT_ASSISTED";
 var AUTHORED_ENV = "CLIO_CODER_COMMIT_AUTHORED";
+var DECISIONS_ENV = "CLIO_CODER_COMMIT_DECISIONS";
 var CONFIG_BASE_COUNT_ENV = "CLIO_CODER_GIT_CONFIG_BASE_COUNT";
 var DEFAULT_HOOKS_EQUIVALENT_ENV = "CLIO_CODER_GIT_DEFAULT_HOOKS_EQUIVALENT";
-var MANAGED_HOOK_VERSION = 2;
+var MANAGED_HOOK_VERSION = 3;
 var DIAGNOSTIC_MAX_CHARS = 300;
 var COUNT = /^(?:0|[1-9][0-9]*)$/u;
 var reportedDiagnostics = /* @__PURE__ */ new Set();
@@ -122,7 +138,24 @@ var PROBE_CACHE_TTL_MS = 1e4;
 var PROBE_CACHE_MAX_ENTRIES = 32;
 var probeCache = /* @__PURE__ */ new Map();
 var installedHooksDirectory = null;
-var PER_SPAWN_ENV_NAMES = [ASSISTED_ENV, AUTHORED_ENV, CONFIG_BASE_COUNT_ENV, DEFAULT_HOOKS_EQUIVALENT_ENV];
+var PER_SPAWN_ENV_NAMES = [
+  ASSISTED_ENV,
+  AUTHORED_ENV,
+  DECISIONS_ENV,
+  CONFIG_BASE_COUNT_ENV,
+  DEFAULT_HOOKS_EQUIVALENT_ENV
+];
+var decisionRefsProvider = null;
+function setCommitDecisionRefsProvider(provider) {
+  decisionRefsProvider = provider;
+}
+function providedDecisionRefs() {
+  try {
+    return decisionRefsProvider?.() ?? [];
+  } catch {
+    return [];
+  }
+}
 function reportCommitAttributionDiagnostic(diagnostic) {
   if (diagnostic === null || reportedDiagnostics.has(diagnostic)) return;
   reportedDiagnostics.add(diagnostic);
@@ -279,6 +312,14 @@ if [ "$${ASSISTED_ENV}" = '1' ] || [ "$${AUTHORED_ENV}" = '1' ]; then
   append_trailer '${CLIO_COMMIT_TRAILERS.assisted}'
 fi
 if [ "$${AUTHORED_ENV}" = '1' ]; then append_trailer '${CLIO_COMMIT_TRAILERS.coAuthored}'; fi
+# Decision refs are validated again here: only <id>/<key> shapes become
+# trailers, so a stray value cannot inject a second line into the message.
+for decision_ref in $${DECISIONS_ENV}; do
+  case "$decision_ref" in
+    *[!A-Za-z0-9:._/-]* | */*/* | /* | */ | *-*-) continue ;;
+    */*) append_trailer "${CLIO_DECISION_TRAILER_KEY}: $decision_ref" ;;
+  esac
+done
 exit 0
 `;
 function installManagedHook(directory, name) {
@@ -358,6 +399,8 @@ function withManagedGitCommitAttributionEnvironment(source, options = {}) {
   const evidence = options.evidence ?? { materiallyAssisted: true, materiallyAuthored: true };
   env[ASSISTED_ENV] = evidence.materiallyAssisted === true ? "1" : "0";
   env[AUTHORED_ENV] = evidence.materiallyAuthored === true ? "1" : "0";
+  const decisions = decisionTrailerRefs(evidence.decisions ?? providedDecisionRefs());
+  if (decisions.length > 0) env[DECISIONS_ENV] = decisions.join(" ");
   const countRaw = env.GIT_CONFIG_COUNT;
   const count = countRaw === void 0 ? 0 : COUNT.test(countRaw) ? Number(countRaw) : Number.NaN;
   if (!Number.isSafeInteger(count) || count > 1024) {
@@ -394,9 +437,10 @@ function withManagedGitCommitAttributionEnvironment(source, options = {}) {
 
 export {
   attributeCommitMessage,
+  setCommitDecisionRefsProvider,
   reportCommitAttributionDiagnostic,
   setGitCommitAttributionEnabled,
   gitCommitAttributionEnabled,
   withManagedGitCommitAttributionEnvironment
 };
-//# sourceMappingURL=chunk-JIEGK6UF.js.map
+//# sourceMappingURL=chunk-U6TMQNSI.js.map

package/dist/{chunk-AX2THNSA.js → chunk-UEPWCCTY.js}

@@ -159,7 +159,7 @@ Run \`clio-coder auth login ${verdict.store}\` if the endpoint requires one; loc
     } else if (verdict.kind !== "usable") {
       process.stdout.write(`${describeVerdict(verdict)} Starting \`clio-coder configure\`.
 `);
-      const { runConfigureCommand } = await import("./configure-LE3IK2TJ.js");
+      const { runConfigureCommand } = await import("./configure-VEPX4NMX.js");
       const configured = await runConfigureCommand([]);
       if (configured !== 0) return configured;
       startupSettings = readStrictLayeredSettings(process.cwd()).settings;
@@ -174,7 +174,7 @@ Run \`clio-coder auth login ${verdict.store}\` if the endpoint requires one; loc
   let terminalLease;
   try {
     if (terminalLeaseEligible(options)) {
-      const { createProcessTerminalLease, instantShellEnabled } = await import("./terminal-lease-TUHIJ6Y2.js");
+      const { createProcessTerminalLease, instantShellEnabled } = await import("./terminal-lease-C2J3JYRE.js");
       if (instantShellEnabled()) {
         let stage0FrameId = null;
         terminalLease = createProcessTerminalLease({
@@ -197,7 +197,7 @@ Run \`clio-coder auth login ${verdict.store}\` if the endpoint requires one; loc
         throw new Error("injected Stage 1 hydration failure");
       }
     }
-    const { bootOrchestrator } = await import("./orchestrator-VDFAEFAI.js");
+    const { bootOrchestrator } = await import("./orchestrator-J4BSH4WQ.js");
     const result = await bootOrchestrator({
       ...options,
       ...startupSettings ? { startupSettings } : {},
@@ -220,4 +220,4 @@ Run \`clio-coder auth login ${verdict.store}\` if the endpoint requires one; loc
 export {
   runClioCommand
 };
-//# sourceMappingURL=chunk-AX2THNSA.js.map
+//# sourceMappingURL=chunk-UEPWCCTY.js.map

package/dist/{chunk-QWGDJJYJ.js → chunk-USR47QNF.js}

@@ -4,10 +4,10 @@ import {
 } from "./chunk-5ICU3EUH.js";
 import {
   parseAgentRecipeSchema
-} from "./chunk-RRNP2ANY.js";
+} from "./chunk-7UGL4MB5.js";
 import {
   parseFleetContract
-} from "./chunk-2VIKGWFZ.js";
+} from "./chunk-OEJSLEPW.js";
 import {
   parseFrontmatter
 } from "./chunk-RKKLTLYB.js";
@@ -21,7 +21,7 @@ import {
 import {
   assertAgentSpecPolicy,
   normalizeAgentSpec
-} from "./chunk-B4OAX3SI.js";
+} from "./chunk-KFV5L5SK.js";
 import {
   readSettings,
   settingsPath,
@@ -792,4 +792,4 @@ export {
   importShareArchive,
   ShareDomainModule
 };
-//# sourceMappingURL=chunk-QWGDJJYJ.js.map
+//# sourceMappingURL=chunk-USR47QNF.js.map

package/dist/{chunk-Y3CBHOR6.js → chunk-V6HJFQZE.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   sha256
-} from "./chunk-IWT4SF4R.js";
+} from "./chunk-CUSRQKPU.js";
 import {
   resolvePackageRoot
 } from "./chunk-IWHMRKLL.js";
@@ -225,4 +225,4 @@ export {
   renderCodewikiDigest,
   loadFragments
 };
-//# sourceMappingURL=chunk-Y3CBHOR6.js.map
+//# sourceMappingURL=chunk-V6HJFQZE.js.map

package/dist/chunk-V76WTFTW.js

@@ -0,0 +1,318 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  compareCodepoints
+} from "./chunk-I5FWO7L5.js";
+import {
+  byteLength
+} from "./chunk-6XLNIQDB.js";
+import {
+  resolveSafeCwd
+} from "./chunk-TOIVGRUX.js";
+import {
+  require_dist
+} from "./chunk-APJ265NV.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-3R73A4XB.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-V76WTFTW.js.map

package/dist/{chunk-NMJXSHBJ.js → chunk-W54I7H25.js}

@@ -3,7 +3,7 @@ import {
   gitCommitAttributionEnabled,
   reportCommitAttributionDiagnostic,
   withManagedGitCommitAttributionEnvironment
-} from "./chunk-JIEGK6UF.js";
+} from "./chunk-U6TMQNSI.js";
 import {
   clampTimerDelayMs
 } from "./chunk-EBY63B7G.js";
@@ -280,4 +280,4 @@ export {
   combineBashOutput,
   runBashCommand
 };
-//# sourceMappingURL=chunk-NMJXSHBJ.js.map
+//# sourceMappingURL=chunk-W54I7H25.js.map

package/dist/{chunk-2UG5F4C5.js → chunk-XULDXHTN.js}

@@ -7,17 +7,17 @@ import {
 } from "./chunk-2WZ546HR.js";
 import {
   isTerminalRunEnvelope
-} from "./chunk-PAJQJ7BS.js";
-import {
-  taskBoardCounts
-} from "./chunk-L47TF46W.js";
+} from "./chunk-75W7L2E2.js";
 import {
   hashToolCall
-} from "./chunk-RSJ25QSL.js";
+} from "./chunk-6QOTUPRG.js";
+import {
+  taskBoardCounts
+} from "./chunk-6PAZTBPA.js";
 import {
   legacyToolResultDigest,
   sanitizeToolResultDigest
-} from "./chunk-JDAY6FIL.js";
+} from "./chunk-NAI6ZFCY.js";
 import {
   SKILL_INSTALL_OFFER_OPTION_NEVER,
   SKILL_INSTALL_OFFER_OPTION_NOT_NOW,
@@ -25,13 +25,13 @@ import {
   SKILL_INSTALL_OFFER_OPTION_USER,
   SKILL_SUGGESTION_ANCHOR,
   SKILL_SUGGESTION_PREFIX
-} from "./chunk-JGRC33J2.js";
+} from "./chunk-54X7T7DK.js";
 import {
   ToolNames
-} from "./chunk-K6BSR66V.js";
+} from "./chunk-4NSRCOYP.js";
 import {
   registerForegroundStream
-} from "./chunk-XPWWI35G.js";
+} from "./chunk-JSD46VO2.js";
 import {
   ceilChars
 } from "./chunk-NZMNUPZZ.js";
@@ -41,7 +41,7 @@ import {
 import {
   reportCommitAttributionDiagnostic,
   withManagedGitCommitAttributionEnvironment
-} from "./chunk-JIEGK6UF.js";
+} from "./chunk-U6TMQNSI.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -1217,8 +1217,11 @@ var NO_EFFECTS2 = [];
 function offerBindingTag(offerTag) {
   return `[clio-install:${offerTag}]`;
 }
+function boundedDescription(text) {
+  return text.replace(/\[[^[\]]*\]/gu, " ").replace(/\s+/gu, " ").trim().slice(0, 200);
+}
 function marketplaceOfferReminder(entry, offerTag) {
-  return `[Marketplace] This request may need expertise no installed skill covers. The local marketplace has "${entry.name}" (not installed): ${entry.description} First check the installed side with context(scope="skills"); if ${entry.name} is genuinely the right fit and nothing installed serves, ask the operator with ask_user (mode=single_question, header "Install skill") whether to install ${entry.name}, offering exactly these options in this order: "${SKILL_INSTALL_OFFER_OPTION_PROJECT}", "${SKILL_INSTALL_OFFER_OPTION_USER}", "${SKILL_INSTALL_OFFER_OPTION_NOT_NOW}", "${SKILL_INSTALL_OFFER_OPTION_NEVER}". Include the exact tag ${offerBindingTag(offerTag)} verbatim in that question's text so the harness can bind the answer to this offer; the harness acts only on an answer carrying this tag. Then continue the task in the same turn. The harness handles the answer; never install or load a skill yourself. If it is not actually needed, do not mention it.`;
+  return `[Marketplace] This request may need expertise no installed skill covers. The local marketplace has "${entry.name}" (not installed): ${boundedDescription(entry.description)} First check the installed side with context(scope="skills"); if ${entry.name} is genuinely the right fit and nothing installed serves, ask the operator with ask_user (mode=single_question, header "Install skill") whether to install ${entry.name}, offering exactly these options in this order: "${SKILL_INSTALL_OFFER_OPTION_PROJECT}", "${SKILL_INSTALL_OFFER_OPTION_USER}", "${SKILL_INSTALL_OFFER_OPTION_NOT_NOW}", "${SKILL_INSTALL_OFFER_OPTION_NEVER}". Include the exact tag ${offerBindingTag(offerTag)} verbatim in that question's text so the harness can bind the answer to this offer; the harness acts only on an answer carrying this tag. Then continue the task in the same turn. The harness handles the answer; never install or load a skill yourself. If it is not actually needed, do not mention it.`;
 }
 function answersFromDetails(details) {
   const raw = details?.answers;
@@ -1366,6 +1369,15 @@ function createMarketplaceOfferRegistration(deps) {
       const match = bestMatch(input.text ?? "");
       if (!match) return NO_EFFECTS2;
       offeredNames.add(match.entry.name);
+      if (deps.interactive === false) {
+        return [
+          {
+            kind: "inject_reminder",
+            severity: "info",
+            message: `[Marketplace] Skill "${match.entry.name}" matches this request; install with clio-coder skills install ${match.entry.name}.`
+          }
+        ];
+      }
       const tag = newOfferTag();
       pendingOffer = { entry: match.entry, tag };
       return [{ kind: "inject_reminder", severity: "info", message: marketplaceOfferReminder(match.entry, tag) }];
@@ -3084,4 +3096,4 @@ export {
   createWatchdogRegistration,
   MiddlewareDomainModule
 };
-//# sourceMappingURL=chunk-2UG5F4C5.js.map
+//# sourceMappingURL=chunk-XULDXHTN.js.map